@sammorrowdrums/mcpi-ext 0.2.0 → 0.2.1

package/src/docker-e2e.ts

@@ -1,277 +0,0 @@
-import { spawn } from "node:child_process";
-import type {
-  AgentToolResult,
-  AgentToolUpdateCallback,
-  ExtensionContext,
-} from "@sammorrowdrums/mcpi";
-import { Type, type Static } from "typebox";
-
-const DOCKER_IMAGE = "mcpi-ext-e2e";
-
-const DockerE2EParams = Type.Object({
-  task: Type.String({ description: "The task/prompt to run inside the sandbox" }),
-  token: Type.String({
-    description: "GitHub token for Copilot model access",
-  }),
-  model: Type.Optional(
-    Type.String({
-      description: "Model to use (e.g. claude-sonnet-4-5). Defaults to the provider default.",
-    }),
-  ),
-  timeout: Type.Optional(
-    Type.Number({
-      description: "Timeout in seconds. Defaults to 300 (5 minutes).",
-    }),
-  ),
-});
-
-type DockerE2EInput = Static<typeof DockerE2EParams>;
-
-interface RunLogEntry {
-  type: string;
-  timestamp: number;
-  raw: string;
-}
-
-export interface DockerE2EDetails {
-  exitCode: number | null;
-  log: RunLogEntry[];
-  duration: number;
-  model?: string;
-  usage?: {
-    input: number;
-    output: number;
-    cacheRead: number;
-    cacheWrite: number;
-    cost: number;
-    turns: number;
-  };
-}
-
-export function parseJsonlLine(line: string): RunLogEntry | null {
-  const trimmed = line.trim();
-  if (!trimmed) return null;
-  try {
-    const parsed = JSON.parse(trimmed);
-    return { type: parsed.type ?? "unknown", timestamp: Date.now(), raw: trimmed };
-  } catch {
-    return { type: "raw", timestamp: Date.now(), raw: trimmed };
-  }
-}
-
-export function extractAssistantText(log: RunLogEntry[]): string {
-  const parts: string[] = [];
-  for (const entry of log) {
-    if (entry.type !== "message_end") continue;
-    try {
-      const event = JSON.parse(entry.raw);
-      const msg = event.message;
-      if (msg?.role !== "assistant") continue;
-      for (const part of msg.content ?? []) {
-        if (part.type === "text") parts.push(part.text);
-      }
-    } catch {
-      // skip malformed
-    }
-  }
-  return parts.join("\n");
-}
-
-export function extractUsage(log: RunLogEntry[]) {
-  const usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
-  for (const entry of log) {
-    if (entry.type !== "message_end") continue;
-    try {
-      const event = JSON.parse(entry.raw);
-      const msg = event.message;
-      if (msg?.role !== "assistant") continue;
-      usage.turns++;
-      const u = msg.usage;
-      if (u) {
-        usage.input += u.input ?? 0;
-        usage.output += u.output ?? 0;
-        usage.cacheRead += u.cacheRead ?? 0;
-        usage.cacheWrite += u.cacheWrite ?? 0;
-        usage.cost += u.cost?.total ?? 0;
-      }
-    } catch {
-      // skip
-    }
-  }
-  return usage;
-}
-
-export function extractModel(log: RunLogEntry[]): string | undefined {
-  for (const entry of log) {
-    if (entry.type !== "message_end") continue;
-    try {
-      const event = JSON.parse(entry.raw);
-      if (event.message?.model) return event.message.model as string;
-    } catch {
-      // skip
-    }
-  }
-  return undefined;
-}
-
-export function buildDockerArgs(image: string, params: DockerE2EInput): string[] {
-  const args = ["run", "--rm", "-e", `GITHUB_TOKEN=${params.token}`];
-
-  if (params.model) {
-    args.push("-e", `PI_MODEL=${params.model}`);
-  }
-
-  args.push(image, params.task);
-  return args;
-}
-
-export const dockerE2ETool = {
-  name: "docker_e2e",
-  label: "Docker E2E",
-  description:
-    "Run a task end-to-end inside an isolated Docker container with pi and this project's extensions. Returns the full run log for evaluation.",
-  promptSnippet: "Run an isolated e2e task in Docker. Requires a GitHub token and task prompt.",
-  parameters: DockerE2EParams,
-
-  async execute(
-    _toolCallId: string,
-    params: DockerE2EInput,
-    signal: AbortSignal | undefined,
-    onUpdate: AgentToolUpdateCallback<DockerE2EDetails> | undefined,
-    _ctx: ExtensionContext,
-  ): Promise<AgentToolResult<DockerE2EDetails>> {
-    const startTime = Date.now();
-    const timeoutMs = (params.timeout ?? 300) * 1000;
-    const log: RunLogEntry[] = [];
-    let lastAssistantText = "";
-
-    const dockerArgs = buildDockerArgs(DOCKER_IMAGE, params);
-
-    const exitCode = await new Promise<number | null>((resolve) => {
-      const proc = spawn("docker", dockerArgs, {
-        stdio: ["ignore", "pipe", "pipe"],
-      });
-
-      let buffer = "";
-      let timedOut = false;
-      let timeoutHandle: NodeJS.Timeout | undefined;
-
-      if (timeoutMs > 0) {
-        timeoutHandle = setTimeout(() => {
-          timedOut = true;
-          proc.kill("SIGTERM");
-          setTimeout(() => {
-            if (!proc.killed) proc.kill("SIGKILL");
-          }, 5000);
-        }, timeoutMs);
-      }
-
-      const processLine = (line: string) => {
-        const entry = parseJsonlLine(line);
-        if (!entry) return;
-        log.push(entry);
-
-        if (entry.type === "message_end") {
-          const text = extractAssistantText(log);
-          if (text) lastAssistantText = text;
-        }
-
-        onUpdate?.({
-          content: [
-            {
-              type: "text",
-              text: lastAssistantText || `(running… ${log.length} events)`,
-            },
-          ],
-          details: {
-            exitCode: null,
-            log,
-            duration: Date.now() - startTime,
-            model: extractModel(log),
-            usage: extractUsage(log),
-          },
-        });
-      };
-
-      proc.stdout.on("data", (data: Buffer) => {
-        buffer += data.toString();
-        const lines = buffer.split("\n");
-        buffer = lines.pop() ?? "";
-        for (const line of lines) processLine(line);
-      });
-
-      proc.stderr.on("data", (data: Buffer) => {
-        const text = data.toString().trim();
-        if (text) {
-          log.push({ type: "stderr", timestamp: Date.now(), raw: text });
-        }
-      });
-
-      proc.on("close", (code) => {
-        if (timeoutHandle) clearTimeout(timeoutHandle);
-        if (buffer.trim()) processLine(buffer);
-        if (timedOut) {
-          log.push({
-            type: "timeout",
-            timestamp: Date.now(),
-            raw: `Timed out after ${params.timeout ?? 300}s`,
-          });
-        }
-        resolve(timedOut ? null : (code ?? 1));
-      });
-
-      proc.on("error", (err) => {
-        if (timeoutHandle) clearTimeout(timeoutHandle);
-        log.push({
-          type: "error",
-          timestamp: Date.now(),
-          raw: err.message,
-        });
-        resolve(null);
-      });
-
-      if (signal) {
-        const onAbort = () => {
-          proc.kill("SIGTERM");
-          setTimeout(() => {
-            if (!proc.killed) proc.kill("SIGKILL");
-          }, 5000);
-        };
-        if (signal.aborted) onAbort();
-        else signal.addEventListener("abort", onAbort, { once: true });
-      }
-    });
-
-    const duration = Date.now() - startTime;
-    const assistantText = extractAssistantText(log);
-    const usage = extractUsage(log);
-    const model = extractModel(log);
-    const fullLog = log.map((e) => e.raw).join("\n");
-
-    const summary = [
-      `## Docker E2E Run Complete`,
-      ``,
-      `**Exit code:** ${exitCode ?? "killed"}`,
-      `**Duration:** ${(duration / 1000).toFixed(1)}s`,
-      model ? `**Model:** ${model}` : null,
-      usage.turns > 0
-        ? `**Usage:** ${usage.turns} turns, ↑${usage.input} ↓${usage.output} tokens, $${usage.cost.toFixed(4)}`
-        : null,
-      ``,
-      `### Output`,
-      assistantText || "(no assistant output)",
-      ``,
-      `### Full Log (${log.length} events)`,
-      "```",
-      fullLog,
-      "```",
-    ]
-      .filter((l) => l !== null)
-      .join("\n");
-
-    return {
-      content: [{ type: "text", text: summary }],
-      details: { exitCode, log, duration, model, usage },
-    };
-  },
-};

package/src/index.test.ts

@@ -1,8 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-describe("mcpi-ext", () => {
-  it("exports a default function", async () => {
-    const mod = await import("./index.js");
-    expect(typeof mod.default).toBe("function");
-  });
-});

package/src/index.ts

@@ -1,179 +0,0 @@
-import type {
-  BeforeAgentStartEvent,
-  ExtensionAPI,
-  ExtensionContext,
-  SessionStartEvent,
-  ToolCallEvent,
-} from "@sammorrowdrums/mcpi";
-import { CodeModeManager } from "./code-mode/index.js";
-import { dockerE2ETool } from "./docker-e2e.js";
-import { McpClientManager, loadMcpConfig } from "./mcp/index.js";
-import {
-  SkillRegistry,
-  createLoadSkillTool,
-  discoverSkillsFromServer,
-  formatMcpSkillsForPrompt,
-  registerMcpToolProxies,
-} from "./skills/index.js";
-import { ToolCliServer, formatToolCliForPrompt } from "./tool-cli/index.js";
-import type { ToolProvider } from "./tool-cli/index.js";
-
-export default function (pi: ExtensionAPI) {
-  pi.registerTool(dockerE2ETool);
-
-  pi.registerFlag("mcp-config", {
-    description: "Path to MCP server configuration JSON file",
-    type: "string",
-  });
-
-  const mcpManager = new McpClientManager();
-  const skillRegistry = new SkillRegistry();
-  const codeModeManager = new CodeModeManager();
-  const enabledTools = new Set<string>();
-  const gatedToolNames = new Set<string>();
-
-  // Bridge McpClientManager to the ToolProvider interface
-  const toolProvider: ToolProvider = {
-    getServerNames: () => mcpManager.getConnectedServers(),
-    getTools: (server) => mcpManager.getToolsForServer(server),
-    async callTool(server, tool, args) {
-      const client = mcpManager.getClient(server);
-      if (!client) throw new Error(`No client for server "${server}"`);
-      const result = await client.callTool({ name: tool, arguments: args });
-      return {
-        content: result.content as unknown[],
-        isError: result.isError === true ? true : undefined,
-        structuredContent: result.structuredContent as Record<string, unknown> | undefined,
-      };
-    },
-  };
-  const rpcServer = new ToolCliServer(toolProvider);
-
-  // Register the load_skill tool so the model can activate MCP skills
-  pi.registerTool(createLoadSkillTool({ registry: skillRegistry, mcpManager, enabledTools }));
-
-  pi.on("session_start", async (_event: SessionStartEvent, ctx: ExtensionContext) => {
-    if (ctx.hasUI) {
-      ctx.ui.notify("mcpi-ext loaded", "info");
-    }
-
-    const configPath = pi.getFlag("mcp-config") as string | undefined;
-    const log = (msg: string) => {
-      if (ctx.hasUI) {
-        ctx.ui.notify(msg, "info");
-      } else {
-        console.error(msg);
-      }
-    };
-    try {
-      const config = await loadMcpConfig(configPath);
-      const serverCount = Object.keys(config.mcpServers).length;
-      if (serverCount > 0) {
-        await mcpManager.connectAll(config, log);
-        const tools = mcpManager.getTools();
-        log(
-          `MCP: ${mcpManager.getConnectedServers().length} server(s), ${tools.length} tool(s) discovered`,
-        );
-
-        // Pre-register all MCP tools as deferred Pi tool proxies
-        // (in tools array for dispatch but excluded from system prompt)
-        const allToolNames = tools.map((t) => t.name);
-        registerMcpToolProxies(allToolNames, mcpManager, pi);
-
-        // Discover skills from all connected servers
-        for (const serverName of mcpManager.getConnectedServers()) {
-          const client = mcpManager.getClient(serverName);
-          if (!client) continue;
-          try {
-            const skills = await discoverSkillsFromServer(client, serverName, log);
-            skillRegistry.registerAll(skills);
-          } catch (err) {
-            log(
-              `[skills] Failed to discover skills from "${serverName}": ${(err as Error).message}`,
-            );
-          }
-        }
-
-        if (skillRegistry.size > 0) {
-          for (const skill of skillRegistry.getAll()) {
-            for (const t of skill.allowedTools) {
-              gatedToolNames.add(t);
-            }
-          }
-          log(
-            `MCP: ${skillRegistry.size} skill(s) discovered, ${gatedToolNames.size} tool(s) deferred`,
-          );
-        }
-
-        // Start the tool-cli RPC server for progressive tool discovery
-        try {
-          const { port, token } = await rpcServer.start(log);
-          pi.setEnv("TOOL_CLI_PORT", String(port));
-          pi.setEnv("TOOL_CLI_TOKEN", token);
-        } catch (err) {
-          log(`[tool-cli] Failed to start RPC server: ${(err as Error).message}`);
-        }
-
-        // Initialize code mode (Tier 3) for read-only tools with structured output
-        codeModeManager.initialize(mcpManager);
-        if (codeModeManager.isActive) {
-          const { codeSearch, codeExecute } = codeModeManager.createTools();
-          pi.registerTool(codeSearch);
-          pi.registerTool(codeExecute);
-          log(
-            `MCP: Code mode active (${codeModeManager.getEligibleTools().length} eligible tool(s))`,
-          );
-        }
-      }
-    } catch (err) {
-      const msg = `MCP config error: ${(err as Error).message}`;
-      if (ctx.hasUI) {
-        ctx.ui.notify(msg, "warning");
-      } else {
-        console.error(msg);
-      }
-    }
-  });
-
-  // Inject MCP skills, tool-cli advice, and code mode type hints into the system prompt
-  pi.on("before_agent_start", async (event: BeforeAgentStartEvent) => {
-    let extra = "";
-
-    const skills = skillRegistry.getAll();
-    if (skills.length > 0) {
-      extra += formatMcpSkillsForPrompt(skills);
-    }
-
-    const serverCount = mcpManager.getConnectedServers().length;
-    extra += formatToolCliForPrompt(serverCount);
-
-    if (codeModeManager.isActive) {
-      extra += codeModeManager.formatSystemPromptSection();
-    }
-
-    if (extra.length === 0) return;
-    return { systemPrompt: event.systemPrompt + extra };
-  });
-
-  // Block deferred MCP tools until their skill is loaded
-  pi.on("tool_call", async (event: ToolCallEvent) => {
-    const name = "toolName" in event ? event.toolName : undefined;
-    if (!name || !gatedToolNames.has(name) || enabledTools.has(name)) return;
-    const relevantSkills = skillRegistry
-      .getAll()
-      .filter((s) => s.allowedTools.includes(name))
-      .map((s) => s.name);
-    return {
-      block: true,
-      reason: `Tool "${name}" requires loading a skill first. Call load_skill with one of: ${relevantSkills.join(", ")}`,
-    };
-  });
-
-  pi.on("session_shutdown", async () => {
-    pi.unsetEnv("TOOL_CLI_PORT");
-    pi.unsetEnv("TOOL_CLI_TOKEN");
-    await rpcServer.stop();
-    await mcpManager.disconnectAll();
-    skillRegistry.clear();
-  });
-}