@matthugh1/conductor-cli 0.1.0

package/dist/chunk-IHARLSA6.js

@@ -0,0 +1,605 @@
+#!/usr/bin/env node
+import {
+  runGit
+} from "./chunk-FAZ7FCZQ.js";
+import {
+  query
+} from "./chunk-PANC6BTV.js";
+
+// ../../src/core/branch-overview-match.ts
+function slugifyTitle(title) {
+  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function normalizeBranchRef(raw) {
+  let s = raw.trim();
+  if (s.startsWith("refs/heads/")) {
+    s = s.slice("refs/heads/".length);
+  }
+  return s.toLowerCase();
+}
+function branchMatchesDeliverable(branchName, slug) {
+  if (slug.length === 0) {
+    return false;
+  }
+  const lower = branchName.toLowerCase();
+  return lower === slug || lower.endsWith(`/${slug}`) || lower.includes(`/${slug}/`) || lower.includes(slug);
+}
+function matchDeliverableFromSlug(branchName, hints) {
+  for (const h of hints) {
+    if (branchMatchesDeliverable(branchName, h.slug)) {
+      return { id: h.id, title: h.title, status: h.status };
+    }
+  }
+  return null;
+}
+function resolveDeliverableLink(branchName, hints, sessionByBranch) {
+  const key = normalizeBranchRef(branchName);
+  const fromSession = sessionByBranch.get(key) ?? null;
+  const fromSlug = matchDeliverableFromSlug(branchName, hints);
+  if (fromSession !== null && fromSlug !== null) {
+    if (fromSession.id === fromSlug.id) {
+      return {
+        id: fromSession.id,
+        title: fromSession.title,
+        status: fromSession.status,
+        source: "both"
+      };
+    }
+    return {
+      id: fromSession.id,
+      title: fromSession.title,
+      status: fromSession.status,
+      source: "session"
+    };
+  }
+  if (fromSession !== null) {
+    return {
+      id: fromSession.id,
+      title: fromSession.title,
+      status: fromSession.status,
+      source: "session"
+    };
+  }
+  if (fromSlug !== null) {
+    return {
+      id: fromSlug.id,
+      title: fromSlug.title,
+      status: fromSlug.status,
+      source: "name_match"
+    };
+  }
+  return null;
+}
+
+// ../../src/core/branch-overview.ts
+var STALE_MS = 7 * 24 * 60 * 60 * 1e3;
+var MAX_COMMITS = 20;
+var MAX_FILES = 40;
+var REPO_OPS_CONFLICT_TITLE_PREFIX = "Resolve merge conflicts: ";
+async function loadRepoOpsConflictDeliverableByBranch(projectId) {
+  const rows = await query(
+    `
+    SELECT d.id, d.title
+    FROM deliverables d
+    INNER JOIN outcomes o ON o.id = d.outcome_id
+    INNER JOIN initiatives i ON i.id = o.initiative_id
+    WHERE i.project_id = $1
+      AND d.assigned_role = 'repo-ops'
+      AND d.status IN ('todo', 'in_progress')
+      AND d.title LIKE $2
+    `,
+    [projectId, `${REPO_OPS_CONFLICT_TITLE_PREFIX}%`]
+  );
+  const map = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    if (!r.title.startsWith(REPO_OPS_CONFLICT_TITLE_PREFIX)) {
+      continue;
+    }
+    const branch = r.title.slice(REPO_OPS_CONFLICT_TITLE_PREFIX.length);
+    if (branch.length > 0) {
+      map.set(branch, r.id);
+    }
+  }
+  return map;
+}
+async function loadDeliverableHints(projectId) {
+  const rows = await query(
+    `
+    SELECT d.id, d.title, d.status AS deliverable_status
+    FROM deliverables d
+    INNER JOIN outcomes o ON o.id = d.outcome_id
+    INNER JOIN initiatives i ON i.id = o.initiative_id
+    WHERE i.project_id = $1
+    `,
+    [projectId]
+  );
+  return rows.map((r) => ({
+    id: r.id,
+    title: r.title,
+    slug: slugifyTitle(r.title),
+    status: r.deliverable_status
+  }));
+}
+async function loadSessionBranchDeliverables(projectId) {
+  const rows = await query(
+    `
+    SELECT DISTINCT ON (lower(trim(s.branch)))
+      trim(s.branch) AS branch_raw,
+      d.id AS deliverable_id,
+      d.title AS deliverable_title,
+      d.status AS deliverable_status
+    FROM sessions s
+    LEFT JOIN deliverables d ON d.id = s.deliverable_id
+    WHERE s.project_id = $1
+      AND s.branch IS NOT NULL
+      AND trim(s.branch) <> ''
+    ORDER BY lower(trim(s.branch)), s.started_at DESC
+    `,
+    [projectId]
+  );
+  const map = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    if (r.deliverable_id === null || r.deliverable_title === null) {
+      continue;
+    }
+    const key = normalizeBranchRef(r.branch_raw);
+    map.set(key, {
+      id: r.deliverable_id,
+      title: r.deliverable_title,
+      status: r.deliverable_status ?? ""
+    });
+  }
+  return map;
+}
+async function resolveDefaultBranchName(projectRoot, branchNames) {
+  if (branchNames.length === 0) {
+    return null;
+  }
+  if (branchNames.includes("main")) {
+    return "main";
+  }
+  if (branchNames.includes("master")) {
+    return "master";
+  }
+  return branchNames[0] ?? null;
+}
+async function listLocalBranchNames(projectRoot) {
+  const out = await runGit(projectRoot, [
+    "branch",
+    "--format=%(refname:short)"
+  ]);
+  return out.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+}
+async function listUnmergedBranchNames(projectRoot, mainBranch) {
+  try {
+    const out = await runGit(projectRoot, [
+      "branch",
+      "--no-merged",
+      mainBranch,
+      "--format=%(refname:short)"
+    ]);
+    return out.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+  } catch {
+    return null;
+  }
+}
+function formatAge(iso) {
+  const t = Date.parse(iso);
+  if (Number.isNaN(t)) {
+    return "unknown age";
+  }
+  const diff = Date.now() - t;
+  const mins = Math.floor(diff / 6e4);
+  if (mins < 90) {
+    return `${mins} min ago`;
+  }
+  const hours = Math.floor(diff / 36e5);
+  if (hours < 36) {
+    return `${hours} hr ago`;
+  }
+  const days = Math.floor(diff / 864e5);
+  if (days < 14) {
+    return `${days} days ago`;
+  }
+  const weeks = Math.floor(days / 7);
+  return `${weeks} wk ago`;
+}
+async function detectMergeConflicts(projectRoot, mainBranch, featureBranch) {
+  if (mainBranch === featureBranch) {
+    return { hasConflicts: false, files: [] };
+  }
+  try {
+    const base = (await runGit(projectRoot, ["merge-base", mainBranch, featureBranch])).trim();
+    if (base.length === 0) {
+      return { hasConflicts: true, files: [] };
+    }
+    const treeOut = await runGit(projectRoot, [
+      "merge-tree",
+      base,
+      mainBranch,
+      featureBranch
+    ]);
+    const files = /* @__PURE__ */ new Set();
+    if (treeOut.includes("<<<<<<<") || treeOut.includes("CONFLICT")) {
+      for (const line of treeOut.split("\n")) {
+        if (line.includes("CONFLICT") && line.includes("content")) {
+          const m = line.match(/in\s+(.+)$/);
+          if (m !== null && m[1] !== void 0) {
+            files.add(m[1].trim());
+          }
+        }
+      }
+      return { hasConflicts: true, files: [...files].slice(0, MAX_FILES) };
+    }
+    return { hasConflicts: false, files: [] };
+  } catch {
+    return { hasConflicts: false, files: [] };
+  }
+}
+async function getAheadBehind(projectRoot, mainBranch, featureBranch) {
+  const out = (await runGit(projectRoot, [
+    "rev-list",
+    "--left-right",
+    "--count",
+    `${mainBranch}...${featureBranch}`
+  ])).trim();
+  const parts = out.split(/\s+/);
+  if (parts.length < 2) {
+    return { ahead: 0, behind: 0 };
+  }
+  const behind = Number.parseInt(parts[0] ?? "0", 10);
+  const ahead = Number.parseInt(parts[1] ?? "0", 10);
+  return {
+    ahead: Number.isNaN(ahead) ? 0 : ahead,
+    behind: Number.isNaN(behind) ? 0 : behind
+  };
+}
+async function isBranchFullyOnMain(projectRoot, mainBranch, branchName) {
+  try {
+    await runGit(projectRoot, [
+      "merge-base",
+      "--is-ancestor",
+      branchName,
+      mainBranch
+    ]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadCommitsAheadFixed(projectRoot, mainBranch, featureBranch) {
+  const range = `${mainBranch}..${featureBranch}`;
+  const out = await runGit(projectRoot, [
+    "log",
+    "--oneline",
+    range,
+    "-n",
+    String(MAX_COMMITS)
+  ]);
+  const rows = [];
+  for (const line of out.split("\n")) {
+    if (line.trim().length === 0) {
+      continue;
+    }
+    const space = line.indexOf(" ");
+    if (space === -1) {
+      rows.push({ hash: line.trim(), message: "" });
+    } else {
+      rows.push({
+        hash: line.slice(0, space),
+        message: line.slice(space + 1).trim()
+      });
+    }
+  }
+  return rows;
+}
+async function loadChangedFiles(projectRoot, mainBranch, featureBranch) {
+  const out = await runGit(projectRoot, [
+    "diff",
+    "--name-only",
+    `${mainBranch}...${featureBranch}`
+  ]);
+  const lines = out.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+  return lines.slice(0, MAX_FILES);
+}
+async function getConflictBranchesForWorkQueue(projectRoot, options) {
+  let branchNames = [];
+  try {
+    branchNames = await listLocalBranchNames(projectRoot);
+  } catch {
+    return { defaultBranch: "main", conflicts: [] };
+  }
+  const defaultBranch = await resolveDefaultBranchName(projectRoot, branchNames);
+  if (defaultBranch === null) {
+    return { defaultBranch: "main", conflicts: [] };
+  }
+  const unmergedOrNull = await listUnmergedBranchNames(
+    projectRoot,
+    defaultBranch
+  );
+  const assumeTipsNotInMain = unmergedOrNull !== null && unmergedOrNull.length > 0;
+  if (unmergedOrNull !== null && unmergedOrNull.length === 0) {
+    return { defaultBranch, conflicts: [] };
+  }
+  const namesToScan = unmergedOrNull !== null ? unmergedOrNull : branchNames;
+  let hints = [];
+  let sessionByBranch = /* @__PURE__ */ new Map();
+  if (options.projectId !== null && options.projectId.length > 0) {
+    try {
+      hints = await loadDeliverableHints(options.projectId);
+    } catch {
+      hints = [];
+    }
+    try {
+      sessionByBranch = await loadSessionBranchDeliverables(
+        options.projectId
+      );
+    } catch {
+      sessionByBranch = /* @__PURE__ */ new Map();
+    }
+  }
+  const conflicts = [];
+  for (const name of namesToScan) {
+    if (name === defaultBranch) {
+      continue;
+    }
+    let lastIso = "";
+    try {
+      const raw = (await runGit(projectRoot, [
+        "log",
+        "-1",
+        "--format=%cI%x00%s",
+        name
+      ])).trim();
+      const z = raw.indexOf("\0");
+      if (z !== -1) {
+        lastIso = raw.slice(0, z);
+      }
+    } catch {
+      lastIso = (/* @__PURE__ */ new Date(0)).toISOString();
+    }
+    const mergedIntoMain = assumeTipsNotInMain ? false : await isBranchFullyOnMain(projectRoot, defaultBranch, name);
+    const { ahead } = await getAheadBehind(
+      projectRoot,
+      defaultBranch,
+      name
+    );
+    let hasMergeConflicts = false;
+    let conflictFiles = [];
+    if (!mergedIntoMain && ahead > 0) {
+      const det = await detectMergeConflicts(
+        projectRoot,
+        defaultBranch,
+        name
+      );
+      hasMergeConflicts = det.hasConflicts;
+      conflictFiles = det.files;
+    }
+    const lastMs = Date.parse(lastIso);
+    const stale = !mergedIntoMain && name !== defaultBranch && !Number.isNaN(lastMs) && Date.now() - lastMs > STALE_MS;
+    const safety = name.startsWith("conductor-safety-");
+    if (!hasMergeConflicts || stale || safety) {
+      continue;
+    }
+    conflicts.push({
+      name,
+      conflictFiles,
+      deliverable: resolveDeliverableLink(name, hints, sessionByBranch)
+    });
+  }
+  conflicts.sort((a, b) => a.name.localeCompare(b.name));
+  return { defaultBranch, conflicts };
+}
+async function getBranchOverview(projectRoot, options) {
+  let branchNames = [];
+  try {
+    branchNames = await listLocalBranchNames(projectRoot);
+  } catch {
+    return {
+      defaultBranch: "main",
+      currentBranch: options.currentBranch,
+      hideOverview: true,
+      branches: []
+    };
+  }
+  const defaultBranch = await resolveDefaultBranchName(projectRoot, branchNames);
+  if (defaultBranch === null) {
+    return {
+      defaultBranch: "main",
+      currentBranch: options.currentBranch,
+      hideOverview: true,
+      branches: []
+    };
+  }
+  const hideOverview = branchNames.length < 2;
+  let hints = [];
+  let sessionByBranch = /* @__PURE__ */ new Map();
+  if (options.projectId !== null && options.projectId.length > 0) {
+    try {
+      hints = await loadDeliverableHints(options.projectId);
+    } catch {
+      hints = [];
+    }
+    try {
+      sessionByBranch = await loadSessionBranchDeliverables(
+        options.projectId
+      );
+    } catch {
+      sessionByBranch = /* @__PURE__ */ new Map();
+    }
+  }
+  let repoOpsConflictByBranch = /* @__PURE__ */ new Map();
+  if (options.projectId !== null && options.projectId.length > 0) {
+    try {
+      repoOpsConflictByBranch = await loadRepoOpsConflictDeliverableByBranch(
+        options.projectId
+      );
+    } catch {
+      repoOpsConflictByBranch = /* @__PURE__ */ new Map();
+    }
+  }
+  const rows = [];
+  for (const name of branchNames) {
+    let lastIso = "";
+    let lastMsg = "";
+    try {
+      const raw = (await runGit(projectRoot, [
+        "log",
+        "-1",
+        "--format=%cI%x00%s",
+        name
+      ])).trim();
+      const z = raw.indexOf("\0");
+      if (z !== -1) {
+        lastIso = raw.slice(0, z);
+        lastMsg = raw.slice(z + 1);
+      }
+    } catch {
+      lastIso = (/* @__PURE__ */ new Date(0)).toISOString();
+      lastMsg = "";
+    }
+    const mergedIntoMain = await isBranchFullyOnMain(
+      projectRoot,
+      defaultBranch,
+      name
+    );
+    const { ahead, behind } = await getAheadBehind(
+      projectRoot,
+      defaultBranch,
+      name
+    );
+    let hasMergeConflicts = false;
+    let conflictFiles = [];
+    if (name !== defaultBranch && !mergedIntoMain && ahead > 0) {
+      const det = await detectMergeConflicts(
+        projectRoot,
+        defaultBranch,
+        name
+      );
+      hasMergeConflicts = det.hasConflicts;
+      conflictFiles = det.files;
+    }
+    const lastMs = Date.parse(lastIso);
+    const stale = !mergedIntoMain && name !== defaultBranch && !Number.isNaN(lastMs) && Date.now() - lastMs > STALE_MS;
+    const isCurrent = options.currentBranch === name;
+    const safety = name.startsWith("conductor-safety-");
+    let group;
+    let badgeLabel;
+    let explanation;
+    if (name === defaultBranch) {
+      group = "base_branch";
+      badgeLabel = "Base branch";
+      explanation = "This is your main line of work. Other branches are compared to it.";
+    } else if (safety) {
+      group = "safety_snapshot";
+      badgeLabel = "Safety snapshot";
+      explanation = "Conductor created this branch before a risky command. You can usually clean it up once you are sure you do not need it.";
+    } else if (mergedIntoMain && ahead === 0) {
+      group = "merged_cleanup";
+      badgeLabel = "Merged";
+      explanation = "Everything on this branch is already on your main branch. It is safe to remove the branch name when you no longer need the label.";
+    } else if (stale) {
+      group = "stale";
+      badgeLabel = "Stale";
+      explanation = "This branch has been quiet for a while and is not fully merged. Review or delete it so names do not pile up.";
+    } else if (hasMergeConflicts && ahead > 0) {
+      group = "needs_review";
+      badgeLabel = "Needs review";
+      explanation = "This branch has changes that overlap with main. The agent will resolve these automatically when it merges.";
+    } else if (behind > 0 && ahead > 0) {
+      group = "needs_review";
+      badgeLabel = "Needs review";
+      explanation = "This branch and main have both moved. Update or merge carefully so you do not lose work.";
+    } else if (ahead > 0 && behind === 0) {
+      group = "ready_to_merge";
+      badgeLabel = "Ready to merge";
+      explanation = "This branch is ahead of main with no extra commits on main waiting to come in. Good candidate to fold into main when you are ready.";
+    } else {
+      group = "keep";
+      badgeLabel = "Keep";
+      explanation = "No urgent action \u2014 check back when you have finished work on this line.";
+    }
+    const commitsOnBranch = await loadCommitsAheadFixed(
+      projectRoot,
+      defaultBranch,
+      name
+    );
+    const changedFiles = await loadChangedFiles(
+      projectRoot,
+      defaultBranch,
+      name
+    );
+    rows.push({
+      name,
+      isCurrentBranch: isCurrent,
+      lastCommitIso: lastIso || (/* @__PURE__ */ new Date(0)).toISOString(),
+      lastCommitMessage: lastMsg,
+      ageShort: formatAge(lastIso || (/* @__PURE__ */ new Date(0)).toISOString()),
+      ahead,
+      behind,
+      mergedIntoMain,
+      hasMergeConflicts,
+      conflictFiles,
+      group,
+      badgeLabel,
+      explanation,
+      deliverable: resolveDeliverableLink(name, hints, sessionByBranch),
+      commitsOnBranch,
+      changedFiles,
+      repoOpsConflictDeliverableId: repoOpsConflictByBranch.get(name) ?? null
+    });
+  }
+  rows.sort((a, b) => a.name.localeCompare(b.name));
+  return {
+    defaultBranch,
+    currentBranch: options.currentBranch,
+    hideOverview,
+    branches: rows
+  };
+}
+async function assertCanQueueMerge(projectRoot, defaultBranch, featureBranch) {
+  if (featureBranch === defaultBranch) {
+    throw new Error("Pick a branch other than your main branch to merge.");
+  }
+  const merged = await isBranchFullyOnMain(projectRoot, defaultBranch, featureBranch);
+  if (merged) {
+    throw new Error("That branch is already merged into main \u2014 there is nothing to merge.");
+  }
+  const { ahead } = await getAheadBehind(projectRoot, defaultBranch, featureBranch);
+  if (ahead === 0) {
+    throw new Error("That branch does not have commits to bring into main.");
+  }
+  const det = await detectMergeConflicts(projectRoot, defaultBranch, featureBranch);
+  if (det.hasConflicts) {
+    const fileHint = det.files.length > 0 ? ` Conflicting files include: ${det.files.slice(0, 5).join(", ")}.` : "";
+    throw new Error(
+      `This branch has overlapping changes with main.${fileHint} The agent will resolve these when merging.`
+    );
+  }
+}
+async function getMergeStats(projectRoot, defaultBranch, featureBranch) {
+  let commitCount = 0;
+  try {
+    const raw = (await runGit(projectRoot, [
+      "rev-list",
+      "--count",
+      `${defaultBranch}..${featureBranch}`
+    ])).trim();
+    commitCount = Number.parseInt(raw, 10);
+    if (Number.isNaN(commitCount)) {
+      commitCount = 0;
+    }
+  } catch {
+    commitCount = 0;
+  }
+  const files = await loadChangedFiles(projectRoot, defaultBranch, featureBranch);
+  return { commitCount, fileCount: files.length };
+}
+
+export {
+  isBranchFullyOnMain,
+  getConflictBranchesForWorkQueue,
+  getBranchOverview,
+  assertCanQueueMerge,
+  getMergeStats
+};