@biffo/cli 0.312.5 → 0.313.1

package/dist/index.js

@@ -719,7 +719,8 @@ function checkCoreOwnership({
   branch = "",
   commitMessage = "",
   warnOnly = [],
-  templateShippedPaths = null
+  templateShippedPaths = null,
+  upgradeCommitFiles = null
 }) {
   const empty = {
     blocked: [],
@@ -729,8 +730,13 @@ function checkCoreOwnership({
     knownOrphans: []
   };
   if (!isInstance) return { skipped: "template", ...empty };
-  if (branch.startsWith(UPGRADE_BRANCH_PREFIX)) return { skipped: "upgrade-branch", ...empty };
-  const manifestTemplateOwned = changedFiles.filter((f) => isTemplateOwned(f, manifest));
+  let effectiveChangedFiles = changedFiles;
+  if (branch.startsWith(UPGRADE_BRANCH_PREFIX)) {
+    const exempt = new Set(upgradeCommitFiles ?? []);
+    effectiveChangedFiles = changedFiles.filter((f) => !exempt.has(f));
+    if (effectiveChangedFiles.length === 0) return { skipped: "upgrade-branch", ...empty };
+  }
+  const manifestTemplateOwned = effectiveChangedFiles.filter((f) => isTemplateOwned(f, manifest));
   const knownOrphans = [];
   const templateOwned = [];
   for (const path of manifestTemplateOwned) {
@@ -12722,7 +12728,37 @@ async function fetchTemplateShippedPaths(repoRoot, runner = defaultRunner) {
   return paths.length > 0 ? new Set(paths) : null;
 }
 
+// src/lib/upgrade-commit-files.ts
+var defaultRunner2 = async (args, cwd) => {
+  const result = await execa("git", args, { cwd, reject: false, timeout: 15e3 });
+  return { stdout: String(result.stdout ?? ""), exitCode: result.exitCode ?? null };
+};
+var splitLines = (stdout) => stdout.split("\n").map((line) => line.trim()).filter(Boolean);
+async function resolveUpgradeCommitFiles(repoRoot, base, opts = {}, runner = defaultRunner2) {
+  let rev;
+  try {
+    rev = await runner(["rev-list", "--reverse", `${base}..HEAD`], repoRoot);
+  } catch {
+    return null;
+  }
+  if (rev.exitCode !== 0) return null;
+  const commits = splitLines(rev.stdout);
+  if (commits.length === 0) {
+    return opts.stagedFallbackFiles ?? null;
+  }
+  const first = commits[0];
+  let diff;
+  try {
+    diff = await runner(["diff-tree", "--no-commit-id", "--name-only", "-r", first], repoRoot);
+  } catch {
+    return null;
+  }
+  if (diff.exitCode !== 0) return null;
+  return splitLines(diff.stdout);
+}
+
 // src/scripts/check-core-ownership.ts
+var LOCAL_UPGRADE_BASE = "origin/dev";
 var BOLD = "\x1B[1m";
 var DIM = "\x1B[2m";
 var RED = "\x1B[31m";
@@ -12748,6 +12784,7 @@ async function runOwnershipCheck(argv) {
   let changedFiles;
   let deletedFiles = [];
   let commitMessage = "";
+  let ciBase = null;
   if (staged) {
     const { stdout } = await execa("git", ["diff", "--cached", "--name-status"], { cwd: root });
     ({ changed: changedFiles, deleted: deletedFiles } = parseNameStatus(stdout));
@@ -12762,11 +12799,12 @@ async function runOwnershipCheck(argv) {
       process.exit(2);
     }
     await execa("git", ["fetch", "--quiet", "origin", base], { cwd: root, reject: false });
-    const { stdout } = await execa("git", ["diff", "--name-status", `origin/${base}...HEAD`], {
+    ciBase = `origin/${base}`;
+    const { stdout } = await execa("git", ["diff", "--name-status", `${ciBase}...HEAD`], {
       cwd: root
     });
     ({ changed: changedFiles, deleted: deletedFiles } = parseNameStatus(stdout));
-    const { stdout: log2 } = await execa("git", ["log", "--format=%B", `origin/${base}..HEAD`], {
+    const { stdout: log2 } = await execa("git", ["log", "--format=%B", `${ciBase}..HEAD`], {
       cwd: root,
       reject: false
     });
@@ -12777,6 +12815,11 @@ async function runOwnershipCheck(argv) {
     reject: false
   });
   const branch = resolveBranch(process.env, gitBranch);
+  const upgradeCommitFiles = branch.startsWith(UPGRADE_BRANCH_PREFIX) ? await resolveUpgradeCommitFiles(
+    root,
+    ciBase ?? LOCAL_UPGRADE_BASE,
+    staged ? { stagedFallbackFiles: changedFiles } : {}
+  ) : null;
   const templateShippedPaths = staged ? null : await fetchTemplateShippedPaths(root);
   if (!staged && templateShippedPaths === null) {
     console.error(
@@ -12790,6 +12833,7 @@ async function runOwnershipCheck(argv) {
     branch,
     commitMessage,
     warnOnly: readDivergenceConfig(root).warnOnly,
+    upgradeCommitFiles,
     templateShippedPaths
   });
   if (result.knownOrphans.length > 0) {
@@ -16299,7 +16343,7 @@ function rawArgsAfter(subcommand) {
 
 // src/commands/doctor.ts
 import { existsSync as existsSync56, readFileSync as readFileSync47 } from "fs";
-import { join as join68, resolve as resolve20 } from "path";
+import { join as join69, resolve as resolve20 } from "path";
 import chalk21 from "chalk";
 import { Command as Command25 } from "commander";
 
@@ -16638,33 +16682,110 @@ async function reapAllBareBranches(cwd, branches, worktrees, currentBranch, deps
   return outcomes;
 }
 
-// src/commands/doctor.ts
+// src/lib/scratch-clone-scan.ts
+import { readdirSync as readdirSync29, statSync as statSync18 } from "fs";
+import { join as join68 } from "path";
 var INTEGRATION_BRANCH = "dev";
+function isPlainCloneDir(path) {
+  try {
+    return statSync18(join68(path, ".git")).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function repoNameFromRemoteUrl(url) {
+  const trimmed = url.trim();
+  if (trimmed === "") return null;
+  const match = /\/([^/]+?)(\.git)?\/?$/.exec(trimmed);
+  return match?.[1] && match[1] !== "" ? match[1] : null;
+}
+async function findScratchCloneCandidates(estateRoot, deps) {
+  const names = readdirSync29(estateRoot, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+  const candidates = [];
+  for (const name of names) {
+    const path = join68(estateRoot, name);
+    if (!isPlainCloneDir(path)) continue;
+    let branch;
+    try {
+      branch = await deps.git.currentBranch(path);
+    } catch {
+      candidates.push({ path, branch: "", invalidRepo: true });
+      continue;
+    }
+    const remoteUrl = await deps.git.getRemoteUrl(path).catch(() => "");
+    const repoName = remoteUrl === "" ? null : repoNameFromRemoteUrl(remoteUrl);
+    const looksLikeKnownRepoCheckout = repoName !== null && repoName.toLowerCase() === name.toLowerCase() && branch === INTEGRATION_BRANCH;
+    if (looksLikeKnownRepoCheckout) continue;
+    candidates.push({ path, branch });
+  }
+  return candidates;
+}
+async function classifyScratchClones(candidates, deps) {
+  const reports = [];
+  for (const candidate of candidates) {
+    if (candidate.invalidRepo === true) {
+      reports.push({ candidate, verdict: { action: "keep", reason: "not-a-git-repository" } });
+      continue;
+    }
+    const isDetached = candidate.branch === "HEAD" || candidate.branch === "";
+    const isDirty = await deps.git.hasUncommittedChanges(candidate.path);
+    const prVerdict = isDetached || isDirty ? "unknown" : await deps.github.prVerdictForBranch(candidate.path, candidate.branch);
+    let mergeContainsHead = true;
+    if (prVerdict === "merged") {
+      const [headSha, mergedHeadSha] = await Promise.all([
+        deps.git.headSha(candidate.path),
+        deps.github.mergedHeadSha(candidate.path, candidate.branch)
+      ]);
+      mergeContainsHead = headSha === null || mergedHeadSha === null ? null : await deps.git.isAncestor(candidate.path, headSha, mergedHeadSha);
+    }
+    const verdict = classifyReapCandidate({
+      isDetached,
+      isDirty,
+      hasFleetClaim: false,
+      prVerdict,
+      mergeContainsHead
+    });
+    reports.push({ candidate, verdict });
+  }
+  return reports;
+}
+
+// src/commands/doctor.ts
+var INTEGRATION_BRANCH2 = "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").option(
   "--fix",
   "Also remove any worktree, and delete any bare local branch, 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 tip 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."
-).action(async (options) => {
-  const cwd = options.cwd ? resolve20(options.cwd) : process.cwd();
-  const git = new GitAdapter();
-  try {
-    const facts = await gatherRepoFacts({ cwd, fetch: options.fetch !== false }, { git });
-    const findings = runDoctorChecks(facts);
-    printFindings(findings);
-    if (options.fix === true) {
-      const github = new GithubCliAdapter();
-      const outcomes = await runDoctorFix(cwd, facts, { git, github });
-      printReapOutcomes(outcomes);
-      const branchOutcomes = await runDoctorFixBranches(cwd, facts, { git, github });
-      printBranchReapOutcomes(branchOutcomes);
-    }
-    if (findings.some((f) => f.severity === "error")) process.exit(1);
-  } catch (err) {
-    log.error(err.message);
-    process.exit(1);
+).option(
+  "--scratch-clones <estateRoot>",
+  "Instead of checking one repo, scan <estateRoot> for top-level plain `git clone` directories (#1949) \u2014 invisible to every check above, which all start from `git worktree list`. Each is classified the same way `--fix` classifies a worktree (GitHub's own PR verdict), but nothing is ever removed by this mode: a wrongly-excluded directory costs a report line, an `rm -rf` on a wrongly-included one would not be recoverable the way `git worktree remove` is."
+).action(
+  async (options) => {
+    if (options.scratchClones !== void 0) {
+      await runScratchCloneScan(resolve20(options.scratchClones));
+      return;
+    }
+    const cwd = options.cwd ? resolve20(options.cwd) : process.cwd();
+    const git = new GitAdapter();
+    try {
+      const facts = await gatherRepoFacts({ cwd, fetch: options.fetch !== false }, { git });
+      const findings = runDoctorChecks(facts);
+      printFindings(findings);
+      if (options.fix === true) {
+        const github = new GithubCliAdapter();
+        const outcomes = await runDoctorFix(cwd, facts, { git, github });
+        printReapOutcomes(outcomes);
+        const branchOutcomes = await runDoctorFixBranches(cwd, facts, { git, github });
+        printBranchReapOutcomes(branchOutcomes);
+      }
+      if (findings.some((f) => f.severity === "error")) process.exit(1);
+    } catch (err) {
+      log.error(err.message);
+      process.exit(1);
+    }
   }
-});
+);
 async function gatherRepoFacts(options, deps) {
   const { git } = deps;
   if (!await git.isGitRepo(options.cwd)) {
@@ -16680,13 +16801,13 @@ async function gatherRepoFacts(options, deps) {
   const worktrees = await Promise.all(
     worktreePaths.map(async (w) => ({
       ...w,
-      behind: await git.countBehind(options.cwd, w.branch, `origin/${INTEGRATION_BRANCH}`)
+      behind: await git.countBehind(options.cwd, w.branch, `origin/${INTEGRATION_BRANCH2}`)
     }))
   );
   return {
     currentBranch,
     isPrimary,
-    integrationBranch: INTEGRATION_BRANCH,
+    integrationBranch: INTEGRATION_BRANCH2,
     ahead,
     behind,
     hasUpstream,
@@ -16697,7 +16818,7 @@ async function gatherRepoFacts(options, deps) {
     // a fault in it.
     localCoreVersion: readLocalCoreVersion(options.cwd),
     remoteCoreVersion: parseCoreRecord(
-      await git.showFileAtRef(options.cwd, `origin/${INTEGRATION_BRANCH}`, INSTANCE_CORE_FILE)
+      await git.showFileAtRef(options.cwd, `origin/${INTEGRATION_BRANCH2}`, INSTANCE_CORE_FILE)
     ),
     fossilCoreVersion: readFossil(options.cwd),
     branches,
@@ -16719,8 +16840,50 @@ async function runDoctorFixBranches(cwd, facts, deps = { git: new GitAdapter(),
     remoteBranchNames
   );
 }
+async function runScratchCloneScan(estateRoot) {
+  const git = new GitAdapter();
+  const github = new GithubCliAdapter();
+  try {
+    const candidates = await findScratchCloneCandidates(estateRoot, { git });
+    const reports = await classifyScratchClones(candidates, { git, github });
+    printScratchCloneReports(estateRoot, reports);
+  } catch (err) {
+    log.error(err.message);
+    process.exit(1);
+  }
+}
+function printScratchCloneReports(estateRoot, reports) {
+  if (reports.length === 0) {
+    console.log(
+      chalk21.dim(`  scratch-clones: no plain git-clone directory found under ${estateRoot}.
+`)
+    );
+    return;
+  }
+  const reapable = reports.filter((r) => r.verdict.action === "reap");
+  const kept = reports.filter((r) => r.verdict.action === "keep");
+  console.log("");
+  for (const r of reapable) {
+    console.log(
+      chalk21.yellow(
+        `  reapable  ${r.candidate.path} (${r.candidate.branch}) \u2014 branch's PR merged and this clone's tip is contained in what shipped; plain git clone, not a worktree, so \`git worktree remove\` does not apply \u2014 remove by hand once confirmed: rm -rf '${r.candidate.path}'`
+      )
+    );
+  }
+  for (const r of kept) {
+    const reason = r.verdict.reason === void 0 ? "unknown" : KEEP_REASON_TEXT[r.verdict.reason];
+    console.log(chalk21.dim(`  kept      ${r.candidate.path} (${r.candidate.branch}) \u2014 ${reason}`));
+  }
+  console.log(
+    chalk21.dim(
+      `
+  scratch-clones: ${String(reapable.length)} reapable, ${String(kept.length)} kept, of ${String(reports.length)} plain git-clone director${reports.length === 1 ? "y" : "ies"} found under ${estateRoot}.
+`
+    )
+  );
+}
 function readLocalCoreVersion(cwd) {
-  const path = join68(cwd, INSTANCE_CORE_FILE);
+  const path = join69(cwd, INSTANCE_CORE_FILE);
   if (!existsSync56(path)) return null;
   try {
     return extractVersionField(readFileSync47(path, "utf8"));
@@ -16743,7 +16906,7 @@ function extractVersionField(contents) {
   return match?.[1] ?? null;
 }
 function readFossil(cwd) {
-  const path = join68(cwd, CORE_VERSION_FILE);
+  const path = join69(cwd, CORE_VERSION_FILE);
   if (!existsSync56(path)) return null;
   try {
     const value = readFileSync47(path, "utf8").trim();
@@ -16783,7 +16946,8 @@ var KEEP_REASON_TEXT = {
   "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"
+  "unknown-merge-head": "could not confirm worktree HEAD is contained in what merged",
+  "not-a-git-repository": "the .git directory exists but is not a resolvable, initialised git repository"
 };
 function printReapOutcomes(outcomes) {
   if (outcomes.length === 0) {
@@ -17277,18 +17441,18 @@ function resolveGithubToken4() {
 
 // src/lib/packaged-script-command.ts
 import { spawnSync } from "child_process";
-import { chmodSync as chmodSync2, statSync as statSync18 } from "fs";
+import { chmodSync as chmodSync2, statSync as statSync19 } from "fs";
 import { dirname as dirname12 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 import { Command as Command27 } from "commander";
 
 // src/lib/packaged-scripts.ts
 import { existsSync as existsSync57 } from "fs";
-import { dirname as dirname11, join as join69 } from "path";
+import { dirname as dirname11, join as join70 } from "path";
 function findPackagedScript(startDir, relativePath) {
   let dir = startDir;
   for (; ; ) {
-    const candidate = join69(dir, relativePath);
+    const candidate = join70(dir, relativePath);
     if (existsSync57(candidate)) return candidate;
     const parent = dirname11(dir);
     if (parent === dir) return null;
@@ -17303,7 +17467,7 @@ It ships with this package via cli/scripts/packaged-root-assets.mjs; if you are
 // src/lib/packaged-script-command.ts
 function ensureExecutable(script) {
   try {
-    const { mode } = statSync18(script);
+    const { mode } = statSync19(script);
     if ((mode & 73) === 0) chmodSync2(script, mode | 493);
   } catch {
   }

package/package.json

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