@matthugh1/conductor-cli 0.2.0 → 0.2.2

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
+};

package/dist/agent.js

@@ -2,7 +2,7 @@
 import {
   ensureDatabaseUrl,
   postToServer
-} from "./chunk-MJKFQIYA.js";
+} from "./chunk-B2WDTKD7.js";
 
 // ../../src/cli/agent.ts
 import { resolve } from "path";
@@ -18,6 +18,12 @@ function parseArgs(argv) {
   let consecutiveFailures = 3;
   let skipPermissions = false;
   let dryRun = false;
+  let checkInterval = 3e4;
+  let maxPerDay = 50;
+  let maxConcurrent = 1;
+  let noWorktree = false;
+  let apiUrl;
+  let apiKey;
   let command;
   let subcommand;
   for (let i = 0; i < args.length; i++) {
@@ -36,6 +42,18 @@ function parseArgs(argv) {
       skipPermissions = true;
     } else if (arg === "--dry-run") {
       dryRun = true;
+    } else if (arg === "--check-interval" && i + 1 < args.length) {
+      checkInterval = Number.parseInt(args[++i], 10);
+    } else if (arg === "--max-per-day" && i + 1 < args.length) {
+      maxPerDay = Number.parseInt(args[++i], 10);
+    } else if (arg === "--max-concurrent" && i + 1 < args.length) {
+      maxConcurrent = Number.parseInt(args[++i], 10);
+    } else if (arg === "--no-worktree") {
+      noWorktree = true;
+    } else if (arg === "--api-url" && i + 1 < args.length) {
+      apiUrl = args[++i];
+    } else if (arg === "--api-key" && i + 1 < args.length) {
+      apiKey = args[++i];
     } else if (arg === "--json") {
       json = true;
     } else if (arg === "--help" || arg === "-h") {
@@ -48,7 +66,7 @@ function parseArgs(argv) {
       subcommand = arg;
     }
   }
-  return { command, subcommand, projectRoot, project, json, help, once, maxDeliverables, timeout, consecutiveFailures, skipPermissions, dryRun };
+  return { command, subcommand, projectRoot, project, json, help, once, maxDeliverables, timeout, consecutiveFailures, skipPermissions, dryRun, checkInterval, maxPerDay, maxConcurrent, noWorktree, apiUrl, apiKey };
 }
 var HELP_TEXT = `
 Conductor \u2014 local agent CLI
@@ -62,10 +80,12 @@ Commands:
   hooks       Check hook status or install hooks
   watch       Poll for cleanup tasks and execute them locally
   run         Autonomous runner \u2014 work through deliverable queue
+  daemon      Long-running daemon \u2014 polls for autonomous work
+  daemon cancel  Stop a running daemon
 
 Options:
   --project-root <path>         Project directory (default: cwd)
-  --project <name>              Project name (for run command)
+  --project <name>              Project name (for run/daemon commands)
   --json                        Output as JSON instead of plain English
   --once                        Process one task and exit (watch only)
   --help                        Show this help text
@@ -77,6 +97,15 @@ Run options:
   --skip-permissions            Allow Claude to write files without prompting
   --dry-run                     Show queue without spawning agents
 
+Daemon options:
+  --check-interval <ms>         Poll interval in milliseconds (default: 30000)
+  --max-per-day <n>             Max tasks per day (default: 50)
+  --max-concurrent <n>          Max concurrent agent tasks (default: 1)
+  --timeout <minutes>           Max minutes per deliverable (default: 120)
+  --consecutive-failures <n>    Stop after N failures in a row (default: 3)
+  --no-worktree                 Skip git worktree isolation
+  --skip-permissions            Allow Claude to write files without prompting
+
 Examples:
   conductor check
   conductor init --project-root /path/to/project
@@ -85,6 +114,8 @@ Examples:
   conductor watch
   conductor run --project Conductor --skip-permissions
   conductor run --project Conductor --dry-run
+  conductor daemon --project Conductor
+  conductor daemon cancel --project Conductor
 `.trim();
 function writeOut(text) {
   process.stdout.write(text + "\n");
@@ -113,7 +144,7 @@ async function cmdCheck(projectRoot, jsonOutput) {
     }
     return 1;
   }
-  const { getEnvironmentHealthReport } = await import("./health-CTND2ANA.js");
+  const { getEnvironmentHealthReport } = await import("./health-UFK7YCKQ.js");
   const report = await getEnvironmentHealthReport(projects[0].id);
   if (jsonOutput) {
     writeOut(JSON.stringify(report, null, 2));
@@ -188,7 +219,7 @@ async function cmdCheck(projectRoot, jsonOutput) {
   }
   try {
     const { getGitBranchInfo } = await import("./git-wrapper-DVJ46TMA.js");
-    const { getBranchOverview } = await import("./branch-overview-XVHTGFCJ.js");
+    const { getBranchOverview } = await import("./branch-overview-DSSCUE5F.js");
     const { saveBranchOverviewSnapshot } = await import("./git-snapshots-N3FBS7T3.js");
     const branchInfo = await getGitBranchInfo(projectRoot);
     let currentBranch = branchInfo.branchName;
@@ -214,7 +245,7 @@ async function cmdCheck(projectRoot, jsonOutput) {
   return 0;
 }
 async function cmdScan(projectRoot, jsonOutput) {
-  const { scanWorktrees } = await import("./worktree-manager-QKRBTPVC.js");
+  const { scanWorktrees } = await import("./worktree-manager-2ZUJEL3L.js");
   const { query: dbQuery } = await import("./db-U6Y3QJDD.js");
   const projects = await dbQuery(
     "SELECT id FROM projects WHERE path = $1 LIMIT 1",
@@ -262,7 +293,7 @@ async function cmdScan(projectRoot, jsonOutput) {
 async function cmdInit(projectRoot, jsonOutput) {
   const { resolve: resolvePath, basename, join } = await import("path");
   const { realpath, mkdir, readFile, writeFile, access } = await import("fs/promises");
-  const { getServerBaseUrl } = await import("./cli-config-TDSTAXIA.js");
+  const { getServerBaseUrl } = await import("./cli-config-2ZDXUUQN.js");
   let root = resolvePath(projectRoot.trim());
   try {
     root = await realpath(root);
@@ -379,7 +410,7 @@ async function cmdHooks(projectRoot, subcommand, jsonOutput) {
   return 2;
 }
 async function cmdWatch(projectRoot, once, jsonOutput) {
-  const { claimNextTask, executeTask, failStaleTasks } = await import("./cli-tasks-NW3BONXC.js");
+  const { claimNextTask, executeTask, failStaleTasks } = await import("./cli-tasks-NM5D5PIZ.js");
   const { query: dbQuery } = await import("./db-U6Y3QJDD.js");
   const projects = await dbQuery(
     "SELECT id FROM projects WHERE path = $1 LIMIT 1",
@@ -464,8 +495,8 @@ async function cmdWatch(projectRoot, once, jsonOutput) {
 async function cmdRun(opts) {
   const { spawn } = await import("child_process");
   const { readFileSync, existsSync } = await import("fs");
-  const { assembleAutonomousPrompt } = await import("./runner-prompt-2B6EXGN6.js");
-  const { computeWorkQueue } = await import("./work-queue-YE5P4S7R.js");
+  const { assembleAutonomousPrompt } = await import("./runner-prompt-MOOPKA5P.js");
+  const { computeWorkQueue } = await import("./work-queue-U3JYHLX2.js");
   const { query: dbQuery } = await import("./db-U6Y3QJDD.js");
   let project = opts.projectName ?? opts.projectRoot;
   if (opts.projectName) {
@@ -647,12 +678,15 @@ async function main() {
     writeOut(HELP_TEXT);
     process.exit(parsed.help ? 0 : 1);
   }
-  const hasDb = await ensureDatabaseUrl();
-  if (!hasDb) {
-    writeErr(
-      "Could not find a database connection. Make sure the MCP server is running (npm run mcp) and try again."
-    );
-    process.exit(1);
+  const needsDb = parsed.command !== "daemon";
+  if (needsDb) {
+    const hasDb = await ensureDatabaseUrl();
+    if (!hasDb) {
+      writeErr(
+        "Could not find a database connection. Make sure the MCP server is running (npm run mcp) and try again."
+      );
+      process.exit(1);
+    }
   }
   try {
     let exitCode;
@@ -692,6 +726,34 @@ async function main() {
           jsonOutput: parsed.json
         });
         break;
+      case "daemon": {
+        const { cmdDaemon, cmdDaemonCancel } = await import("./daemon-GGOJDZDB.js");
+        if (parsed.subcommand === "cancel") {
+          exitCode = await cmdDaemonCancel(
+            parsed.projectRoot,
+            parsed.project,
+            parsed.json,
+            parsed.apiUrl,
+            parsed.apiKey
+          );
+        } else {
+          exitCode = await cmdDaemon({
+            projectRoot: parsed.projectRoot,
+            projectName: parsed.project,
+            apiUrl: parsed.apiUrl,
+            apiKey: parsed.apiKey,
+            checkInterval: parsed.checkInterval,
+            maxPerDay: parsed.maxPerDay,
+            maxConsecutiveFailures: parsed.consecutiveFailures,
+            timeout: parsed.timeout,
+            maxConcurrent: parsed.maxConcurrent,
+            noWorktree: parsed.noWorktree,
+            skipPermissions: parsed.skipPermissions,
+            jsonOutput: parsed.json
+          });
+        }
+        break;
+      }
       default:
         writeErr(`Unknown command: ${parsed.command}`);
         writeErr("Run conductor --help for usage.");

package/dist/{branch-overview-XVHTGFCJ.js → branch-overview-DSSCUE5F.js}

@@ -5,7 +5,7 @@ import {
   getConflictBranchesForWorkQueue,
   getMergeStats,
   isBranchFullyOnMain
-} from "./chunk-IHARLSA6.js";
+} from "./chunk-7S5HKGS5.js";
 import "./chunk-FAZ7FCZQ.js";
 import "./chunk-PANC6BTV.js";
 import "./chunk-4YEHSYVN.js";

package/dist/chunk-3MJBQK2F.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+import {
+  query
+} from "./chunk-PANC6BTV.js";
+
+// ../../src/core/notifications.ts
+var VALID_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "gate_rejection",
+  "gate_bypassed",
+  "review_needed",
+  "handoff_needed",
+  "decision_pending",
+  "stale_session",
+  "abandoned_session",
+  "missing_checkin",
+  "orphan_work",
+  "stage_transition",
+  "watchdog_flag",
+  "stale_worktree",
+  "autonomous_flag_changed"
+]);
+var VALID_PRIORITIES = /* @__PURE__ */ new Set([
+  "info",
+  "warning",
+  "action_needed"
+]);
+var VALID_LINK_TYPES = /* @__PURE__ */ new Set([
+  "deliverable",
+  "decision",
+  "initiative",
+  "session"
+]);
+async function createNotification(params) {
+  if (!params.projectId || params.projectId.trim().length === 0) {
+    throw new Error("A project id is required to create a notification.");
+  }
+  if (!VALID_EVENT_TYPES.has(params.eventType)) {
+    throw new Error(
+      `Unknown event type "${params.eventType}". Expected one of: ${[...VALID_EVENT_TYPES].join(", ")}.`
+    );
+  }
+  if (!params.message || params.message.trim().length === 0) {
+    throw new Error("A notification needs a message.");
+  }
+  if (!VALID_PRIORITIES.has(params.priority)) {
+    throw new Error(
+      `Unknown priority "${params.priority}". Expected info, warning, or action_needed.`
+    );
+  }
+  if (params.linkType !== void 0 && !VALID_LINK_TYPES.has(params.linkType)) {
+    throw new Error(
+      `Unknown link type "${params.linkType}". Expected deliverable, decision, initiative, or session.`
+    );
+  }
+  const rows = await query(
+    `INSERT INTO notifications (project_id, event_type, message, priority, link_type, link_id, agent_type, agent_name)
+     VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+     RETURNING id`,
+    [
+      params.projectId,
+      params.eventType,
+      params.message.trim(),
+      params.priority,
+      params.linkType ?? null,
+      params.linkId ?? null,
+      params.agentType ?? null,
+      params.agentName ?? null
+    ]
+  );
+  return rows[0].id;
+}
+
+export {
+  createNotification
+};