@biffo/cli 0.299.1 → 0.300.0

package/dist/index.js

@@ -1255,6 +1255,51 @@ var GitAdapter = class {
     const { exitCode } = await execa("git", ["branch", "-D", branch], { cwd, reject: false });
     return exitCode === 0;
   }
+  /**
+   * Removes a linked worktree, returning whether it went.
+   *
+   * Deliberately NOT `--force`: the caller (`doctor --fix`, #1682) only ever
+   * reaches this after confirming the worktree is clean, so a plain `remove`
+   * should always succeed. If it does not — a lock file, a submodule holding
+   * a reference, something this check did not anticipate — failing rather
+   * than forcing past it is the point: an unexpected refusal is new
+   * information, not an obstacle to blast through on a path that deletes
+   * things.
+   */
+  async removeWorktree(cwd, path) {
+    const { exitCode } = await execa("git", ["worktree", "remove", path], { cwd, reject: false });
+    return exitCode === 0;
+  }
+  /**
+   * `HEAD`'s commit SHA at `cwd`, or `null` if it cannot be resolved (an
+   * unborn branch, a path that is not a git repo). Used by `doctor --fix`
+   * (#1810) to prove a worktree's *current* tip — not just its branch name —
+   * is what a merged PR actually shipped, before trusting it is safe to
+   * delete.
+   */
+  async headSha(cwd) {
+    const { stdout, exitCode } = await execa("git", ["rev-parse", "HEAD"], { cwd, reject: false });
+    return exitCode === 0 ? stdout.trim() : null;
+  }
+  /**
+   * Is `ancestor` reachable from `descendant` (including `ancestor ===
+   * descendant`)? Three-valued, not boolean: `git merge-base --is-ancestor`
+   * exits `0` for yes, `1` for no, and anything else — most commonly a SHA
+   * this repo has never fetched the object for — is a genuine "cannot tell",
+   * which callers must treat as unsafe rather than as a "no" (#1810). `cwd`
+   * only needs to be *any* worktree of the same clone: the object database is
+   * shared, so a commit reachable from one worktree's history is visible from
+   * every other.
+   */
+  async isAncestor(cwd, ancestor, descendant) {
+    const { exitCode } = await execa("git", ["merge-base", "--is-ancestor", ancestor, descendant], {
+      cwd,
+      reject: false
+    });
+    if (exitCode === 0) return true;
+    if (exitCode === 1) return false;
+    return null;
+  }
   /** Create and switch to a new branch. Fails if it already exists. */
   async createBranch(cwd, branch) {
     await execa("git", ["switch", "-c", branch], { cwd });
@@ -14724,6 +14769,97 @@ import { join as join61, resolve as resolve20 } from "path";
 import chalk21 from "chalk";
 import { Command as Command25 } from "commander";
 
+// src/adapters/github-cli/index.ts
+var GithubCliAdapter = class {
+  /**
+   * What GitHub says happened to `branch`'s pull request(s), in this repo.
+   *
+   * `--state all` so a merged or closed PR is not filtered out before we see
+   * it. `open` wins over any other state present (an open PR is never safe to
+   * touch regardless of history), `merged` wins over `closed` next (a branch
+   * can carry more than one PR across its life — a reopened one, say — and
+   * "was ever merged" is the fact that matters). `none` means no PR was ever
+   * opened from this branch; `unknown` means the lookup itself could not be
+   * trusted (no network, `gh` unauthenticated, unparseable output) and is
+   * handled identically to a hard "keep" by the caller — never as license to
+   * guess.
+   */
+  async prVerdictForBranch(cwd, branch) {
+    const { stdout, exitCode } = await execa(
+      "gh",
+      ["pr", "list", "--head", branch, "--state", "all", "--json", "state", "--limit", "20"],
+      { cwd, reject: false }
+    );
+    if (exitCode !== 0) return "unknown";
+    let parsed;
+    try {
+      const value = JSON.parse(stdout);
+      if (!Array.isArray(value)) return "unknown";
+      parsed = value;
+    } catch {
+      return "unknown";
+    }
+    const states = new Set(
+      parsed.map((p) => typeof p.state === "string" ? p.state : "").filter((s) => s !== "")
+    );
+    if (states.size === 0) return "none";
+    if (states.has("OPEN")) return "open";
+    if (states.has("MERGED")) return "merged";
+    if (states.has("CLOSED")) return "closed";
+    return "unknown";
+  }
+  /**
+   * The head commit SHA (`headRefOid`) GitHub recorded for `branch`'s merged
+   * pull request, or `null` when there is none or the lookup could not be
+   * trusted.
+   *
+   * This is the fact `prVerdictForBranch` alone cannot supply, and #1810 is
+   * the reason it must be asked for separately: "a PR merged for this branch
+   * name" proves the branch's history at *some* point merged, never that the
+   * worktree's *current* tip is that same point — a worktree can carry real,
+   * committed, unpushed commits on top of an already-merged branch, and nothing
+   * about the branch name changes. GitHub keeps `headRefOid` pointing at the
+   * PR's last pushed commit even after the remote branch itself is deleted
+   * post-merge (nothing can push to a deleted ref again), so it stays a stable
+   * "this is what actually shipped" marker for the caller to check the
+   * worktree's HEAD against via `GitAdapter.isAncestor`.
+   *
+   * Deliberately a second call rather than folding `headRefOid` into
+   * `prVerdictForBranch`'s existing `--json state` query: that function's
+   * return type and every existing caller are already covered by tests
+   * written against `Promise<PrVerdict>`, and this fact is only ever needed
+   * once a verdict of `'merged'` is already in hand.
+   */
+  async mergedHeadSha(cwd, branch) {
+    const { stdout, exitCode } = await execa(
+      "gh",
+      [
+        "pr",
+        "list",
+        "--head",
+        branch,
+        "--state",
+        "merged",
+        "--json",
+        "headRefOid",
+        "--limit",
+        "20"
+      ],
+      { cwd, reject: false }
+    );
+    if (exitCode !== 0) return null;
+    let parsed;
+    try {
+      parsed = JSON.parse(stdout);
+    } catch {
+      return null;
+    }
+    if (!Array.isArray(parsed) || parsed.length === 0) return null;
+    const first = parsed[0];
+    return typeof first.headRefOid === "string" && /^[0-9a-f]{7,40}$/i.test(first.headRefOid) ? first.headRefOid : null;
+  }
+};
+
 // src/lib/doctor.ts
 function checkCheckoutCurrency(facts) {
   const findings = [];
@@ -14843,22 +14979,90 @@ function runDoctorChecks(facts) {
   ];
 }
 
+// src/lib/doctor-reaper.ts
+function classifyReapCandidate(facts) {
+  if (facts.isDetached) return { action: "keep", reason: "detached-head" };
+  if (facts.isDirty) return { action: "keep", reason: "uncommitted-changes" };
+  switch (facts.prVerdict) {
+    case "merged":
+      if (facts.mergeContainsHead === true) return { action: "reap" };
+      if (facts.mergeContainsHead === false) {
+        return { action: "keep", reason: "commits-not-in-merge" };
+      }
+      return { action: "keep", reason: "unknown-merge-head" };
+    case "open":
+      return { action: "keep", reason: "pr-open" };
+    case "closed":
+      return { action: "keep", reason: "pr-closed" };
+    case "none":
+      return { action: "keep", reason: "no-pr" };
+    case "unknown":
+      return { action: "keep", reason: "unknown-pr-verdict" };
+  }
+}
+function findReapCandidates(branches, worktrees) {
+  const goneBranches = new Set(branches.filter((b) => b.track.includes("gone")).map((b) => b.name));
+  return worktrees.filter((w) => goneBranches.has(w.branch)).map((w) => ({ branch: w.branch, worktreePath: w.path }));
+}
+async function reapCandidate(cwd, candidate, deps) {
+  const { git, github } = deps;
+  const [current, isDirty] = await Promise.all([
+    git.currentBranch(candidate.worktreePath),
+    git.hasUncommittedChanges(candidate.worktreePath)
+  ]);
+  const isDetached = current === "HEAD" || current === "";
+  const prVerdict = isDetached || isDirty ? "unknown" : await github.prVerdictForBranch(cwd, candidate.branch);
+  let mergeContainsHead = true;
+  if (prVerdict === "merged") {
+    const [headSha, mergedHeadSha] = await Promise.all([
+      git.headSha(candidate.worktreePath),
+      github.mergedHeadSha(cwd, candidate.branch)
+    ]);
+    mergeContainsHead = headSha === null || mergedHeadSha === null ? null : await git.isAncestor(cwd, headSha, mergedHeadSha);
+  }
+  const verdict = classifyReapCandidate({ isDetached, isDirty, prVerdict, mergeContainsHead });
+  if (verdict.action === "keep") {
+    return { candidate, verdict, worktreeRemoved: null };
+  }
+  const worktreeRemoved = await git.removeWorktree(cwd, candidate.worktreePath);
+  return { candidate, verdict, worktreeRemoved };
+}
+async function reapAll(cwd, branches, worktrees, currentBranch, deps) {
+  const candidates = findReapCandidates(branches, worktrees).filter(
+    (c) => c.branch !== currentBranch
+  );
+  const outcomes = [];
+  for (const candidate of candidates) {
+    outcomes.push(await reapCandidate(cwd, candidate, deps));
+  }
+  return outcomes;
+}
+
 // src/commands/doctor.ts
 var INTEGRATION_BRANCH = "dev";
 var doctorCommand = new Command25("doctor").description(
   "Report repo-state conditions that make everything read from this checkout unreliable"
-).option("--cwd <path>", "Repo root to inspect (defaults to the current directory)").option("--no-fetch", "Skip the fetch; report against refs as they already are locally").action(async (options) => {
+).option("--cwd <path>", "Repo root to inspect (defaults to the current directory)").option("--no-fetch", "Skip the fetch; report against refs as they already are locally").option(
+  "--fix",
+  "Also remove any worktree PROVEN safe: one whose branch's PR merged, verified via GitHub (never local commit reachability \u2014 a squash merge rewrites every SHA), AND whose current HEAD is confirmed contained in what that PR actually shipped \u2014 not merely on a branch of the same name (#1810). Everything else (no PR, PR open, PR closed unmerged, detached HEAD, uncommitted changes, commits ahead of what merged, or that containment could not be confirmed) is reported, never touched. Branch deletion is not yet automated here \u2014 that is #1682 milestone 2."
+).action(async (options) => {
   const cwd = options.cwd ? resolve20(options.cwd) : process.cwd();
+  const git = new GitAdapter();
   try {
-    const findings = await runDoctor({ cwd, fetch: options.fetch !== false });
+    const facts = await gatherRepoFacts({ cwd, fetch: options.fetch !== false }, { git });
+    const findings = runDoctorChecks(facts);
     printFindings(findings);
+    if (options.fix === true) {
+      const outcomes = await runDoctorFix(cwd, facts, { git, github: new GithubCliAdapter() });
+      printReapOutcomes(outcomes);
+    }
     if (findings.some((f) => f.severity === "error")) process.exit(1);
   } catch (err) {
     log.error(err.message);
     process.exit(1);
   }
 });
-async function runDoctor(options, deps = { git: new GitAdapter() }) {
+async function gatherRepoFacts(options, deps) {
   const { git } = deps;
   if (!await git.isGitRepo(options.cwd)) {
     throw new Error(`${options.cwd} is not a git repository.`);
@@ -14876,7 +15080,7 @@ async function runDoctor(options, deps = { git: new GitAdapter() }) {
       behind: await git.countBehind(options.cwd, w.branch, `origin/${INTEGRATION_BRANCH}`)
     }))
   );
-  const facts = {
+  return {
     currentBranch,
     isPrimary,
     integrationBranch: INTEGRATION_BRANCH,
@@ -14896,7 +15100,9 @@ async function runDoctor(options, deps = { git: new GitAdapter() }) {
     branches,
     worktrees
   };
-  return runDoctorChecks(facts);
+}
+async function runDoctorFix(cwd, facts, deps = { git: new GitAdapter(), github: new GithubCliAdapter() }) {
+  return reapAll(cwd, facts.branches, facts.worktrees, facts.currentBranch, deps);
 }
 function readLocalCoreVersion(cwd) {
   const path = join61(cwd, INSTANCE_CORE_FILE);
@@ -14953,6 +15159,51 @@ function printFindings(findings) {
     )
   );
 }
+var KEEP_REASON_TEXT = {
+  "detached-head": "worktree HEAD is detached",
+  "uncommitted-changes": "worktree has uncommitted changes",
+  "pr-open": "PR is still open",
+  "pr-closed": "PR closed unmerged",
+  "no-pr": "no PR was ever opened from this branch",
+  "unknown-pr-verdict": "could not read this branch's PR state from GitHub",
+  "commits-not-in-merge": "worktree HEAD includes commits the merged PR never shipped",
+  "unknown-merge-head": "could not confirm worktree HEAD is contained in what merged"
+};
+function printReapOutcomes(outcomes) {
+  if (outcomes.length === 0) {
+    console.log(chalk21.dim("  --fix: no worktree with a gone upstream to consider.\n"));
+    return;
+  }
+  const attempted = outcomes.filter((o) => o.verdict.action === "reap");
+  const kept = outcomes.filter((o) => o.verdict.action === "keep");
+  const removed = attempted.filter((o) => o.worktreeRemoved === true);
+  const failed = attempted.filter((o) => o.worktreeRemoved !== true);
+  console.log("");
+  for (const o of attempted) {
+    if (o.worktreeRemoved === true) {
+      console.log(chalk21.green(`  removed  ${o.candidate.worktreePath} (${o.candidate.branch})`));
+    } else {
+      console.log(
+        chalk21.red(
+          `  FAILED   ${o.candidate.worktreePath} (${o.candidate.branch}) \u2014 judged safe to remove but 'git worktree remove' did not succeed; left as-is`
+        )
+      );
+    }
+  }
+  for (const o of kept) {
+    const reason = o.verdict.reason === void 0 ? "unknown" : KEEP_REASON_TEXT[o.verdict.reason];
+    console.log(
+      chalk21.dim(`  kept     ${o.candidate.worktreePath} (${o.candidate.branch}) \u2014 ${reason}`)
+    );
+  }
+  console.log(
+    chalk21.dim(
+      `
+  --fix: ${String(removed.length)} removed, ${String(failed.length)} failed, ${String(kept.length)} kept, of ${String(outcomes.length)} worktree(s) considered.
+`
+    )
+  );
+}
 
 // src/commands/teardown.ts
 import { execSync as execSync7 } from "child_process";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@biffo/cli",
-  "version": "0.299.1",
+  "version": "0.300.0",
   "description": "Biffo project scaffolding CLI",
   "license": "MIT",
   "type": "module",