feat: auto-discover MCP servers from VS Code, Claude Code, Copilot, and Gemini configs

Users who configure MCP servers in other AI tools no longer need to
manually duplicate that config. At startup, altimate-code now reads
.vscode/mcp.json, .github/copilot/mcp.json, .mcp.json, and
.gemini/settings.json, transforming their entries into native config
format at lowest priority (user config always wins).

Adds /discover-and-add-mcps command to permanently write discovered
servers into project or global config.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: kulvirgit

.opencode/command/discover-and-add-mcps.md

@@ -0,0 +1,32 @@
+---
+description: "Discover MCP servers from external AI tool configs and add them permanently"
+---
+
+Discover MCP servers configured in other AI tools (VS Code, GitHub Copilot, Claude Code, Gemini CLI) and offer to add them to the altimate-code config.
+
+## Instructions
+
+1. Look for MCP server configurations in the current project directory from these sources:
+   - `.vscode/mcp.json` (key: `servers`) — VS Code / Copilot
+   - `.github/copilot/mcp.json` (key: `mcpServers`) — GitHub Copilot
+   - `.mcp.json` (key: `mcpServers`) — Claude Code
+   - `.gemini/settings.json` (key: `mcpServers`) — Gemini CLI
+
+2. For each file found, parse it and extract server definitions. Transform them to altimate-code format:
+   - Local servers: `{ command, args?, env? }` → `{ type: "local", command: [command, ...args], environment: env }`
+   - Remote servers: `{ url }` → `{ type: "remote", url, headers }`
+
+3. Show the user what was discovered:
+   - Server name
+   - Source file it came from
+   - Command or URL
+
+4. Ask the user which servers they want to add permanently.
+
+5. Write selected servers to the project config at `.altimate-code/altimate-code.json` using the `mcp` key.
+   - If $ARGUMENTS contains `--scope global`, write to the global config at `~/.config/opencode/opencode.json` instead.
+   - If $ARGUMENTS contains `--scope project`, write to `.altimate-code/altimate-code.json` (default).
+
+6. Skip any servers that are already configured in the target config file.
+
+7. Report what was added and where.

packages/opencode/src/config/config.ts

@@ -127,6 +127,21 @@ export namespace Config {
       }
     }
 
+    // Discover MCP servers from external AI tool configs (VS Code, Claude Code, Gemini).
+    // Lowest priority — user's explicit mcp config always wins.
+    if (!Flag.OPENCODE_DISABLE_PROJECT_CONFIG) {
+      const { discoverExternalMcp } = await import("../mcp/discover")
+      const externalMcp = await discoverExternalMcp(Instance.worktree)
+      if (Object.keys(externalMcp).length > 0) {
+        result.mcp ??= {}
+        for (const [name, server] of Object.entries(externalMcp)) {
+          if (!(name in result.mcp)) {
+            result.mcp[name] = server
+          }
+        }
+      }
+    }
+
     result.agent = result.agent || {}
     result.mode = result.mode || {}
     result.plugin = result.plugin || []

packages/opencode/src/mcp/discover.ts

@@ -0,0 +1,118 @@
+import path from "path"
+import { parse as parseJsonc } from "jsonc-parser"
+import { Log } from "../util/log"
+import { Filesystem } from "../util/filesystem"
+import type { Config } from "../config/config"
+
+const log = Log.create({ service: "mcp.discover" })
+
+interface ExternalMcpSource {
+  /** Relative path from worktree root */
+  file: string
+  /** Key in the parsed JSON that holds the server map */
+  key: string
+}
+
+const SOURCES: ExternalMcpSource[] = [
+  { file: ".vscode/mcp.json", key: "servers" },
+  { file: ".github/copilot/mcp.json", key: "mcpServers" },
+  { file: ".mcp.json", key: "mcpServers" },
+  { file: ".gemini/settings.json", key: "mcpServers" },
+]
+
+/**
+ * Transform a single external MCP entry into our Config.Mcp shape.
+ * Returns undefined if the entry is invalid (no command or url).
+ */
+function transform(entry: Record<string, any>): Config.Mcp | undefined {
+  // Remote server
+  if (entry.url && typeof entry.url === "string") {
+    const result: Record<string, any> = {
+      type: "remote" as const,
+      url: entry.url,
+    }
+    if (entry.headers && typeof entry.headers === "object") {
+      result.headers = entry.headers
+    }
+    return result as Config.Mcp
+  }
+
+  // Local server
+  if (entry.command) {
+    const cmd = Array.isArray(entry.command)
+      ? entry.command.map(String)
+      : [String(entry.command), ...(Array.isArray(entry.args) ? entry.args.map(String) : [])]
+
+    const result: Record<string, any> = {
+      type: "local" as const,
+      command: cmd,
+    }
+    if (entry.env && typeof entry.env === "object") {
+      result.environment = entry.env
+    }
+    return result as Config.Mcp
+  }
+
+  return undefined
+}
+
+/**
+ * Discover MCP servers configured in external AI tool configs
+ * (VS Code, GitHub Copilot, Claude Code, Gemini CLI).
+ *
+ * Returns a Record where keys are server names and values are Config.Mcp objects.
+ * First-discovered-wins per server name across sources.
+ */
+export async function discoverExternalMcp(worktree: string): Promise<Record<string, Config.Mcp>> {
+  const result: Record<string, Config.Mcp> = {}
+  const contributingSources: string[] = []
+
+  for (const source of SOURCES) {
+    const filePath = path.join(worktree, source.file)
+
+    let text: string
+    try {
+      text = await Filesystem.readText(filePath)
+    } catch {
+      // File doesn't exist or can't be read — skip
+      continue
+    }
+
+    let parsed: any
+    try {
+      // Use JSONC parser to handle comments (common in VS Code configs)
+      parsed = parseJsonc(text)
+    } catch {
+      log.debug("failed to parse external MCP config", { file: source.file })
+      continue
+    }
+
+    if (!parsed || typeof parsed !== "object") continue
+
+    const servers = parsed[source.key]
+    if (!servers || typeof servers !== "object") continue
+
+    let added = 0
+    for (const [name, entry] of Object.entries(servers)) {
+      if (name in result) continue // first source wins
+      if (!entry || typeof entry !== "object") continue
+
+      const transformed = transform(entry as Record<string, any>)
+      if (transformed) {
+        result[name] = transformed
+        added++
+      }
+    }
+
+    if (added > 0) {
+      contributingSources.push(source.file)
+    }
+  }
+
+  if (contributingSources.length > 0) {
+    const count = Object.keys(result).length
+    log.info(`Discovered ${count} MCP server(s) from ${contributingSources.join(", ")}. Run /discover-and-add-mcps to make them permanent.`)
+  }
+
+  return result
+}