@matthugh1/conductor-cli 0.1.0 → 0.2.2

package/dist/daemon-client-BE64H437.js

@@ -0,0 +1,312 @@
+#!/usr/bin/env node
+
+// ../../src/core/daemon-client-types.ts
+var DaemonClientError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "DaemonClientError";
+  }
+  status;
+};
+var RETRY_STATUSES = /* @__PURE__ */ new Set([502, 503, 504]);
+var MAX_RETRIES = 2;
+async function fetchWithRetry(url, init) {
+  let lastError;
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      const res = await fetch(url, init);
+      if (attempt < MAX_RETRIES && RETRY_STATUSES.has(res.status)) {
+        await sleep(backoffMs(attempt));
+        continue;
+      }
+      return res;
+    } catch (err) {
+      lastError = err;
+      if (attempt < MAX_RETRIES && isTransient(err)) {
+        await sleep(backoffMs(attempt));
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw lastError;
+}
+function isTransient(err) {
+  if (err instanceof TypeError) return true;
+  if (err instanceof Error) {
+    const msg = err.message.toLowerCase();
+    return msg.includes("econnrefused") || msg.includes("econnreset");
+  }
+  return false;
+}
+function backoffMs(attempt) {
+  return (attempt + 1) * 500;
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+async function assertOk(res, context) {
+  if (res.ok) return;
+  let message = `${context}: HTTP ${res.status}`;
+  try {
+    const body = await res.json();
+    if (body.error) message = `${context}: ${body.error}`;
+  } catch {
+  }
+  throw new DaemonClientError(message, res.status);
+}
+async function jsonBody(res, context) {
+  await assertOk(res, context);
+  return await res.json();
+}
+
+// ../../src/core/daemon-client.ts
+function createDaemonClient(baseUrl = "https://conductor-297703646986.europe-west2.run.app", apiKey) {
+  const base = baseUrl.replace(/\/+$/, "");
+  let defaultProjectId;
+  let resolvedKey = apiKey ?? process.env.CONDUCTOR_API_KEY;
+  let cliConfigLoaded = false;
+  async function ensureConfig() {
+    if (cliConfigLoaded) return;
+    cliConfigLoaded = true;
+    try {
+      const { readApiKey, readProjectId } = await import("./cli-config-2ZDXUUQN.js");
+      if (!resolvedKey) resolvedKey = readApiKey();
+      if (!defaultProjectId) defaultProjectId = readProjectId();
+    } catch {
+    }
+  }
+  function authHeaders() {
+    const headers = {};
+    if (resolvedKey) {
+      headers.Authorization = `Bearer ${resolvedKey}`;
+    }
+    return headers;
+  }
+  function url(path, params) {
+    const u = new URL(path, base);
+    if (defaultProjectId) {
+      u.searchParams.set("projectId", defaultProjectId);
+    }
+    if (params) {
+      for (const [k, v] of Object.entries(params)) {
+        u.searchParams.set(k, v);
+      }
+    }
+    return u.toString();
+  }
+  async function post(path, body, params) {
+    await ensureConfig();
+    return fetchWithRetry(url(path, params), {
+      method: "POST",
+      headers: { ...authHeaders(), "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+  }
+  async function patch(path, body, params) {
+    await ensureConfig();
+    return fetchWithRetry(url(path, params), {
+      method: "PATCH",
+      headers: { ...authHeaders(), "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+  }
+  async function get(path, params) {
+    await ensureConfig();
+    return fetchWithRetry(url(path, params), {
+      method: "GET",
+      headers: authHeaders()
+    });
+  }
+  async function del(path, params) {
+    await ensureConfig();
+    return fetchWithRetry(url(path, params), {
+      method: "DELETE",
+      headers: authHeaders()
+    });
+  }
+  return {
+    async resolveProject(opts) {
+      const res = await get("/api/projects");
+      const { projects } = await jsonBody(
+        res,
+        "resolveProject"
+      );
+      const match = projects.find((p) => {
+        if (opts.name && p.name === opts.name) return true;
+        if (opts.path && p.path === opts.path) return true;
+        return false;
+      });
+      if (!match) {
+        throw new DaemonClientError(
+          `Project not found (name=${opts.name ?? ""}, path=${opts.path ?? ""})`,
+          404
+        );
+      }
+      if (!match.path) {
+        throw new DaemonClientError(
+          `Project "${match.name}" has no local path registered.`,
+          400
+        );
+      }
+      defaultProjectId = match.id;
+      return { id: match.id, path: match.path };
+    },
+    async upsertHeartbeat(opts) {
+      const res = await post("/api/daemon/heartbeat", opts);
+      await assertOk(res, "upsertHeartbeat");
+    },
+    async clearHeartbeat(projectId) {
+      const res = await del("/api/daemon/heartbeat", { projectId });
+      await assertOk(res, "clearHeartbeat");
+    },
+    async createRun(opts) {
+      const res = await post("/api/daemon/runs", opts);
+      const { run } = await jsonBody(res, "createRun");
+      return run;
+    },
+    async completeRun(runId, opts) {
+      const res = await patch(`/api/daemon/runs/${runId}`, opts);
+      await assertOk(res, "completeRun");
+    },
+    async updateRunPid(runId, pid) {
+      const res = await patch(`/api/daemon/runs/${runId}`, { pid });
+      await assertOk(res, "updateRunPid");
+    },
+    async getQuota(projectId) {
+      const res = await get("/api/daemon/quota", { projectId });
+      const { count } = await jsonBody(res, "getQuota");
+      return count;
+    },
+    async purgeOldRuns(daysOld) {
+      const body = daysOld !== void 0 ? { daysOld } : {};
+      const res = await post("/api/daemon/purge", body);
+      const { purged } = await jsonBody(
+        res,
+        "purgeOldRuns"
+      );
+      return purged;
+    },
+    async pollWorkQueue(projectId, limit, opts) {
+      const params = { projectId };
+      if (limit !== void 0) params.limit = String(limit);
+      if (opts?.autonomous) params.autonomous = "true";
+      const res = await get("/api/work-queue", params);
+      return jsonBody(res, "pollWorkQueue");
+    },
+    async updateDeliverableStatus(deliverableId, status) {
+      const res = await patch(`/api/backlog/${deliverableId}`, { status });
+      await assertOk(res, "updateDeliverableStatus");
+    },
+    async getDeliverableDetail(deliverableId) {
+      const res = await get(`/api/backlog/${deliverableId}`);
+      if (res.status === 404) return null;
+      const data = await jsonBody(res, "getDeliverableDetail");
+      return {
+        prompt: data.deliverable?.prompt ?? null,
+        type: data.deliverable?.type ?? null
+      };
+    },
+    async getInitiativeForDeliverable(deliverableId) {
+      const res = await get(
+        `/api/pipeline/deliverables/${deliverableId}`
+      );
+      if (res.status === 404) return null;
+      const data = await jsonBody(res, "getInitiativeForDeliverable");
+      const d = data.parent;
+      if (!d?.initiativeId || !d.initiativeTitle) return null;
+      return {
+        initiativeId: d.initiativeId,
+        initiativeTitle: d.initiativeTitle
+      };
+    },
+    async appendOutputLine(runId, opts) {
+      const res = await post(`/api/daemon/runs/${runId}/output`, opts);
+      await assertOk(res, "appendOutputLine");
+    },
+    async hasPendingDecisions(projectId, deliverableId) {
+      const res = await get("/api/decisions", {
+        status: "pending",
+        scope: "deliverable",
+        deliverableId,
+        projectId
+      });
+      const { pending } = await jsonBody(res, "hasPendingDecisions");
+      return pending.length > 0;
+    },
+    async ingestAutonomousDeliverables(projectId, projectRoot) {
+      const res = await post("/api/daemon/ingest", {
+        projectId,
+        projectRoot
+      });
+      const { created } = await jsonBody(
+        res,
+        "ingestAutonomousDeliverables"
+      );
+      return created;
+    },
+    async routeUnassignedTasks(projectId) {
+      const res = await post(
+        "/api/daemon/tasks/route-unassigned",
+        { projectId }
+      );
+      const { assignments } = await jsonBody(res, "routeUnassignedTasks");
+      return assignments;
+    },
+    async routePendingTasks(projectId, projectRoot) {
+      const res = await post("/api/daemon/route", {
+        projectId,
+        projectRoot
+      });
+      return jsonBody(
+        res,
+        "routePendingTasks"
+      );
+    },
+    // ── Agent backlog methods ───────────────────────────────────────
+    async listEnabledAgents(projectId) {
+      const res = await get("/api/daemon/agents", {
+        projectId,
+        enabledOnly: "true"
+      });
+      const { agents } = await jsonBody(
+        res,
+        "listEnabledAgents"
+      );
+      return agents;
+    },
+    async getNextTasksForAgent(agentId, limit) {
+      const params = { agentId };
+      if (limit !== void 0) params.limit = String(limit);
+      const res = await get("/api/daemon/tasks/next", params);
+      const { tasks } = await jsonBody(
+        res,
+        "getNextTasksForAgent"
+      );
+      return tasks;
+    },
+    async claimTask(taskId) {
+      const res = await post(`/api/daemon/tasks/${taskId}/claim`, {});
+      if (res.status === 409) return null;
+      const { task } = await jsonBody(
+        res,
+        "claimTask"
+      );
+      return task;
+    },
+    async updateTask(taskId, updates) {
+      const res = await patch(`/api/daemon/tasks/${taskId}`, updates);
+      if (res.status === 404) return null;
+      const { task } = await jsonBody(
+        res,
+        "updateTask"
+      );
+      return task;
+    }
+  };
+}
+export {
+  DaemonClientError,
+  createDaemonClient
+};

package/dist/{health-CTND2ANA.js → health-UFK7YCKQ.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   getProjectPathById
-} from "./chunk-VYINBHPQ.js";
+} from "./chunk-6VMREHG4.js";
 import {
   runGit
 } from "./chunk-FAZ7FCZQ.js";

package/dist/runner-prompt-MOOPKA5P.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import {
+  assembleAutonomousPrompt,
+  assembleTaskPrompt
+} from "./chunk-6AA726KG.js";
+export {
+  assembleAutonomousPrompt,
+  assembleTaskPrompt
+};

package/dist/{work-queue-YE5P4S7R.js → work-queue-U3JYHLX2.js}

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 import {
   getConflictBranchesForWorkQueue
-} from "./chunk-IHARLSA6.js";
-import "./chunk-VYINBHPQ.js";
+} from "./chunk-7S5HKGS5.js";
+import "./chunk-3MJBQK2F.js";
+import "./chunk-6VMREHG4.js";
 import {
   getGitBranchInfo
 } from "./chunk-FAZ7FCZQ.js";
@@ -444,7 +445,7 @@ async function computeWorkQueue(projectRoot, limit = 20, options) {
     try {
       const activeRows = await query(
         `
-        SELECT d.id, d.title, d.assigned_role, i.title AS initiative_title,
+        SELECT d.id, d.title, d.assigned_role, d.autonomous, i.title AS initiative_title,
           i.rice_score::text AS rice_score
         FROM deliverables d
         JOIN outcomes o ON o.id = d.outcome_id
@@ -469,7 +470,8 @@ async function computeWorkQueue(projectRoot, limit = 20, options) {
           entityId: row.id,
           entityType: "deliverable",
           initiativeTitle: row.initiative_title,
-          riceScore: rice
+          riceScore: rice,
+          autonomous: row.autonomous
         });
       }
     } catch {
@@ -477,7 +479,7 @@ async function computeWorkQueue(projectRoot, limit = 20, options) {
     try {
       const readyRows = await query(
         `
-        SELECT d.id, d.title, d.assigned_role, i.title AS initiative_title,
+        SELECT d.id, d.title, d.assigned_role, d.autonomous, i.title AS initiative_title,
           i.rice_score::text AS rice_score, i.current_stage
         FROM deliverables d
         JOIN outcomes o ON o.id = d.outcome_id
@@ -506,7 +508,8 @@ async function computeWorkQueue(projectRoot, limit = 20, options) {
           entityId: row.id,
           entityType: "deliverable",
           initiativeTitle: row.initiative_title,
-          riceScore: rice
+          riceScore: rice,
+          autonomous: row.autonomous
         });
       }
     } catch {
@@ -555,16 +558,7 @@ async function computeWorkQueue(projectRoot, limit = 20, options) {
           ON prev.outcome_id = cur.outcome_id AND prev.rn = cur.rn - 1
         WHERE cur.status = 'todo'
           AND prev.status IN ('done', 'review')
-          AND NOT EXISTS (
-            SELECT 1 FROM prompts p
-            WHERE p.deliverable_id = cur.id
-          )
-          AND NOT EXISTS (
-            SELECT 1 FROM prompts p
-            WHERE p.project_id = cur.project_id
-              AND p.initiative_id IS NULL
-              AND p.deliverable_id IS NULL
-          )
+          AND (cur.prompt IS NULL OR cur.prompt = '')
         `,
         [projectId]
       );
@@ -612,7 +606,7 @@ async function computeWorkQueue(projectRoot, limit = 20, options) {
       );
       for (const row of blockedRows) {
         const rice = parseRice(row.rice_score);
-        const isUnblocked = row.blocker_status === "done";
+        const isUnblocked = row.blocker_status === "done" || row.blocker_status === "review";
         items.push({
           priority: isUnblocked ? 0 : 50,
           tier: isUnblocked ? "ready" : "pipeline",

package/dist/{worktree-manager-QKRBTPVC.js → worktree-manager-2ZUJEL3L.js}

@@ -11,7 +11,8 @@ import {
   removeWorktree,
   scanWorktrees,
   slugifyForBranch
-} from "./chunk-JZT526HU.js";
+} from "./chunk-KB2DTST2.js";
+import "./chunk-3MJBQK2F.js";
 import "./chunk-FAZ7FCZQ.js";
 import "./chunk-PANC6BTV.js";
 import "./chunk-4YEHSYVN.js";

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@matthugh1/conductor-cli",
-  "version": "0.1.0",
+  "version": "0.2.2",
   "description": "Conductor CLI — session management, health checks, and autonomous runner for the Conductor pipeline",
   "type": "module",
   "bin": {
-    "conductor": "./dist/agent.js"
+    "conductor": "dist/agent.js"
   },
   "files": [
     "dist"

package/dist/runner-prompt-2B6EXGN6.js

@@ -1,139 +0,0 @@
-#!/usr/bin/env node
-
-// ../../src/core/runner-prompt.ts
-var AUTONOMOUS_WORKFLOW = `
-## Identity
-
-You are an autonomous implementation engineer spawned by Conductor's runner.
-You have no human in the loop \u2014 every decision you cannot make yourself must
-be parked for morning review. Work carefully and methodically.
-
-## Workflow (follow in order)
-
-### 1. Start your session
-
-Call conductor_session_brief with:
-- projectRoot: the project name given in your assignment below
-- deliverableId: the deliverable ID given in your assignment below
-- agentRole: "implementation-engineer"
-- agentType: "claude-code"
-
-Save the returned sessionId \u2014 pass it to every subsequent Conductor call.
-
-### 2. Read the brief and understand your assignment
-
-The session brief contains your deliverable title, description, and
-acceptance criteria. Read them carefully before writing any code.
-
-### 3. Branch from main
-
-Run: git checkout main && git pull && git checkout -b <branch-name>
-
-Name the branch after the deliverable (e.g., feat/prompt-template).
-Never branch from another feature branch.
-
-### 4. Mark your deliverable in-progress
-
-Call conductor_update_deliverable with status "in_progress".
-
-### 5. Do the work
-
-Implement the deliverable according to its acceptance criteria.
-After each meaningful chunk of work, call conductor_log_built with
-a plain English summary and the sessionId.
-
-### 6. Self-check before submitting
-
-Before creating a PR, run ALL of these checks:
-
-1. npx tsc --noEmit          (type check)
-2. npm run build              (build)
-3. npm test                   (tests)
-4. git status                 (working tree clean?)
-5. Review your own code for:
-   - No \`any\` type assertions
-   - No console.log in production code
-   - No large files (>200 lines of code)
-   - No large functions (>50 lines)
-   - No unused imports
-   - No secrets or .env files staged
-
-### 7. Retry on failure (up to 3 attempts)
-
-If any check fails:
-- Read the error output carefully
-- Fix the issue
-- Re-run the failing check
-- Repeat up to 3 total attempts per check
-
-If a check still fails after 3 attempts, go to the parking procedure (step 10).
-
-### 8. Create a PR
-
-When all checks pass:
-- git add the relevant files (never use git add -A)
-- git commit with a descriptive message
-- git push -u origin <branch-name>
-- gh pr create --title "<deliverable title>" --body "<summary>"
-- Save the PR URL \u2014 you need it for the completion report
-
-Never merge your own PR. Only create it.
-
-### 9. Submit for review
-
-Call conductor_update_deliverable with:
-- status: "review"
-- completionReport with all check results and the prUrl
-
-Then call conductor_end_session with the sessionId.
-
-### 10. Parking procedure (when stuck)
-
-If you cannot complete the work:
-- If it is a judgment call or ambiguous requirement:
-  Call conductor_log_decision with the options and reasoning.
-- Call conductor_update_deliverable with status "parked".
-- Call conductor_log_next describing what remains and why you stopped.
-- Call conductor_end_session with the sessionId.
-- Exit cleanly.
-
-## Rules
-
-- Follow all rules in CLAUDE.md (included above if present).
-- Never merge your own PR.
-- Never make silent decisions \u2014 log every judgment call via conductor_log_decision.
-- If a subsequent deliverable exists in the same outcome, create a handoff
-  prompt via conductor_create_prompt before submitting for review.
-- Keep commits atomic and messages descriptive.
-- Do not install new dependencies without logging a decision.
-- Do not modify files outside the scope of your deliverable.
-- If you encounter merge conflicts, resolve them yourself.
-- Work within the existing code style and patterns.
-`.trim();
-function assembleAutonomousPrompt(ctx) {
-  const parts = [];
-  if (ctx.claudeMd.length > 0) {
-    parts.push("# Project Rules (CLAUDE.md)\n\n" + ctx.claudeMd);
-  }
-  parts.push("# Autonomous Runner Instructions\n\n" + AUTONOMOUS_WORKFLOW);
-  parts.push(
-    `# Your Assignment
-
-Project: ${ctx.projectName}
-Deliverable: ${ctx.item.title}
-Deliverable ID: ${ctx.item.entityId}
-Initiative: ${ctx.item.initiativeTitle ?? "unknown"}
-Priority: P${ctx.item.priority}
-Action: ${ctx.item.action}
-
-Start by calling conductor_session_brief with:
-- projectRoot: "${ctx.projectName}"
-- deliverableId: "${ctx.item.entityId}"
-- agentRole: "implementation-engineer"
-- agentType: "claude-code"`
-  );
-  return parts.join("\n\n---\n\n");
-}
-export {
-  assembleAutonomousPrompt
-};