@matthugh1/conductor-cli 0.2.0 → 0.2.3

package/dist/daemon-client-CTYOJMJP.js

@@ -0,0 +1,435 @@
+#!/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-LEERSU5N.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"
+      );
+    },
+    // ── CLI operation methods ─────────────────────────────────────────
+    async resolveProjectByPath(path) {
+      const res = await get("/api/projects/resolve", { path });
+      if (res.status === 404) return null;
+      return jsonBody(
+        res,
+        "resolveProjectByPath"
+      );
+    },
+    async saveHealthSnapshot(projectId, report) {
+      const res = await post("/api/environment/health", {
+        projectId,
+        report
+      });
+      await assertOk(res, "saveHealthSnapshot");
+    },
+    async saveGitStatusSnapshot(projectId, snapshot) {
+      const res = await post("/api/environment/health/git-snapshot", {
+        projectId,
+        snapshot
+      });
+      await assertOk(res, "saveGitStatusSnapshot");
+    },
+    async saveBranchOverviewSnapshot(projectId, overview) {
+      const res = await post("/api/environment/health/branch-overview", {
+        projectId,
+        overview
+      });
+      await assertOk(res, "saveBranchOverviewSnapshot");
+    },
+    async claimNextCliTask(projectId) {
+      const res = await post("/api/cli-tasks/claim", { projectId });
+      const { task } = await jsonBody(
+        res,
+        "claimNextCliTask"
+      );
+      return task;
+    },
+    async completeCliTask(taskId, result) {
+      const body = { status: "done" };
+      if (result !== void 0) body.result = result;
+      const res = await patch(`/api/cli-tasks/${taskId}`, body);
+      await assertOk(res, "completeCliTask");
+    },
+    async failCliTask(taskId, error) {
+      const body = { status: "failed" };
+      if (error !== void 0) body.error = error;
+      const res = await patch(`/api/cli-tasks/${taskId}`, body);
+      await assertOk(res, "failCliTask");
+    },
+    async failStaleCliTasks(projectId) {
+      const res = await post("/api/cli-tasks/fail-stale", { projectId });
+      const { count } = await jsonBody(
+        res,
+        "failStaleCliTasks"
+      );
+      return count;
+    },
+    async getWorktreeForInitiative(projectId, initiativeId) {
+      const res = await get("/api/git/worktrees", {
+        projectId,
+        initiativeId,
+        status: "active"
+      });
+      const { worktrees } = await jsonBody(res, "getWorktreeForInitiative");
+      return worktrees.length > 0 ? worktrees[0] : null;
+    },
+    async createWorktreeViaApi(projectId, initiativeId, initiativeTitle) {
+      const res = await post("/api/git/worktrees", {
+        projectId,
+        action: "create",
+        initiativeId,
+        initiativeTitle
+      });
+      const { worktree } = await jsonBody(res, "createWorktreeViaApi");
+      return worktree;
+    },
+    async registerWorktree(opts) {
+      const res = await post("/api/git/worktrees/register", {
+        projectId: opts.projectId,
+        initiativeId: opts.initiativeId,
+        branchName: opts.branchName,
+        worktreePath: opts.worktreePath
+      });
+      return jsonBody(res, "registerWorktree");
+    },
+    async scanWorktreesViaApi(projectId) {
+      const res = await post("/api/git/worktrees", {
+        projectId,
+        action: "scan"
+      });
+      return jsonBody(
+        res,
+        "scanWorktreesViaApi"
+      );
+    },
+    async listActiveWorktrees(projectId) {
+      const res = await get("/api/git/worktrees", {
+        projectId,
+        status: "active"
+      });
+      const { worktrees } = await jsonBody(res, "listActiveWorktrees");
+      return worktrees;
+    },
+    async removeWorktreeViaApi(projectId, worktreeId) {
+      const res = await post("/api/git/worktrees", {
+        projectId,
+        action: "remove",
+        worktreeId
+      });
+      await assertOk(res, "removeWorktreeViaApi");
+    },
+    async logGitActivityViaApi(opts) {
+      const res = await post("/api/git/activity/hook", {
+        hookName: "cli",
+        eventType: opts.eventType,
+        branch: opts.branch,
+        projectRoot: opts.projectRoot,
+        summary: opts.summary,
+        detail: opts.detail ?? {}
+      });
+      await assertOk(res, "logGitActivityViaApi");
+    },
+    // ── 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/{git-hooks-UZJ6AER4.js → git-hooks-RQ6WJQS4.js}

@@ -1,8 +1,7 @@
 #!/usr/bin/env node
 import {
   runGit
-} from "./chunk-FAZ7FCZQ.js";
-import "./chunk-4YEHSYVN.js";
+} from "./chunk-N2KKNG4C.js";
 
 // ../../src/core/git-hooks.ts
 import { chmod, mkdir, readFile, writeFile } from "fs/promises";

package/dist/{git-wrapper-DVJ46TMA.js → git-wrapper-QRZYTYCZ.js}

@@ -11,8 +11,7 @@ import {
   getRecentCommits,
   getStatusSummary,
   runGit
-} from "./chunk-FAZ7FCZQ.js";
-import "./chunk-4YEHSYVN.js";
+} from "./chunk-N2KKNG4C.js";
 export {
   classifyGitCommand,
   createSafetySnapshot,

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matthugh1/conductor-cli",
-  "version": "0.2.0",
+  "version": "0.2.3",
   "description": "Conductor CLI — session management, health checks, and autonomous runner for the Conductor pipeline",
   "type": "module",
   "bin": {

package/dist/branch-overview-XVHTGFCJ.js

@@ -1,18 +0,0 @@
-#!/usr/bin/env node
-import {
-  assertCanQueueMerge,
-  getBranchOverview,
-  getConflictBranchesForWorkQueue,
-  getMergeStats,
-  isBranchFullyOnMain
-} from "./chunk-IHARLSA6.js";
-import "./chunk-FAZ7FCZQ.js";
-import "./chunk-PANC6BTV.js";
-import "./chunk-4YEHSYVN.js";
-export {
-  assertCanQueueMerge,
-  getBranchOverview,
-  getConflictBranchesForWorkQueue,
-  getMergeStats,
-  isBranchFullyOnMain
-};

package/dist/chunk-4YEHSYVN.js

@@ -1,17 +0,0 @@
-#!/usr/bin/env node
-
-// ../../src/core/errors.ts
-var ConductorError = class extends Error {
-  code;
-  retryable;
-  constructor(code, message, retryable = false) {
-    super(message);
-    this.name = "ConductorError";
-    this.code = code;
-    this.retryable = retryable;
-  }
-};
-
-export {
-  ConductorError
-};