@rtorcato/repo-tooling 3.40.0 → 3.41.0

package/dist/base/git-identity.js

@@ -92,7 +92,7 @@ function repoScopedEnv() {
     return env;
 }
 /** Never rejects; a missing or failing git resolves to null. */
-export const realGitExec = (args, cwd) => new Promise((resolve) => {
+export const realGitExec = (args, cwd, timeoutMs = GIT_TIMEOUT_MS) => new Promise((resolve) => {
     let settled = false;
     const done = (v) => {
         if (settled)
@@ -112,7 +112,7 @@ export const realGitExec = (args, cwd) => new Promise((resolve) => {
     const timer = setTimeout(() => {
         child.kill();
         done(null);
-    }, GIT_TIMEOUT_MS);
+    }, timeoutMs);
     child.stdout?.on('data', (d) => {
         stdout += d;
     });

package/dist/cli/commands/loop-cleanup.js

@@ -0,0 +1,100 @@
+import path from 'node:path';
+import chalk from 'chalk';
+import { realGitExec } from '../../base/git-identity.js';
+import { realGhExec } from '../../base/github-settings.js';
+import { defaultWorktreeRoot, findLive } from './loop-guard.js';
+/** How far back to look for the squash subject. */
+const SQUASH_WINDOW = 200;
+async function findPr(gh, heads) {
+    for (const head of heads) {
+        const r = await gh(['pr', 'list', '--head', head, '--state', 'all', '--json', 'number,state']);
+        if (!r.ok)
+            continue;
+        const [pr] = JSON.parse(r.stdout || '[]');
+        if (pr)
+            return pr;
+    }
+    return null;
+}
+export async function runLoopCleanup(options = {}) {
+    const root = path.resolve(options.root ?? process.cwd());
+    const worktreeRoot = options.worktreeRoot
+        ? path.resolve(options.worktreeRoot)
+        : defaultWorktreeRoot(root);
+    // Fetch and `worktree remove` outlast the 5s probe timeout on a real repo.
+    const git = options.git ?? ((args) => realGitExec(args, root, 120_000));
+    const gh = options.gh ?? ((args, stdin) => realGhExec(args, stdin, root));
+    const dirs = await findLive([worktreeRoot, path.join(root, '.claude', 'worktrees')]);
+    let subjects = null;
+    const worktrees = [];
+    for (const dir of dirs) {
+        const slug = path.basename(dir);
+        const issue = Number(slug.match(/^ai-(\d+)-/)?.[1]) || null;
+        // `worktree-` is the prefix EnterWorktree once gave branches — legacy.
+        const heads = [slug, `worktree-${slug}`];
+        const branch = (await git(['branch', '--list', ...heads, '--format=%(refname:short)']))
+            ?.split('\n')[0]
+            ?.trim() || null;
+        const pr = await findPr(gh, heads);
+        const entry = {
+            path: dir,
+            issue,
+            branch,
+            pr: pr?.number ?? null,
+            prState: pr?.state ?? null,
+            action: 'kept',
+            reason: '',
+        };
+        worktrees.push(entry);
+        if (!pr || pr.state === 'OPEN') {
+            entry.reason = pr ? 'PR still open' : 'no PR';
+            continue;
+        }
+        if (pr.state === 'MERGED') {
+            if (subjects === null) {
+                // Best-effort: a failed fetch leaves origin/main stale, which can
+                // only keep a worktree, never remove one wrongly.
+                await git(['fetch', '--prune', 'origin']);
+                const log = await git(['log', 'origin/main', `-n${SQUASH_WINDOW}`, '--format=%s']);
+                subjects = log ? log.split('\n') : [];
+            }
+            if (!subjects.some((s) => s.trimEnd().endsWith(`(#${pr.number})`))) {
+                entry.reason = `squash for #${pr.number} not on origin/main`;
+                continue;
+            }
+        }
+        if ((await git(['worktree', 'remove', '--force', dir])) === null) {
+            entry.action = 'remove-failed';
+            entry.reason = 'git worktree remove failed';
+            continue;
+        }
+        if (branch)
+            await git(['branch', '-D', branch]);
+        entry.action = 'removed';
+        entry.reason = pr.state === 'MERGED' ? `#${pr.number} landed on main` : `#${pr.number} closed`;
+    }
+    return {
+        root,
+        worktreeRoot,
+        removed: worktrees.some((w) => w.action === 'removed'),
+        worktrees,
+        exitCode: worktrees.some((w) => w.action === 'remove-failed') ? 1 : 0,
+    };
+}
+export async function loopCleanupCommand(options) {
+    const result = await runLoopCleanup(options);
+    if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else {
+        console.log();
+        if (result.worktrees.length === 0)
+            console.log(chalk.gray('  no ai-* worktrees'));
+        for (const w of result.worktrees) {
+            const line = `${w.action.padEnd(13)} ${path.basename(w.path)} — ${w.reason}`;
+            console.log(`  ${w.action === 'remove-failed' ? chalk.yellow(line) : chalk.gray(line)}`);
+        }
+        console.log();
+    }
+    process.exitCode = result.exitCode;
+}

package/dist/cli/commands/loop-guard.js

@@ -107,7 +107,7 @@ async function gitEntryKind(root) {
     }
 }
 /** `ai-*` directories one level down, in either place worktrees are kept. */
-async function findLive(dirs) {
+export async function findLive(dirs) {
     const live = [];
     for (const dir of dirs) {
         // A missing worktree root is the normal case, not an error.

package/dist/cli/index.js

@@ -5,6 +5,7 @@ import { Command } from 'commander';
 import fs from 'fs-extra';
 import { doctorCommand } from './commands/doctor.js';
 import { fixCommand } from './commands/fix.js';
+import { loopCleanupCommand } from './commands/loop-cleanup.js';
 import { loopEnvCommand } from './commands/loop-env.js';
 import { loopGuardCommand } from './commands/loop-guard.js';
 import { setupProject } from './commands/setup.js';
@@ -379,6 +380,15 @@ loop
     .addHelpText('after', "\nWithout --json, prints KEY='value' lines for eval. Empty means none.\n" +
     'Exits 1 when the checkout or its GitHub repo cannot be resolved.\n')
     .action(loopEnvCommand);
+loop
+    .command('cleanup')
+    .description('🧹 Remove ai-* worktrees whose PR landed on main or was closed')
+    .option('--root <path>', 'Main checkout the loop branches worktrees from', process.cwd())
+    .option('--worktree-root <path>', 'Where ai-* worktrees live (default: <root>-worktrees)')
+    .option('--json', 'Emit machine-readable JSON output')
+    .addHelpText('after', '\nPass `removed` from --json to `loop guard --removed`.\n' +
+    'Exits 1 when a worktree removal failed.\n')
+    .action(loopCleanupCommand);
 program.hook('preAction', async (_, actionCommand) => {
     const name = actionCommand.name();
     if (name === 'setup' || name === 'doctor' || name === 'fix') {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@rtorcato/repo-tooling",
-	"version": "3.40.0",
+	"version": "3.41.0",
 	"description": "One CLI to scaffold, audit and fix your repo's whole toolchain — linting, tests, commits, releases & CI.",
 	"type": "module",
 	"keywords": [