Merge pull request #49 from githubnext/autoloop/python-to-go-migration

[Autoloop: python-to-go-migration]

Author: mrjf

benchmarks/migration-status.json

@@ -0,0 +1,47 @@
+// Package base defines the MCPClientAdapter interface and shared regex helpers.
+//
+// Mirrors src/apm_cli/adapters/client/base.py.
+package base
+
+import (
+	"regexp"
+)
+
+// InputVarRE matches ${input:NAME} placeholders that adapters must warn about.
+var InputVarRE = regexp.MustCompile(`\$\{input:([^}]+)\}`)
+
+// EnvVarRE matches ${VAR} and ${env:VAR}, capturing the variable name.
+// Does NOT match ${input:VAR} or GitHub Actions ${{ ... }}.
+var EnvVarRE = regexp.MustCompile(`\$\{(?:env:)?([A-Za-z_][A-Za-z0-9_]*)\}`)
+
+// MCPClientAdapter is the interface all MCP client adapters must satisfy.
+type MCPClientAdapter interface {
+	// GetConfigPath returns the path to this adapter's config file.
+	GetConfigPath() string
+
+	// UpdateConfig merges config_updates into the adapter's config file.
+	UpdateConfig(configUpdates map[string]interface{}) error
+
+	// GetCurrentConfig reads and returns the current config, or empty map on error.
+	GetCurrentConfig() map[string]interface{}
+
+	// ConfigureMCPServer installs a single MCP server into the adapter config.
+	// Returns true on success.
+	ConfigureMCPServer(serverURL, serverName string, enabled bool,
+		envOverrides, serverInfoCache map[string]interface{},
+		runtimeVars map[string]string) bool
+
+	// FormatServerConfig converts registry server info to the adapter's wire format.
+	FormatServerConfig(serverInfo map[string]interface{},
+		envOverrides map[string]interface{},
+		runtimeVars map[string]string) (map[string]interface{}, error)
+
+	// TargetName returns the canonical adapter target name (e.g. "copilot", "vscode").
+	TargetName() string
+
+	// MCPServersKey returns the top-level JSON key for server entries.
+	MCPServersKey() string
+
+	// SupportsUserScope reports whether this adapter has a user/global config scope.
+	SupportsUserScope() bool
+}

internal/adapters/client/base/base.go

@@ -0,0 +1,135 @@
+package base_test
+
+import (
+"testing"
+
+"github.com/githubnext/apm/internal/adapters/client/base"
+)
+
+func TestInputVarRE(t *testing.T) {
+cases := []struct {
+input string
+match bool
+name  string
+}{
+{"${input:MY_VAR}", true, "MY_VAR"},
+{"${input:foo}", true, "foo"},
+{"${env:BAR}", false, ""},
+{"${BAR}", false, ""},
+{"no placeholder", false, ""},
+{"${input:a} and ${input:b}", true, "a"},
+}
+for _, c := range cases {
+m := base.InputVarRE.FindStringSubmatch(c.input)
+if c.match {
+if m == nil {
+t.Errorf("InputVarRE: expected match for %q", c.input)
+} else if m[1] != c.name {
+t.Errorf("InputVarRE: got name %q, want %q", m[1], c.name)
+}
+} else {
+if m != nil {
+t.Errorf("InputVarRE: expected no match for %q, got %v", c.input, m)
+}
+}
+}
+}
+
+func TestEnvVarRE(t *testing.T) {
+cases := []struct {
+input string
+match bool
+name  string
+}{
+{"${MY_VAR}", true, "MY_VAR"},
+{"${env:MY_VAR}", true, "MY_VAR"},
+{"${input:foo}", false, ""},
+{"${{ ctx.token }}", false, ""},
+{"no placeholder", false, ""},
+{"${A_1}", true, "A_1"},
+}
+for _, c := range cases {
+m := base.EnvVarRE.FindStringSubmatch(c.input)
+if c.match {
+if m == nil {
+t.Errorf("EnvVarRE: expected match for %q", c.input)
+} else if m[1] != c.name {
+t.Errorf("EnvVarRE: got name %q, want %q", m[1], c.name)
+}
+} else {
+if m != nil {
+t.Errorf("EnvVarRE: expected no match for %q, got %v", c.input, m)
+}
+}
+}
+}
+
+func TestEnvVarREAllMatches(t *testing.T) {
+input := "${FOO} and ${env:BAR} and ${input:skip}"
+matches := base.EnvVarRE.FindAllStringSubmatch(input, -1)
+if len(matches) != 2 {
+t.Fatalf("expected 2 matches, got %d", len(matches))
+}
+if matches[0][1] != "FOO" {
+t.Errorf("first match: want FOO, got %s", matches[0][1])
+}
+if matches[1][1] != "BAR" {
+t.Errorf("second match: want BAR, got %s", matches[1][1])
+}
+}
+
+func TestInputVarRE_MultipleMatches(t *testing.T) {
+input := "${input:FOO} and ${input:BAR}"
+matches := base.InputVarRE.FindAllStringSubmatch(input, -1)
+if len(matches) != 2 {
+t.Fatalf("expected 2 matches, got %d", len(matches))
+}
+if matches[0][1] != "FOO" {
+t.Errorf("first match: want FOO, got %s", matches[0][1])
+}
+if matches[1][1] != "BAR" {
+t.Errorf("second match: want BAR, got %s", matches[1][1])
+}
+}
+
+func TestInputVarRE_EnvNotMatched(t *testing.T) {
+cases := []string{"${MY_VAR}", "${env:MY_VAR}", "${{ secrets.TOKEN }}"}
+for _, c := range cases {
+if base.InputVarRE.MatchString(c) {
+t.Errorf("InputVarRE should not match %q", c)
+}
+}
+}
+
+func TestEnvVarRE_NoMatchGitHubActions(t *testing.T) {
+cases := []string{"${{ secrets.TOKEN }}", "${{ env.VAR }}", "literal"}
+for _, c := range cases {
+if base.EnvVarRE.MatchString(c) {
+t.Errorf("EnvVarRE should not match %q", c)
+}
+}
+}
+
+func TestEnvVarRE_CaseSensitive(t *testing.T) {
+// Variable names are case-sensitive in the regex
+if !base.EnvVarRE.MatchString("${MY_VAR}") {
+t.Error("expected match for ${MY_VAR}")
+}
+}
+
+func TestEnvVarRE_WithPrefix(t *testing.T) {
+m := base.EnvVarRE.FindStringSubmatch("${env:SECRET_KEY}")
+if m == nil {
+t.Fatal("expected match for ${env:SECRET_KEY}")
+}
+if m[1] != "SECRET_KEY" {
+t.Errorf("expected SECRET_KEY, got %q", m[1])
+}
+}
+
+func TestEnvVarRE_DigitStartNotMatched(t *testing.T) {
+// Variable names cannot start with a digit
+if base.EnvVarRE.MatchString("${1VAR}") {
+t.Error("EnvVarRE should not match variable starting with digit")
+}
+}

internal/adapters/client/base/base_test.go

@@ -0,0 +1,209 @@
+// Package claude implements the Claude Code MCP client adapter.
+//
+// Mirrors src/apm_cli/adapters/client/claude.py.
+//
+// Claude Code uses .mcp.json at the project root (project scope) or
+// ~/.claude.json (user scope) with top-level "mcpServers" key.
+package claude
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/githubnext/apm/internal/adapters/client/copilot"
+)
+
+// Adapter is the Claude Code MCP client adapter.
+//
+// It inherits all helper methods from the Copilot adapter but:
+//   - Does NOT support runtime env substitution (installs literal values)
+//   - Normalises entries for Claude Code's on-disk shape (strips Copilot-only fields)
+//   - Supports both project scope (.mcp.json) and user scope (~/.claude.json)
+type Adapter struct {
+	*copilot.Adapter
+}
+
+// New creates a new Claude adapter.
+func New(projectRoot string, userScope bool) *Adapter {
+	base := copilot.New(projectRoot, userScope)
+	base.SupportsRuntimeEnvSubstitution = false
+	return &Adapter{Adapter: base}
+}
+
+// TargetName returns "claude".
+func (a *Adapter) TargetName() string { return "claude" }
+
+// MCPServersKey returns "mcpServers".
+func (a *Adapter) MCPServersKey() string { return "mcpServers" }
+
+// SupportsUserScope returns true.
+func (a *Adapter) SupportsUserScope() bool { return true }
+
+// GetConfigPath returns the scope-resolved config file path.
+//
+// Project scope: <project_root>/.mcp.json
+// User scope:    ~/.claude.json
+func (a *Adapter) GetConfigPath() string {
+	if a.UserScope {
+		home, _ := os.UserHomeDir()
+		return filepath.Join(home, ".claude.json")
+	}
+	root := a.ProjectRoot
+	if root == "" {
+		var err error
+		root, err = os.Getwd()
+		if err != nil {
+			root = "."
+		}
+	}
+	return filepath.Join(root, ".mcp.json")
+}
+
+// GetCurrentConfig reads the current config from the appropriate file.
+func (a *Adapter) GetCurrentConfig() map[string]interface{} {
+	data, err := os.ReadFile(a.GetConfigPath())
+	if err != nil {
+		return map[string]interface{}{}
+	}
+	var cfg map[string]interface{}
+	if err := json.Unmarshal(data, &cfg); err != nil {
+		return map[string]interface{}{}
+	}
+	return cfg
+}
+
+// UpdateConfig merges configUpdates into the mcpServers section.
+//
+// For user scope, creates the file with 0o600 permissions on first write.
+func (a *Adapter) UpdateConfig(configUpdates map[string]interface{}) error {
+	configPath := a.GetConfigPath()
+	current := a.GetCurrentConfig()
+
+	if _, ok := current["mcpServers"]; !ok {
+		current["mcpServers"] = map[string]interface{}{}
+	}
+	servers, _ := current["mcpServers"].(map[string]interface{})
+	for k, v := range configUpdates {
+		servers[k] = v
+	}
+	current["mcpServers"] = servers
+
+	if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {
+		return err
+	}
+
+	data, err := json.MarshalIndent(current, "", "  ")
+	if err != nil {
+		return err
+	}
+
+	perm := os.FileMode(0o644)
+	if a.UserScope {
+		perm = 0o600
+	}
+	return os.WriteFile(configPath, data, perm)
+}
+
+// FormatServerConfig wraps the Copilot formatter then normalises the entry
+// for Claude Code's on-disk shape.
+func (a *Adapter) FormatServerConfig(
+	serverInfo map[string]interface{},
+	envOverrides map[string]interface{},
+	runtimeVars map[string]string,
+) (map[string]interface{}, error) {
+	raw, err := a.Adapter.FormatServerConfig(serverInfo, envOverrides, runtimeVars)
+	if err != nil {
+		return nil, err
+	}
+	return normalizeMCPEntryForClaudeCode(raw), nil
+}
+
+// normalizeMCPEntryForClaudeCode strips Copilot-only fields and emits
+// the Claude Code on-disk shape.
+//
+// For remote servers: keeps type/url/headers per Claude Code docs.
+// For stdio servers:  drops type:"local", tools, and empty id; emits type:"stdio".
+func normalizeMCPEntryForClaudeCode(entry map[string]interface{}) map[string]interface{} {
+	out := make(map[string]interface{}, len(entry))
+	for k, v := range entry {
+		out[k] = v
+	}
+
+	entryType, _ := out["type"].(string)
+
+	if entryType == "http" || entryType == "remote" {
+		// Remote: keep as-is, delete Copilot-only fields.
+		delete(out, "tools")
+		delete(out, "id")
+		return out
+	}
+
+	// stdio: normalise.
+	delete(out, "tools")
+	if id, _ := out["id"].(string); id == "" {
+		delete(out, "id")
+	}
+	delete(out, "type")
+
+	// Only emit type:stdio when command is present.
+	if cmd, _ := out["command"].(string); cmd != "" {
+		out["type"] = "stdio"
+	}
+
+	return out
+}
+
+// ConfigureMCPServer installs a single MCP server into the Claude config.
+func (a *Adapter) ConfigureMCPServer(
+	serverURL, serverName string,
+	enabled bool,
+	envOverrides map[string]interface{},
+	serverInfoCache map[string]interface{},
+	runtimeVars map[string]string,
+) bool {
+	if serverURL == "" {
+		fmt.Fprintln(os.Stderr, "[x] server_url cannot be empty")
+		return false
+	}
+
+	var serverInfo map[string]interface{}
+	if serverInfoCache != nil {
+		if v, ok := serverInfoCache[serverURL]; ok {
+			serverInfo, _ = v.(map[string]interface{})
+		}
+	}
+	if serverInfo == nil {
+		fmt.Fprintf(os.Stderr, "[x] MCP server '%s' not found in registry\n", serverURL)
+		return false
+	}
+
+	serverConfig, err := a.FormatServerConfig(serverInfo, envOverrides, runtimeVars)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "[x] Error formatting server config: %s\n", err)
+		return false
+	}
+
+	configKey := serverKeyFor(serverURL, serverName)
+	if err := a.UpdateConfig(map[string]interface{}{configKey: serverConfig}); err != nil {
+		fmt.Fprintf(os.Stderr, "[x] Error writing Claude config: %s\n", err)
+		return false
+	}
+
+	fmt.Printf("[+] Configured MCP server '%s' for Claude Code\n", configKey)
+	return true
+}
+
+// ---- helpers ----
+
+func serverKeyFor(serverURL, serverName string) string {
+	if serverName != "" {
+		return serverName
+	}
+	if idx := strings.LastIndex(serverURL, "/"); idx >= 0 {
+		return serverURL[idx+1:]
+	}
+	return serverURL
+}