@gaberrb/polypus 0.2.1 → 0.3.0

package/dist/index.js

@@ -3,7 +3,7 @@
 // src/cli/index.ts
 import { Command } from "commander";
 import { createRequire } from "module";
-import pc10 from "picocolors";
+import pc12 from "picocolors";
 
 // src/cli/commands/add-agent.ts
 import pc from "picocolors";
@@ -80,6 +80,16 @@ var en = {
   "cli.cmd.run": "Run a coding task with an agent",
   "cli.cmd.swarm": "Split a task across multiple agents working in parallel git worktrees",
   "cli.cmd.models": "Browse OpenRouter models (price, context, tool support)",
+  "cli.cmd.prd": "Generate a PRD from a GitHub issue (uses a free OpenRouter model)",
+  "cli.arg.prdIssue": "issue number to turn into a PRD",
+  "cli.cmd.review": "Review a pull request diff (uses a free OpenRouter model)",
+  "cli.arg.reviewPr": "pull request number to review",
+  "cli.opt.out": "write output to this file instead of stdout",
+  "cli.opt.input": 'read input from a file (or "-" for stdin) instead of calling gh',
+  "prd.wrote": "\u2713 PRD written to {path}",
+  "review.wrote": "\u2713 Review written to {path}",
+  "cli.invalidRef": "Invalid number '{ref}': expected a numeric issue/PR number.",
+  "cli.stdinTty": "--input - expects piped stdin, but none was provided.",
   "cli.opt.search": "filter by id/name substring",
   "cli.opt.toolsOnly": "only models that support tool-calling",
   "cli.opt.free": "only free models",
@@ -167,6 +177,15 @@ var en = {
   "swarm.mergeConflict": "  conflict merging {branch}",
   "swarm.summary": "Summary:",
   "swarm.allMerged": "\u2713 All committed branches merged cleanly.",
+  "swarm.view.header": "Swarm \xB7 orchestrator [{lead}]",
+  "swarm.view.decomposing": "splitting the task\u2026",
+  "swarm.view.pending": "queued",
+  "swarm.view.running": "running",
+  "swarm.view.done": "done",
+  "swarm.view.stopped": "stopped",
+  "swarm.view.conflict": "conflict",
+  "swarm.view.step": "step {n}",
+  "swarm.view.steps": "{n} steps",
   "swarm.conflictsHeader": "\u26A0 {n} branch(es) had merge conflicts (kept for inspection):",
   "swarm.statusDone": "done",
   "swarm.statusIncomplete": "incomplete",
@@ -270,6 +289,16 @@ var ptBR = {
   "cli.cmd.run": "Executa uma tarefa de c\xF3digo com um agente",
   "cli.cmd.swarm": "Divide uma tarefa entre v\xE1rios agentes trabalhando em paralelo em git worktrees",
   "cli.cmd.models": "Explora os modelos do OpenRouter (pre\xE7o, contexto, suporte a tools)",
+  "cli.cmd.prd": "Gera um PRD a partir de uma issue do GitHub (usa um modelo gratuito do OpenRouter)",
+  "cli.arg.prdIssue": "n\xFAmero da issue para transformar em PRD",
+  "cli.cmd.review": "Revisa o diff de um pull request (usa um modelo gratuito do OpenRouter)",
+  "cli.arg.reviewPr": "n\xFAmero do pull request a revisar",
+  "cli.opt.out": "grava a sa\xEDda neste arquivo em vez do stdout",
+  "cli.opt.input": 'l\xEA a entrada de um arquivo (ou "-" para stdin) em vez de chamar o gh',
+  "prd.wrote": "\u2713 PRD gravado em {path}",
+  "review.wrote": "\u2713 Review gravado em {path}",
+  "cli.invalidRef": "N\xFAmero inv\xE1lido '{ref}': esperado um n\xFAmero de issue/PR.",
+  "cli.stdinTty": "--input - espera entrada via pipe (stdin), mas nenhuma foi fornecida.",
   "cli.opt.search": "filtra por trecho do id/nome",
   "cli.opt.toolsOnly": "apenas modelos com suporte a tool-calling",
   "cli.opt.free": "apenas modelos gratuitos",
@@ -353,6 +382,15 @@ var ptBR = {
   "swarm.mergeConflict": "  conflito ao mesclar {branch}",
   "swarm.summary": "Resumo:",
   "swarm.allMerged": "\u2713 Todos os branches commitados foram mesclados sem conflito.",
+  "swarm.view.header": "Swarm \xB7 orquestrador [{lead}]",
+  "swarm.view.decomposing": "dividindo a tarefa\u2026",
+  "swarm.view.pending": "na fila",
+  "swarm.view.running": "executando",
+  "swarm.view.done": "conclu\xEDdo",
+  "swarm.view.stopped": "parado",
+  "swarm.view.conflict": "conflito",
+  "swarm.view.step": "passo {n}",
+  "swarm.view.steps": "{n} passos",
   "swarm.conflictsHeader": "\u26A0 {n} branch(es) tiveram conflitos de merge (mantidos para inspe\xE7\xE3o):",
   "swarm.statusDone": "ok",
   "swarm.statusIncomplete": "incompleta",
@@ -1448,6 +1486,14 @@ function getTool(name) {
 // src/core/agent/correction.ts
 import { readFile as readFile4, readdir as readdir2 } from "fs/promises";
 import { dirname as dirname2, resolve as resolve6 } from "path";
+function truncationGuidance(toolName) {
+  const fileHint = toolName === "write_file" || toolName === "edit_file" ? " Write large files in parts: create the file with the first chunk via write_file, then append the rest with edit_file in the next steps." : "";
+  return [
+    "AUTO-CORRECTION \u2014 your previous response was cut off at the output token limit,",
+    "so the tool call was incomplete (e.g. 'content' missing or partial).",
+    "Do NOT resend the same large output \u2014 produce a smaller one this time." + fileHint
+  ].join("\n");
+}
 async function buildCorrection(call, output, deps) {
   const deterministic = await deterministicCorrection(call, output, deps);
   if (deterministic) return deterministic;
@@ -1455,6 +1501,7 @@ async function buildCorrection(call, output, deps) {
   return null;
 }
 async function deterministicCorrection(call, output, deps) {
+  if (deps.truncated) return truncationGuidance(call.name);
   const path = typeof call.arguments.path === "string" ? call.arguments.path : void 0;
   if (call.name === "edit_file" && /was not found/i.test(output) && path) {
     const search = typeof call.arguments.search === "string" ? call.arguments.search : "";
@@ -1694,7 +1741,18 @@ async function runAgent(opts) {
     const { toolCalls, text: text2 } = driver.parse(response);
     messages.push(driver.assistantMessage(response, toolCalls));
     if (text2) events?.onAssistantText?.(text2);
+    const truncated = response.finishReason === "length" || response.finishReason === "max_tokens";
     if (toolCalls.length === 0) {
+      if (truncated && autoCorrect) {
+        if (consecutiveNoTool < maxReprompts) {
+          consecutiveNoTool++;
+          const guidance = truncationGuidance();
+          events?.onCorrection?.({ id: "trunc", name: "", arguments: {} }, guidance);
+          messages.push({ role: "user", content: guidance });
+          continue;
+        }
+        return { finished: false, reason: "stalled", steps: step, messages, usage };
+      }
       const stalled = text2.trim().length === 0 || looksLikeStall(text2);
       if (stalled) {
         if (consecutiveNoTool < maxReprompts) {
@@ -1725,6 +1783,7 @@ async function runAgent(opts) {
           workspace: opts.workspace,
           allow: opts.promptContext.allow,
           toolSpec: tool?.spec,
+          truncated,
           // Only spend a fixer-LLM call once the model has already repeated a
           // failing call — the first failure gets deterministic help for free.
           escalate: sig === lastFailSig ? makeLLMEscalator(agent.provider) : void 0
@@ -1735,6 +1794,12 @@ async function runAgent(opts) {
 ${guidance}`;
           events?.onCorrection?.(call, guidance);
         }
+      } else if (result.ok && truncated && autoCorrect) {
+        const guidance = truncationGuidance(call.name);
+        resultText = `${result.output}
+
+${guidance}`;
+        events?.onCorrection?.(call, guidance);
       }
       messages.push(driver.toolResultMessage(call, resultText));
       if (result.ok) {
@@ -2155,9 +2220,9 @@ var TENTACLE_FRAMES = [
 ];
 var WIDTH = Math.max(...[...ART].map((l) => [...l].length));
 function center(line) {
-  const pad = WIDTH - [...line].length;
-  const left = Math.floor(pad / 2);
-  return " ".repeat(left) + line + " ".repeat(pad - left);
+  const pad2 = WIDTH - [...line].length;
+  const left = Math.floor(pad2 / 2);
+  return " ".repeat(left) + line + " ".repeat(pad2 - left);
 }
 var GLYPHS = {
   P: ["\u2588\u2588\u2588\u2588\u2588\u2588", "\u2588\u2588  \u2588\u2588", "\u2588\u2588\u2588\u2588\u2588\u2588", "\u2588\u2588    ", "\u2588\u2588    "],
@@ -2788,6 +2853,169 @@ function extractJsonArray(text2) {
   }
 }
 
+// src/ui/swarm-view.ts
+var RESET3 = "\x1B[0m";
+var FRAMES2 = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function describeToolCall(call) {
+  const raw = call.name === "run_command" ? call.arguments.command : call.arguments.path;
+  const arg = typeof raw === "string" ? raw : "";
+  const short = arg.length > 40 ? arg.slice(0, 39) + "\u2026" : arg;
+  return short ? `${call.name} ${short}` : call.name;
+}
+var SwarmView = class {
+  constructor(leadName, opts = {}) {
+    this.leadName = leadName;
+    this.tty = opts.tty ?? (Boolean(process.stdout.isTTY) && !process.env.NO_COLOR);
+    this.color = opts.color ?? this.tty;
+    this.write = opts.sink ?? ((s) => process.stdout.write(s));
+  }
+  leadName;
+  tty;
+  color;
+  write;
+  workers = /* @__PURE__ */ new Map();
+  order = [];
+  phase = "decomposing";
+  frame = 0;
+  lastLines = 0;
+  timer;
+  start() {
+    if (!this.tty) {
+      this.write(`\u{1F419} ${t("swarm.view.header", { lead: this.leadName })} \u2014 ${t("swarm.view.decomposing")}
+`);
+      return;
+    }
+    this.flush();
+    this.timer = setInterval(() => {
+      this.frame = (this.frame + 1) % FRAMES2.length;
+      this.flush();
+    }, 110);
+    this.timer.unref?.();
+  }
+  setSubtasks(subtasks) {
+    this.phase = "running";
+    for (const s of subtasks) {
+      this.workers.set(s.id, { id: s.id, title: s.title, agent: "", status: "pending", action: "", steps: 0 });
+      this.order.push(s.id);
+    }
+    if (!this.tty) {
+      this.write(`  ${t("swarm.decomposed", { n: subtasks.length })}
+`);
+      for (const s of subtasks) this.write(`  ${s.id}: ${s.title}
+`);
+    }
+    this.flush();
+  }
+  workerStart(id, agent) {
+    const w = this.workers.get(id);
+    if (!w) return;
+    w.agent = agent;
+    w.status = "running";
+    if (!this.tty) this.write(`  \u25B6 ${id} [${agent}] ${w.title}
+`);
+    this.flush();
+  }
+  workerAction(id, action) {
+    const w = this.workers.get(id);
+    if (!w) return;
+    w.action = action;
+    this.flush();
+  }
+  workerStep(id, n) {
+    const w = this.workers.get(id);
+    if (!w) return;
+    w.steps = n;
+    this.flush();
+  }
+  workerDone(o) {
+    const w = this.workers.get(o.subtask.id);
+    if (!w) return;
+    w.status = o.finished ? "done" : "stopped";
+    w.steps = o.steps;
+    w.branch = o.branch;
+    w.action = "";
+    if (!this.tty) {
+      const tag = o.finished ? "\u2713" : "\u25A0";
+      const changes = o.committed ? t("swarm.changesCommitted") : t("swarm.noChanges");
+      this.write(`  ${tag} ${o.subtask.id} (${t("swarm.view.steps", { n: o.steps })}, ${changes})
+`);
+    }
+    this.flush();
+  }
+  merge(r) {
+    for (const w of this.workers.values()) {
+      if (w.branch === r.branch) w.merge = r.ok ? "ok" : "conflict";
+    }
+    if (!this.tty) {
+      this.write(r.ok ? `  \u2935 ${t("swarm.merged", { branch: r.branch })}
+` : `  \u2717 ${t("swarm.mergeConflict", { branch: r.branch })}
+`);
+    }
+    this.flush();
+  }
+  stop() {
+    this.phase = "done";
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = void 0;
+    }
+    this.flush();
+  }
+  /** Content lines of the dashboard (no cursor control). Exposed for tests. */
+  frameLines() {
+    const spin = this.dim(FRAMES2[this.frame]);
+    const lead = `\u{1F419} ${t("swarm.view.header", { lead: this.leadName })}`;
+    const lines = [];
+    if (this.phase === "decomposing") {
+      lines.push(`${spin} ${lead}`);
+      lines.push("  " + this.dim(t("swarm.view.decomposing")));
+      return lines;
+    }
+    lines.push(`${this.phase === "running" ? spin : "  "} ${lead}`);
+    lines.push("");
+    for (const id of this.order) {
+      const w = this.workers.get(id);
+      lines.push(this.row(w, spin));
+    }
+    return lines;
+  }
+  // -------------------------------------------------------------------------
+  row(w, spin) {
+    const icon = w.status === "running" ? spin : w.status === "done" ? this.c("\u2713", "32") : w.status === "stopped" ? this.c("\u25A0", "33") : this.dim("\xB7");
+    const status = this.statusLabel(w);
+    const meta = w.steps > 0 ? this.dim(" \xB7 " + (w.status === "running" ? t("swarm.view.step", { n: w.steps }) : t("swarm.view.steps", { n: w.steps }))) : "";
+    const action = w.action ? w.action : this.dim("\u2014");
+    return `  ${icon} ${pad(w.id, 4)} ${pad(status, 12)} ${pad(`[${w.agent}]`, 14)} ${action}${meta}`;
+  }
+  statusLabel(w) {
+    if (w.merge === "conflict") return this.c(t("swarm.view.conflict"), "31");
+    if (w.status === "running") return this.c(t("swarm.view.running"), "36");
+    if (w.status === "done") return this.c(t("swarm.view.done"), "32");
+    if (w.status === "stopped") return this.c(t("swarm.view.stopped"), "33");
+    return this.dim(t("swarm.view.pending"));
+  }
+  /** Redraw the block in place (TTY) by clearing the previous frame first. */
+  flush() {
+    if (!this.tty) return;
+    const lines = this.frameLines();
+    let s = "";
+    if (this.lastLines > 0) s += `\x1B[${this.lastLines}A`;
+    s += "\x1B[0J";
+    s += lines.join("\n") + "\n";
+    this.write(s);
+    this.lastLines = lines.length;
+  }
+  c(s, code) {
+    return this.color ? `\x1B[${code}m${s}${RESET3}` : s;
+  }
+  dim(s) {
+    return this.color ? `\x1B[2m${s}${RESET3}` : s;
+  }
+};
+function pad(s, n) {
+  return s.length >= n ? s : s + " ".repeat(n - s.length);
+}
+
 // src/cli/commands/swarm.ts
 async function swarm(task, opts) {
   const config = await loadConfig();
@@ -2804,15 +3032,32 @@ async function swarm(task, opts) {
     pc8.dim(t("swarm.status", { agents: resolved.map((a) => a.config.name).join(", "), workspace: process.cwd() }))
   );
   console.log(pc8.yellow(t("swarm.bypassNote") + "\n"));
-  const result = await runSwarm({
-    task,
-    workspace: process.cwd(),
-    agents: resolved,
-    allow: config.permissions.allow,
-    deny: config.permissions.deny,
-    maxSubtasks: opts.maxSubtasks ? Number(opts.maxSubtasks) : void 0,
-    events: renderSwarmEvents()
-  });
+  const view = new SwarmView(resolved[0].config.name);
+  view.start();
+  let result;
+  try {
+    result = await runSwarm({
+      task,
+      workspace: process.cwd(),
+      agents: resolved,
+      allow: config.permissions.allow,
+      deny: config.permissions.deny,
+      maxSubtasks: opts.maxSubtasks ? Number(opts.maxSubtasks) : void 0,
+      events: {
+        onDecomposed: (subtasks) => view.setSubtasks(subtasks),
+        onWorkerStart: (subtask, agentName) => view.workerStart(subtask.id, agentName),
+        onWorkerDone: (outcome) => view.workerDone(outcome),
+        onMerge: (merge) => view.merge(merge),
+        workerEvents: (subtask) => ({
+          onToolCall: (call) => view.workerAction(subtask.id, describeToolCall(call)),
+          onStep: (step) => view.workerStep(subtask.id, step)
+        })
+      }
+    });
+  } finally {
+    view.stop();
+  }
+  console.log("");
   console.log(pc8.bold("\n" + t("swarm.summary")));
   for (const o of result.outcomes) {
     const status = o.finished ? pc8.green(t("swarm.statusDone")) : pc8.yellow(t("swarm.statusIncomplete"));
@@ -2829,26 +3074,6 @@ async function swarm(task, opts) {
     console.log(pc8.green("\n" + t("swarm.allMerged")));
   }
 }
-function renderSwarmEvents() {
-  return {
-    onDecomposed(subtasks) {
-      console.log(pc8.bold(t("swarm.decomposed", { n: subtasks.length })));
-      for (const s of subtasks) console.log(pc8.dim(`  ${s.id}: ${s.title}`));
-      console.log("");
-    },
-    onWorkerStart(subtask, agentName) {
-      console.log(pc8.cyan(t("swarm.workerStart", { id: subtask.id, agent: agentName })));
-    },
-    onWorkerDone(o) {
-      const head = o.finished ? pc8.green(t("swarm.workerDone", { id: o.subtask.id })) : pc8.yellow(t("swarm.workerStopped", { id: o.subtask.id }));
-      const changes = o.committed ? t("swarm.changesCommitted") : t("swarm.noChanges");
-      console.log(head + pc8.dim(t("swarm.workerMeta", { steps: o.steps, changes })));
-    },
-    onMerge(m) {
-      console.log(m.ok ? pc8.dim(t("swarm.merged", { branch: m.branch })) : pc8.red(t("swarm.mergeConflict", { branch: m.branch })));
-    }
-  };
-}
 
 // src/cli/commands/models.ts
 import pc9 from "picocolors";
@@ -2908,17 +3133,263 @@ async function resolveOpenRouterKey() {
   }
 }
 
+// src/cli/commands/prd.ts
+import { writeFile as writeFile4, readFile as readFile5 } from "fs/promises";
+import { execFile } from "child_process";
+import { promisify as promisify2 } from "util";
+import pc10 from "picocolors";
+
+// src/core/agent/prd.ts
+var SYSTEM = [
+  "You are a product analyst. You turn a GitHub issue into a concise, structured PRD",
+  "(Product Requirements Document) in Markdown.",
+  "Rules:",
+  "- Use ONLY information present in the issue and its comments. Do NOT invent scope,",
+  "  numbers, deadlines, or stakeholders. If something is unknown, write 'A definir'.",
+  "- Be objective and short; prefer bullet points over prose.",
+  "- Write in the same language as the issue (Portuguese if the issue is in Portuguese)."
+].join("\n");
+function buildPrdPrompt(issue) {
+  const comments = (issue.comments ?? []).map((c, i) => `Coment\xE1rio ${i + 1}${c.author ? ` (@${c.author})` : ""}:
+${c.body}`).join("\n\n");
+  return [
+    `Issue${issue.number ? ` #${issue.number}` : ""}: ${issue.title}`,
+    "",
+    "Corpo:",
+    issue.body || "(vazio)",
+    comments ? `
+${comments}` : "",
+    "",
+    "Gere um PRD com EXATAMENTE estas se\xE7\xF5es (H2 com ##):",
+    "## Contexto / Problema",
+    "## Objetivo",
+    "## Escopo (in / out)",
+    "## Requisitos funcionais",
+    "## Crit\xE9rios de aceite",
+    "## Riscos e alternativas"
+  ].join("\n");
+}
+async function generatePrd(issue, provider, projectContext) {
+  const messages = [{ role: "system", content: SYSTEM }];
+  if (projectContext) {
+    messages.push({
+      role: "system",
+      content: `Project context (for grounding; do not restate verbatim):
+${projectContext}`
+    });
+  }
+  messages.push({ role: "user", content: buildPrdPrompt(issue) });
+  const res = await provider.chat({
+    messages,
+    params: { maxTokens: 2e3, temperature: 0.2 }
+  });
+  const text2 = res.content.trim();
+  if (!text2) throw new Error("The model returned an empty PRD.");
+  return text2;
+}
+
+// src/core/agent/free-provider.ts
+function resolveFreeProvider(model) {
+  if (!process.env.OPENROUTER_API_KEY) {
+    throw new Error(
+      "OPENROUTER_API_KEY is not set. Export it (or add it as a repo secret in CI) before running this command."
+    );
+  }
+  const config = {
+    name: "openrouter-free",
+    provider: "openrouter",
+    model,
+    apiKey: "${OPENROUTER_API_KEY}",
+    toolMode: "native"
+  };
+  return createProvider(config);
+}
+var DEFAULT_PRD_MODEL = process.env.POLYPUS_PRD_MODEL ?? "openai/gpt-oss-120b:free";
+var DEFAULT_REVIEW_MODEL = process.env.POLYPUS_REVIEW_MODEL ?? "openai/gpt-oss-120b:free";
+async function withRetry(fn, opts = {}) {
+  const attempts = opts.attempts ?? 4;
+  const baseMs = opts.baseMs ?? 2e3;
+  let lastErr;
+  for (let i = 0; i < attempts; i++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastErr = err;
+      const msg = err?.message ?? "";
+      const transient = /\b429\b|\b5\d\d\b|rate|timeout|ETIMEDOUT|ECONNRESET|EAI_AGAIN/i.test(msg);
+      if (!transient || i === attempts - 1) throw err;
+      await new Promise((r) => setTimeout(r, baseMs * 2 ** i));
+    }
+  }
+  throw lastErr;
+}
+
+// src/cli/commands/cli-io.ts
+import { readFileSync, existsSync as existsSync2 } from "fs";
+import { resolve as resolve7 } from "path";
+var GUIDE_MAX = 12e3;
+function readProjectGuide(files) {
+  const parts = [];
+  for (const file of files) {
+    try {
+      const path = resolve7(process.cwd(), file);
+      if (existsSync2(path)) parts.push(`# ${file}
+${readFileSync(path, "utf8").trim()}`);
+    } catch {
+    }
+  }
+  if (parts.length === 0) return void 0;
+  const joined = parts.join("\n\n");
+  return joined.length > GUIDE_MAX ? joined.slice(0, GUIDE_MAX) + "\n\u2026(truncated)" : joined;
+}
+function numericRef(ref) {
+  const num = ref.replace(/^#/, "");
+  if (!/^\d+$/.test(num)) throw new Error(t("cli.invalidRef", { ref }));
+  return num;
+}
+async function readStdin() {
+  if (process.stdin.isTTY) throw new Error(t("cli.stdinTty"));
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf8");
+}
+function stripBom(s) {
+  return s.charCodeAt(0) === 65279 ? s.slice(1) : s;
+}
+
+// src/cli/commands/prd.ts
+var exec2 = promisify2(execFile);
+async function prd(issueRef, opts) {
+  const issue = await loadIssue(issueRef, opts.input);
+  const { provider } = resolveFreeProvider(opts.model ?? DEFAULT_PRD_MODEL);
+  const guide = readProjectGuide(["context.md"]);
+  const markdown = await withRetry(() => generatePrd(issue, provider, guide));
+  if (opts.out) {
+    await writeFile4(opts.out, markdown + "\n", "utf8");
+    console.error(pc10.green(t("prd.wrote", { path: opts.out })));
+  } else {
+    process.stdout.write(markdown + "\n");
+  }
+}
+async function loadIssue(issueRef, input) {
+  if (input) {
+    const raw = input === "-" ? await readStdin() : await readFile5(input, "utf8");
+    return normalize2(JSON.parse(stripBom(raw)));
+  }
+  const num = numericRef(issueRef);
+  const { stdout: stdout2 } = await exec2("gh", ["issue", "view", num, "--json", "number,title,body,comments"]);
+  const data = normalize2(JSON.parse(stdout2));
+  data.number ??= Number(num);
+  return data;
+}
+function normalize2(raw) {
+  return {
+    number: raw.number,
+    title: raw.title ?? "",
+    body: raw.body ?? "",
+    comments: (raw.comments ?? []).map((c) => ({ author: c.author?.login, body: c.body ?? "" }))
+  };
+}
+
+// src/cli/commands/review.ts
+import { writeFile as writeFile5, readFile as readFile6 } from "fs/promises";
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify3 } from "util";
+import pc11 from "picocolors";
+
+// src/core/agent/review.ts
+var MAX_DIFF_CHARS = Number(process.env.POLYPUS_MAX_DIFF_CHARS) || 6e4;
+var SYSTEM2 = [
+  "You are a senior code reviewer. Review the pull request diff below and report",
+  "concrete findings in Markdown.",
+  "Rules:",
+  "- Focus on correctness bugs, security risks, and clear, actionable improvements.",
+  "- Reference file paths (and line hints when visible) so findings are easy to locate.",
+  "- Be concise. Skip style nitpicks unless they hide a real problem.",
+  "- If there are no relevant problems, say so briefly instead of inventing issues.",
+  "- Write in the same language as the PR description (Portuguese if it is in Portuguese)."
+].join("\n");
+function clampDiff(diff, max = MAX_DIFF_CHARS) {
+  if (diff.length <= max) return diff;
+  const dropped = diff.length - max;
+  return `${diff.slice(0, max)}
+
+\u2026 [diff truncado: ${dropped} caracteres omitidos para caber no contexto do modelo]`;
+}
+function buildReviewPrompt(diff, meta) {
+  return [
+    `PR${meta.number ? ` #${meta.number}` : ""}: ${meta.title}`,
+    "",
+    "Descri\xE7\xE3o:",
+    meta.body || "(vazia)",
+    "",
+    "Diff:",
+    "```diff",
+    clampDiff(diff),
+    "```",
+    "",
+    "Liste os achados agrupados por severidade (\u{1F534} bug, \u{1F7E1} aten\xE7\xE3o, \u{1F7E2} sugest\xE3o)."
+  ].join("\n");
+}
+async function reviewDiff(diff, meta, provider, projectGuide) {
+  if (!diff.trim()) return "_Sem altera\xE7\xF5es no diff para revisar._";
+  const messages = [{ role: "system", content: SYSTEM2 }];
+  if (projectGuide) {
+    messages.push({
+      role: "system",
+      content: `Project context and conventions to review against:
+${projectGuide}`
+    });
+  }
+  messages.push({ role: "user", content: buildReviewPrompt(diff, meta) });
+  const res = await provider.chat({
+    messages,
+    params: { maxTokens: 1500, temperature: 0.2 }
+  });
+  const text2 = res.content.trim();
+  if (!text2) throw new Error("The model returned an empty review.");
+  return text2;
+}
+
+// src/cli/commands/review.ts
+var exec3 = promisify3(execFile2);
+async function review(prRef, opts) {
+  const num = opts.input ? prRef.replace(/^#/, "") : numericRef(prRef);
+  const diff = await loadDiff(num, opts.input);
+  const meta = await loadMeta(num, opts.input);
+  const { provider } = resolveFreeProvider(opts.model ?? DEFAULT_REVIEW_MODEL);
+  const guide = readProjectGuide(["rules.md", "context.md"]);
+  const markdown = await withRetry(() => reviewDiff(diff, meta, provider, guide));
+  if (opts.out) {
+    await writeFile5(opts.out, markdown + "\n", "utf8");
+    console.error(pc11.green(t("review.wrote", { path: opts.out })));
+  } else {
+    process.stdout.write(markdown + "\n");
+  }
+}
+async function loadDiff(num, input) {
+  if (input) return input === "-" ? readStdin() : readFile6(input, "utf8");
+  const { stdout: stdout2 } = await exec3("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 exec3("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 join3 } from "path";
 
 // src/core/config/dotenv.ts
-import { existsSync as existsSync2, readFileSync } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
 function loadDotenv(paths) {
   for (const path of paths) {
-    if (!existsSync2(path)) continue;
+    if (!existsSync3(path)) continue;
     let text2;
     try {
-      text2 = readFileSync(path, "utf8");
+      text2 = readFileSync2(path, "utf8");
     } catch {
       continue;
     }
@@ -2943,7 +3414,7 @@ async function launchInteractive() {
   const config = await loadConfig();
   if (config.agents.length === 0) {
     console.log(banner());
-    console.log("  " + pc10.yellow(t("welcome.firstRun")) + "\n");
+    console.log("  " + pc12.yellow(t("welcome.firstRun")) + "\n");
     await setup();
   }
   await run(void 0, {});
@@ -2972,6 +3443,8 @@ function buildProgram() {
   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("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));
+  program.command("review").argument("<pr>", t("cli.arg.reviewPr")).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.review")).action((pr, opts) => review(pr, opts));
   return program;
 }
 async function main() {
@@ -2980,7 +3453,7 @@ async function main() {
     await resolveLocale();
     await buildProgram().parseAsync(process.argv);
   } catch (err) {
-    console.error(pc10.red(`\u2717 ${err.message}`));
+    console.error(pc12.red(`\u2717 ${err.message}`));
     process.exitCode = 1;
   }
 }