@matthugh1/conductor-cli 0.1.0

package/dist/chunk-JZT526HU.js

@@ -0,0 +1,536 @@
+#!/usr/bin/env node
+import {
+  runGit
+} from "./chunk-FAZ7FCZQ.js";
+import {
+  query
+} from "./chunk-PANC6BTV.js";
+
+// ../../src/core/worktree-manager.ts
+import { existsSync } from "fs";
+import path from "path";
+
+// ../../src/core/git-activity.ts
+function rowToEvent(row) {
+  return {
+    id: row.id,
+    projectId: row.project_id,
+    initiativeId: row.initiative_id,
+    worktreeId: row.worktree_id,
+    eventType: row.event_type,
+    summary: row.summary,
+    plainEnglish: row.plain_english,
+    branch: row.branch,
+    detail: row.detail,
+    source: row.source,
+    createdAt: row.created_at.toISOString()
+  };
+}
+async function logGitActivity(input) {
+  const rows = await query(
+    `
+    INSERT INTO git_activity (
+      project_id, initiative_id, worktree_id, event_type,
+      summary, plain_english, branch, detail, source
+    )
+    VALUES ($1, $2, $3, $4, $5, $6, $7, $8::jsonb, $9)
+    RETURNING *
+    `,
+    [
+      input.projectId,
+      input.initiativeId ?? null,
+      input.worktreeId ?? null,
+      input.eventType,
+      input.summary,
+      input.plainEnglish,
+      input.branch ?? null,
+      JSON.stringify(input.detail ?? {}),
+      input.source ?? "mcp"
+    ]
+  );
+  if (rows.length === 0) {
+    throw new Error("Could not save the git activity event.");
+  }
+  return rowToEvent(rows[0]);
+}
+
+// ../../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;
+}
+
+// ../../src/core/worktree-manager.ts
+var STALE_DAYS = 7;
+var STALE_MS = STALE_DAYS * 24 * 60 * 60 * 1e3;
+function rowToRecord(row) {
+  return {
+    id: row.id,
+    projectId: row.project_id,
+    initiativeId: row.initiative_id,
+    branchName: row.branch_name,
+    worktreePath: row.worktree_path,
+    status: row.status,
+    source: row.source,
+    createdAt: row.created_at.toISOString(),
+    mergedAt: row.merged_at?.toISOString() ?? null,
+    removedAt: row.removed_at?.toISOString() ?? null
+  };
+}
+function rowToWithInitiative(row) {
+  return {
+    ...rowToRecord(row),
+    initiativeTitle: row.initiative_title,
+    lastCommitAt: null,
+    // Enriched later by enrichWithLastCommit
+    deliverableTitle: row.deliverable_title ?? null
+  };
+}
+async function enrichWithLastCommit(projectRoot, worktrees) {
+  return Promise.all(
+    worktrees.map(async (wt) => {
+      try {
+        const output = await runGit(projectRoot, [
+          "log",
+          "-1",
+          "--format=%cI",
+          wt.branchName,
+          "--"
+        ]);
+        const trimmed = output.trim();
+        return { ...wt, lastCommitAt: trimmed || null };
+      } catch {
+        return wt;
+      }
+    })
+  );
+}
+function slugifyForBranch(title) {
+  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
+}
+async function createWorktree(projectId, projectRoot, initiativeId, initiativeTitle) {
+  const existing = await getWorktreeForInitiative(projectId, initiativeId);
+  if (existing !== null) {
+    throw new Error(
+      `A worktree already exists for "${initiativeTitle}" at ${existing.worktreePath}`
+    );
+  }
+  const slug = slugifyForBranch(initiativeTitle);
+  const branchName = slug;
+  const projectDir = path.basename(projectRoot);
+  const parentDir = path.dirname(projectRoot);
+  const worktreeDir = path.join(parentDir, `${projectDir}--${slug}`);
+  try {
+    await runGit(projectRoot, ["rev-parse", "--verify", branchName]);
+  } catch {
+    await runGit(projectRoot, ["branch", branchName]);
+  }
+  await runGit(projectRoot, ["worktree", "add", worktreeDir, branchName]);
+  const rows = await query(
+    `
+    WITH inserted AS (
+      INSERT INTO worktrees (project_id, initiative_id, branch_name, worktree_path)
+      VALUES ($1, $2, $3, $4)
+      RETURNING *
+    )
+    SELECT inserted.*, i.title AS initiative_title
+    FROM inserted
+    JOIN initiatives i ON i.id = inserted.initiative_id
+    `,
+    [projectId, initiativeId, branchName, worktreeDir]
+  );
+  if (rows.length === 0) {
+    throw new Error("Could not record the new worktree.");
+  }
+  const record = rowToWithInitiative(rows[0]);
+  await logGitActivity({
+    projectId,
+    initiativeId,
+    worktreeId: record.id,
+    eventType: "worktree_created",
+    summary: `Created worktree for "${initiativeTitle}"`,
+    plainEnglish: `Set up a separate working area for the "${initiativeTitle}" initiative at ${worktreeDir}. The agent can work here without affecting the main codebase.`,
+    branch: branchName,
+    source: "system"
+  });
+  return record;
+}
+async function listWorktrees(projectId, opts) {
+  const statusFilter = opts?.status;
+  const baseQuery = `
+    SELECT w.*, i.title AS initiative_title,
+      (
+        SELECT d.title FROM deliverables d
+        JOIN outcomes o ON o.id = d.outcome_id
+        WHERE o.initiative_id = w.initiative_id
+          AND d.status = 'in_progress'
+        LIMIT 1
+      ) AS deliverable_title
+    FROM worktrees w
+    LEFT JOIN initiatives i ON i.id = w.initiative_id
+    WHERE w.project_id = $1
+  `;
+  if (statusFilter) {
+    const rows2 = await query(
+      `${baseQuery} AND w.status = $2 ORDER BY w.created_at DESC`,
+      [projectId, statusFilter]
+    );
+    return rows2.map(rowToWithInitiative);
+  }
+  const rows = await query(
+    `${baseQuery} ORDER BY w.created_at DESC`,
+    [projectId]
+  );
+  return rows.map(rowToWithInitiative);
+}
+async function getWorktreeForInitiative(projectId, initiativeId) {
+  const rows = await query(
+    `
+    SELECT * FROM worktrees
+    WHERE project_id = $1 AND initiative_id = $2 AND status = 'active'
+    LIMIT 1
+    `,
+    [projectId, initiativeId]
+  );
+  if (rows.length === 0) return null;
+  return rowToRecord(rows[0]);
+}
+async function getWorktreeByBranch(projectId, branchName) {
+  const rows = await query(
+    `
+    SELECT w.*, i.title AS initiative_title
+    FROM worktrees w
+    LEFT JOIN initiatives i ON i.id = w.initiative_id
+    WHERE w.project_id = $1 AND w.branch_name = $2 AND w.status = 'active'
+    LIMIT 1
+    `,
+    [projectId, branchName]
+  );
+  if (rows.length === 0) return null;
+  return rowToWithInitiative(rows[0]);
+}
+async function mergeWorktree(projectId, projectRoot, worktreeId, defaultBranch) {
+  const rows = await query(
+    `
+    SELECT w.*, i.title AS initiative_title
+    FROM worktrees w
+    LEFT JOIN initiatives i ON i.id = w.initiative_id
+    WHERE w.id = $1 AND w.project_id = $2 AND w.status = 'active'
+    LIMIT 1
+    `,
+    [worktreeId, projectId]
+  );
+  if (rows.length === 0) {
+    throw new Error("That worktree is not active or could not be found.");
+  }
+  const wt = rowToWithInitiative(rows[0]);
+  await runGit(projectRoot, ["switch", defaultBranch]);
+  const output = await runGit(projectRoot, ["merge", "--no-ff", wt.branchName]);
+  await query(
+    `UPDATE worktrees SET status = 'merged', merged_at = now() WHERE id = $1`,
+    [worktreeId]
+  );
+  await logGitActivity({
+    projectId,
+    initiativeId: wt.initiativeId,
+    worktreeId: wt.id,
+    eventType: "merge",
+    summary: `Merged "${wt.initiativeTitle}" into ${defaultBranch}`,
+    plainEnglish: `The "${wt.initiativeTitle}" initiative has been merged into ${defaultBranch}. All changes from that initiative are now part of the main codebase.`,
+    branch: defaultBranch,
+    source: "system"
+  });
+  return { output };
+}
+async function removeWorktree(projectId, projectRoot, worktreeId) {
+  const rows = await query(
+    `
+    SELECT w.*, i.title AS initiative_title
+    FROM worktrees w
+    LEFT JOIN initiatives i ON i.id = w.initiative_id
+    WHERE w.id = $1 AND w.project_id = $2
+    LIMIT 1
+    `,
+    [worktreeId, projectId]
+  );
+  if (rows.length === 0) {
+    throw new Error("That worktree could not be found.");
+  }
+  const wt = rowToWithInitiative(rows[0]);
+  try {
+    await runGit(projectRoot, ["worktree", "remove", wt.worktreePath, "--force"]);
+  } catch {
+  }
+  await query(
+    `UPDATE worktrees SET status = 'removed', removed_at = now() WHERE id = $1`,
+    [worktreeId]
+  );
+  await logGitActivity({
+    projectId,
+    initiativeId: wt.initiativeId,
+    worktreeId: wt.id,
+    eventType: "worktree_removed",
+    summary: `Removed worktree for "${wt.initiativeTitle}"`,
+    plainEnglish: `Cleaned up the working area for "${wt.initiativeTitle}". The branch still exists in git if you need it.`,
+    branch: wt.branchName,
+    source: "system"
+  });
+}
+function parseWorktreeListPorcelain(output) {
+  const entries = [];
+  const blocks = output.trim().split("\n\n");
+  for (const block of blocks) {
+    const lines = block.trim().split("\n");
+    let wtPath = "";
+    let head = "";
+    let branch = null;
+    let bare = false;
+    for (const line of lines) {
+      if (line.startsWith("worktree ")) {
+        wtPath = line.slice("worktree ".length);
+      } else if (line.startsWith("HEAD ")) {
+        head = line.slice("HEAD ".length);
+      } else if (line.startsWith("branch ")) {
+        const ref = line.slice("branch ".length);
+        branch = ref.replace("refs/heads/", "");
+      } else if (line === "bare") {
+        bare = true;
+      }
+    }
+    if (wtPath) {
+      entries.push({ path: wtPath, head, branch, bare });
+    }
+  }
+  return entries;
+}
+async function scanWorktrees(projectId, projectRoot) {
+  let mainRepoRoot = projectRoot;
+  try {
+    const commonDir = (await runGit(projectRoot, ["rev-parse", "--git-common-dir"])).trim();
+    if (path.isAbsolute(commonDir) && commonDir.endsWith(".git")) {
+      mainRepoRoot = path.dirname(commonDir);
+    }
+  } catch {
+  }
+  const output = await runGit(mainRepoRoot, ["worktree", "list", "--porcelain"]);
+  const diskWorktrees = parseWorktreeListPorcelain(output);
+  const additionalWorktrees = diskWorktrees.filter(
+    (wt) => !wt.bare && wt.path !== mainRepoRoot
+  );
+  const diskPaths = new Set(additionalWorktrees.map((wt) => wt.path));
+  const dbRows = await query(
+    `SELECT w.id, w.branch_name, w.worktree_path, i.title AS initiative_title,
+            w.status, w.source
+     FROM worktrees w
+     LEFT JOIN initiatives i ON i.id = w.initiative_id
+     WHERE w.project_id = $1 AND w.status = 'active'`,
+    [projectId]
+  );
+  const registeredPaths = new Set(dbRows.map((r) => r.worktree_path));
+  const entries = [];
+  let newlyDetected = 0;
+  let removedFromDisk = 0;
+  for (const wt of additionalWorktrees) {
+    const isNew = !registeredPaths.has(wt.path);
+    if (isNew) {
+      await query(
+        `INSERT INTO worktrees (project_id, initiative_id, branch_name, worktree_path, source)
+         VALUES ($1, NULL, $2, $3, 'auto')
+         ON CONFLICT (project_id, branch_name) DO NOTHING`,
+        [projectId, wt.branch ?? `detached-${wt.head.slice(0, 8)}`, wt.path]
+      );
+      newlyDetected++;
+    }
+    let lastCommitAt = null;
+    try {
+      const logOutput = await runGit(wt.path, ["log", "-1", "--format=%cI"]);
+      lastCommitAt = logOutput.trim() || null;
+    } catch {
+    }
+    entries.push({
+      branchName: wt.branch ?? `detached-${wt.head.slice(0, 8)}`,
+      worktreePath: wt.path,
+      initiativeTitle: isNew ? null : dbRows.find((r) => r.worktree_path === wt.path)?.initiative_title ?? null,
+      status: "active",
+      source: isNew ? "auto" : dbRows.find((r) => r.worktree_path === wt.path)?.source ?? "auto",
+      lastCommitAt,
+      removedFromDisk: false,
+      newlyRegistered: isNew
+    });
+  }
+  for (const row of dbRows) {
+    if (!diskPaths.has(row.worktree_path) && !existsSync(row.worktree_path)) {
+      await query(
+        `UPDATE worktrees SET status = 'removed', removed_at = now() WHERE id = $1`,
+        [row.id]
+      );
+      removedFromDisk++;
+      entries.push({
+        branchName: row.branch_name,
+        worktreePath: row.worktree_path,
+        initiativeTitle: row.initiative_title,
+        status: "removed",
+        source: row.source,
+        lastCommitAt: null,
+        removedFromDisk: true,
+        newlyRegistered: false
+      });
+    }
+  }
+  return {
+    registered: registeredPaths.size,
+    newlyDetected,
+    removedFromDisk,
+    total: registeredPaths.size + newlyDetected,
+    worktrees: entries
+  };
+}
+async function checkStaleness(projectId) {
+  const worktrees = await listWorktrees(projectId, { status: "active" });
+  const stale = [];
+  const now = Date.now();
+  for (const wt of worktrees) {
+    let lastCommitAt = null;
+    let directoryMissing = false;
+    if (!existsSync(wt.worktreePath)) {
+      directoryMissing = true;
+    } else {
+      try {
+        const output = await runGit(wt.worktreePath, ["log", "-1", "--format=%cI"]);
+        lastCommitAt = output.trim() || null;
+      } catch {
+      }
+    }
+    const commitTime = lastCommitAt ? new Date(lastCommitAt).getTime() : 0;
+    const msSinceCommit = lastCommitAt ? now - commitTime : Infinity;
+    const daysSinceCommit = Math.floor(msSinceCommit / (24 * 60 * 60 * 1e3));
+    if (directoryMissing || msSinceCommit >= STALE_MS) {
+      stale.push({
+        id: wt.id,
+        path: wt.worktreePath,
+        branch: wt.branchName,
+        lastCommitAt,
+        daysSinceCommit,
+        directoryMissing
+      });
+      const message = directoryMissing ? `Worktree "${wt.branchName}" directory is missing \u2014 it may have been deleted outside Conductor.` : `Worktree "${wt.branchName}" has had no commits for ${daysSinceCommit} days.`;
+      try {
+        await createNotification({
+          projectId,
+          eventType: "stale_worktree",
+          message,
+          priority: directoryMissing ? "action_needed" : "warning",
+          linkType: wt.initiativeId ? "initiative" : void 0,
+          linkId: wt.initiativeId ?? void 0
+        });
+      } catch {
+      }
+    }
+  }
+  return stale;
+}
+async function listWorktreesWithStaleness(projectId) {
+  const worktrees = await listWorktrees(projectId, { status: "active" });
+  const now = Date.now();
+  const results = [];
+  for (const wt of worktrees) {
+    let lastCommitAt = null;
+    let daysSinceCommit = null;
+    if (existsSync(wt.worktreePath)) {
+      try {
+        const output = await runGit(wt.worktreePath, ["log", "-1", "--format=%cI"]);
+        lastCommitAt = output.trim() || null;
+        if (lastCommitAt) {
+          const commitTime = new Date(lastCommitAt).getTime();
+          daysSinceCommit = Math.floor((now - commitTime) / (24 * 60 * 60 * 1e3));
+        }
+      } catch {
+      }
+    }
+    const stale = daysSinceCommit !== null ? daysSinceCommit >= STALE_DAYS : true;
+    results.push({
+      ...wt,
+      stale,
+      lastCommitAt,
+      daysSinceCommit,
+      source: wt.source ?? "manual"
+    });
+  }
+  return results;
+}
+
+export {
+  logGitActivity,
+  enrichWithLastCommit,
+  slugifyForBranch,
+  createWorktree,
+  listWorktrees,
+  getWorktreeForInitiative,
+  getWorktreeByBranch,
+  mergeWorktree,
+  removeWorktree,
+  scanWorktrees,
+  checkStaleness,
+  listWorktreesWithStaleness
+};

package/dist/chunk-MJKFQIYA.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+
+// ../../src/core/cli-config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { homedir } from "os";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var CONFIG_DIR = join(homedir(), ".conductor");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+var KEY_FILE = join(CONFIG_DIR, "api-key");
+function readConfig() {
+  if (!existsSync(CONFIG_FILE)) {
+    return {};
+  }
+  try {
+    const raw = readFileSync(CONFIG_FILE, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed !== null && typeof parsed === "object") {
+      return parsed;
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+function writeConfig(config) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", {
+    mode: 384
+  });
+}
+function readApiKey() {
+  if (!existsSync(KEY_FILE)) {
+    return void 0;
+  }
+  try {
+    const key = readFileSync(KEY_FILE, "utf8").trim();
+    return key.length > 0 ? key : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function getConfigEndpoint() {
+  const candidates = [
+    join(process.cwd(), ".mcp.json"),
+    join(__dirname, "../../.mcp.json")
+  ];
+  for (const filePath of candidates) {
+    if (!existsSync(filePath)) continue;
+    try {
+      const raw = readFileSync(filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      const mcpUrl = parsed.mcpServers?.conductor?.url;
+      if (mcpUrl) {
+        return mcpUrl.replace(/\/mcp\/?$/, "/config");
+      }
+    } catch {
+      continue;
+    }
+  }
+  return "http://localhost:3001/config";
+}
+function getServerBaseUrl() {
+  const configUrl = getConfigEndpoint();
+  return configUrl.replace(/\/config\/?$/, "");
+}
+async function fetchConfigFromServer() {
+  const apiKey = readApiKey();
+  if (!apiKey) {
+    return void 0;
+  }
+  const configUrl = getConfigEndpoint();
+  try {
+    const resp = await fetch(configUrl, {
+      headers: { Authorization: `Bearer ${apiKey}` },
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!resp.ok) {
+      return void 0;
+    }
+    const body = await resp.json();
+    return body.databaseUrl ?? void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function postToServer(path, body, projectRoot) {
+  const apiKey = readApiKey();
+  if (!apiKey) return false;
+  const baseUrl = getServerBaseUrl();
+  const url = new URL(path, baseUrl);
+  if (projectRoot) {
+    url.searchParams.set("projectRoot", projectRoot);
+  }
+  try {
+    const resp = await fetch(url.toString(), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(5e3)
+    });
+    return resp.ok;
+  } catch {
+    return false;
+  }
+}
+async function ensureDatabaseUrl() {
+  if (process.env.DATABASE_URL) {
+    return true;
+  }
+  const config = readConfig();
+  if (config.databaseUrl) {
+    process.env.DATABASE_URL = config.databaseUrl;
+    return true;
+  }
+  const url = await fetchConfigFromServer();
+  if (url) {
+    writeConfig({ ...config, databaseUrl: url });
+    process.env.DATABASE_URL = url;
+    return true;
+  }
+  return false;
+}
+
+export {
+  readConfig,
+  writeConfig,
+  getServerBaseUrl,
+  fetchConfigFromServer,
+  postToServer,
+  ensureDatabaseUrl
+};