@matthugh1/conductor-cli 0.2.0 → 0.2.3

package/dist/agent-spawner-BNOGEYDK.js

@@ -0,0 +1,232 @@
+#!/usr/bin/env node
+import {
+  assembleAutonomousPrompt
+} from "./chunk-6AA726KG.js";
+
+// ../../src/core/agent-spawner.ts
+import { spawn } from "child_process";
+import { readFile } from "fs/promises";
+import { join } from "path";
+import { createInterface } from "readline";
+async function readClaudeMd(projectRoot) {
+  try {
+    return await readFile(join(projectRoot, "CLAUDE.md"), "utf8");
+  } catch {
+    return "";
+  }
+}
+function parseStreamJsonLine(raw) {
+  let event;
+  try {
+    event = JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+  const type = event.type;
+  if (type === "assistant") {
+    const msg = event.message;
+    const content = msg?.content;
+    if (!content) return null;
+    const parts = [];
+    for (const block of content) {
+      if (block.type === "text" && typeof block.text === "string") {
+        parts.push(block.text);
+      } else if (block.type === "tool_use") {
+        const name = block.name;
+        parts.push(`[tool] ${name}`);
+      }
+    }
+    return parts.length > 0 ? parts.join("\n") : null;
+  }
+  if (type === "tool_result") {
+    const name = event.tool_name ?? "tool";
+    const content = event.content;
+    if (content && content.length > 200) {
+      return `[${name}] ${content.slice(0, 200)}...`;
+    }
+    return content ? `[${name}] ${content}` : `[${name}] done`;
+  }
+  if (type === "result") {
+    const subtype = event.subtype;
+    const result = event.result;
+    if (subtype === "success" && result) {
+      return `[result] ${result.slice(0, 500)}`;
+    }
+    if (subtype === "error") {
+      return `[error] ${event.error ?? "unknown error"}`;
+    }
+    return null;
+  }
+  if (type === "system" || type === "rate_limit_event") {
+    return null;
+  }
+  return null;
+}
+function spawnAgent(opts) {
+  let child = null;
+  let cancelled = false;
+  let pid = null;
+  const cancel = () => {
+    cancelled = true;
+    if (child !== null && child.exitCode === null) {
+      child.kill("SIGTERM");
+    }
+  };
+  const done = runAgent(opts, (c) => {
+    child = c;
+    pid = c.pid ?? null;
+  }, () => cancelled);
+  return { done, cancel, get pid() {
+    return pid;
+  } };
+}
+async function runAgent(opts, onChild, isCancelled) {
+  const startTime = Date.now();
+  let lineCount = 0;
+  let prompt;
+  if (opts.assembledPrompt) {
+    prompt = opts.assembledPrompt;
+  } else {
+    const claudeMd = await readClaudeMd(opts.projectRoot);
+    prompt = assembleAutonomousPrompt({
+      claudeMd,
+      projectName: opts.projectRoot,
+      item: opts.item
+    });
+  }
+  const args = ["-p", prompt, "--output-format", "stream-json", "--verbose"];
+  if (opts.modelOverride) {
+    args.push("--model", opts.modelOverride);
+  }
+  if (opts.skipPermissions !== false) {
+    args.push("--dangerously-skip-permissions");
+  }
+  const child = spawn("claude", args, {
+    cwd: opts.projectRoot,
+    stdio: ["ignore", "pipe", "pipe"],
+    env: { ...process.env }
+  });
+  onChild(child);
+  if (child.pid === void 0) {
+    return {
+      outcome: "failed",
+      exitCode: null,
+      lineCount: 0,
+      durationMs: Date.now() - startTime,
+      errorMessage: "Failed to spawn claude process"
+    };
+  }
+  if (child.stdout !== null) {
+    const rl = createInterface({ input: child.stdout });
+    rl.on("line", (raw) => {
+      const text = parseStreamJsonLine(raw);
+      if (text === null) return;
+      lineCount++;
+      const currentLine = lineCount;
+      opts.onLine?.("stdout", text);
+      opts.client.appendOutputLine(opts.runId, {
+        lineNumber: currentLine,
+        stream: "stdout",
+        content: text
+      }).catch(() => {
+      });
+    });
+  }
+  if (child.stderr !== null) {
+    const rl = createInterface({ input: child.stderr });
+    rl.on("line", (line) => {
+      lineCount++;
+      const currentLine = lineCount;
+      opts.onLine?.("stderr", line);
+      opts.client.appendOutputLine(opts.runId, {
+        lineNumber: currentLine,
+        stream: "stderr",
+        content: line
+      }).catch(() => {
+      });
+    });
+  }
+  const exitCode = await waitWithTimeout(
+    child,
+    opts.timeoutMs,
+    opts.client,
+    opts.projectId,
+    opts.deliverableId,
+    isCancelled
+  );
+  const durationMs = Date.now() - startTime;
+  if (isCancelled()) {
+    return { outcome: "cancelled", exitCode, lineCount, durationMs };
+  }
+  if (exitCode === null) {
+    child.kill("SIGTERM");
+    await new Promise((r) => setTimeout(r, 2e3));
+    if (child.exitCode === null) {
+      child.kill("SIGKILL");
+    }
+    return {
+      outcome: "timeout",
+      exitCode: null,
+      lineCount,
+      durationMs,
+      errorMessage: `Task timed out after ${Math.round(opts.timeoutMs / 1e3)}s`
+    };
+  }
+  if (exitCode === 0) {
+    return { outcome: "completed", exitCode, lineCount, durationMs };
+  }
+  return {
+    outcome: "failed",
+    exitCode,
+    lineCount,
+    durationMs,
+    errorMessage: `Agent exited with code ${exitCode}`
+  };
+}
+async function waitWithTimeout(child, timeoutMs, client, projectId, deliverableId, isCancelled) {
+  return new Promise((resolve) => {
+    let resolved = false;
+    let elapsedMs = 0;
+    const TICK_MS = 3e3;
+    const finish = (code) => {
+      if (!resolved) {
+        resolved = true;
+        clearInterval(timer);
+        resolve(code);
+      }
+    };
+    child.on("close", (code) => {
+      finish(code ?? 1);
+    });
+    child.on("error", () => {
+      finish(1);
+    });
+    const timer = setInterval(async () => {
+      if (resolved || isCancelled()) {
+        clearInterval(timer);
+        if (isCancelled() && !resolved) {
+          finish(null);
+        }
+        return;
+      }
+      if (deliverableId) {
+        try {
+          const paused = await client.hasPendingDecisions(projectId, deliverableId);
+          if (!paused) {
+            elapsedMs += TICK_MS;
+          }
+        } catch {
+          elapsedMs += TICK_MS;
+        }
+      } else {
+        elapsedMs += TICK_MS;
+      }
+      if (elapsedMs >= timeoutMs) {
+        finish(null);
+      }
+    }, TICK_MS);
+  });
+}
+export {
+  spawnAgent
+};