@gaberrb/polypus 0.4.18 → 0.4.19

package/README.md

@@ -218,6 +218,27 @@ worktree (in `bypass` mode, since the worktree is throwaway), and the branches
 are merged back sequentially. Conflicting branches are kept for manual
 inspection rather than force-merged.
 
+## MCP (external tool servers)
+
+Connect [Model Context Protocol](https://modelcontextprotocol.io) servers to give
+the agent extra tools. Declare them in `.poly/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "filesystem": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-filesystem", "."]
+    }
+  }
+}
+```
+
+On each run Polypus spawns the servers (stdio transport), lists their tools and
+exposes them to the agent as `mcp__<server>__<tool>` — for both native and
+emulated models. Servers that fail to start are skipped, the processes are shut
+down when the run ends, and external MCP tools are disabled in `plan` mode.
+
 ## Autonomous agent — the tool self-improving 🤖
 
 Polypus can run **itself** in CI to implement its own issues. Label an issue

package/dist/index.js

@@ -146,6 +146,7 @@ var en = {
   "run.cancelled": "\u25A0 cancelled",
   "compaction.done": "context compacted: ~{before} \u2192 ~{after} tokens",
   "tools.customLoaded": "loaded custom tool(s): {names}",
+  "mcp.connected": "connected MCP server(s): {servers} ({n} tool(s))",
   "run.jsonNeedsTask": "--json requires a task argument (headless mode has no interactive REPL).",
   "review.approveAll": "approve all",
   "review.reject": "reject",
@@ -417,6 +418,7 @@ var ptBR = {
   "run.cancelled": "\u25A0 cancelado",
   "compaction.done": "contexto compactado: ~{before} \u2192 ~{after} tokens",
   "tools.customLoaded": "tool(s) customizada(s) carregada(s): {names}",
+  "mcp.connected": "servidor(es) MCP conectado(s): {servers} ({n} tool(s))",
   "run.jsonNeedsTask": "--json exige um argumento de tarefa (o modo headless n\xE3o tem REPL interativo).",
   "review.approveAll": "aprovar tudo",
   "review.reject": "rejeitar",
@@ -2847,6 +2849,195 @@ function clamp3(s) {
   return s.length > MAX_OUTPUT4 ? s.slice(0, MAX_OUTPUT4) + "\n\u2026[truncated]" : s;
 }
 
+// src/core/mcp/index.ts
+import { readFile as readFile14 } from "fs/promises";
+import { join as join8 } from "path";
+import { z as z10 } from "zod";
+
+// src/core/mcp/client.ts
+import { spawn } from "child_process";
+var PROTOCOL_VERSION = "2024-11-05";
+var McpClient = class {
+  constructor(command, args = [], env = {}) {
+    this.command = command;
+    this.args = args;
+    this.env = env;
+  }
+  command;
+  args;
+  env;
+  proc;
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  buffer = "";
+  closed = false;
+  /** Spawn the server and perform the initialize handshake. */
+  async initialize(timeoutMs = 2e4) {
+    this.proc = spawn(this.command, this.args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, ...this.env },
+      windowsHide: true
+    });
+    this.proc.stdout.setEncoding("utf8");
+    this.proc.stdout.on("data", (chunk) => this.onData(chunk));
+    this.proc.on("exit", () => this.failAll(new Error("MCP server process exited")));
+    this.proc.on("error", (err) => this.failAll(err));
+    await this.request(
+      "initialize",
+      {
+        protocolVersion: PROTOCOL_VERSION,
+        capabilities: {},
+        clientInfo: { name: "polypus", version: "1" }
+      },
+      timeoutMs
+    );
+    this.notify("notifications/initialized");
+  }
+  /** List the tools the server exposes. */
+  async listTools() {
+    const res = await this.request("tools/list", {});
+    return res.tools ?? [];
+  }
+  /** Call a tool and return its textual output. */
+  async callTool(name, args) {
+    try {
+      const res = await this.request("tools/call", { name, arguments: args });
+      const text2 = (res.content ?? []).map((c) => c.type === "text" ? c.text ?? "" : `[${c.type}]`).join("\n").trim();
+      return { ok: !res.isError, text: text2 || "(no output)" };
+    } catch (err) {
+      return { ok: false, text: `MCP call failed: ${err.message}` };
+    }
+  }
+  /** Terminate the server process. */
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.failAll(new Error("MCP client closed"));
+    this.proc?.kill();
+  }
+  onData(chunk) {
+    this.buffer += chunk;
+    let nl;
+    while ((nl = this.buffer.indexOf("\n")) !== -1) {
+      const line = this.buffer.slice(0, nl).trim();
+      this.buffer = this.buffer.slice(nl + 1);
+      if (!line) continue;
+      let msg;
+      try {
+        msg = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (typeof msg.id !== "number") continue;
+      const p4 = this.pending.get(msg.id);
+      if (!p4) continue;
+      this.pending.delete(msg.id);
+      if (msg.error) p4.reject(new Error(msg.error.message ?? "MCP error"));
+      else p4.resolve(msg.result);
+    }
+  }
+  request(method, params, timeoutMs = 2e4) {
+    if (!this.proc) return Promise.reject(new Error("MCP client not initialized"));
+    const id = this.nextId++;
+    const payload = JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n";
+    return new Promise((resolve12, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`MCP request "${method}" timed out`));
+      }, timeoutMs);
+      this.pending.set(id, {
+        resolve: (v) => {
+          clearTimeout(timer);
+          resolve12(v);
+        },
+        reject: (e) => {
+          clearTimeout(timer);
+          reject(e);
+        }
+      });
+      this.proc.stdin.write(payload);
+    });
+  }
+  notify(method, params = {}) {
+    this.proc?.stdin.write(JSON.stringify({ jsonrpc: "2.0", method, params }) + "\n");
+  }
+  failAll(err) {
+    for (const [, p4] of this.pending) p4.reject(err);
+    this.pending.clear();
+  }
+};
+
+// src/core/mcp/index.ts
+var ServerSchema = z10.object({
+  command: z10.string().min(1),
+  args: z10.array(z10.string()).default([]),
+  env: z10.record(z10.string()).default({})
+});
+var McpConfigSchema = z10.object({
+  mcpServers: z10.record(ServerSchema).default({})
+});
+var MAX_OUTPUT5 = 2e4;
+async function loadMcpTools(workspace) {
+  let raw;
+  try {
+    raw = await readFile14(join8(workspace, ".poly", "mcp.json"), "utf8");
+  } catch {
+    return { tools: [], servers: [], close: async () => {
+    } };
+  }
+  const parsed = McpConfigSchema.safeParse(safeJson(raw));
+  if (!parsed.success) return { tools: [], servers: [], close: async () => {
+  } };
+  const clients = [];
+  const tools = [];
+  const servers = [];
+  for (const [name, cfg] of Object.entries(parsed.data.mcpServers)) {
+    const client = new McpClient(cfg.command, cfg.args, cfg.env);
+    try {
+      await client.initialize();
+      const defs = await client.listTools();
+      for (const def of defs) tools.push(wrapTool(name, client, def.name, def.description, def.inputSchema));
+      clients.push(client);
+      servers.push(name);
+    } catch {
+      await client.close().catch(() => {
+      });
+    }
+  }
+  return {
+    tools,
+    servers,
+    close: async () => {
+      await Promise.all(clients.map((c) => c.close().catch(() => {
+      })));
+    }
+  };
+}
+function wrapTool(server, client, toolName, description, inputSchema) {
+  return {
+    mutating: true,
+    spec: {
+      name: `mcp__${server}__${toolName}`,
+      description: `[MCP:${server}] ${description ?? toolName}`,
+      parameters: inputSchema ?? { type: "object", properties: {} }
+    },
+    async run(args, ctx) {
+      if (ctx.permissions.mode === "plan") {
+        return { ok: false, output: "plan mode: external MCP tools are disabled" };
+      }
+      const { ok, text: text2 } = await client.callTool(toolName, args);
+      return { ok, output: text2.length > MAX_OUTPUT5 ? text2.slice(0, MAX_OUTPUT5) + "\n\u2026[truncated]" : text2 };
+    }
+  };
+}
+function safeJson(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
 // src/cli/commands/json-output.ts
 var OUTPUT_PREVIEW = 500;
 function createJsonCollector() {
@@ -3645,7 +3836,7 @@ import pc7 from "picocolors";
 // src/core/git/worktree.ts
 import { mkdtemp } from "fs/promises";
 import { tmpdir } from "os";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 import { simpleGit } from "simple-git";
 async function ensureRepo(workspace) {
   const git = simpleGit(workspace);
@@ -3666,7 +3857,7 @@ async function identityArgs(git) {
 }
 async function createWorktree(git, label) {
   const branch = `polypus/${label}-${Date.now().toString(36)}`;
-  const path = await mkdtemp(join8(tmpdir(), "polypus-wt-"));
+  const path = await mkdtemp(join9(tmpdir(), "polypus-wt-"));
   await git.raw(["worktree", "add", "-b", branch, path, "HEAD"]);
   return { path, branch };
 }
@@ -4337,9 +4528,17 @@ async function executeTask(task, resolved, workspace, session, json = false, ver
       return ok;
     }
   });
-  const [extraTools, hooks] = await Promise.all([loadCustomTools(workspace), loadHooks(workspace)]);
-  if (!json && extraTools.length > 0) {
-    console.log(pc8.dim(t("tools.customLoaded", { names: extraTools.map((tl) => tl.spec.name).join(", ") })));
+  const [customTools, hooks, mcp] = await Promise.all([
+    loadCustomTools(workspace),
+    loadHooks(workspace),
+    loadMcpTools(workspace)
+  ]);
+  const extraTools = [...customTools, ...mcp.tools];
+  if (!json && customTools.length > 0) {
+    console.log(pc8.dim(t("tools.customLoaded", { names: customTools.map((tl) => tl.spec.name).join(", ") })));
+  }
+  if (!json && mcp.servers.length > 0) {
+    console.log(pc8.dim(t("mcp.connected", { servers: mcp.servers.join(", "), n: mcp.tools.length })));
   }
   const runOnce = (taskText) => runAgent({
     task: taskText,
@@ -4366,6 +4565,7 @@ async function executeTask(task, resolved, workspace, session, json = false, ver
   } finally {
     spinner3.stop();
     cancel2.dispose();
+    await mcp.close();
   }
   if (!session.title) session.title = deriveTitle(session.history);
   await saveSession({
@@ -4540,7 +4740,7 @@ import pc9 from "picocolors";
 
 // src/core/scaffold/init.ts
 import { mkdir as mkdir5, writeFile as writeFile5, access } from "fs/promises";
-import { dirname as dirname3, join as join9 } from "path";
+import { dirname as dirname3, join as join10 } from "path";
 
 // src/core/scaffold/templates.ts
 function polyTemplates(locale) {
@@ -4783,7 +4983,7 @@ async function scaffoldPoly(workspace, opts) {
   const skipped = [];
   for (const [rel, content] of Object.entries(templates)) {
     const display = `.poly/${rel}`;
-    const abs = join9(workspace, ".poly", ...rel.split("/"));
+    const abs = join10(workspace, ".poly", ...rel.split("/"));
     if (!opts.force && await exists(abs)) {
       skipped.push(display);
       continue;
@@ -5007,7 +5207,7 @@ function fmtTokens3(n) {
 }
 
 // src/cli/commands/prd.ts
-import { writeFile as writeFile6, readFile as readFile14 } from "fs/promises";
+import { writeFile as writeFile6, readFile as readFile15 } from "fs/promises";
 import { execFile } from "child_process";
 import { promisify as promisify5 } from "util";
 import pc14 from "picocolors";
@@ -5146,7 +5346,7 @@ async function prd(issueRef, opts) {
 }
 async function loadIssue(issueRef, input) {
   if (input) {
-    const raw = input === "-" ? await readStdin() : await readFile14(input, "utf8");
+    const raw = input === "-" ? await readStdin() : await readFile15(input, "utf8");
     return normalize2(JSON.parse(stripBom(raw)));
   }
   const num = numericRef(issueRef);
@@ -5165,7 +5365,7 @@ function normalize2(raw) {
 }
 
 // src/cli/commands/review.ts
-import { writeFile as writeFile7, readFile as readFile15 } from "fs/promises";
+import { writeFile as writeFile7, readFile as readFile16 } from "fs/promises";
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify6 } from "util";
 import pc15 from "picocolors";
@@ -5241,7 +5441,7 @@ async function review(prRef, opts) {
   }
 }
 async function loadDiff(num, input) {
-  if (input) return input === "-" ? readStdin() : readFile15(input, "utf8");
+  if (input) return input === "-" ? readStdin() : readFile16(input, "utf8");
   const { stdout: stdout2 } = await exec6("gh", ["pr", "diff", num]);
   return stdout2;
 }
@@ -5253,7 +5453,7 @@ async function loadMeta(num, input) {
 }
 
 // src/cli/index.ts
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 
 // src/core/config/dotenv.ts
 import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
@@ -5325,7 +5525,7 @@ function buildProgram() {
 }
 async function main() {
   try {
-    loadDotenv([join10(configDir(), ".env"), join10(process.cwd(), ".env")]);
+    loadDotenv([join11(configDir(), ".env"), join11(process.cwd(), ".env")]);
     await resolveLocale();
     await buildProgram().parseAsync(process.argv);
   } catch (err) {