@matthugh1/conductor-cli 0.1.0

package/dist/branch-overview-XVHTGFCJ.js

@@ -0,0 +1,18 @@
+#!/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

@@ -0,0 +1,17 @@
+#!/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
+};

package/dist/chunk-FAZ7FCZQ.js

@@ -0,0 +1,534 @@
+#!/usr/bin/env node
+import {
+  ConductorError
+} from "./chunk-4YEHSYVN.js";
+
+// ../../src/core/git-wrapper.ts
+import { execFile } from "child_process";
+import { randomBytes } from "crypto";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var MAX_BUFFER = 10 * 1024 * 1024;
+var READ_TIMEOUT_MS = 3e4;
+var WRITE_TIMEOUT_MS = 6e4;
+var READ_ONLY_SUBCOMMANDS = /* @__PURE__ */ new Set([
+  "status",
+  "log",
+  "diff",
+  "show",
+  "branch",
+  "tag",
+  "remote",
+  "config",
+  "ls-files",
+  "ls-tree",
+  "ls-remote",
+  "rev-parse",
+  "rev-list",
+  "describe",
+  "shortlog",
+  "blame",
+  "reflog",
+  "stash",
+  // stash list is read-only; stash push is write but rare
+  "name-rev",
+  "cat-file",
+  "count-objects",
+  "verify-pack"
+]);
+function gitTimeoutForArgs(args) {
+  const subcommand = args.find((a) => !a.startsWith("-"))?.toLowerCase();
+  if (subcommand && READ_ONLY_SUBCOMMANDS.has(subcommand)) {
+    return READ_TIMEOUT_MS;
+  }
+  return WRITE_TIMEOUT_MS;
+}
+async function runGit(projectRoot, args, options) {
+  const timeout = options?.timeoutMs ?? gitTimeoutForArgs(args);
+  try {
+    const { stdout } = await execFileAsync("git", ["-C", projectRoot, ...args], {
+      maxBuffer: MAX_BUFFER,
+      timeout
+    });
+    return stdout;
+  } catch (err) {
+    const e = err;
+    if (e.killed || e.signal === "SIGTERM") {
+      throw new ConductorError(
+        "GIT_TIMEOUT" /* GIT_TIMEOUT */,
+        `Git command timed out after ${Math.round(timeout / 1e3)}s. The command was killed. If this is a network operation (push, pull, fetch), check your connection.`,
+        true
+      );
+    }
+    if (e.code === "ENOENT") {
+      throw new ConductorError("GIT_NOT_FOUND" /* GIT_NOT_FOUND */, "Git is not installed or not on your PATH");
+    }
+    const stderr = typeof e.stderr === "string" ? e.stderr : "";
+    const firstLine = stderr.split("\n").find((line) => line.trim().length > 0) ?? "";
+    if (firstLine.includes("not a git repository")) {
+      throw new ConductorError("GIT_NOT_A_REPO" /* GIT_NOT_A_REPO */, "This folder is not a git repository");
+    }
+    if (e.status === 128 && firstLine.length > 0) {
+      throw new ConductorError("GIT_FAILED" /* GIT_FAILED */, firstLine);
+    }
+    if (firstLine.length > 0) {
+      throw new ConductorError("GIT_FAILED" /* GIT_FAILED */, firstLine);
+    }
+    throw new ConductorError("GIT_FAILED" /* GIT_FAILED */, "Git exited with an error");
+  }
+}
+async function getGitBranchInfo(projectRoot) {
+  try {
+    await runGit(projectRoot, ["rev-parse", "--is-inside-work-tree"]);
+  } catch {
+    return { isNotGitRepo: true, hasNoCommits: false, branchName: null };
+  }
+  try {
+    await runGit(projectRoot, ["rev-parse", "HEAD"]);
+  } catch {
+    return { isNotGitRepo: false, hasNoCommits: true, branchName: null };
+  }
+  try {
+    const out = await runGit(projectRoot, [
+      "rev-parse",
+      "--abbrev-ref",
+      "HEAD"
+    ]);
+    const name = out.trim();
+    if (name === "HEAD") {
+      const short = await runGit(projectRoot, ["rev-parse", "--short", "HEAD"]);
+      return {
+        isNotGitRepo: false,
+        hasNoCommits: false,
+        branchName: `detached (${short.trim()})`
+      };
+    }
+    return { isNotGitRepo: false, hasNoCommits: false, branchName: name };
+  } catch {
+    return { isNotGitRepo: false, hasNoCommits: false, branchName: null };
+  }
+}
+function formatGitBranchLine(info) {
+  if (info.isNotGitRepo) {
+    return "Not a git repository";
+  }
+  if (info.hasNoCommits) {
+    return "No commits yet \u2014 Git will name a branch after the first commit";
+  }
+  if (info.branchName !== null && info.branchName.length > 0) {
+    return info.branchName;
+  }
+  return "Branch unknown";
+}
+async function getCurrentBranch(projectRoot) {
+  const info = await getGitBranchInfo(projectRoot);
+  if (info.isNotGitRepo || info.hasNoCommits) {
+    return null;
+  }
+  if (info.branchName !== null && info.branchName.startsWith("detached (")) {
+    return null;
+  }
+  return info.branchName;
+}
+async function getStatusSummary(projectRoot) {
+  try {
+    const out = await runGit(projectRoot, ["status", "--porcelain"]);
+    const lines = out.split("\n").filter((l) => l.length > 0);
+    if (lines.length === 0) {
+      return "Clean \u2014 no uncommitted changes";
+    }
+    let modified = 0;
+    let added = 0;
+    let deleted = 0;
+    let untracked = 0;
+    for (const line of lines) {
+      const code = line.slice(0, 2);
+      if (code.includes("?")) {
+        untracked += 1;
+        continue;
+      }
+      if (code.includes("A") || code.includes("N")) {
+        added += 1;
+      }
+      if (code.includes("M")) {
+        modified += 1;
+      }
+      if (code.includes("D")) {
+        deleted += 1;
+      }
+    }
+    const parts = [];
+    if (modified > 0) {
+      parts.push(`${modified} file${modified === 1 ? "" : "s"} changed`);
+    }
+    if (added > 0) {
+      parts.push(`${added} new file${added === 1 ? "" : "s"}`);
+    }
+    if (deleted > 0) {
+      parts.push(`${deleted} deleted file${deleted === 1 ? "" : "s"}`);
+    }
+    if (untracked > 0) {
+      parts.push(`${untracked} untracked file${untracked === 1 ? "" : "s"}`);
+    }
+    if (parts.length === 0) {
+      return `${lines.length} change${lines.length === 1 ? "" : "s"} in the working tree`;
+    }
+    return parts.join(", ");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "Could not read git status.";
+    return msg;
+  }
+}
+async function getRecentCommits(projectRoot) {
+  const out = await runGit(projectRoot, ["log", "--oneline", "-5"]);
+  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, message: "" });
+    } else {
+      rows.push({
+        hash: line.slice(0, space),
+        message: line.slice(space + 1).trim()
+      });
+    }
+  }
+  return rows;
+}
+function commandSummary(gitArgs) {
+  if (gitArgs.length === 0) {
+    return "git";
+  }
+  return `git ${gitArgs.join(" ")}`;
+}
+var lower = (a) => a.map((x) => x.toLowerCase());
+function tierAndCopy(gitArgs) {
+  const args = lower(gitArgs);
+  const joined = args.join(" ");
+  if (args.length === 0) {
+    return {
+      tier: "yellow",
+      plainEnglish: "Runs git with no subcommand \u2014 unusual and may show help or do nothing.",
+      whatChanges: "Depends on your git version.",
+      whatCouldGoWrong: "Use a clear subcommand (for example status or commit) so the intent is obvious."
+    };
+  }
+  if (joined.includes("push") && (args.includes("--force") || args.includes("-f"))) {
+    return {
+      tier: "red",
+      plainEnglish: "Overwrite the remote branch with your local history (force push).",
+      whatChanges: "The remote branch may lose commits that exist only on the server.",
+      whatCouldGoWrong: "If others use this branch, their work can be overwritten or confused \u2014 coordinate before force pushing."
+    };
+  }
+  if (args.includes("reset") && args.includes("--hard")) {
+    return {
+      tier: "red",
+      plainEnglish: "Discard uncommitted changes and move your branch pointer.",
+      whatChanges: "Uncommitted edits in your working tree can be permanently removed.",
+      whatCouldGoWrong: "Anything not saved in a commit may be gone for good."
+    };
+  }
+  if (args.includes("clean")) {
+    const isDryRun = args.includes("-n") || args.includes("--dry-run");
+    const forcesClean = args.some(
+      (x) => x === "-f" || x === "-fd" || x === "-xffd" || x.startsWith("-f")
+    );
+    if (!isDryRun && forcesClean) {
+      return {
+        tier: "red",
+        plainEnglish: "Delete untracked files (and sometimes directories) from your project folder.",
+        whatChanges: "Files that are not tracked by git can be removed from disk.",
+        whatCouldGoWrong: "You may delete files you still need \u2014 there is no undo from git."
+      };
+    }
+  }
+  if (args.includes("rebase")) {
+    return {
+      tier: "red",
+      plainEnglish: "Replay commits on top of another branch (rewrite history locally).",
+      whatChanges: "Commit hashes and history can change; conflicts may need resolving.",
+      whatCouldGoWrong: "Mistakes during rebase can be hard to untangle \u2014 snapshot or branch first."
+    };
+  }
+  if (args.includes("branch") && gitArgs.includes("-D")) {
+    return {
+      tier: "red",
+      plainEnglish: "Delete a branch even if it is not fully merged.",
+      whatChanges: "The branch ref is removed from your repo.",
+      whatCouldGoWrong: "Commits may become harder to find if you still needed that branch."
+    };
+  }
+  if (args.includes("stash") && (args.includes("drop") || args.includes("clear"))) {
+    return {
+      tier: "red",
+      plainEnglish: "Permanently remove one or all stash entries.",
+      whatChanges: "Stashed work can be deleted.",
+      whatCouldGoWrong: "You can lose saved work that only lived in the stash."
+    };
+  }
+  if (args.includes("checkout") && args.includes("--force")) {
+    return {
+      tier: "red",
+      plainEnglish: "Force checkout, potentially overwriting local changes.",
+      whatChanges: "Your working tree may match another branch or commit aggressively.",
+      whatCouldGoWrong: "Local changes can be overwritten without a prompt."
+    };
+  }
+  const g0 = args[0];
+  const greenVerbs = /* @__PURE__ */ new Set([
+    "status",
+    "diff",
+    "log",
+    "show",
+    "ls-files",
+    "rev-parse",
+    "blame",
+    "grep"
+  ]);
+  if (greenVerbs.has(g0)) {
+    return {
+      tier: "green",
+      plainEnglish: describeGreen(g0, args),
+      whatChanges: "Only reads repository state; it does not change commits or the index by itself.",
+      whatCouldGoWrong: "Low risk \u2014 output may be large in big repos."
+    };
+  }
+  if (g0 === "remote" && !args.includes("add") && !args.includes("remove") && !args.includes("rm") && !args.includes("set-url")) {
+    return {
+      tier: "green",
+      plainEnglish: "Show or list configured remotes.",
+      whatChanges: "No files or commits are modified.",
+      whatCouldGoWrong: "Very low risk."
+    };
+  }
+  if (g0 === "branch") {
+    const listsBranches = !args.includes("-D") && !args.includes("-d") && !args.includes("-m") && !args.includes("--set-upstream") && (args.length === 1 || args.includes("-a") || args.includes("-r") || args.includes("-v") || args.includes("-vv") || args.includes("--list"));
+    if (listsBranches) {
+      return {
+        tier: "green",
+        plainEnglish: "List branches (local and/or remote).",
+        whatChanges: "Does not create, delete, or switch branches.",
+        whatCouldGoWrong: "Very low risk."
+      };
+    }
+  }
+  if (g0 === "tag") {
+    if (args.length === 1 || args.includes("-l") || args.includes("--list")) {
+      return {
+        tier: "green",
+        plainEnglish: "List tags (read-only).",
+        whatChanges: "Does not create or delete tags.",
+        whatCouldGoWrong: "Low risk."
+      };
+    }
+  }
+  if (g0 === "stash" && (args[1] === "list" || args[1] === "show")) {
+    return {
+      tier: "green",
+      plainEnglish: "Inspect saved stash entries.",
+      whatChanges: "Does not apply or drop stash entries.",
+      whatCouldGoWrong: "Low risk."
+    };
+  }
+  if (g0 === "fetch") {
+    return {
+      tier: "green",
+      plainEnglish: "Download updates from the remote without merging into your branch.",
+      whatChanges: "Updates remote-tracking branches locally.",
+      whatCouldGoWrong: "Usually safe; large fetches can be slow."
+    };
+  }
+  const yellowVerbs = /* @__PURE__ */ new Set([
+    "add",
+    "commit",
+    "push",
+    "pull",
+    "checkout",
+    "switch",
+    "merge",
+    "restore",
+    "mv",
+    "rm"
+  ]);
+  if (yellowVerbs.has(g0)) {
+    return {
+      tier: "yellow",
+      plainEnglish: describeYellow(g0, args),
+      whatChanges: "Updates your repo, index, or working tree depending on the subcommand.",
+      whatCouldGoWrong: "Conflicts, partial updates, or pushes can fail \u2014 read git messages if something goes wrong."
+    };
+  }
+  if (g0 === "branch" && args.length > 1) {
+    return {
+      tier: "yellow",
+      plainEnglish: "Create, rename, or delete branches (not a simple list).",
+      whatChanges: "Branch pointers or names change.",
+      whatCouldGoWrong: "Wrong branch names can confuse history \u2014 double-check names."
+    };
+  }
+  if (g0 === "stash" && (args.includes("push") || args.includes("pop") || args.includes("apply"))) {
+    return {
+      tier: "yellow",
+      plainEnglish: "Save or restore work in progress using the stash.",
+      whatChanges: "Working tree and possibly index change when applying or popping.",
+      whatCouldGoWrong: "Stash pop can conflict; you may need to resolve overlaps by hand."
+    };
+  }
+  if (g0 === "tag" && !args.includes("-l") && !args.includes("--list")) {
+    return {
+      tier: "yellow",
+      plainEnglish: "Create or manage tags.",
+      whatChanges: "Tags point to commits and can be pushed.",
+      whatCouldGoWrong: "Tagging mistakes can confuse releases \u2014 confirm names and targets."
+    };
+  }
+  return {
+    tier: "yellow",
+    plainEnglish: `Run git subcommand \u201C${g0}\u201D with your arguments.`,
+    whatChanges: "May read or write the repository depending on what you asked for.",
+    whatCouldGoWrong: "If you are unsure, prefer read-only commands (status, diff, log) first."
+  };
+}
+function describeGreen(verb, args) {
+  switch (verb) {
+    case "status":
+      return "Show which files changed, staged, or are untracked.";
+    case "diff":
+      return "Show line-by-line differences.";
+    case "log":
+      return "Show recent commits.";
+    case "show":
+      return "Show a commit, tag, or object details.";
+    case "ls-files":
+      return "List files known to git in the index or working tree.";
+    case "rev-parse":
+      return "Resolve refs (for example branch names) to commit hashes.";
+    case "blame":
+      return "Show who last changed each line of a file.";
+    case "grep":
+      return "Search tracked files for a pattern.";
+    default:
+      return `Run git ${verb} in read-only fashion.`;
+  }
+}
+function describeYellow(verb, gitArgs) {
+  switch (verb) {
+    case "add":
+      return "Stage files so the next commit includes them.";
+    case "commit":
+      return "Save staged changes as a new commit.";
+    case "push":
+      return "Upload local commits to a remote repository.";
+    case "pull":
+      return "Download and merge changes from a remote branch.";
+    case "checkout":
+      return "Switch branches or restore files (can change your working tree).";
+    case "switch":
+      return "Switch to another branch.";
+    case "merge":
+      return "Combine another branch into your current branch.";
+    case "restore":
+      return "Restore working tree or index files.";
+    case "mv":
+    case "rm":
+      return "Change or remove tracked files as requested.";
+    default:
+      return `Run git ${verb} ${gitArgs.slice(1).join(" ")}`.trim();
+  }
+}
+function classifyGitCommand(gitArgs) {
+  const summary = commandSummary(gitArgs);
+  const { tier, plainEnglish, whatChanges, whatCouldGoWrong } = tierAndCopy(gitArgs);
+  const needsSnapshot = tier === "red";
+  return {
+    tier,
+    needsSnapshot,
+    summary,
+    plainEnglish,
+    whatChanges,
+    whatCouldGoWrong
+  };
+}
+async function explainGitCommand(projectRoot, gitArgs) {
+  void projectRoot;
+  return classifyGitCommand(gitArgs);
+}
+async function createSafetySnapshot(projectRoot) {
+  const suffix = randomBytes(4).toString("hex");
+  const branchName = `conductor-safety-${Date.now()}-${suffix}`;
+  await runGit(projectRoot, ["branch", branchName]);
+  let stashSaved = false;
+  try {
+    await runGit(projectRoot, [
+      "stash",
+      "push",
+      "-u",
+      "-m",
+      "Conductor safety stash before a risky git command"
+    ]);
+    stashSaved = true;
+  } catch {
+    stashSaved = false;
+  }
+  return { branchName, stashSaved };
+}
+async function executeConfirmedGitCommand(projectRoot, gitArgs) {
+  const c = classifyGitCommand(gitArgs);
+  if (c.tier === "green") {
+    const output = await runGit(projectRoot, gitArgs);
+    return {
+      tier: c.tier,
+      summary: c.summary,
+      ran: true,
+      output,
+      snapshot: null
+    };
+  }
+  return {
+    tier: c.tier,
+    summary: c.summary,
+    ran: false,
+    output: "",
+    snapshot: null,
+    classification: c
+  };
+}
+async function executeNarrated(projectRoot, gitArgs) {
+  const c = classifyGitCommand(gitArgs);
+  if (c.tier === "green" || c.tier === "yellow") {
+    const output = await runGit(projectRoot, gitArgs);
+    return {
+      tier: c.tier,
+      summary: c.summary,
+      ran: true,
+      output,
+      snapshot: null
+    };
+  }
+  return {
+    tier: c.tier,
+    summary: c.summary,
+    ran: false,
+    output: "",
+    snapshot: null,
+    classification: c
+  };
+}
+
+export {
+  runGit,
+  getGitBranchInfo,
+  formatGitBranchLine,
+  getCurrentBranch,
+  getStatusSummary,
+  getRecentCommits,
+  classifyGitCommand,
+  explainGitCommand,
+  createSafetySnapshot,
+  executeConfirmedGitCommand,
+  executeNarrated
+};