decorated-pi 0.5.4 → 0.6.0

package/{extensions/mcp/builtin.ts → tools/mcp/config.ts}

@@ -1,12 +1,22 @@
 /**
- * MCP server configuration — builtin + global + project-level.
+ * 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/decorated-pi.json` (under `mcpServers`)
+ *   - project: `<cwd>/.pi/agent/mcp.json` (under `mcpServers`)
  */
 import * as fs from "node:fs";
-import * as path from "node:path";
 import * as os from "node:os";
+import * as path from "node:path";
 import { spawnSync } from "node:child_process";
-import { loadConfig } from "../settings.js";
-import type { DependencyStatus } from "../rtk";
+import { loadConfig } from "../../settings.js";
+import type { DependencyStatus } from "../../hooks/skeleton.js";
+import { BUILTIN_MCP_SERVERS, codegraphEnabled } from "./builtin/index.js";
+
+export { BUILTIN_MCP_SERVERS } from "./builtin/index.js";
 
 export interface McpServerConfig {
   name: string;
@@ -19,22 +29,6 @@ export interface McpServerConfig {
   source: "builtin" | "global" | "project";
 }
 
-/** Builtin servers — zero-config, always available unless overridden. */
-export const BUILTIN_MCP_SERVERS: Omit<McpServerConfig, "source">[] = [
-  {
-    name: "context7",
-    url: "https://mcp.context7.com/mcp",
-    enabled: true,
-  },
-  {
-    name: "exa",
-    url: "https://mcp.exa.ai/mcp",
-    enabled: true,
-  },
-];
-
-// ── Project-level config discovery ─────────────────────────────────────────
-
 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"));
@@ -104,9 +98,14 @@ export function isSseUrl(url: string): boolean {
 export function resolveMcpConfigs(cwd: string): McpServerConfig[] {
   const byName = new Map<string, McpServerConfig>();
 
-  // Builtin (lowest priority)
+  // Builtin (lowest priority). The codegraph entry's `enabled` flag is
+  // computed at resolve time from the dp-settings module toggle.
   for (const s of BUILTIN_MCP_SERVERS) {
-    byName.set(s.name, { ...s, source: "builtin" });
+    if (s.name === "codegraph") {
+      byName.set(s.name, { ...s, enabled: codegraphEnabled(), source: "builtin" });
+    } else {
+      byName.set(s.name, { ...s, source: "builtin" });
+    }
   }
 
   // Global — preserve url/command/description from builtin if not overridden
@@ -176,100 +175,6 @@ function commandExists(command: string): boolean {
   return result.status === 0;
 }
 
-/** Write auto-generated description back to project mcp.json. */
-export function saveProjectMcpDescription(cwd: string, name: string, description: string): void {
-  const filePath = path.join(cwd, ".pi/agent/mcp.json");
-  const servers = readMcpJson(filePath);
-  if (!servers || !servers[name]) return;
-  servers[name] = { ...servers[name], description };
-  const dir = path.dirname(filePath);
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(filePath, JSON.stringify({ mcpServers: servers }, null, 2) + "\n", "utf-8");
-}
-
-// ── Metadata cache (tool descriptions + schemas) ──────────────────────────
-
-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 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;
-}
-
-/** Save cache to global or project scope. */
-export function saveMcpCache(cache: McpCache, scope: "global" | "project", cwd?: string): void {
-  const p = scope === "project" && cwd ? projectCachePath(cwd) : globalCachePath();
-  writeCacheFile(p, 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 = scope === "project" && cwd ? projectCachePath(cwd) : globalCachePath();
-  const existing = readCacheFile(p) || { servers: {} };
-  existing.servers[serverName] = entry;
-  writeCacheFile(p, existing);
-}
-
-// ── Enable / Disable helpers ────────────────────────────────────────────
-
 function readMcpJsonSafe(filePath: string): Record<string, any> | null {
   try {
     return JSON.parse(fs.readFileSync(filePath, "utf-8"));
@@ -296,7 +201,6 @@ export function toggleMcpServerEnabled(
       if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
       fs.writeFileSync(filePath, JSON.stringify(raw, null, 2) + "\n", "utf-8");
     } else {
-      const { loadConfig } = require("../settings.js");
       const config = loadConfig();
       config.mcpServers = config.mcpServers || {};
       config.mcpServers[serverName] = { ...(config.mcpServers[serverName] || {}), enabled };
@@ -310,67 +214,3 @@ export function toggleMcpServerEnabled(
     return false;
   }
 }
-
-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);
-    }
-  }
-}
-
-// ── Large result externalization ────────────────────────────────────────
-
-export const EXTERNALIZE_THRESHOLD = 50_000; // 50KB
-export const EXTERNALIZE_PREVIEW_SIZE = 2_000; // 2KB preview
-import { writeOutputToTemp } from "../io-tool-output.js";
-
-/**
- * If content exceeds threshold, save to temp file and return preview + path.
- * Otherwise return original content unchanged.
- * Falls back to returning full text if file write fails.
- */
-export function maybeExternalizeMcpResult(
-  text: string,
-  toolName: string,
-  toolCallId: string,
-): { content: Array<{ type: "text"; text: string }>; details: Record<string, unknown> } {
-  if (text.length <= EXTERNALIZE_THRESHOLD) {
-    return { content: [{ type: "text", text }], details: {} };
-  }
-
-  const filePath = writeOutputToTemp(toolName, toolCallId, text);
-  if (!filePath) {
-    return { content: [{ type: "text", text }], details: {} };
-  }
-  const preview = text.slice(0, EXTERNALIZE_PREVIEW_SIZE);
-  return {
-    content: [{ type: "text", text: `${preview}\n\n[Truncated: ${text.length.toLocaleString()} chars total. Full output saved to: ${filePath}]` }],
-    details: {
-      fullOutputPath: filePath,
-      truncation: { truncated: true, outputChars: EXTERNALIZE_PREVIEW_SIZE, totalChars: text.length, maxBytes: EXTERNALIZE_THRESHOLD },
-    },
-  };
-}

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;

package/tools/mcp/tool-definition.ts

@@ -0,0 +1,112 @@
+/**
+ * Pure MCP tool-definition helpers.
+ *
+ * No hook/module state lives here. Callers provide `findConnection`
+ * so both hooks/mcp.ts and tools/mcp/index.ts can share the same tool
+ * factory without importing each other.
+ */
+
+import { keyHint } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import type { McpConnection } from "./client.js";
+import type { McpServerConfig } from "./config.js";
+
+const MCP_RESULT_FOLD_LINES = 45;
+
+function trimTrailingEmptyLines(lines: string[]): string[] {
+  let end = lines.length;
+  while (end > 0 && lines[end - 1] === "") end -= 1;
+  return lines.slice(0, end);
+}
+
+function collapseMcpText(text: string, maxLines = MCP_RESULT_FOLD_LINES) {
+  const lines = trimTrailingEmptyLines(text.split("\n"));
+  return {
+    totalLines: lines.length,
+    displayLines: lines.slice(0, maxLines),
+    remainingLines: Math.max(0, lines.length - maxLines),
+  };
+}
+
+function getTextContent(result: { content?: Array<{ type: string; text?: string }> }): string {
+  return (result.content ?? [])
+    .filter((c): c is { type: "text"; text?: string } => c.type === "text")
+    .map((c) => c.text ?? "")
+    .join("\n");
+}
+
+function formatMcpResultText(text: string, expanded: boolean, theme: any): string {
+  const { totalLines, displayLines, remainingLines } = collapseMcpText(text, expanded ? Number.MAX_SAFE_INTEGER : MCP_RESULT_FOLD_LINES);
+  const lastLine = displayLines[displayLines.length - 1] || "";
+  let outputLines = [...displayLines];
+  let truncationMsg = "";
+  if (lastLine.startsWith("[Truncated: ") && lastLine.endsWith("]")) {
+    truncationMsg = lastLine;
+    outputLines = outputLines.slice(0, -1);
+  }
+  const outputText = outputLines.join("\n");
+  let rendered = outputText ? theme.fg("toolOutput", outputText) : "";
+  if (truncationMsg) rendered += (rendered ? "\n" : "") + theme.fg("warning", truncationMsg);
+  if (!expanded && remainingLines > 0) {
+    rendered += `${theme.fg("muted", `\n... (${remainingLines} more lines, ${totalLines} total,`)} ${keyHint("app.tools.expand", "to expand")})`;
+  }
+  return rendered;
+}
+
+function renderMcpResult(result: any, options: { expanded: boolean }, theme: any, context: any) {
+  const component = context.lastComponent ?? new Text("", 0, 0);
+  component.setText(formatMcpResultText(getTextContent(result), options.expanded, theme));
+  return component;
+}
+
+function makeToolName(serverName: string, toolName: string): string {
+  return `${serverName}_${toolName}`;
+}
+
+function makeToolLabel(serverName: string, toolName: string, desc?: string): string {
+  return `MCP ${serverName}: ${toolName}${desc ? ` (${desc.slice(0, 20)})` : ""}`;
+}
+
+export function buildMcpTool(
+  config: McpServerConfig,
+  toolEntry: { name: string; description?: string; inputSchema?: Record<string, unknown> },
+  findConnection: (serverName: string) => McpConnection | undefined,
+): {
+  name: string;
+  label: string;
+  description: string;
+  promptSnippet: string;
+  renderResult: (result: any, options: { expanded: boolean }, theme: any, context: any) => any;
+  parameters: Record<string, unknown> | undefined;
+  execute: (id: string, params: any, signal: any, update: any, ctx: any) => Promise<any>;
+} {
+  const toolName = makeToolName(config.name, toolEntry.name);
+  const desc = toolEntry.description || `${toolEntry.name} (MCP tool)`;
+  return {
+    name: toolName,
+    label: makeToolLabel(config.name, toolEntry.name, toolEntry.description),
+    description: desc,
+    promptSnippet: desc || `MCP tool ${config.name}/${toolEntry.name}`,
+    renderResult: renderMcpResult,
+    parameters: toolEntry.inputSchema,
+    execute: async (_id: string, params: any, _signal: any, _update: any, _ctx: any) => {
+      const conn = findConnection(config.name);
+      if (!conn) {
+        return {
+          content: [{ type: "text", text: `MCP server "${config.name}" is not connected. Use /reload to retry.` }],
+          isError: false,
+          details: {},
+        };
+      }
+      try {
+        const text = await conn.callTool(toolEntry.name, params ?? {});
+        return { content: [{ type: "text", text }], isError: false, details: {} };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: "text", text: `MCP tool "${toolName}" error: ${msg}` }], isError: true, details: {} };
+      }
+    },
+  };
+}
+
+export const __mcpToolDefinitionTest = { collapseMcpText, buildMcpTool };