@gaberrb/polypus 0.4.11 → 0.4.13

package/dist/index.js

@@ -205,6 +205,7 @@ var en = {
   "swarm.needsAgents": "Swarm mode needs at least {min} configured agents (you have {have}). Add more with `polypus add-agent`, or use `polypus run` for a single agent.",
   "swarm.status": "swarm agents=[{agents}] workspace={workspace}",
   "swarm.bypassNote": "Workers run in bypass mode inside isolated git worktrees; branches are merged at the end.",
+  "swarm.cancelling": "cancelling swarm \u2014 finishing in-flight workers, then merging what committed\u2026",
   "swarm.decomposed": "Decomposed into {n} subtask(s):",
   "swarm.workerStart": "\u25B6 {id} started by {agent}",
   "swarm.workerDone": "\u2713 {id} done",
@@ -464,6 +465,7 @@ var ptBR = {
   "swarm.needsAgents": "O modo swarm precisa de pelo menos {min} agentes configurados (voc\xEA tem {have}). Adicione mais com `polypus add-agent`, ou use `polypus run` para um agente s\xF3.",
   "swarm.status": "swarm agentes=[{agents}] workspace={workspace}",
   "swarm.bypassNote": "Os workers rodam em modo bypass dentro de git worktrees isoladas; os branches s\xE3o mesclados no final.",
+  "swarm.cancelling": "cancelando o swarm \u2014 encerrando os workers em andamento e mesclando o que commitou\u2026",
   "swarm.decomposed": "Dividido em {n} subtarefa(s):",
   "swarm.workerStart": "\u25B6 {id} iniciada por {agent}",
   "swarm.workerDone": "\u2713 {id} conclu\xEDda",
@@ -908,15 +910,33 @@ var OpenAICompatibleProvider = class {
         parameters: t2.parameters
       }
     }));
+    const base = {
+      model: this.model,
+      messages,
+      ...tools && tools.length > 0 ? { tools } : {},
+      temperature: req.params?.temperature,
+      // Generous default so large files aren't truncated mid tool-call.
+      max_tokens: req.params?.maxTokens ?? 8192
+    };
+    if (req.onDelta) {
+      const stream = await this.client.chat.completions.create(
+        { ...base, stream: true, stream_options: { include_usage: true } },
+        { signal: req.signal }
+      );
+      const agg = await aggregateStream(stream, req.onDelta);
+      return {
+        content: agg.content,
+        toolCalls: agg.toolCalls.map((tc, i) => ({
+          id: tc.id || `call_${i}`,
+          name: tc.name,
+          arguments: safeParseArgs(tc.arguments)
+        })),
+        finishReason: agg.finishReason || "stop",
+        usage: agg.usage
+      };
+    }
     const completion = await this.client.chat.completions.create(
-      {
-        model: this.model,
-        messages,
-        ...tools && tools.length > 0 ? { tools } : {},
-        temperature: req.params?.temperature,
-        // Generous default so large files aren't truncated mid tool-call.
-        max_tokens: req.params?.maxTokens ?? 8192
-      },
+      { ...base },
       { signal: req.signal }
     );
     const choice = completion.choices[0];
@@ -937,6 +957,34 @@ var OpenAICompatibleProvider = class {
     };
   }
 };
+async function aggregateStream(stream, onDelta) {
+  let content = "";
+  let finishReason = "";
+  let usage2;
+  const toolAcc = [];
+  for await (const chunk of stream) {
+    const choice = chunk.choices?.[0];
+    const delta = choice?.delta;
+    if (delta?.content) {
+      content += delta.content;
+      onDelta?.(delta.content);
+    }
+    for (const tc of delta?.tool_calls ?? []) {
+      const slot = toolAcc[tc.index] ??= { id: "", name: "", arguments: "" };
+      if (tc.id) slot.id = tc.id;
+      if (tc.function?.name) slot.name = tc.function.name;
+      if (tc.function?.arguments) slot.arguments += tc.function.arguments;
+    }
+    if (choice?.finish_reason) finishReason = choice.finish_reason;
+    if (chunk.usage) {
+      usage2 = {
+        promptTokens: chunk.usage.prompt_tokens,
+        completionTokens: chunk.usage.completion_tokens
+      };
+    }
+  }
+  return { content, finishReason, usage: usage2, toolCalls: toolAcc.filter(Boolean) };
+}
 function toOpenAIMessage(m) {
   switch (m.role) {
     case "tool":
@@ -2282,13 +2330,15 @@ async function runAgent(opts) {
         }
       }
     }
+    const wantDelta = driver.kind === "native" && typeof events?.onAssistantDelta === "function";
     let response;
     try {
       response = await agent.provider.chat({
         messages,
         tools: driver.providerTools(),
         params: opts.params,
-        signal: opts.signal
+        signal: opts.signal,
+        onDelta: wantDelta ? (chunk) => events.onAssistantDelta(chunk) : void 0
       });
     } catch (err) {
       if (opts.signal?.aborted) return { finished: false, reason: "cancelled", steps: step, messages, usage: usage2 };
@@ -3632,7 +3682,7 @@ async function removeWorktree(git, wt) {
 }
 
 // src/core/agent/worker.ts
-async function runWorker(subtask, agent, wt, allow, deny, events) {
+async function runWorker(subtask, agent, wt, allow, deny, events, signal) {
   const permissions = new PermissionEngine({
     mode: "bypass",
     policy: { workspace: wt.path, allow, deny },
@@ -3644,9 +3694,10 @@ async function runWorker(subtask, agent, wt, allow, deny, events) {
     agent,
     permissions,
     promptContext: { workspace: wt.path, mode: "bypass", allow, briefing: subtask.brief },
-    events
+    events,
+    signal
   });
-  const committed = await commitWorktree(wt, `polypus(${subtask.id}): ${subtask.title}`);
+  const committed = result.reason === "cancelled" ? false : await commitWorktree(wt, `polypus(${subtask.id}): ${subtask.title}`);
   return {
     subtask,
     agentName: agent.config.name,
@@ -3663,30 +3714,23 @@ async function runSwarm(opts) {
   const lead = opts.agents[0];
   if (!lead) throw new Error("Swarm requires at least one agent.");
   const maxSubtasks = opts.maxSubtasks ?? Math.max(opts.agents.length, 2);
+  const concurrency = Math.max(1, opts.concurrency ?? opts.agents.length);
+  const idleTimeoutMs2 = opts.idleTimeoutMs ?? 0;
   const git = await ensureRepo(opts.workspace);
-  const subtasks = await decompose(lead, opts.task, maxSubtasks);
+  const subtasks = await decompose(lead, opts.task, maxSubtasks, opts.signal);
   opts.events?.onDecomposed?.(subtasks);
   const worktrees = [];
   for (const subtask of subtasks) {
     worktrees.push(await createWorktree(git, subtask.id));
   }
-  const outcomes = await Promise.all(
-    subtasks.map(async (subtask, i) => {
-      const agent = opts.agents[i % opts.agents.length];
-      const wt = worktrees[i];
-      opts.events?.onWorkerStart?.(subtask, agent.config.name);
-      const outcome = await runWorker(
-        subtask,
-        agent,
-        wt,
-        opts.allow,
-        opts.deny,
-        opts.events?.workerEvents?.(subtask)
-      );
-      opts.events?.onWorkerDone?.(outcome);
-      return outcome;
-    })
-  );
+  const runOne = (subtask, i) => guardedWorker(subtask, opts.agents[i % opts.agents.length], worktrees[i], {
+    allow: opts.allow,
+    deny: opts.deny,
+    idleTimeoutMs: idleTimeoutMs2,
+    signal: opts.signal,
+    events: opts.events
+  });
+  const outcomes = await runPool(subtasks, concurrency, runOne);
   const merges = [];
   for (const outcome of outcomes) {
     if (!outcome.committed) continue;
@@ -3704,13 +3748,69 @@ async function runSwarm(opts) {
   }
   return { subtasks, outcomes, merges };
 }
+async function guardedWorker(subtask, agent, wt, opts) {
+  const ac = new AbortController();
+  const onAbort = () => ac.abort();
+  if (opts.signal) {
+    if (opts.signal.aborted) ac.abort();
+    else opts.signal.addEventListener("abort", onAbort, { once: true });
+  }
+  let idleTimer;
+  const resetIdle = () => {
+    if (opts.idleTimeoutMs <= 0) return;
+    if (idleTimer) clearTimeout(idleTimer);
+    idleTimer = setTimeout(() => ac.abort(), opts.idleTimeoutMs);
+    idleTimer.unref?.();
+  };
+  const base = opts.events?.workerEvents?.(subtask);
+  const events = {
+    ...base,
+    onStep: (n) => {
+      resetIdle();
+      base?.onStep?.(n);
+    }
+  };
+  opts.events?.onWorkerStart?.(subtask, agent.config.name);
+  resetIdle();
+  let outcome;
+  try {
+    outcome = await runWorker(subtask, agent, wt, opts.allow, opts.deny, events, ac.signal);
+  } catch {
+    outcome = {
+      subtask,
+      agentName: agent.config.name,
+      branch: wt.branch,
+      finished: false,
+      committed: false,
+      steps: 0
+    };
+  } finally {
+    if (idleTimer) clearTimeout(idleTimer);
+    opts.signal?.removeEventListener("abort", onAbort);
+  }
+  opts.events?.onWorkerDone?.(outcome);
+  return outcome;
+}
+async function runPool(items, limit, fn) {
+  const results = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    for (; ; ) {
+      const i = next++;
+      if (i >= items.length) return;
+      results[i] = await fn(items[i], i);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+  return results;
+}
 var DECOMPOSE_SYSTEM = [
   "You are a tech lead splitting a coding task into independent subtasks that can be done in parallel.",
   'Return ONLY a JSON array. Each item: {"title": string, "brief": string}.',
   "Make subtasks touch DIFFERENT files/areas to minimize merge conflicts.",
   "Keep the list small (prefer 2-4 items). Each brief must be self-contained and actionable."
 ].join("\n");
-async function decompose(lead, task, maxSubtasks) {
+async function decompose(lead, task, maxSubtasks, signal) {
   try {
     const res = await lead.provider.chat({
       messages: [
@@ -3720,7 +3820,8 @@ ${task}
 
 Return at most ${maxSubtasks} subtasks as a JSON array.` }
       ],
-      params: { temperature: 0 }
+      params: { temperature: 0 },
+      signal
     });
     const parsed = extractJsonArray(res.content);
     if (parsed && parsed.length > 0) {
@@ -3746,6 +3847,28 @@ function extractJsonArray(text2) {
   }
 }
 
+// src/core/agent/concurrency.ts
+var OLLAMA_ENDPOINT_CONCURRENCY = 2;
+var DEFAULT_IDLE_TIMEOUT_MS = 3e5;
+function endpointKey(agent) {
+  return `${agent.config.provider}:${agent.config.baseUrl ?? "default"}`;
+}
+function recommendConcurrency(agents) {
+  const perEndpoint = /* @__PURE__ */ new Map();
+  for (const a of agents) {
+    perEndpoint.set(endpointKey(a), (perEndpoint.get(endpointKey(a)) ?? 0) + 1);
+  }
+  let total = 0;
+  for (const [key, count] of perEndpoint) {
+    total += key.startsWith("ollama:") ? Math.min(count, OLLAMA_ENDPOINT_CONCURRENCY) : count;
+  }
+  return Math.max(1, total);
+}
+function idleTimeoutMs() {
+  const raw = Number(process.env.POLYPUS_SWARM_IDLE_TIMEOUT_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_IDLE_TIMEOUT_MS;
+}
+
 // src/ui/swarm-view.ts
 var RESET2 = "\x1B[0m";
 var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
@@ -3909,6 +4032,35 @@ function pad(s, n) {
   return s.length >= n ? s : s + " ".repeat(n - s.length);
 }
 
+// src/ui/cancel.ts
+function listenForCancel(controller) {
+  const stdin2 = process.stdin;
+  if (!stdin2.isTTY) return { pause() {
+  }, resume() {
+  }, dispose() {
+  } };
+  const onData = (buf) => {
+    if (buf.length === 1 && (buf[0] === 27 || buf[0] === 3)) controller.abort();
+  };
+  let active = false;
+  const attach = () => {
+    if (active) return;
+    stdin2.setRawMode(true);
+    stdin2.resume();
+    stdin2.on("data", onData);
+    active = true;
+  };
+  const detach = () => {
+    if (!active) return;
+    stdin2.off("data", onData);
+    stdin2.setRawMode(false);
+    stdin2.pause();
+    active = false;
+  };
+  attach();
+  return { pause: detach, resume: attach, dispose: detach };
+}
+
 // src/cli/commands/swarm.ts
 var MIN_SWARM_AGENTS = 3;
 function canSwarm(agentCount) {
@@ -3932,6 +4084,11 @@ async function runSwarmSession(task, config, opts = {}) {
     pc7.dim(t("swarm.status", { agents: resolved.map((a) => a.config.name).join(", "), workspace }))
   );
   console.log(pc7.yellow(t("swarm.bypassNote") + "\n"));
+  const controller = new AbortController();
+  const cancel2 = listenForCancel(controller);
+  controller.signal.addEventListener("abort", () => console.log(pc7.dim("\n" + t("swarm.cancelling"))), {
+    once: true
+  });
   const view = new SwarmView(resolved[0].config.name);
   view.start();
   let result;
@@ -3943,6 +4100,9 @@ async function runSwarmSession(task, config, opts = {}) {
       allow: config.permissions.allow,
       deny: config.permissions.deny,
       maxSubtasks: opts.maxSubtasks,
+      concurrency: recommendConcurrency(resolved),
+      idleTimeoutMs: idleTimeoutMs(),
+      signal: controller.signal,
       events: {
         onDecomposed: (subtasks) => view.setSubtasks(subtasks),
         onWorkerStart: (subtask, agentName) => view.workerStart(subtask.id, agentName),
@@ -3956,6 +4116,7 @@ async function runSwarmSession(task, config, opts = {}) {
     });
   } finally {
     view.stop();
+    cancel2.dispose();
   }
   console.log("");
   console.log(pc7.bold("\n" + t("swarm.summary")));
@@ -4228,33 +4389,6 @@ async function executeTask(task, resolved, workspace, session, json = false, ver
 function fmtTokens(n) {
   return n >= 1e3 ? `${(n / 1e3).toFixed(1)}k` : String(n);
 }
-function listenForCancel(controller) {
-  const stdin2 = process.stdin;
-  if (!stdin2.isTTY) return { pause() {
-  }, resume() {
-  }, dispose() {
-  } };
-  const onData = (buf) => {
-    if (buf.length === 1 && (buf[0] === 27 || buf[0] === 3)) controller.abort();
-  };
-  let active = false;
-  const attach = () => {
-    if (active) return;
-    stdin2.setRawMode(true);
-    stdin2.resume();
-    stdin2.on("data", onData);
-    active = true;
-  };
-  const detach = () => {
-    if (!active) return;
-    stdin2.off("data", onData);
-    stdin2.setRawMode(false);
-    stdin2.pause();
-    active = false;
-  };
-  attach();
-  return { pause: detach, resume: attach, dispose: detach };
-}
 async function confirmAction(req) {
   if (req.kind === "write" && req.hunks && req.hunks.length > 0) {
     renderDiff(req.hunks);
@@ -4320,16 +4454,27 @@ function renderDiff(hunks) {
   }
 }
 function renderEvents(spinner3) {
+  let streamed = false;
   return {
     onStep() {
+      streamed = false;
       spinner3.start(t("ui.thinking"));
     },
     onUsage(usage2) {
       const total = usage2.promptTokens + usage2.completionTokens;
       if (total > 0) spinner3.setSuffix(t("ui.tokensShort", { total: fmtTokens(total) }));
     },
+    onAssistantDelta(chunk) {
+      spinner3.stop();
+      process.stdout.write(pc8.cyan(chunk));
+      streamed = true;
+    },
     onAssistantText(text2) {
       spinner3.stop();
+      if (streamed) {
+        process.stdout.write("\n");
+        return;
+      }
       if (text2.trim()) console.log(pc8.cyan(text2.trim()));
     },
     onToolCall(call) {