@gaberrb/polypus 0.4.2 → 0.4.4

package/dist/index.js

@@ -109,6 +109,7 @@ var en = {
   "cli.opt.agent": "which configured agent to use",
   "cli.opt.mode": "plan | review | bypass (overrides config)",
   "cli.opt.maxSteps": "maximum agent steps",
+  "cli.opt.json": "headless mode: emit a single JSON object (steps, tool calls, files changed, usage) instead of the TUI \u2014 use with --mode bypass",
   "cli.arg.swarmTask": "high-level task to split across agents",
   "cli.opt.agents": "comma-separated agent names (default: all configured)",
   "cli.opt.maxSubtasks": "maximum number of parallel subtasks",
@@ -135,6 +136,7 @@ var en = {
   "run.reprompt": "\u21BB no tool call \u2014 reinforcing instructions (attempt {attempt})",
   "run.autocorrect": "\u21BB tool failed \u2014 auto-correcting with extra context",
   "run.cancelled": "\u25A0 cancelled",
+  "run.jsonNeedsTask": "--json requires a task argument (headless mode has no interactive REPL).",
   // repl
   "repl.welcome": "Polypus interactive session.",
   "repl.welcomeHint": " Type /help for commands, /exit to quit.",
@@ -285,7 +287,11 @@ var en = {
   "welcome.firstRun": "No agents configured yet \u2014 let's set you up.",
   // agent system prompt
   "prompt.language": "Communicate with the user in {language}.",
-  "prompt.projectInstructions": "Project-specific operating instructions follow, loaded from `.poly/agents.md`. Treat them as authoritative for how to work in THIS repo. Paths they reference (e.g. skills/*.md, ../context.md, ../rules.md) are relative to the `.poly/` directory \u2014 read those files when relevant before acting:"
+  "prompt.projectInstructions": "Project-specific operating instructions follow, loaded from `.poly/agents.md`. Treat them as authoritative for how to work in THIS repo. Paths they reference (e.g. skills/*.md, ../context.md, ../rules.md) are relative to the `.poly/` directory \u2014 read those files when relevant before acting:",
+  // @-mentions
+  "mentions.injectedHeader": "Referenced files (@-mentions)",
+  "mentions.dirHeader": "@{path} (directory listing)",
+  "mentions.notFound": "(could not resolve @{path}: not found or outside the allow-list)"
 };
 var ptBR = {
   "common.default": "padr\xE3o",
@@ -330,6 +336,7 @@ var ptBR = {
   "cli.opt.agent": "qual agente configurado usar",
   "cli.opt.mode": "plan | review | bypass (sobrescreve a config)",
   "cli.opt.maxSteps": "n\xFAmero m\xE1ximo de passos do agente",
+  "cli.opt.json": "modo headless: emite um \xFAnico objeto JSON (passos, tool calls, arquivos alterados, uso) em vez da TUI \u2014 use com --mode bypass",
   "cli.arg.swarmTask": "tarefa de alto n\xEDvel para dividir entre os agentes",
   "cli.opt.agents": "nomes de agentes separados por v\xEDrgula (padr\xE3o: todos)",
   "cli.opt.maxSubtasks": "n\xFAmero m\xE1ximo de subtarefas paralelas",
@@ -354,6 +361,7 @@ var ptBR = {
   "run.reprompt": "\u21BB nenhuma chamada de tool \u2014 refor\xE7ando instru\xE7\xF5es (tentativa {attempt})",
   "run.autocorrect": "\u21BB tool falhou \u2014 autocorrigindo com contexto extra",
   "run.cancelled": "\u25A0 cancelado",
+  "run.jsonNeedsTask": "--json exige um argumento de tarefa (o modo headless n\xE3o tem REPL interativo).",
   "repl.welcome": "Sess\xE3o interativa do Polypus.",
   "repl.welcomeHint": " Digite /help para comandos, /exit para sair.",
   "repl.modeChanged": "modo \u2192 {mode}",
@@ -478,6 +486,10 @@ var ptBR = {
   "wizard.keyPrompt": "Chave de API (armazenada em texto puro no arquivo de config)",
   "prompt.language": "Comunique-se com o usu\xE1rio em {language}.",
   "prompt.projectInstructions": "Seguem instru\xE7\xF5es operacionais espec\xEDficas do projeto, carregadas de `.poly/agents.md`. Trate-as como autoritativas para trabalhar NESTE reposit\xF3rio. Os caminhos que elas citam (ex.: skills/*.md, ../context.md, ../rules.md) s\xE3o relativos \xE0 pasta `.poly/` \u2014 leia esses arquivos quando relevante antes de agir:",
+  // @-mentions
+  "mentions.injectedHeader": "Arquivos referenciados (@-mentions)",
+  "mentions.dirHeader": "@{path} (conte\xFAdo do diret\xF3rio)",
+  "mentions.notFound": "(n\xE3o foi poss\xEDvel resolver @{path}: n\xE3o encontrado ou fora da allow-list)",
   "models.fetching": "Buscando modelos do OpenRouter\u2026",
   "models.fetchError": "N\xE3o foi poss\xEDvel buscar modelos: {msg}",
   "models.none": "Nenhum modelo corresponde aos filtros.",
@@ -1974,6 +1986,110 @@ ${guidance}`;
   return { finished: false, reason: "maxsteps", steps: maxSteps, messages, usage };
 }
 
+// src/core/context/mentions.ts
+import { readdir as readdir4, readFile as readFile7, stat as stat2 } from "fs/promises";
+import { resolve as resolve8 } from "path";
+var MAX_FILE_CHARS = 1e4;
+var MENTION_RE = /(?:^|\s)@([\w./-]+)/g;
+async function resolveMentions(task, policy) {
+  const tokens2 = [...task.matchAll(MENTION_RE)].map((m) => m[1]);
+  const unique = [...new Set(tokens2)];
+  if (unique.length === 0) return { task, injected: [] };
+  const blocks = [];
+  const injected = [];
+  for (const token of unique) {
+    const decision = checkPath(policy, token);
+    if (!decision.allowed) {
+      blocks.push(`## @${token}
+${t("mentions.notFound", { path: token })}`);
+      continue;
+    }
+    const abs = resolve8(policy.workspace, token);
+    try {
+      const info = await stat2(abs);
+      if (info.isDirectory()) {
+        const entries = await readdir4(abs, { withFileTypes: true });
+        const listing = entries.map((e) => e.isDirectory() ? `${e.name}/` : e.name).sort().join("\n");
+        blocks.push(`## ${t("mentions.dirHeader", { path: decision.rel })}
+${listing || "(empty)"}`);
+        injected.push(decision.rel);
+      } else {
+        const raw = await readFile7(abs, "utf8");
+        const content = raw.length > MAX_FILE_CHARS ? raw.slice(0, MAX_FILE_CHARS) + "\n\u2026[truncated]" : raw;
+        blocks.push(`## @${decision.rel}
+\`\`\`
+${content}
+\`\`\``);
+        injected.push(decision.rel);
+      }
+    } catch {
+      blocks.push(`## @${token}
+${t("mentions.notFound", { path: token })}`);
+    }
+  }
+  if (injected.length === 0) return { task, injected: [] };
+  const augmented = `${task}
+
+--- ${t("mentions.injectedHeader")} ---
+
+${blocks.join("\n\n")}`;
+  return { task: augmented, injected };
+}
+
+// src/cli/commands/json-output.ts
+var OUTPUT_PREVIEW = 500;
+function createJsonCollector() {
+  const log = [];
+  const filesChanged = /* @__PURE__ */ new Set();
+  const events = {
+    onStep(step) {
+      log.push({ type: "step", step });
+    },
+    onAssistantText(text2) {
+      if (text2.trim()) log.push({ type: "assistant", text: text2 });
+    },
+    onToolCall(call) {
+      log.push({ type: "tool_call", name: call.name, arguments: call.arguments });
+    },
+    onToolResult(call, result) {
+      log.push({
+        type: "tool_result",
+        name: call.name,
+        ok: result.ok,
+        output: result.output.slice(0, OUTPUT_PREVIEW)
+      });
+      if (result.ok && (call.name === "write_file" || call.name === "edit_file")) {
+        const path = call.arguments.path;
+        if (typeof path === "string") filesChanged.add(path);
+      }
+    },
+    onCorrection(call) {
+      log.push({ type: "correction", name: call.name });
+    },
+    onReprompt(attempt) {
+      log.push({ type: "reprompt", attempt });
+    },
+    onUsage() {
+    }
+  };
+  return {
+    events,
+    build(result) {
+      return {
+        result: {
+          reason: result.reason,
+          finished: result.finished,
+          steps: result.steps,
+          summary: result.summary,
+          filesChanged: [...filesChanged],
+          usage: result.usage
+        },
+        events: log
+      };
+    }
+  };
+}
+
 // src/ui/repl.ts
 import pc6 from "picocolors";
 
@@ -2612,10 +2728,10 @@ async function readLineTTY(prompt) {
   stdin.resume();
   stdin.on("data", onData);
   try {
-    const line = await new Promise((resolve9) => {
-      rl.question(prompt).then(resolve9, () => resolve9(null));
-      rl.on("SIGINT", () => resolve9(null));
-      rl.on("close", () => resolve9(null));
+    const line = await new Promise((resolve10) => {
+      rl.question(prompt).then(resolve10, () => resolve10(null));
+      rl.on("SIGINT", () => resolve10(null));
+      rl.on("close", () => resolve10(null));
     });
     return line === null ? null : store.expand(line);
   } finally {
@@ -3227,20 +3343,23 @@ async function run(task, opts) {
     const resolved2 = createProvider(active);
     await executeTask(taskText, resolved2, workspace, session);
   };
+  if (opts.json && !task) throw new Error(t("run.jsonNeedsTask"));
   if (task) {
     const resolved2 = createProvider(agentConfig);
-    console.log(
-      pc8.dim(
-        t("run.status", {
-          name: resolved2.config.name,
-          provider: resolved2.config.provider,
-          model: resolved2.config.model,
-          toolMode: resolved2.toolMode,
-          mode: session.mode
-        })
-      )
-    );
-    await executeTask(task, resolved2, workspace, session);
+    if (!opts.json) {
+      console.log(
+        pc8.dim(
+          t("run.status", {
+            name: resolved2.config.name,
+            provider: resolved2.config.provider,
+            model: resolved2.config.model,
+            toolMode: resolved2.toolMode,
+            mode: session.mode
+          })
+        )
+      );
+    }
+    await executeTask(task, resolved2, workspace, session, opts.json ?? false);
     return;
   }
   const resolved = createProvider(agentConfig);
@@ -3263,15 +3382,26 @@ async function run(task, opts) {
   };
   await startRepl(ctx);
 }
-async function executeTask(task, resolved, workspace, session) {
+async function executeTask(task, resolved, workspace, session, json = false) {
+  const mention = await resolveMentions(task, {
+    workspace,
+    allow: session.allow,
+    deny: session.deny
+  });
+  if (mention.injected.length > 0) {
+    task = mention.task;
+    if (!json) console.log(pc8.dim(`\u21B3 @ ${mention.injected.join(", ")}`));
+  }
   const spinner3 = new Spinner();
   const controller = new AbortController();
   const cancel2 = listenForCancel(controller);
+  const collector = json ? createJsonCollector() : void 0;
   const permissions = new PermissionEngine({
     mode: session.mode,
     policy: { workspace, allow: session.allow, deny: session.deny },
     allowedCommands: session.allowedCommands,
-    confirm: async (req) => {
+    // Headless runs have no TTY for confirmations — use --mode bypass instead.
+    confirm: json ? async () => false : async (req) => {
       spinner3.stop();
       cancel2.pause();
       const ok = await confirmAction(req);
@@ -3279,7 +3409,7 @@ async function executeTask(task, resolved, workspace, session) {
       return ok;
     }
   });
-  spinner3.start(t("ui.thinking"));
+  if (!json) spinner3.start(t("ui.thinking"));
   let result;
   try {
     result = await runAgent({
@@ -3291,13 +3421,17 @@ async function executeTask(task, resolved, workspace, session) {
       history: session.history,
       maxSteps: session.maxSteps,
       signal: controller.signal,
-      events: renderEvents(spinner3)
+      events: collector ? collector.events : renderEvents(spinner3)
     });
   } finally {
     spinner3.stop();
     cancel2.dispose();
   }
   session.history = result.messages;
+  if (collector) {
+    process.stdout.write(JSON.stringify(collector.build(result)) + "\n");
+    return;
+  }
   if (result.reason === "finished") {
     console.log(pc8.green("\n" + t("run.done", { steps: result.steps })) + (result.summary ? ` ${result.summary}` : ""));
   } else if (result.reason === "cancelled") {
@@ -3742,7 +3876,7 @@ async function resolveOpenRouterKey() {
 }
 
 // src/cli/commands/prd.ts
-import { writeFile as writeFile5, readFile as readFile7 } from "fs/promises";
+import { writeFile as writeFile5, readFile as readFile8 } from "fs/promises";
 import { execFile } from "child_process";
 import { promisify as promisify2 } from "util";
 import pc11 from "picocolors";
@@ -3834,13 +3968,13 @@ async function withRetry(fn, opts = {}) {
 
 // src/cli/commands/cli-io.ts
 import { readFileSync, existsSync as existsSync2 } from "fs";
-import { resolve as resolve8 } from "path";
+import { resolve as resolve9 } from "path";
 var GUIDE_MAX = 12e3;
 function readProjectGuide(files) {
   const parts = [];
   for (const file of files) {
     try {
-      const path = resolve8(process.cwd(), file);
+      const path = resolve9(process.cwd(), file);
       if (existsSync2(path)) parts.push(`# ${file}
 ${readFileSync(path, "utf8").trim()}`);
     } catch {
@@ -3881,7 +4015,7 @@ async function prd(issueRef, opts) {
 }
 async function loadIssue(issueRef, input) {
   if (input) {
-    const raw = input === "-" ? await readStdin() : await readFile7(input, "utf8");
+    const raw = input === "-" ? await readStdin() : await readFile8(input, "utf8");
     return normalize2(JSON.parse(stripBom(raw)));
   }
   const num = numericRef(issueRef);
@@ -3900,7 +4034,7 @@ function normalize2(raw) {
 }
 
 // src/cli/commands/review.ts
-import { writeFile as writeFile6, readFile as readFile8 } from "fs/promises";
+import { writeFile as writeFile6, readFile as readFile9 } from "fs/promises";
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify3 } from "util";
 import pc12 from "picocolors";
@@ -3976,7 +4110,7 @@ async function review(prRef, opts) {
   }
 }
 async function loadDiff(num, input) {
-  if (input) return input === "-" ? readStdin() : readFile8(input, "utf8");
+  if (input) return input === "-" ? readStdin() : readFile9(input, "utf8");
   const { stdout: stdout2 } = await exec3("gh", ["pr", "diff", num]);
   return stdout2;
 }
@@ -4048,7 +4182,7 @@ function buildProgram() {
   program.command("add-agent").argument("<name>", t("cli.arg.addAgentName")).requiredOption("--provider <provider>", t("cli.opt.provider")).requiredOption("--model <model>", t("cli.opt.model")).option("--api-key <key>", t("cli.opt.apiKey")).option("--base-url <url>", t("cli.opt.baseUrl")).option("--tool-mode <mode>", t("cli.opt.toolMode"), "auto").option("--set-default", t("cli.opt.setDefault")).description(t("cli.cmd.addAgent")).action((name, opts) => addAgent(name, opts));
   program.command("remove-agent").argument("<name>", t("cli.arg.removeAgentName")).description(t("cli.cmd.removeAgent")).action((name) => removeAgent(name));
   program.command("list-agents").alias("agents").description(t("cli.cmd.listAgents")).action(() => listAgents());
-  program.command("run").argument("[task]", t("cli.arg.runTask")).option("--agent <name>", t("cli.opt.agent")).option("--mode <mode>", t("cli.opt.mode")).option("--max-steps <n>", t("cli.opt.maxSteps")).description(t("cli.cmd.run")).action((task, opts) => run(task, opts));
+  program.command("run").argument("[task]", t("cli.arg.runTask")).option("--agent <name>", t("cli.opt.agent")).option("--mode <mode>", t("cli.opt.mode")).option("--max-steps <n>", t("cli.opt.maxSteps")).option("--json", t("cli.opt.json")).description(t("cli.cmd.run")).action((task, opts) => run(task, opts));
   program.command("swarm").argument("<task>", t("cli.arg.swarmTask")).option("--agents <names>", t("cli.opt.agents")).option("--max-subtasks <n>", t("cli.opt.maxSubtasks")).description(t("cli.cmd.swarm")).action((task, opts) => swarm(task, opts));
   program.command("models").option("--search <text>", t("cli.opt.search")).option("--tools", t("cli.opt.toolsOnly")).option("--free", t("cli.opt.free")).option("--max-price <usd>", t("cli.opt.maxPrice")).option("--sort <order>", t("cli.opt.sort")).option("--limit <n>", t("cli.opt.limit")).description(t("cli.cmd.models")).action((opts) => models(opts));
   program.command("prd").argument("<issue>", t("cli.arg.prdIssue")).option("--out <file>", t("cli.opt.out")).option("--model <model>", t("cli.opt.model")).option("--input <file>", t("cli.opt.input")).description(t("cli.cmd.prd")).action((issue, opts) => prd(issue, opts));