decorated-pi 0.5.5 → 0.7.0

package/{extensions → tools}/lsp/tools.ts

@@ -4,7 +4,7 @@
 import { keyHint, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
-import { LspServerManager, LspToolError, formatToolError } from "./manager.js";
+import { LspServerManager, formatToolError } from "./manager.js";
 
 // ─── TUI rendering ─────────────────────────────────────────────────────────
 
@@ -53,24 +53,6 @@ function err(details: any): ToolResult {
   return ok(formatToolError(details), { ok: false, error: details });
 }
 
-async function withFile(
-  manager: LspServerManager,
-  file: string,
-  fn: (s: { abs: string; uri: string; state: any }) => Promise<string>,
-  options: { timeoutMs?: number } = {},
-): Promise<ToolResult> {
-  const resolved = await manager.resolveFileState(file, { timeoutMs: options.timeoutMs });
-  if (!resolved.ok) return err(resolved.error);
-  const { result } = resolved;
-  try {
-    const text = await fn(result);
-    return ok(text, { ok: true, language: result.state.language, workspace_root: result.state.workspaceRoot });
-  } catch (error) {
-    if (error instanceof LspToolError) return err(error.details);
-    return err({ kind: "tool_execution_failed", file: result.abs, language: result.state.language, workspace_root: result.state.workspaceRoot, command: result.state.command, install_hint: result.state.installHint, message: error instanceof Error ? error.message : String(error) });
-  }
-}
-
 function withTimeout(promise: Promise<ToolResult>, ms: number, label: string): Promise<ToolResult> {
   return Promise.race([
     promise,
@@ -84,25 +66,6 @@ function severityLabel(s: number): string {
   return s === 1 ? "error" : s === 2 ? "warning" : s === 3 ? "info" : "hint";
 }
 
-function symbolKindLabel(kind: number): string {
-  const labels: Record<number, string> = { 2:"module",3:"namespace",5:"class",6:"method",7:"property",8:"field",9:"constructor",11:"interface",12:"function",13:"variable",14:"constant",23:"struct",24:"event" };
-  return labels[kind] ?? "symbol";
-}
-
-function formatDocumentSymbols(file: string, symbols: any[]): string {
-  if (symbols.length === 0) return `${file}: no symbols`;
-  const lines = [`${file}: ${symbols.length} top-level symbol(s)`];
-  const append = (syms: any[], depth: number) => {
-    for (const s of syms) {
-      const detail = s.detail ? ` — ${s.detail}` : "";
-      lines.push(`${"  ".repeat(depth)}${symbolKindLabel(s.kind)} ${s.name}${detail} @ ${s.range.start.line + 1}:${s.range.start.character + 1}`);
-      if (s.children?.length) append(s.children, depth + 1);
-    }
-  };
-  append(symbols, 1);
-  return lines.join("\n");
-}
-
 // ─── Register tools ───────────────────────────────────────────────────────
 
 export function registerLspTools(pi: ExtensionAPI, manager: LspServerManager) {
@@ -156,34 +119,6 @@ export function registerLspTools(pi: ExtensionAPI, manager: LspServerManager) {
       })(), totalTimeout, "LSP diagnostics");
     },
   });
-
-  // ── lsp_document_symbols ───────────────────────────────────────────────
-  pi.registerTool({
-    name: "lsp_document_symbols",
-    label: "LSP: document symbols",
-    description: "List symbols in a file (functions, classes, variables) using the language server.",
-    promptSnippet: "List functions, classes, and variables in a file",
-    promptGuidelines: [
-      "Prefer lsp_document_symbols to find functions, classes, or variables in code instead of grep.",
-      "Supported languages: typescript, c, cpp, python, rust, go, ruby, java, lua, svelte.",
-    ],
-    renderResult: renderLspResult,
-    parameters: Type.Object({
-      path: Type.String({ description: "Path to the file (relative or absolute)." }),
-      timeout_ms: Type.Optional(Type.Number({ description: "Overall max ms including server startup. Default 10000." })),
-    }),
-    execute: async (_id, params, _signal, _update, _ctx): Promise<ToolResult> => {
-      const timeoutMs = params.timeout_ms ?? 10_000;
-      return withTimeout(
-        withFile(manager, params.path, async (result) => {
-          const symbols = await result.state.client.documentSymbols(result.uri, timeoutMs);
-          return formatDocumentSymbols(result.abs, symbols);
-        }, { timeoutMs }),
-        timeoutMs,
-        "LSP document symbols",
-      );
-    },
-  });
 }
 
 // ─── Formatting ────────────────────────────────────────────────────────────

package/{extensions → tools}/lsp/types.ts

@@ -29,14 +29,3 @@ export interface LspHover {
   contents: unknown;
   range?: LspRange;
 }
-
-export interface LspDocumentSymbol {
-  name: string;
-  kind: number;
-  range: LspRange;
-  selectionRange?: LspRange;
-  containerName?: string;
-  detail?: string;
-  children?: LspDocumentSymbol[];
-  uri?: string;
-}

package/tools/mcp/builtin/codegraph.ts

@@ -0,0 +1,21 @@
+/**
+ * codegraph builtin MCP server — config + project artefact check.
+ *
+ * Enabled state is controlled like any other MCP server: through the
+ * MCP config (global `~/.pi/agent/mcp.json` under `mcpServers`, or
+ * project `.pi/agent/mcp.json`) or via the `/mcp` command. There is no
+ * separate /dp-settings toggle; codegraph is just one MCP server.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { McpServerConfig } from "../config.js";
+
+export const CODEGRAPH_BUILTIN: Omit<McpServerConfig, "source"> = {
+    name: "codegraph",
+    command: "codegraph",
+    args: ["serve", "--mcp"],
+    enabled: false,
+    description:
+        "Local code knowledge graph (colbymchenry/codegraph). Enable via /mcp.",
+    canUseInProject: (cwd: string) => fs.existsSync(path.join(cwd, ".codegraph")),
+};

package/tools/mcp/builtin/context7.ts

@@ -0,0 +1,10 @@
+/**
+ * context7 builtin MCP server definition.
+ */
+import type { McpServerConfig } from "../config.js";
+
+export const CONTEXT7_BUILTIN: Omit<McpServerConfig, "source"> = {
+  name: "context7",
+  url: "https://mcp.context7.com/mcp",
+  enabled: true,
+};

package/tools/mcp/builtin/exa.ts

@@ -0,0 +1,10 @@
+/**
+ * exa builtin MCP server definition.
+ */
+import type { McpServerConfig } from "../config.js";
+
+export const EXA_BUILTIN: Omit<McpServerConfig, "source"> = {
+  name: "exa",
+  url: "https://mcp.exa.ai/mcp",
+  enabled: true,
+};

package/tools/mcp/builtin/index.ts

@@ -0,0 +1,19 @@
+/**
+ * Builtin MCP servers — aggregate. Each server has its own file; this
+ * module re-exports them and the all-server list.
+ */
+import type { McpServerConfig } from "../config.js";
+import { CONTEXT7_BUILTIN } from "./context7.js";
+import { EXA_BUILTIN } from "./exa.js";
+import { CODEGRAPH_BUILTIN } from "./codegraph.js";
+
+export { CONTEXT7_BUILTIN } from "./context7.js";
+export { EXA_BUILTIN } from "./exa.js";
+export { CODEGRAPH_BUILTIN } from "./codegraph.js";
+
+/** All builtin servers — flat list for `resolveMcpConfigs` to merge. */
+export const BUILTIN_MCP_SERVERS: Omit<McpServerConfig, "source">[] = [
+  CONTEXT7_BUILTIN,
+  EXA_BUILTIN,
+  CODEGRAPH_BUILTIN,
+];

package/tools/mcp/cache.ts

@@ -0,0 +1,124 @@
+/**
+ * MCP server metadata cache — persisted tool descriptions and schemas.
+ * Stored at `~/.pi/agent/mcp-cache.json` (global) and `<cwd>/.pi/agent/mcp-cache.json` (project).
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import type { McpServerConfig } from "./config.js";
+
+export interface McpToolCache {
+  name: string;
+  description?: string;
+  inputSchema: Record<string, unknown>;
+}
+
+export interface McpServerCache {
+  description?: string;
+  tools: McpToolCache[];
+  cachedAt: number;
+}
+
+export interface McpCache {
+  servers: Record<string, McpServerCache>;
+}
+
+function globalCachePath(): string {
+  return path.join(os.homedir(), ".pi/agent/mcp-cache.json");
+}
+
+function projectCachePath(cwd: string): string {
+  return path.join(cwd, ".pi/agent/mcp-cache.json");
+}
+
+function scopedCachePath(scope: "global" | "project", cwd?: string): string {
+  return scope === "project" && cwd ? projectCachePath(cwd) : globalCachePath();
+}
+
+function readCacheFile(p: string): McpCache | null {
+  try {
+    if (!fs.existsSync(p)) return null;
+    return JSON.parse(fs.readFileSync(p, "utf-8")) as McpCache;
+  } catch {
+    return null;
+  }
+}
+
+function writeCacheFile(p: string, cache: McpCache): void {
+  const dir = path.dirname(p);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  const tmp = `${p}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(cache, null, 2), "utf-8");
+  fs.renameSync(tmp, p);
+}
+
+/** Load merged cache: global + project. */
+export function loadMcpCache(cwd?: string): McpCache | null {
+  const merged: McpCache = { servers: {} };
+
+  const globalCache = readCacheFile(globalCachePath());
+  if (globalCache) {
+    merged.servers = { ...merged.servers, ...globalCache.servers };
+  }
+
+  if (cwd) {
+    const projectCache = readCacheFile(projectCachePath(cwd));
+    if (projectCache) {
+      merged.servers = { ...merged.servers, ...projectCache.servers };
+    }
+  }
+
+  return merged;
+}
+
+export function loadScopedMcpCache(scope: "global" | "project", cwd?: string): McpCache | null {
+  return readCacheFile(scopedCachePath(scope, cwd));
+}
+
+/** Save cache to global or project scope. */
+export function saveMcpCache(cache: McpCache, scope: "global" | "project", cwd?: string): void {
+  writeCacheFile(scopedCachePath(scope, cwd), cache);
+}
+
+/** Update a single server's entry in the appropriate cache. */
+export function updateServerCache(
+  serverName: string,
+  entry: McpServerCache,
+  scope: "global" | "project",
+  cwd?: string,
+): void {
+  const p = scopedCachePath(scope, cwd);
+  const existing = readCacheFile(p) || { servers: {} };
+  existing.servers[serverName] = entry;
+  writeCacheFile(p, existing);
+}
+
+function cleanupOneCache(p: string, names: Set<string>): void {
+  const cache = readCacheFile(p);
+  if (!cache) return;
+  let changed = false;
+  for (const name of Object.keys(cache.servers)) {
+    if (!names.has(name)) {
+      delete cache.servers[name];
+      changed = true;
+    }
+  }
+  if (changed) writeCacheFile(p, cache);
+}
+
+export function cleanupStaleCache(configs: McpServerConfig[], cwd?: string): void {
+  const names = new Set(configs.map(c => c.name));
+  cleanupOneCache(globalCachePath(), names);
+  if (cwd) {
+    const projectCache = projectCachePath(cwd);
+    const projectMcpJson = path.join(cwd, ".pi/agent/mcp.json");
+    // If project mcp.json doesn't exist, remove project cache entirely
+    if (!fs.existsSync(projectMcpJson)) {
+      if (fs.existsSync(projectCache)) {
+        fs.unlinkSync(projectCache);
+      }
+    } else {
+      cleanupOneCache(projectCache, names);
+    }
+  }
+}

package/{extensions → tools}/mcp/client.ts

@@ -2,8 +2,8 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import type { McpServerConfig } from "./builtin.js";
-import { isSseUrl } from "./builtin.js";
+import type { McpServerConfig } from "./config.js";
+import { isSseUrl } from "./config.js";
 
 export interface McpToolSpec {
   name: string;

package/tools/mcp/config.ts

@@ -0,0 +1,288 @@
+/**
+ * MCP server configuration — type, discovery, resolution, toggle.
+ *
+ * Sources (in priority order): builtin → global → project. The first
+ * hit sets defaults; later sources can override specific fields.
+ *
+ * Persistence locations:
+ *   - global: `~/.pi/agent/mcp.json` (under `mcpServers`)
+ *   - project: `<cwd>/.pi/agent/mcp.json` (under `mcpServers`)
+ *
+ * Legacy: global MCP servers used to live in `~/.pi/agent/decorated-pi.json`
+ * under `mcpServers`. `loadGlobalMcpConfigs()` automatically migrates that
+ * data to `~/.pi/agent/mcp.json` on first read.
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { spawnSync } from "node:child_process";
+import { isModuleEnabled } from "../../settings.js";
+import type { DependencyStatus } from "../../hooks/skeleton.js";
+import { BUILTIN_MCP_SERVERS } from "./builtin/index.js";
+
+export { BUILTIN_MCP_SERVERS } from "./builtin/index.js";
+
+export interface McpServerConfig {
+  name: string;
+  url?: string;
+  command?: string;
+  args?: string[];
+  env?: Record<string, string>;
+  description?: string;
+  enabled: boolean;
+  source: "builtin" | "global" | "project";
+  /** Optional predicate: return false if this server cannot be used in the given project. */
+  canUseInProject?: (cwd: string) => boolean;
+}
+
+function globalMcpJsonPath(): string {
+  return path.join(os.homedir(), ".pi", "agent", "mcp.json");
+}
+
+function readMcpJson(filePath: string): Record<string, { url?: string; command?: string; args?: string[]; env?: Record<string, string>; enabled?: boolean; description?: string }> | null {
+  try {
+    const raw = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+    const servers = raw.mcpServers ?? raw["mcp-servers"];
+    if (!servers || typeof servers !== "object" || Array.isArray(servers)) return null;
+    return servers as Record<string, { url?: string; command?: string; args?: string[]; env?: Record<string, string>; enabled?: boolean }>;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * One-time migration: older versions stored global MCP servers in
+ * `~/.pi/agent/decorated-pi.json` under `mcpServers`. Move that data to
+ * the dedicated `~/.pi/agent/mcp.json` file so global and project configs
+ * are symmetric.
+ *
+ * Rules:
+ *   - Only runs when the legacy file has at least one `mcpServers` entry.
+ *   - For each legacy server name, if `mcp.json` already has an entry with
+ *     the same name, the legacy entry is skipped (new file wins).
+ *   - Idempotent: after running once, the legacy file no longer has
+ *     `mcpServers`, so a second call is a no-op.
+ */
+export function migrateLegacyGlobalMcpConfig(): void {
+  const legacyPath = path.join(os.homedir(), ".pi", "agent", "decorated-pi.json");
+  const newPath = globalMcpJsonPath();
+
+  let legacy: Record<string, any> | null = null;
+  try {
+    legacy = JSON.parse(fs.readFileSync(legacyPath, "utf-8"));
+  } catch {
+    return;
+  }
+  if (!legacy || !legacy.mcpServers || typeof legacy.mcpServers !== "object") return;
+  if (Object.keys(legacy.mcpServers).length === 0) return;
+
+  // Load existing new file (if any). If it is corrupt, leave everything
+  // alone — safer than clobbering.
+  let newConfig: Record<string, any> = { mcpServers: {} };
+  if (fs.existsSync(newPath)) {
+    try {
+      const parsed = JSON.parse(fs.readFileSync(newPath, "utf-8"));
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        newConfig = parsed;
+        if (!newConfig.mcpServers || typeof newConfig.mcpServers !== "object") {
+          newConfig.mcpServers = {};
+        }
+      }
+    } catch {
+      return;
+    }
+  }
+
+  // Merge: only add legacy entries that don't already exist in the new file.
+  for (const [name, entry] of Object.entries(legacy.mcpServers)) {
+    if (!(name in newConfig.mcpServers)) {
+      newConfig.mcpServers[name] = entry;
+    }
+  }
+
+  const dir = path.dirname(newPath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(newPath, JSON.stringify(newConfig, null, 2) + "\n", "utf-8");
+
+  delete legacy.mcpServers;
+  fs.writeFileSync(legacyPath, JSON.stringify(legacy, null, 2) + "\n", "utf-8");
+}
+
+/** Load project-level MCP configs from cwd only. */
+export function loadProjectMcpConfigs(cwd: string): McpServerConfig[] {
+  const configs: McpServerConfig[] = [];
+  const seen = new Set<string>();
+
+  const filePath = path.join(cwd, ".pi/agent/mcp.json");
+  if (!fs.existsSync(filePath)) return [];
+  const servers = readMcpJson(filePath);
+  if (!servers) return [];
+
+  for (const [name, entry] of Object.entries(servers)) {
+    if (seen.has(name)) continue;
+    seen.add(name);
+    configs.push({
+      name,
+      url: entry.url,
+      command: entry.command,
+      args: entry.args,
+      env: entry.env,
+      enabled: entry.enabled !== false,
+      description: entry.description,
+      source: "project",
+    });
+  }
+
+  return configs;
+}
+
+/** Load global MCP configs from ~/.pi/agent/mcp.json. */
+export function loadGlobalMcpConfigs(): McpServerConfig[] {
+  const servers = readMcpJson(globalMcpJsonPath());
+  if (!servers) return [];
+
+  return Object.entries(servers).map(([name, entry]) => ({
+    name,
+    url: entry.url,
+    command: entry.command,
+    args: entry.args,
+    env: entry.env,
+    description: entry.description,
+    enabled: entry.enabled !== false,
+    source: "global" as const,
+  }));
+}
+
+/** Returns true if the URL should use SSE transport (path ends with /sse). */
+export function isSseUrl(url: string): boolean {
+  return url.endsWith("/sse") || url.endsWith("/sse/");
+}
+
+/**
+ * Merge all MCP configs: builtin → global → project.
+ * Later sources override earlier ones for the same server name.
+ */
+export function resolveMcpConfigs(cwd: string): McpServerConfig[] {
+  // The mcp module switch is the master switch. When it is off, no MCP
+  // server config is considered active — this keeps the chain simple:
+  // mcp off → all servers off → no codegraph guidance.
+  if (!isModuleEnabled("mcp")) return [];
+
+  const byName = new Map<string, McpServerConfig>();
+
+  // Builtin (lowest priority). Use the builtin's own `enabled` default.
+  // Servers can be enabled via the `/mcp` command or by editing mcp.json.
+  for (const s of BUILTIN_MCP_SERVERS) {
+    byName.set(s.name, { ...s, source: "builtin" });
+  }
+
+  // Global — preserve url/command/description from builtin if not overridden
+  for (const s of loadGlobalMcpConfigs()) {
+    const existing = byName.get(s.name);
+    if (existing) {
+      byName.set(s.name, {
+        ...existing,
+        ...s,
+        url: s.url ?? existing.url,
+        command: s.command ?? existing.command,
+        args: s.args ?? existing.args,
+        env: s.env ?? existing.env,
+        description: s.description ?? existing.description,
+        source: "global",
+        canUseInProject: s.canUseInProject ?? existing.canUseInProject,
+      });
+    } else {
+      byName.set(s.name, s);
+    }
+  }
+
+  // Project (highest priority) — same preservation logic
+  for (const s of loadProjectMcpConfigs(cwd)) {
+    const existing = byName.get(s.name);
+    if (existing) {
+      byName.set(s.name, {
+        ...existing,
+        ...s,
+        url: s.url ?? existing.url,
+        command: s.command ?? existing.command,
+        args: s.args ?? existing.args,
+        env: s.env ?? existing.env,
+        description: s.description ?? existing.description,
+        source: "project",
+        canUseInProject: s.canUseInProject ?? existing.canUseInProject,
+      });
+    } else {
+      byName.set(s.name, s);
+    }
+  }
+
+  return [...byName.values()].filter((s) => s.url || s.command);
+}
+
+export function collectMcpDependencyStatuses(cwd: string): DependencyStatus[] {
+  const seen = new Set<string>();
+  const statuses: DependencyStatus[] = [];
+  for (const cfg of resolveMcpConfigs(cwd)) {
+    if (!cfg.enabled || !cfg.command || seen.has(cfg.command)) continue;
+    seen.add(cfg.command);
+    statuses.push({
+      module: `mcp:${cfg.name}`,
+      label: cfg.command,
+      state: commandExists(cfg.command) ? "ok" : "missing",
+      detail: `Install the MCP server command for \"${cfg.name}\" or update its config.`,
+    });
+  }
+  return statuses;
+}
+
+function commandExists(command: string): boolean {
+  if (path.isAbsolute(command) || command.includes("/") || command.includes("\\")) {
+    return fs.existsSync(command);
+  }
+  const result = process.platform === "win32"
+    ? spawnSync("where", [command], { encoding: "utf-8" })
+    : spawnSync(process.env.SHELL || "sh", ["-lc", `command -v '${command.replace(/'/g, `'"'"'`)}'`], { encoding: "utf-8" });
+  return result.status === 0;
+}
+
+function readMcpJsonSafe(filePath: string): Record<string, any> | null {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+/** Toggle a server's enabled state in the appropriate config file. */
+export function toggleMcpServerEnabled(
+  serverName: string,
+  enabled: boolean,
+  scope: "global" | "project",
+  cwd?: string,
+): boolean {
+  try {
+    if (scope === "project" && cwd) {
+      const filePath = path.join(cwd, ".pi/agent/mcp.json");
+      const raw = readMcpJsonSafe(filePath) || { mcpServers: {} };
+      const servers = raw.mcpServers ?? {};
+      servers[serverName] = { ...(servers[serverName] || {}), enabled };
+      raw.mcpServers = servers;
+      const dir = path.dirname(filePath);
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(filePath, JSON.stringify(raw, null, 2) + "\n", "utf-8");
+    } else {
+      const filePath = globalMcpJsonPath();
+      const raw = readMcpJsonSafe(filePath) || { mcpServers: {} };
+      const servers = raw.mcpServers ?? {};
+      servers[serverName] = { ...(servers[serverName] || {}), enabled };
+      raw.mcpServers = servers;
+      const dir = path.dirname(filePath);
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(filePath, JSON.stringify(raw, null, 2) + "\n", "utf-8");
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}

package/tools/mcp/index.ts

@@ -0,0 +1,44 @@
+/**
+ * mcp tool registration — reads cache, registers tools dynamically.
+ * Connection lifecycle is in hooks/mcp.ts.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { loadMcpCache, type McpCache } from "./cache.js";
+import { resolveMcpConfigs, type McpServerConfig } from "./config.js";
+import { buildMcpTool, __mcpToolDefinitionTest } from "./tool-definition.js";
+import { getActiveMcpConnections } from "../../hooks/mcp.js";
+
+export function registerMcpToolsFromCache(pi: ExtensionAPI, cache: McpCache, configs: McpServerConfig[]): void {
+  for (const config of configs) {
+    if (!config.enabled) continue;
+    const entry = cache.servers[config.name];
+    if (!entry || entry.tools.length === 0) continue;
+    for (const t of entry.tools) {
+      try {
+        pi.registerTool(buildMcpTool(config, t, (name) => getActiveMcpConnections().find(c => c.serverName === name)) as any);
+      } catch {
+        // pi-core may throw on duplicate name (e.g. on /reload when the
+        // same tool is re-registered). The previous registration is
+        // still in effect, so silently ignore.
+      }
+    }
+  }
+}
+
+export function registerMcpTools(pi: ExtensionAPI, cwd: string): void {
+  const cache = loadMcpCache(cwd);
+  if (!cache) return;
+  const configs = resolveMcpConfigs(cwd).filter(s => s.enabled);
+  registerMcpToolsFromCache(pi, cache, configs);
+}
+
+// Re-exports
+export { McpConnection } from "./client.js";
+export { buildMcpTool } from "./tool-definition.js";
+export { getActiveMcpConnections, getCachedMcpConfigs, getMcpStatus, updateConfigEnabled, refreshServerCache } from "../../hooks/mcp.js";
+export type { McpServerConfig } from "./config.js";
+export type { McpCache } from "./cache.js";
+
+// Test exports
+export const __mcpIndexTest = __mcpToolDefinitionTest;