refactored the dir structure

2026-03-23 09:03:00 +02:00
parent b273f3a304
commit 026aa14b2f
21 changed files with 16 additions and 12 deletions
@@ -0,0 +1,292 @@
+package sidekick
+
+import (
+  "context"
+  "encoding/json"
+  "fmt"
+  "io"
+  "os"
+  "os/exec"
+  "strings"
+  "time"
+
+  "github.com/mark3labs/mcp-go/client"
+  "github.com/mark3labs/mcp-go/client/transport"
+  "github.com/mark3labs/mcp-go/mcp"
+)
+
+// MCPClientInterface represents a scoped connection to an MCP server
+type MCPClientInterface interface {
+  CallTool(ctx context.Context, name string, args map[string]interface{}) (string, error)
+  ListTools(ctx context.Context) ([]ToolDefinition, error)
+  Close() error
+}
+
+type mcpGoClientWrapper struct {
+  client *client.Client
+}
+
+func (w *mcpGoClientWrapper) CallTool(ctx context.Context, name string,
+  args map[string]interface{}) (string, error) {
+  req := mcp.CallToolRequest{}
+  req.Params.Name = name
+  req.Params.Arguments = args
+
+  res, err := w.client.CallTool(ctx, req)
+  if err != nil {
+    return "", err
+  }
+
+  if res.IsError {
+    return "", fmt.Errorf("tool returned error")
+  }
+
+  // Extract text from result content
+  var output string
+  for _, c := range res.Content {
+    if textContent, ok := c.(mcp.TextContent); ok {
+      output += textContent.Text + "\n"
+    } else {
+      output += fmt.Sprintf("%v\n", c)
+    }
+  }
+  return output, nil
+}
+
+func (w *mcpGoClientWrapper) ListTools(ctx context.Context) ([]ToolDefinition, error) {
+  req := mcp.ListToolsRequest{}
+  res, err := w.client.ListTools(ctx, req)
+  if err != nil {
+    return nil, err
+  }
+
+  var tools []ToolDefinition
+  for _, t := range res.Tools {
+    var params map[string]interface{}
+    b, err := json.Marshal(t.InputSchema)
+    if err == nil {
+      _ = json.Unmarshal(b, &params)
+    }
+
+    tools = append(tools, ToolDefinition{
+      Name:        t.Name,
+      Description: t.Description,
+      Parameters:  params,
+      Internal:    false,
+    })
+  }
+  return tools, nil
+}
+
+func (w *mcpGoClientWrapper) Close() error {
+  if w.client != nil {
+    return w.client.Close()
+  }
+  return nil
+}
+
+// Global server configurations
+var mcpServers map[string]MCPServerConfig
+
+// GlobalLogger is an optional logger for MCP connections
+var GlobalLogger func(format string, v ...interface{})
+
+// InitMCPServers sets up the global registry for MCP factories
+func InitMCPServers(servers map[string]MCPServerConfig) {
+  mcpServers = servers
+}
+
+type sidekickLogger struct{}
+
+func (l *sidekickLogger) Infof(format string, v ...any) {
+  if GlobalLogger != nil {
+    GlobalLogger(format, v...)
+  }
+}
+
+func (l *sidekickLogger) Errorf(format string, v ...any) {
+  if GlobalLogger != nil {
+    GlobalLogger("ERROR: "+format, v...)
+  }
+}
+
+// defaultMCPFactory creates a real MCP client based on the global configuration
+var defaultMCPFactory MCPClientFactory = func(toolset string) (MCPClientInterface, error) {
+  cfg, ok := mcpServers[toolset]
+  if !ok {
+    return nil, fmt.Errorf("unknown MCP server: %s", toolset)
+  }
+
+  if GlobalLogger != nil {
+    GlobalLogger("Initializing MCP connection to %s via %s", toolset, cfg.Transport)
+  }
+
+  var c *client.Client
+  var err error
+
+  switch cfg.Transport {
+  case "stdio":
+    if GlobalLogger != nil {
+      GlobalLogger("Running stdio MCP: %s %v (env: %d vars)", cfg.Command, cfg.Args, len(cfg.Env))
+    }
+
+    command := cfg.Command
+    args := cfg.Args
+
+    // If using npx, try to be quiet to avoid stdout pollution
+    if command == "npx" {
+      quietFound := false
+      for _, arg := range args {
+        if arg == "--quiet" || arg == "-q" {
+          quietFound = true
+          break
+        }
+      }
+      if !quietFound {
+        // Prepend --quiet to args
+        args = append([]string{"--quiet"}, args...)
+      }
+    }
+
+    env := cfg.Env
+    if len(env) > 0 {
+      foundPath := false
+      for _, e := range env {
+        if strings.HasPrefix(strings.ToUpper(e), "PATH=") {
+          foundPath = true
+          break
+        }
+      }
+      if !foundPath {
+        if path := os.Getenv("PATH"); path != "" {
+          env = append(env, "PATH="+path)
+        }
+      }
+    } else {
+      env = os.Environ()
+    }
+
+    // Use WithCommandFunc to configure the command environment
+    c, err = client.NewStdioMCPClientWithOptions(command, env, args,
+      transport.WithCommandFunc(func(ctx context.Context, command string,
+        env []string, args []string) (*exec.Cmd, error) {
+        cmd := exec.CommandContext(ctx, command, args...)
+        cmd.Env = env
+        return cmd, nil
+      }),
+    )
+  case "sse":
+    var opts []transport.ClientOption
+    headers := make(map[string]string)
+    if cfg.AuthToken != "" {
+      headers["Authorization"] = "Bearer " + cfg.AuthToken
+    }
+    for k, v := range cfg.Headers {
+      headers[k] = v
+    }
+    if len(headers) > 0 {
+      opts = append(opts, transport.WithHeaders(headers))
+    }
+    c, err = client.NewSSEMCPClient(cfg.URL, opts...)
+  case "http":
+    var opts []transport.StreamableHTTPCOption
+    headers := make(map[string]string)
+    if cfg.AuthToken != "" {
+      headers["Authorization"] = "Bearer " + cfg.AuthToken
+    }
+    for k, v := range cfg.Headers {
+      headers[k] = v
+    }
+    if len(headers) > 0 {
+      opts = append(opts, transport.WithHTTPHeaders(headers))
+    }
+    c, err = client.NewStreamableHttpClient(cfg.URL, opts...)
+  default:
+    return nil, fmt.Errorf("unsupported MCP transport: %s", cfg.Transport)
+  }
+
+  if err != nil {
+    return nil, err
+  }
+
+  // Redirect stderr from the stdio transport to os.Stderr
+  if cfg.Transport == "stdio" {
+    if stderr, ok := client.GetStderr(c); ok {
+      go io.Copy(os.Stderr, stderr)
+    }
+  }
+
+  // Initialize the client session
+  initReq := mcp.InitializeRequest{}
+  initReq.Params.ProtocolVersion = mcp.LATEST_PROTOCOL_VERSION
+  initReq.Params.ClientInfo = mcp.Implementation{
+    Name:    "Sidekick",
+    Version: "1.0.0",
+  }
+
+  initCtx, initCancel := context.WithTimeout(context.Background(), 20*time.Second)
+  defer initCancel()
+  _, err = c.Initialize(initCtx, initReq)
+  if err != nil {
+    _ = c.Close()
+    return nil, fmt.Errorf("failed to initialize MCP client: %w", err)
+  }
+
+  return &mcpGoClientWrapper{client: c}, nil
+}
+
+// MCPClientFactory is a function that creates a new MCP client for a specific toolset
+type MCPClientFactory func(toolset string) (MCPClientInterface, error)
+
+// SetMCPClientFactory allows overriding the factory for testing
+func SetMCPClientFactory(factory MCPClientFactory) {
+  defaultMCPFactory = factory
+}
+
+// LoadExternalTools connects to all registered MCP servers and fetches their tools
+func LoadExternalTools(ctx context.Context) []ToolDefinition {
+  var extTools []ToolDefinition
+  for toolset := range mcpServers {
+    c, err := defaultMCPFactory(toolset)
+    if err != nil {
+      if GlobalLogger != nil {
+        GlobalLogger("Failed to connect to MCP server %s: %v", toolset, err)
+      }
+      continue
+    }
+
+    listCtx, listCancel := context.WithTimeout(ctx, 10*time.Second)
+    tools, err := c.ListTools(listCtx)
+    listCancel()
+    c.Close()
+    if err != nil {
+      if GlobalLogger != nil {
+        GlobalLogger("Failed to list tools from MCP server %s: %v", toolset, err)
+      }
+      continue
+    }
+
+    // Assign toolset to each tool
+    for i := range tools {
+      tools[i].Toolset = toolset
+    }
+
+    if GlobalLogger != nil {
+      GlobalLogger("Loaded %d tools from MCP server %s", len(tools), toolset)
+    }
+    extTools = append(extTools, tools...)
+  }
+  return extTools
+}
+
+// CallExternalTool creates a scoped MCP connection, calls the tool, and cleans up
+func CallExternalTool(ctx context.Context, toolset string, toolName string,
+  args map[string]interface{}) (string, error) {
+  c, err := defaultMCPFactory(toolset)
+  if err != nil {
+    return "", fmt.Errorf("failed to create MCP client for %s: %w", toolset, err)
+  }
+  defer c.Close()
+
+  return c.CallTool(ctx, toolName, args)
+}