decorated-pi 0.3.0 → 0.4.1

package/extensions/lsp/types.ts

@@ -0,0 +1,42 @@
+/**
+ * LSP type definitions — minimal set needed by this extension.
+ */
+
+export interface LspPosition {
+  line: number;
+  character: number;
+}
+
+export interface LspRange {
+  start: LspPosition;
+  end: LspPosition;
+}
+
+export interface LspLocation {
+  uri: string;
+  range: LspRange;
+}
+
+export interface LspDiagnostic {
+  range: LspRange;
+  severity?: number;
+  code?: unknown;
+  source?: string;
+  message: string;
+}
+
+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/extensions/mcp/builtin.ts

@@ -0,0 +1,126 @@
+/**
+ * MCP server configuration — builtin + global + project-level.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { loadConfig } from "../settings.js";
+
+export interface McpServerConfig {
+  name: string;
+  url: string;
+  description?: string;
+  enabled: boolean;
+  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",
+    description: "Context7 documentation and code examples",
+    enabled: true,
+  },
+  {
+    name: "exa",
+    url: "https://mcp.exa.ai/mcp",
+    description: "Exa web search",
+    enabled: true,
+  },
+];
+
+// ── Project-level config discovery ─────────────────────────────────────────
+
+const PROJECT_CONFIG_PATHS = [
+  ".pi/mcp.json",
+  ".pi/.mcp.json",
+  ".agents/mcp.json",
+  ".agents/.mcp.json",
+  ".claude/mcp.json",
+  ".claude/.mcp.json",
+  "mcp.json",
+  ".mcp.json",
+];
+
+function readMcpJson(filePath: string): Record<string, { url: string; enabled?: boolean }> | 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; enabled?: boolean }>;
+  } catch {
+    return null;
+  }
+}
+
+/** Load project-level MCP configs from cwd and its ancestor directories. */
+export function loadProjectMcpConfigs(cwd: string): McpServerConfig[] {
+  const configs: McpServerConfig[] = [];
+  const seen = new Set<string>();
+
+  let current = path.resolve(cwd);
+  while (true) {
+    for (const relative of PROJECT_CONFIG_PATHS) {
+      const filePath = path.join(current, relative);
+      if (!fs.existsSync(filePath)) continue;
+      const servers = readMcpJson(filePath);
+      if (!servers) continue;
+
+      for (const [name, entry] of Object.entries(servers)) {
+        if (seen.has(name)) continue;
+        seen.add(name);
+        configs.push({
+          name,
+          url: entry.url,
+          enabled: entry.enabled !== false,
+          source: "project",
+        });
+      }
+    }
+
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+
+  return configs;
+}
+
+/** Load global MCP configs from ~/.pi/agent/decorated-pi.json. */
+export function loadGlobalMcpConfigs(): McpServerConfig[] {
+  const config = loadConfig();
+  if (!config.mcpServers) return [];
+
+  return Object.entries(config.mcpServers).map(([name, entry]) => ({
+    name,
+    url: entry.url,
+    enabled: entry.enabled !== false,
+    source: "global" as const,
+  }));
+}
+
+/**
+ * Merge all MCP configs: builtin → global → project.
+ * Later sources override earlier ones for the same server name.
+ */
+export function resolveMcpConfigs(cwd: string): McpServerConfig[] {
+  const byName = new Map<string, McpServerConfig>();
+
+  // Builtin (lowest priority)
+  for (const s of BUILTIN_MCP_SERVERS) {
+    byName.set(s.name, { ...s, source: "builtin" });
+  }
+
+  // Global
+  for (const s of loadGlobalMcpConfigs()) {
+    byName.set(s.name, s);
+  }
+
+  // Project (highest priority)
+  for (const s of loadProjectMcpConfigs(cwd)) {
+    byName.set(s.name, s);
+  }
+
+  return [...byName.values()].filter((s) => s.enabled);
+}

package/extensions/mcp/client.ts

@@ -0,0 +1,106 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+
+export interface McpToolSpec {
+  name: string;
+  description: string;
+  inputSchema: Record<string, unknown>;
+}
+
+/** Per-server MCP client wrapper with fallback transport. */
+export class McpConnection {
+  client: Client;
+  transport: StreamableHTTPClientTransport | SSEClientTransport | undefined;
+  tools: McpToolSpec[] = [];
+  private connected = false;
+
+  source: string = "unknown";
+
+  constructor(
+    public readonly serverName: string,
+    public readonly url: string,
+  ) {
+    this.client = new Client({
+      name: `decorated-pi-${serverName}`,
+      version: "0.3.0",
+    });
+  }
+
+  async connect(timeoutMs = 8000): Promise<void> {
+    const connectWithFallback = async (): Promise<void> => {
+      let lastErr: Error | undefined;
+      try {
+        const transport = new StreamableHTTPClientTransport(new URL(this.url));
+        await this.client.connect(transport);
+        this.transport = transport;
+        this.connected = true;
+      } catch (err) {
+        lastErr = err instanceof Error ? err : new Error(String(err));
+        try {
+          const transport = new SSEClientTransport(new URL(this.url));
+          await this.client.connect(transport);
+          this.transport = transport;
+          this.connected = true;
+        } catch (sseErr) {
+          const sseMessage = sseErr instanceof Error ? sseErr.message : String(sseErr);
+          throw new Error(
+            `MCP ${this.serverName}: StreamableHTTP failed (${lastErr.message}); SSE fallback also failed (${sseMessage})`,
+          );
+        }
+      }
+
+      const result = (await this.client.listTools()) as unknown as {
+        tools: Array<{
+          name: string;
+          description?: string;
+          inputSchema?: Record<string, unknown>;
+        }>;
+      };
+
+      this.tools = (result.tools ?? []).map((t) => ({
+        name: t.name,
+        description: t.description || "",
+        inputSchema: t.inputSchema || { type: "object", properties: {} },
+      }));
+    };
+
+    const timeout = new Promise<never>((_, reject) =>
+      setTimeout(() => reject(new Error(`MCP ${this.serverName}: connection timed out after ${timeoutMs}ms`)), timeoutMs),
+    );
+
+    await Promise.race([connectWithFallback(), timeout]);
+  }
+
+  async callTool(name: string, args: Record<string, unknown>): Promise<string> {
+    if (!this.connected) {
+      throw new Error(`MCP ${this.serverName}: not connected`);
+    }
+    const result = (await this.client.callTool({
+      name,
+      arguments: args,
+    })) as unknown as {
+      content?: Array<{ type: string; text?: string }>;
+      isError?: boolean;
+    };
+
+    const text = (result.content ?? [])
+      .filter((c): c is { type: "text"; text: string } => c.type === "text" && typeof c.text === "string")
+      .map((c) => c.text)
+      .join("\n");
+
+    if (result.isError) {
+      throw new Error(text || `MCP tool "${name}" returned an error`);
+    }
+
+    return text || "(empty result)";
+  }
+
+  async disconnect(): Promise<void> {
+    if (!this.connected) return;
+    this.connected = false;
+    try {
+      await this.client.close();
+    } catch {}
+  }
+}

package/extensions/mcp/index.ts

@@ -0,0 +1,123 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { McpConnection } from "./client.js";
+import { resolveMcpConfigs } from "./builtin.js";
+
+export interface McpServerStatus {
+  name: string;
+  url: string;
+  source: string;
+  state: "connecting" | "connected" | "failed";
+  toolCount: number;
+  tools: Array<{ name: string; description: string }>;
+  error?: string;
+}
+
+let activeConnections: McpConnection[] = [];
+let allServers = new Map<string, McpServerStatus>();
+let connectPromise: Promise<void> | null = null;
+
+export function setupMcp(pi: ExtensionAPI) {
+  pi.on("session_start", (_event, ctx: ExtensionContext) => {
+    void (async () => {
+      await teardownMcp();
+
+      const configs = resolveMcpConfigs(ctx.cwd);
+      if (configs.length === 0) return;
+
+      // Initialise every target server as "connecting"
+      allServers = new Map(
+        configs.map((s) => [
+          s.name,
+          {
+            name: s.name,
+            url: s.url,
+            source: s.source,
+            state: "connecting" as const,
+            toolCount: 0,
+            tools: [],
+          },
+        ]),
+      );
+
+      connectPromise = Promise.all(
+        configs.map(async (server) => {
+          const conn = new McpConnection(server.name, server.url);
+          conn.source = server.source;
+
+          try {
+            await conn.connect();
+            activeConnections.push(conn);
+
+            for (const tool of conn.tools) {
+              const prefixedName = `${server.name}_${tool.name}`;
+              pi.registerTool({
+                name: prefixedName,
+                label: `MCP: ${tool.name}`,
+                description: tool.description,
+                promptSnippet: tool.description.slice(0, 120),
+                parameters: Type.Unsafe(tool.inputSchema as never),
+                execute: async (_toolCallId, params, _signal, _onUpdate, _ctx2) => {
+                  const text = await conn.callTool(
+                    tool.name,
+                    params as Record<string, unknown>,
+                  );
+                  return {
+                    content: [{ type: "text" as const, text }],
+                    isError: false,
+                    details: { server: server.name, tool: tool.name },
+                  };
+                },
+              });
+            }
+
+            allServers.set(server.name, {
+              name: server.name,
+              url: server.url,
+              source: server.source,
+              state: "connected",
+              toolCount: conn.tools.length,
+              tools: conn.tools.map((t) => ({ name: t.name, description: t.description })),
+            });
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            allServers.set(server.name, {
+              name: server.name,
+              url: server.url,
+              source: server.source,
+              state: "failed",
+              toolCount: 0,
+              tools: [],
+              error: msg,
+            });
+          }
+        }),
+      ).then(() => undefined);
+
+      await connectPromise;
+      connectPromise = null;
+    })();
+  });
+
+  pi.on("session_shutdown", () => {
+    void teardownMcp();
+  });
+}
+
+export function getMcpStatus(): McpServerStatus[] {
+  return [...allServers.values()];
+}
+
+async function teardownMcp(): Promise<void> {
+  await Promise.all(
+    activeConnections.map(async (conn) => {
+      try {
+        await conn.disconnect();
+      } catch {
+        // Silently ignore disconnect errors.
+      }
+    }),
+  );
+  activeConnections = [];
+  allServers = new Map();
+}