@gaberrb/polypus 0.4.10 → 0.4.11

package/dist/index.js

@@ -143,6 +143,7 @@ var en = {
   "run.autocorrect": "\u21BB tool failed \u2014 auto-correcting with extra context",
   "run.cancelled": "\u25A0 cancelled",
   "compaction.done": "context compacted: ~{before} \u2192 ~{after} tokens",
+  "tools.customLoaded": "loaded custom tool(s): {names}",
   "run.jsonNeedsTask": "--json requires a task argument (headless mode has no interactive REPL).",
   "review.approveAll": "approve all",
   "review.reject": "reject",
@@ -403,6 +404,7 @@ var ptBR = {
   "run.autocorrect": "\u21BB tool falhou \u2014 autocorrigindo com contexto extra",
   "run.cancelled": "\u25A0 cancelado",
   "compaction.done": "contexto compactado: ~{before} \u2192 ~{after} tokens",
+  "tools.customLoaded": "tool(s) customizada(s) carregada(s): {names}",
   "run.jsonNeedsTask": "--json exige um argumento de tarefa (o modo headless n\xE3o tem REPL interativo).",
   "review.approveAll": "aprovar tudo",
   "review.reject": "rejeitar",
@@ -2144,6 +2146,66 @@ ${summary.content.trim()}`
   return system ? [system, summaryMessage, ...tail] : [summaryMessage, ...tail];
 }
 
+// src/core/agent/hooks.ts
+import { exec as exec2 } from "child_process";
+import { readFile as readFile8 } from "fs/promises";
+import { join as join4 } from "path";
+import { promisify as promisify2 } from "util";
+import { z as z8 } from "zod";
+var execAsync2 = promisify2(exec2);
+var HOOK_TIMEOUT = 12e4;
+var HooksSchema = z8.object({
+  /** Shell command run after a successful write_file. `{path}` is substituted. */
+  afterWrite: z8.string().optional(),
+  /** Shell command run after a successful edit_file. `{path}` is substituted. */
+  afterEdit: z8.string().optional(),
+  /** Shell command run after any successful mutating tool. `{tool}`/`{path}` substituted. */
+  afterTool: z8.string().optional(),
+  /** Block run_command when the command contains any of these substrings. */
+  beforeCommand: z8.object({ deny: z8.array(z8.string()).default([]) }).optional()
+});
+async function loadHooks(workspace) {
+  try {
+    const raw = await readFile8(join4(workspace, ".poly", "hooks.json"), "utf8");
+    const parsed = HooksSchema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function screenCommandHook(hooks, command) {
+  const deny = hooks?.beforeCommand?.deny ?? [];
+  for (const needle of deny) {
+    if (needle && command.includes(needle)) {
+      return { blocked: true, reason: `matches deny rule "${needle}"` };
+    }
+  }
+  return { blocked: false };
+}
+function substitute(template, call) {
+  const path = typeof call.arguments.path === "string" ? call.arguments.path : "";
+  return template.replace(/\{path\}/g, path).replace(/\{tool\}/g, call.name);
+}
+async function runAfterHook(hooks, call, workspace) {
+  if (!hooks) return void 0;
+  const commands = [];
+  if (call.name === "write_file" && hooks.afterWrite) commands.push({ label: "afterWrite", cmd: hooks.afterWrite });
+  if (call.name === "edit_file" && hooks.afterEdit) commands.push({ label: "afterEdit", cmd: hooks.afterEdit });
+  if (hooks.afterTool) commands.push({ label: "afterTool", cmd: hooks.afterTool });
+  if (commands.length === 0) return void 0;
+  const notes = [];
+  for (const { label, cmd } of commands) {
+    const resolved = substitute(cmd, call);
+    try {
+      await execAsync2(resolved, { cwd: workspace, timeout: HOOK_TIMEOUT, windowsHide: true });
+      notes.push(`\u21AA hook ${label} ok`);
+    } catch (err) {
+      notes.push(`\u21AA hook ${label} failed: ${err.message.split("\n")[0]}`);
+    }
+  }
+  return notes.join("\n");
+}
+
 // src/core/agent/loop.ts
 function looksLikeStall(text2) {
   const lc = text2.toLowerCase();
@@ -2184,7 +2246,13 @@ async function runAgent(opts) {
   const { agent, permissions, events } = opts;
   const maxSteps = opts.maxSteps ?? 30;
   const maxReprompts = opts.maxReprompts ?? 3;
-  const driver = makeDriver(agent.toolMode, toolSpecs());
+  const extra = opts.extraTools ?? [];
+  const extraByName = new Map(extra.map((tl) => [tl.spec.name, tl]));
+  const baseSpecs = toolSpecs();
+  const finishSpec = baseSpecs[baseSpecs.length - 1];
+  const allSpecs = [...baseSpecs.slice(0, -1), ...extra.map((tl) => tl.spec), finishSpec];
+  const resolveTool = (name) => extraByName.get(name) ?? getTool(name);
+  const driver = makeDriver(agent.toolMode, allSpecs);
   const ctx = { workspace: opts.workspace, permissions };
   const seeding = !(opts.history && opts.history.length > 0);
   const promptContext = seeding && opts.promptContext.projectInstructions === void 0 ? { ...opts.promptContext, projectInstructions: await loadProjectInstructions(opts.workspace) } : opts.promptContext;
@@ -2265,8 +2333,21 @@ async function runAgent(opts) {
         const summary = String(call.arguments.summary ?? "").trim();
         return { finished: true, reason: "finished", summary, steps: step, messages, usage: usage2 };
       }
-      const tool = getTool(call.name);
-      const result = tool ? await tool.run(call.arguments, ctx) : { ok: false, output: `Unknown tool "${call.name}". Available: ${toolSpecs().map((t2) => t2.name).join(", ")}` };
+      const tool = resolveTool(call.name);
+      const hookScreen = call.name === "run_command" ? screenCommandHook(opts.hooks, String(call.arguments.command ?? "")) : { blocked: false };
+      let result;
+      if (hookScreen.blocked) {
+        result = { ok: false, output: `Command blocked by hook: ${hookScreen.reason}` };
+      } else if (tool) {
+        result = await tool.run(call.arguments, ctx);
+        if (result.ok) {
+          const note2 = await runAfterHook(opts.hooks, call, opts.workspace);
+          if (note2) result = { ...result, output: `${result.output}
+${note2}` };
+        }
+      } else {
+        result = { ok: false, output: `Unknown tool "${call.name}". Available: ${allSpecs.map((t2) => t2.name).join(", ")}` };
+      }
       events?.onToolResult?.(call, result);
       const sig = `${call.name}:${JSON.stringify(call.arguments)}`;
       let resultText = result.output;
@@ -2310,7 +2391,7 @@ ${guidance}`;
 }
 
 // src/core/context/mentions.ts
-import { readdir as readdir4, readFile as readFile8, stat as stat2 } from "fs/promises";
+import { readdir as readdir4, readFile as readFile9, stat as stat2 } from "fs/promises";
 import { resolve as resolve9 } from "path";
 var MAX_FILE_CHARS = 1e4;
 var MENTION_RE = /(?:^|\s)@([\w./-]+)/g;
@@ -2337,7 +2418,7 @@ ${t("mentions.notFound", { path: token })}`);
 ${listing || "(empty)"}`);
         injected.push(decision.rel);
       } else {
-        const raw = await readFile8(abs, "utf8");
+        const raw = await readFile9(abs, "utf8");
         const content = raw.length > MAX_FILE_CHARS ? raw.slice(0, MAX_FILE_CHARS) + "\n\u2026[truncated]" : raw;
         blocks.push(`## @${decision.rel}
 \`\`\`
@@ -2360,16 +2441,16 @@ ${blocks.join("\n\n")}`;
 }
 
 // src/core/agent/verify.ts
-import { exec as exec2 } from "child_process";
-import { readFile as readFile9 } from "fs/promises";
+import { exec as exec3 } from "child_process";
+import { readFile as readFile10 } from "fs/promises";
 import { resolve as resolve10 } from "path";
-import { promisify as promisify2 } from "util";
-var execAsync2 = promisify2(exec2);
+import { promisify as promisify3 } from "util";
+var execAsync3 = promisify3(exec3);
 var MAX_OUTPUT3 = 8e3;
 var CHECK_SCRIPTS = ["typecheck", "build", "test"];
 async function detectChecks(workspace) {
   try {
-    const raw = await readFile9(resolve10(workspace, "package.json"), "utf8");
+    const raw = await readFile10(resolve10(workspace, "package.json"), "utf8");
     const scripts = JSON.parse(raw).scripts ?? {};
     return CHECK_SCRIPTS.filter((s) => typeof scripts[s] === "string").map((s) => `npm run ${s}`);
   } catch {
@@ -2380,7 +2461,7 @@ async function runChecks(workspace, commands) {
   const results = [];
   for (const command of commands) {
     try {
-      const { stdout: stdout2, stderr } = await execAsync2(command, {
+      const { stdout: stdout2, stderr } = await execAsync3(command, {
         cwd: workspace,
         timeout: 3e5,
         maxBuffer: 10 * 1024 * 1024,
@@ -2412,8 +2493,8 @@ function clamp2(s) {
 }
 
 // src/core/agent/usage.ts
-import { appendFile, mkdir as mkdir3, readFile as readFile10 } from "fs/promises";
-import { join as join4 } from "path";
+import { appendFile, mkdir as mkdir3, readFile as readFile11 } from "fs/promises";
+import { join as join5 } from "path";
 
 // src/core/providers/openrouter.ts
 var MODELS_URL = "https://openrouter.ai/api/v1/models";
@@ -2513,7 +2594,7 @@ function fmtUsd(n) {
   return `US$${n.toFixed(2)}`;
 }
 function usagePath() {
-  return join4(configDir(), "usage.jsonl");
+  return join5(configDir(), "usage.jsonl");
 }
 async function recordUsage(entry) {
   try {
@@ -2525,7 +2606,7 @@ async function recordUsage(entry) {
 async function aggregateUsage() {
   let text2 = "";
   try {
-    text2 = await readFile10(usagePath(), "utf8");
+    text2 = await readFile11(usagePath(), "utf8");
   } catch {
     return { days: [], total: emptyBucket("total") };
   }
@@ -2559,10 +2640,10 @@ function accumulate(bucket, e) {
 }
 
 // src/core/agent/session-store.ts
-import { mkdir as mkdir4, readFile as readFile11, readdir as readdir5, writeFile as writeFile4 } from "fs/promises";
-import { join as join5 } from "path";
+import { mkdir as mkdir4, readFile as readFile12, readdir as readdir5, writeFile as writeFile4 } from "fs/promises";
+import { join as join6 } from "path";
 function sessionsDir() {
-  return join5(configDir(), "sessions");
+  return join6(configDir(), "sessions");
 }
 function newSessionId() {
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
@@ -2570,7 +2651,7 @@ function newSessionId() {
   return `${stamp}-${rand}`;
 }
 function sessionPath(id) {
-  return join5(sessionsDir(), `${id}.json`);
+  return join6(sessionsDir(), `${id}.json`);
 }
 async function saveSession(record) {
   await mkdir4(sessionsDir(), { recursive: true });
@@ -2582,7 +2663,7 @@ async function saveSession(record) {
 }
 async function loadSession(id) {
   try {
-    return JSON.parse(await readFile11(sessionPath(id), "utf8"));
+    return JSON.parse(await readFile12(sessionPath(id), "utf8"));
   } catch {
     return void 0;
   }
@@ -2597,7 +2678,7 @@ async function listSessions() {
   const summaries = [];
   for (const f of files) {
     try {
-      const r = JSON.parse(await readFile11(join5(sessionsDir(), f), "utf8"));
+      const r = JSON.parse(await readFile12(join6(sessionsDir(), f), "utf8"));
       summaries.push({
         id: r.id,
         updatedAt: r.updatedAt,
@@ -2621,6 +2702,83 @@ function deriveTitle(messages) {
   return text2.length > 60 ? text2.slice(0, 60) + "\u2026" : text2 || "(untitled)";
 }
 
+// src/core/tools/custom.ts
+import { exec as exec4 } from "child_process";
+import { readFile as readFile13, readdir as readdir6 } from "fs/promises";
+import { join as join7 } from "path";
+import { promisify as promisify4 } from "util";
+import { z as z9 } from "zod";
+var execAsync4 = promisify4(exec4);
+var MAX_OUTPUT4 = 2e4;
+var CustomToolSchema = z9.object({
+  name: z9.string().min(1).regex(/^[a-z][a-z0-9_]*$/i, "tool name must be alphanumeric/underscore"),
+  description: z9.string().min(1),
+  /** JSON-schema object for the tool parameters (advertised to the model). */
+  parameters: z9.record(z9.unknown()).optional(),
+  /** Shell command template; `{argName}` placeholders are filled from the call arguments. */
+  command: z9.string().min(1)
+});
+function makeCommandTool(def) {
+  return {
+    mutating: true,
+    spec: {
+      name: def.name,
+      description: def.description,
+      parameters: def.parameters ?? { type: "object", properties: {} }
+    },
+    async run(rawArgs, ctx) {
+      const command = fillTemplate(def.command, rawArgs);
+      const decision = await ctx.permissions.authorizeCommand(command);
+      if (!decision.allowed) return { ok: false, output: `Command denied: ${decision.reason}` };
+      try {
+        const { stdout: stdout2, stderr } = await execAsync4(command, {
+          cwd: ctx.workspace,
+          timeout: 12e4,
+          maxBuffer: 10 * 1024 * 1024,
+          windowsHide: true
+        });
+        return { ok: true, output: clamp3(`${stdout2}${stderr ? `
+[stderr]
+${stderr}` : ""}`.trim() || "(no output)") };
+      } catch (err) {
+        const e = err;
+        return {
+          ok: false,
+          output: clamp3(`Command failed (exit ${e.code ?? "?"}): ${e.message}
+${e.stdout ?? ""}${e.stderr ?? ""}`)
+        };
+      }
+    }
+  };
+}
+async function loadCustomTools(workspace) {
+  let files;
+  try {
+    files = (await readdir6(join7(workspace, ".poly", "tools"))).filter((f) => f.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  const tools = [];
+  for (const f of files) {
+    try {
+      const raw = await readFile13(join7(workspace, ".poly", "tools", f), "utf8");
+      const parsed = CustomToolSchema.safeParse(JSON.parse(raw));
+      if (parsed.success) tools.push(makeCommandTool(parsed.data));
+    } catch {
+    }
+  }
+  return tools;
+}
+function fillTemplate(template, args) {
+  return template.replace(/\{(\w+)\}/g, (_, key) => {
+    const v = args[key];
+    return v === void 0 || v === null ? "" : String(v);
+  });
+}
+function clamp3(s) {
+  return s.length > MAX_OUTPUT4 ? s.slice(0, MAX_OUTPUT4) + "\n\u2026[truncated]" : s;
+}
+
 // src/cli/commands/json-output.ts
 var OUTPUT_PREVIEW = 500;
 function createJsonCollector() {
@@ -3419,7 +3577,7 @@ import pc7 from "picocolors";
 // src/core/git/worktree.ts
 import { mkdtemp } from "fs/promises";
 import { tmpdir } from "os";
-import { join as join6 } from "path";
+import { join as join8 } from "path";
 import { simpleGit } from "simple-git";
 async function ensureRepo(workspace) {
   const git = simpleGit(workspace);
@@ -3440,7 +3598,7 @@ async function identityArgs(git) {
 }
 async function createWorktree(git, label) {
   const branch = `polypus/${label}-${Date.now().toString(36)}`;
-  const path = await mkdtemp(join6(tmpdir(), "polypus-wt-"));
+  const path = await mkdtemp(join8(tmpdir(), "polypus-wt-"));
   await git.raw(["worktree", "add", "-b", branch, path, "HEAD"]);
   return { path, branch };
 }
@@ -3991,6 +4149,10 @@ 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 runOnce = (taskText) => runAgent({
     task: taskText,
     workspace,
@@ -4000,6 +4162,8 @@ async function executeTask(task, resolved, workspace, session, json = false, ver
     history: session.history,
     maxSteps: session.maxSteps,
     compactThresholdTokens: compactionThreshold(),
+    extraTools,
+    hooks,
     signal: controller.signal,
     events
   });
@@ -4204,7 +4368,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 join7 } from "path";
+import { dirname as dirname3, join as join9 } from "path";
 
 // src/core/scaffold/templates.ts
 function polyTemplates(locale) {
@@ -4447,7 +4611,7 @@ async function scaffoldPoly(workspace, opts) {
   const skipped = [];
   for (const [rel, content] of Object.entries(templates)) {
     const display = `.poly/${rel}`;
-    const abs = join7(workspace, ".poly", ...rel.split("/"));
+    const abs = join9(workspace, ".poly", ...rel.split("/"));
     if (!opts.force && await exists(abs)) {
       skipped.push(display);
       continue;
@@ -4587,9 +4751,9 @@ async function sessions() {
 }
 
 // src/cli/commands/prd.ts
-import { writeFile as writeFile6, readFile as readFile12 } from "fs/promises";
+import { writeFile as writeFile6, readFile as readFile14 } from "fs/promises";
 import { execFile } from "child_process";
-import { promisify as promisify3 } from "util";
+import { promisify as promisify5 } from "util";
 import pc13 from "picocolors";
 
 // src/core/agent/prd.ts
@@ -4711,7 +4875,7 @@ function stripBom(s) {
 }
 
 // src/cli/commands/prd.ts
-var exec3 = promisify3(execFile);
+var exec5 = promisify5(execFile);
 async function prd(issueRef, opts) {
   const issue = await loadIssue(issueRef, opts.input);
   const { provider } = resolveFreeProvider(opts.model ?? DEFAULT_PRD_MODEL);
@@ -4726,11 +4890,11 @@ async function prd(issueRef, opts) {
 }
 async function loadIssue(issueRef, input) {
   if (input) {
-    const raw = input === "-" ? await readStdin() : await readFile12(input, "utf8");
+    const raw = input === "-" ? await readStdin() : await readFile14(input, "utf8");
     return normalize2(JSON.parse(stripBom(raw)));
   }
   const num = numericRef(issueRef);
-  const { stdout: stdout2 } = await exec3("gh", ["issue", "view", num, "--json", "number,title,body,comments"]);
+  const { stdout: stdout2 } = await exec5("gh", ["issue", "view", num, "--json", "number,title,body,comments"]);
   const data = normalize2(JSON.parse(stdout2));
   data.number ??= Number(num);
   return data;
@@ -4745,9 +4909,9 @@ function normalize2(raw) {
 }
 
 // src/cli/commands/review.ts
-import { writeFile as writeFile7, readFile as readFile13 } from "fs/promises";
+import { writeFile as writeFile7, readFile as readFile15 } from "fs/promises";
 import { execFile as execFile2 } from "child_process";
-import { promisify as promisify4 } from "util";
+import { promisify as promisify6 } from "util";
 import pc14 from "picocolors";
 
 // src/core/agent/review.ts
@@ -4805,7 +4969,7 @@ ${projectGuide}`
 }
 
 // src/cli/commands/review.ts
-var exec4 = promisify4(execFile2);
+var exec6 = promisify6(execFile2);
 async function review(prRef, opts) {
   const num = opts.input ? prRef.replace(/^#/, "") : numericRef(prRef);
   const diff = await loadDiff(num, opts.input);
@@ -4821,19 +4985,19 @@ async function review(prRef, opts) {
   }
 }
 async function loadDiff(num, input) {
-  if (input) return input === "-" ? readStdin() : readFile13(input, "utf8");
-  const { stdout: stdout2 } = await exec4("gh", ["pr", "diff", num]);
+  if (input) return input === "-" ? readStdin() : readFile15(input, "utf8");
+  const { stdout: stdout2 } = await exec6("gh", ["pr", "diff", num]);
   return stdout2;
 }
 async function loadMeta(num, input) {
   if (input) return { number: Number(num) || void 0, title: `PR ${num}`, body: "" };
-  const { stdout: stdout2 } = await exec4("gh", ["pr", "view", num, "--json", "number,title,body"]);
+  const { stdout: stdout2 } = await exec6("gh", ["pr", "view", num, "--json", "number,title,body"]);
   const raw = JSON.parse(stdout2);
   return { number: raw.number, title: raw.title ?? "", body: raw.body ?? "" };
 }
 
 // src/cli/index.ts
-import { join as join8 } from "path";
+import { join as join10 } from "path";
 
 // src/core/config/dotenv.ts
 import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
@@ -4904,7 +5068,7 @@ function buildProgram() {
 }
 async function main() {
   try {
-    loadDotenv([join8(configDir(), ".env"), join8(process.cwd(), ".env")]);
+    loadDotenv([join10(configDir(), ".env"), join10(process.cwd(), ".env")]);
     await resolveLocale();
     await buildProgram().parseAsync(process.argv);
   } catch (err) {