@osdlc/repo-cleaner 0.10.1 → 0.11.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @osdlc/repo-cleaner
 
+## 0.11.0
+
+### Minor Changes
+
+- 14d4351: A worktree row whose directory is gone, or is no longer a checkout, now reads `prune` instead of `delete` in the report, and `summary` counts those rows in a `prune` column (and a `prune` count in each JSON bucket, a part of `safe-to-delete`). The row's `action` is `prune`.
+  
+  New `--remote-url <url>` on every sweeping command: sweep a remote's branches with no checkout of your own. The URL is cloned once (`--no-checkout`) under the cache directory and reused; deletes are pushed from that clone, so a plan written with `--remote-url` can be applied later from anywhere.
+
+### Patch Changes
+
+- Updated dependencies [14d4351]
+- Updated dependencies [dd2265e]
+  - @osdlc/cli-tool@0.13.0
+
 ## 0.10.1
 
 ### Patch Changes

package/README.md

@@ -205,7 +205,7 @@ worktree, the primary or caller's worktree) has `deletable: false`.
 
 ```bash
 repo-cleaner [status]   # the report: what is merged, what can go (the default)
-repo-cleaner summary    # counts per repository: total, merged, delete, review, keep
+repo-cleaner summary    # counts per repository: total, merged, delete, prune, review, keep
 repo-cleaner plan       # the deletable rows as a plan, to stdout or -o <file>
 repo-cleaner apply      # re-check, show the steps, ask, delete
 ```
@@ -215,14 +215,21 @@ All four take the same paths and sweep options.
 ```console
 $ repo-cleaner summary
 /Users/me/work/api  (acme/api, default main, origin)
-                   total  merged  delete  review   keep
-  local branches      12       8       6       1      5
-  worktrees            4       3       2       1      1
-  remote branches     40      31      30       6      4
+                   total  merged  delete  prune  review   keep
+  local branches      12       8       6      0       1      5
+  worktrees            4       3       1      1       1      1
+  remote branches     40      31      30      0       6      4
 
-38 to delete, 8 to review, across 1 repository.
+37 to delete, 1 to prune, 8 to review, across 1 repository.
 ```
 
+`prune` counts worktree rows whose directory is gone, or is no longer a
+checkout: deleting one runs `git worktree prune` to drop the stale link, and
+a directory that is still there stays. The report labels those rows `prune`
+rather than `delete`. In `--output json` they are `safe-to-delete` with
+`action: "prune"`, and each summary bucket has a `prune` count, a part of its
+`safe-to-delete` count.
+
 `merged` counts rows whose work is on the default branch: by ancestry, by a
 merged PR at the branch's head, or by a patch match. A branch checked out in a
 worktree counts as merged by ancestry or PR alone. The default branch and the
@@ -258,6 +265,34 @@ An entry that resolves to nothing is reported rather than dropped. A worklist
 that silently sweeps four of the five repositories it was given is worse than
 one that says which it could not find.
 
+### A remote with no checkout
+
+```bash
+repo-cleaner --remote-url git@github.com:acme/api.git
+repo-cleaner apply --remote-url git@github.com:acme/api.git
+```
+
+`--remote-url <url>` sweeps a remote's branches when you have no checkout of
+it. It clones the URL once, with `--no-checkout`, into
+`repo-cleaner/remotes/` under the cache directory (`~/Library/Caches` on
+macOS, `$XDG_CACHE_HOME` or `~/.cache` on Linux, `REPO_CLEANER_CACHE_DIR`
+to move it), and sweeps that clone. Later runs reuse the clone and fetch. Only remote branches
+are swept: the clone's own branches and worktree are not yours. Deletes are
+pushed to the URL from the clone, compare-and-swap as always.
+
+The clone is kept, not deleted after the run, so a plan written with
+`--remote-url` can be applied later from anywhere: the plan names the clone's
+directory. Remove the directory to drop it. The clone is a full one, not
+`--filter=blob:none`: the patch check reads file contents, and a partial
+clone fetches them one branch at a time.
+
+The flag repeats for several remotes. It does not combine with paths,
+`--branch` or `--plan`, `--only` may only name `remotes`, and an empty URL is
+refused. A clone is reused only while its `origin` fetches from that URL and
+pushes to it alone; `apply --plan` checks the same of a plan's clone before
+deleting. The clone's directory name and every message carry the URL with
+its credentials, query and fragment removed.
+
 ## Options
 
 Every command that sweeps takes these:
@@ -267,6 +302,7 @@ Every command that sweeps takes these:
 | `--only <list>` | `worktrees`, `branches`, `remotes` (default: all three) |
 | `--branch <name\|HEAD>` | One branch of this repository: its worktree, local and remote branch. Refuses the default branch |
 | `--remote <name>` | Remote to measure against (default `origin`) |
+| `--remote-url <url>` | Sweep this remote's branches with no checkout of your own (see [A remote with no checkout](#a-remote-with-no-checkout)); repeatable |
 | `--no-gh` | Classify on git evidence alone |
 | `--no-fetch` | Skip the fetch; the header then says `not fetched` |
 

package/dist/cli.d.ts

@@ -4,7 +4,7 @@
  * Four verbs over one set of sweep filters:
  *
  *   status  (the default) inventory and classify; read-only but for the fetch
- *   summary the same sweep as counts: totals, merged, delete, review, keep
+ *   summary the same sweep as counts: totals, merged, delete, prune, review, keep
  *   plan    write the deletable rows as a plan, to stdout or a file
  *   apply   re-check, show the steps, ask, then delete
  *

package/dist/cli.js

@@ -4,7 +4,7 @@
  * Four verbs over one set of sweep filters:
  *
  *   status  (the default) inventory and classify; read-only but for the fetch
- *   summary the same sweep as counts: totals, merged, delete, review, keep
+ *   summary the same sweep as counts: totals, merged, delete, prune, review, keep
  *   plan    write the deletable rows as a plan, to stdout or a file
  *   apply   re-check, show the steps, ask, then delete
  *
@@ -21,12 +21,14 @@
  *   10  nothing to sweep: no entry named a repository
  *   11  apply stopped at a failed step; the receipt says which
  */
-import { readSync } from 'node:fs';
-import { basename, dirname, join, resolve } from 'node:path';
+import { existsSync, readSync, realpathSync } from 'node:fs';
+import { basename, dirname, join, resolve, sep } from 'node:path';
 import { isatty } from 'node:tty';
-import { EXIT, askYesNo, canPrompt, defineCli } from '@osdlc/cli-tool';
+import { EXIT, askYesNo, canPrompt, defineCli, systemDirs } from '@osdlc/cli-tool';
 import { Git } from '@osdlc/typed-git';
 import { resolveBranch } from "./branches.js";
+import { VENDOR_DIRS } from "./devlink.js";
+import { ensureMirror, mirrorProblem } from "./remote-mirror.js";
 import { ApplyArgumentError, applyPlan, parseGrant, parseRowRef } from "./apply.js";
 import { PLAN_VERSION, fileStamp, parsePlan, planRepo, readPlan, writePlan, } from "./plan.js";
 import { RECEIPT_VERSION } from "./receipt.js";
@@ -59,6 +61,13 @@ const SWEEP_FLAGS = {
         valueName: 'name',
         help: 'remote to measure against (default: origin)',
     },
+    remoteUrl: {
+        kind: 'list',
+        valueName: 'url',
+        default: [],
+        commaSeparated: false,
+        help: 'sweep the branches of this remote with no checkout of your own, through a clone kept in the cache directory; repeatable',
+    },
     gh: { kind: 'boolean', negatable: true, help: 'classify on git evidence alone' },
     fetch: {
         kind: 'boolean',
@@ -98,7 +107,7 @@ const statusCli = () => defineCli({
     },
     epilogue: `commands:
   ${NAME} [status]   this report (the default)
-  ${NAME} summary    counts per repository: total, merged, delete, review, keep
+  ${NAME} summary    counts per repository: total, merged, delete, prune, review, keep
   ${NAME} plan       write the deletable rows as a plan
   ${NAME} apply      re-check, show the steps, ask, delete
   ${NAME} dev        run ${NAME} from a development checkout
@@ -109,7 +118,7 @@ swept as ./<name>.`,
 const summaryCli = () => defineCli({
     name: `${NAME} summary`,
     summary: 'Count local branches, worktrees and remote branches per repository: how many there are, ' +
-        'how many are merged into the default branch, and how many would be deleted, reviewed or kept.',
+        'how many are merged into the default branch, and how many would be deleted, pruned, reviewed or kept.',
     positionals: PATHS,
     flags: { ...SWEEP_FLAGS, output: OUTPUT },
     epilogue: 'merged: the work is on the default branch. Rows kept for structure (the default ' +
@@ -209,6 +218,10 @@ function failure(ctx, err) {
     ctx.io.stderr(`${NAME}: ${err instanceof Error ? err.message : String(err)}\n`);
     return EXIT.error;
 }
+/** Where `--remote-url` keeps its clones. */
+function mirrorCache(ctx) {
+    return systemDirs(VENDOR_DIRS, { env: ctx.env }).standalone(NAME).cache().app('remotes').path;
+}
 /** Validate the sweep flags and run the sweep, or answer with the exit code. */
 function sweep(name, v, paths, ctx, status) {
     const only = v.only?.filter((s) => s !== '');
@@ -221,6 +234,26 @@ function sweep(name, v, paths, ctx, status) {
         const message = '--branch sweeps this repository only; drop the paths';
         return { kind: 'exit', code: usageError(ctx, name, message) };
     }
+    // An empty URL is refused, not dropped: `--remote-url "$UNSET"` must not
+    // fall back to sweeping the checkout you are standing in.
+    if (v.remoteUrl.some((u) => u.trim() === '')) {
+        return {
+            kind: 'exit',
+            code: usageError(ctx, name, '--remote-url needs a URL; got an empty one'),
+        };
+    }
+    const urls = v.remoteUrl;
+    if (urls.length > 0) {
+        const conflict = paths.length > 0
+            ? '--remote-url sweeps a remote, not a checkout; drop the paths'
+            : v.branch !== undefined
+                ? '--branch reads the checkout you are in; it does not combine with --remote-url'
+                : (only ?? []).some((s) => s !== 'remotes')
+                    ? '--remote-url has remote branches only; drop --only or pass --only remotes'
+                    : null;
+        if (conflict !== null)
+            return { kind: 'exit', code: usageError(ctx, name, conflict) };
+    }
     let branch;
     try {
         branch = v.branch === undefined ? undefined : resolveBranch(v.branch, new Git(ctx.cwd));
@@ -241,9 +274,25 @@ function sweep(name, v, paths, ctx, status) {
         ...(only === undefined ? {} : { scope: only.map((s) => ONLY[s]) }),
         ...(v.remote === undefined ? {} : { remote: v.remote }),
     };
+    let entries = paths.length > 0 ? [...paths] : [ctx.cwd];
+    if (urls.length > 0) {
+        const cache = mirrorCache(ctx);
+        try {
+            entries = urls.map((url, i) => {
+                if (v.progress)
+                    status.update(`${NAME}: cloning remote ${i + 1}/${urls.length}`);
+                return ensureMirror(url, cache);
+            });
+        }
+        catch (err) {
+            status.clear();
+            return { kind: 'exit', code: failure(ctx, err) };
+        }
+        options.scope = ['remote-branches'];
+    }
     if (v.progress)
         status.update(`${NAME}: finding repositories`);
-    const result = sweepRepos(paths.length > 0 ? paths : [ctx.cwd], options);
+    const result = sweepRepos(entries, options);
     status.clear();
     if (branch !== undefined && result.repos.length > 1) {
         const err = new Error(`--branch sweeps one repository; ${result.repos.length} found under ${ctx.cwd}`);
@@ -407,6 +456,7 @@ function applyConflict(v, paths) {
             v.only !== undefined ? '--only' : null,
             v.branch !== undefined ? '--branch' : null,
             v.remote !== undefined ? '--remote' : null,
+            v.remoteUrl.length > 0 ? '--remote-url' : null,
         ].filter((f) => f !== null);
         if (sweepFlags.length > 0)
             return `--plan fixes what is swept; drop ${sweepFlags.join(', ')}`;
@@ -444,6 +494,17 @@ function runApply(argv, ctx, deps, status) {
     if (typeof loaded === 'number')
         return loaded;
     const { plan, source, receiptPath } = loaded;
+    // A plan from `--remote-url` names a clone in the cache. Its deletes are
+    // pushed from there, so the clone must still push only where it fetches from.
+    const cacheDir = mirrorCache(ctx);
+    const cache = (existsSync(cacheDir) ? realpathSync(cacheDir) : cacheDir) + sep;
+    for (const repo of plan.repos) {
+        if (!repo.root.startsWith(cache))
+            continue;
+        const problem = mirrorProblem(repo.root);
+        if (problem !== null)
+            return failure(ctx, new Error(`${problem}; refusing to apply`));
+    }
     const ok = () => (loaded.unreadable ? EXIT.error : EXIT.ok);
     const repoRoot = v.repoRoot === undefined ? undefined : resolve(ctx.cwd, v.repoRoot);
     const print = (receipt, shownPath) => {

package/dist/remote-mirror.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Sweep a remote with no checkout of your own: a clone of it, kept in
+ * repo-cleaner's cache directory, stands in for the checkout.
+ *
+ * The clone is `--no-checkout`, so no files are written outside `.git`. It is
+ * not a partial (`--filter=blob:none`) clone: the patch comparison that
+ * finds squash-merged branches reads file contents, and a partial clone
+ * fetches them over the network one comparison at a time, which made a sweep
+ * of a few hundred branches take minutes instead of seconds. It is kept
+ * rather than thrown away so a plan written from it can be applied later: the
+ * plan names the clone's directory, and `apply` re-sweeps and pushes deletes
+ * from there. A later run reuses it, and the sweep's fetch brings it up to
+ * date.
+ */
+import type { CommandRunner } from '@osdlc/command-seam';
+/** A remote URL that cannot be mirrored, or a mirror that cannot be made or reused. */
+export declare class RemoteMirrorError extends Error {
+    constructor(message: string);
+}
+/**
+ * `text` with every URL's credentials removed: the user-info before `@` in a
+ * `scheme://` URL, and any query string or fragment. For a message or a name
+ * that must not carry a token.
+ */
+export declare function redactUrl(text: string): string;
+/**
+ * The directory name for `url`'s mirror: readable `host-owner-repo`, then a
+ * hash of the whole URL so two URLs never share a mirror. The readable part
+ * is read from the URL with its credentials, query and fragment removed, so a
+ * token never reaches the name.
+ */
+export declare function mirrorName(url: string): string;
+/**
+ * Why `dir` is not a mirror of `url` — or of whatever it was cloned from, when
+ * `url` is omitted — or null when it is. A mirror's `origin` has one fetch URL
+ * and pushes to that URL alone, so a delete cannot be sent elsewhere.
+ */
+export declare function mirrorProblem(dir: string, url?: string, opts?: {
+    git?: CommandRunner | undefined;
+}): string | null;
+/**
+ * The directory of `url`'s mirror under `cacheDir`, cloned on first use. An
+ * existing mirror is reused as it is, once {@link mirrorProblem} finds
+ * nothing wrong with it; the sweep's own fetch brings it up to date. A first
+ * clone goes to a sibling directory and is renamed into place, so a clone
+ * that fails leaves nothing behind, and a run that loses a race to clone the
+ * same URL uses the winner's clone. Messages carry the URL with its
+ * credentials removed.
+ *
+ * @throws RemoteMirrorError when `url` is empty or looks like an option, when
+ *   the clone fails, or when the directory is not a mirror of `url`.
+ */
+export declare function ensureMirror(url: string, cacheDir: string, opts?: {
+    git?: CommandRunner | undefined;
+}): string;

package/dist/remote-mirror.js

@@ -0,0 +1,123 @@
+/**
+ * Sweep a remote with no checkout of your own: a clone of it, kept in
+ * repo-cleaner's cache directory, stands in for the checkout.
+ *
+ * The clone is `--no-checkout`, so no files are written outside `.git`. It is
+ * not a partial (`--filter=blob:none`) clone: the patch comparison that
+ * finds squash-merged branches reads file contents, and a partial clone
+ * fetches them over the network one comparison at a time, which made a sweep
+ * of a few hundred branches take minutes instead of seconds. It is kept
+ * rather than thrown away so a plan written from it can be applied later: the
+ * plan names the clone's directory, and `apply` re-sweeps and pushes deletes
+ * from there. A later run reuses it, and the sweep's fetch brings it up to
+ * date.
+ */
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, renameSync, rmSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { Git, parseRemoteRepo } from '@osdlc/typed-git';
+/** A remote URL that cannot be mirrored, or a mirror that cannot be made or reused. */
+export class RemoteMirrorError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'RemoteMirrorError';
+    }
+}
+/** Characters kept in a directory name; anything else becomes `-`. */
+const UNSAFE = /[^A-Za-z0-9._-]+/g;
+/**
+ * `text` with every URL's credentials removed: the user-info before `@` in a
+ * `scheme://` URL, and any query string or fragment. For a message or a name
+ * that must not carry a token.
+ */
+export function redactUrl(text) {
+    return text
+        .replace(/([a-z][a-z0-9+.-]*:\/\/)[^/@\s]*@/gi, '$1')
+        .replace(/([a-z][a-z0-9+.-]*:\/\/[^\s?#]*)[?#]\S*/gi, '$1');
+}
+/**
+ * The directory name for `url`'s mirror: readable `host-owner-repo`, then a
+ * hash of the whole URL so two URLs never share a mirror. The readable part
+ * is read from the URL with its credentials, query and fragment removed, so a
+ * token never reaches the name.
+ */
+export function mirrorName(url) {
+    const hash = createHash('sha256').update(url).digest('hex').slice(0, 12);
+    const parsed = parseRemoteRepo(redactUrl(url));
+    const readable = parsed === null
+        ? 'remote'
+        : `${parsed.host}-${parsed.owner}-${parsed.repo}`.replace(UNSAFE, '-');
+    return `${readable.replace(/^[.-]+/, '')}-${hash}`;
+}
+/**
+ * Why `dir` is not a mirror of `url` — or of whatever it was cloned from, when
+ * `url` is omitted — or null when it is. A mirror's `origin` has one fetch URL
+ * and pushes to that URL alone, so a delete cannot be sent elsewhere.
+ */
+export function mirrorProblem(dir, url, opts = {}) {
+    const git = new Git(dir, { runner: opts.git });
+    const fetch = git.try.remoteGetUrls('origin');
+    const push = git.try.remoteGetUrls('origin', { push: true });
+    if (!fetch.ok || !push.ok)
+        return `${dir} has no readable origin remote`;
+    const [from] = fetch.value;
+    if (fetch.value.length !== 1 || from === undefined) {
+        return `${dir} has ${fetch.value.length} origin URLs`;
+    }
+    if (url !== undefined && from !== url)
+        return `${dir} is a mirror of another URL`;
+    if (push.value.length !== 1 || push.value[0] !== from) {
+        return `${dir} pushes somewhere other than the URL it was cloned from`;
+    }
+    return null;
+}
+/**
+ * The directory of `url`'s mirror under `cacheDir`, cloned on first use. An
+ * existing mirror is reused as it is, once {@link mirrorProblem} finds
+ * nothing wrong with it; the sweep's own fetch brings it up to date. A first
+ * clone goes to a sibling directory and is renamed into place, so a clone
+ * that fails leaves nothing behind, and a run that loses a race to clone the
+ * same URL uses the winner's clone. Messages carry the URL with its
+ * credentials removed.
+ *
+ * @throws RemoteMirrorError when `url` is empty or looks like an option, when
+ *   the clone fails, or when the directory is not a mirror of `url`.
+ */
+export function ensureMirror(url, cacheDir, opts = {}) {
+    if (url === '' || url.startsWith('-')) {
+        throw new RemoteMirrorError(`not a remote URL: ${JSON.stringify(redactUrl(url))}`);
+    }
+    const shown = redactUrl(url);
+    const dir = join(cacheDir, mirrorName(url));
+    if (existsSync(dir)) {
+        const problem = mirrorProblem(dir, url, opts);
+        if (problem !== null) {
+            throw new RemoteMirrorError(`${problem}, not a mirror of ${shown}; remove the directory and run again`);
+        }
+        return dir;
+    }
+    mkdirSync(dirname(dir), { recursive: true });
+    const staging = `${dir}.partial-${process.pid}`;
+    rmSync(staging, { recursive: true, force: true });
+    try {
+        new Git(dirname(dir), { runner: opts.git }).rawChecked([
+            'clone',
+            '--quiet',
+            '--no-checkout',
+            '--',
+            url,
+            staging,
+        ]);
+        renameSync(staging, dir);
+    }
+    catch (err) {
+        rmSync(staging, { recursive: true, force: true });
+        // Another run cloned the same URL first and won the rename: use its clone.
+        if (existsSync(dir) && mirrorProblem(dir, url, opts) === null)
+            return dir;
+        const detail = err.failure?.detail ??
+            (err instanceof Error ? err.message : String(err));
+        throw new RemoteMirrorError(`cannot clone ${shown}: ${redactUrl(detail.split(url).join(shown)).trim()}`);
+    }
+    return dir;
+}

package/dist/render.d.ts

@@ -30,7 +30,7 @@ export declare function renderScan(result: SweepResult): string | null;
 export declare function renderSummary(result: SweepResult): string;
 /**
  * One repository as counts: a row per category with its total, how many are
- * merged, and how many the sweep would delete, review or keep.
+ * merged, and how many the sweep would delete, prune, review or keep.
  */
 export declare function renderCounts(sweep: RepoSweep): string;
 /** The whole run as counts: a table per repository, then the one-line summary. */

package/dist/render.js

@@ -6,7 +6,7 @@
  * find. JSON carries everything the text report elides, including the facts
  * behind every verdict.
  */
-import { emptyBucket, isUnfetched, summarize, } from "./types.js";
+import { emptyBucket, isPrune, isUnfetched, summarize, } from "./types.js";
 import { hasBlockers } from "./worktrees.js";
 /** Order categories consistently, whatever order they were gathered in. */
 const CATEGORY_ORDER = ['local_branch', 'worktree', 'remote_branch'];
@@ -69,7 +69,9 @@ export function renderRepo(sweep, opts = {}) {
     const idWidth = Math.min(38, Math.max(...shown.map((item) => ellipsize(item.id, 38).length)));
     const categoryWidth = Math.max(...shown.map((item) => item.category.length));
     for (const item of shown) {
-        const action = ACTION_LABEL[item.classification] ?? item.classification;
+        const action = isPrune(item)
+            ? 'prune'
+            : (ACTION_LABEL[item.classification] ?? item.classification);
         const note = requiresNote(item);
         lines.push(`  ${pad(item.category, categoryWidth)}  ${pad(ellipsize(item.id, 38), idWidth)}  ${pad(action, 6)}  ${item.reason}${note ? `; ${note}` : ''}`);
         // A blocked row has no commands; what to do about each blocker goes there instead.
@@ -86,6 +88,7 @@ function totals(result) {
             out.total += bucket.total;
             out.merged += bucket.merged;
             out['safe-to-delete'] += bucket['safe-to-delete'];
+            out.prune += bucket.prune;
             out['safe-to-keep'] += bucket['safe-to-keep'];
             out['needs-investigation'] += bucket['needs-investigation'];
         }
@@ -116,6 +119,10 @@ export function renderScan(result) {
         return line;
     return `${line} ${count(scan.depthLimited)} left unopened at the depth limit.`;
 }
+/** The `safe-to-delete` rows that delete something, not the ones that only prune a stale link. */
+function deleteOnly(bucket) {
+    return bucket['safe-to-delete'] - bucket.prune;
+}
 /** The one-line verdict a person reads first, and often only. */
 export function renderSummary(result) {
     const counts = totals(result);
@@ -128,24 +135,26 @@ export function renderSummary(result) {
         tail.push(`${result.unresolved.length} ${result.unresolved.length === 1 ? 'entry' : 'entries'} unresolved`);
     }
     const suffix = tail.length > 0 ? ` (${tail.join(', ')})` : '';
-    return `${counts['safe-to-delete']} to delete, ${counts['needs-investigation']} to review, across ${repos}${suffix}.`;
+    const prune = counts.prune > 0 ? `${counts.prune} to prune, ` : '';
+    return `${deleteOnly(counts)} to delete, ${prune}${counts['needs-investigation']} to review, across ${repos}${suffix}.`;
 }
 const COUNT_LABEL = {
     local_branch: 'local branches',
     worktree: 'worktrees',
     remote_branch: 'remote branches',
 };
+/** A count table's columns. `delete` leaves out the rows `prune` counts, so each row is in one of delete, prune, review and keep. */
 const COUNT_COLUMNS = [
-    'total',
-    'merged',
-    'safe-to-delete',
-    'needs-investigation',
-    'safe-to-keep',
+    { heading: 'total', of: (b) => b.total },
+    { heading: 'merged', of: (b) => b.merged },
+    { heading: 'delete', of: deleteOnly },
+    { heading: 'prune', of: (b) => b.prune },
+    { heading: 'review', of: (b) => b['needs-investigation'] },
+    { heading: 'keep', of: (b) => b['safe-to-keep'] },
 ];
-const COUNT_HEADINGS = ['total', 'merged', 'delete', 'review', 'keep'];
 /**
  * One repository as counts: a row per category with its total, how many are
- * merged, and how many the sweep would delete, review or keep.
+ * merged, and how many the sweep would delete, prune, review or keep.
  */
 export function renderCounts(sweep) {
     const lines = [repoHeader(sweep)];
@@ -156,10 +165,10 @@ export function renderCounts(sweep) {
     const buckets = summarize(sweep.items);
     const labelWidth = Math.max(...Object.values(COUNT_LABEL).map((l) => l.length));
     const cell = (text, heading) => text.padStart(Math.max(heading.length, 5));
-    lines.push(`  ${' '.repeat(labelWidth)}  ${COUNT_HEADINGS.map((h) => cell(h, h)).join('  ')}`);
+    lines.push(`  ${' '.repeat(labelWidth)}  ${COUNT_COLUMNS.map(({ heading }) => cell(heading, heading)).join('  ')}`);
     for (const category of CATEGORY_ORDER) {
         const bucket = buckets[category] ?? emptyBucket();
-        const cells = COUNT_COLUMNS.map((col, i) => cell(count(bucket[col]), COUNT_HEADINGS[i]));
+        const cells = COUNT_COLUMNS.map(({ heading, of }) => cell(count(of(bucket)), heading));
         lines.push(`  ${pad(COUNT_LABEL[category], labelWidth)}  ${cells.join('  ')}`);
     }
     return lines.join('\n');

package/dist/types.d.ts

@@ -155,12 +155,16 @@ export interface SummaryBucket {
     /** Rows whose work is on the default branch (`facts.merged`). Rows kept for structure are not judged. */
     merged: number;
     'safe-to-delete': number;
+    /** The `safe-to-delete` rows that only prune a stale worktree link (`action: 'prune'`); the directory, if any, stays. */
+    prune: number;
     'safe-to-keep': number;
     'needs-investigation': number;
 }
 export declare function emptyBucket(): SummaryBucket;
 /** Per-category counts over `items`. */
 export declare function summarize(items: readonly SweepItem[]): Record<string, SummaryBucket>;
+/** A row whose deletion only prunes a stale worktree link. */
+export declare function isPrune(item: Pick<SweepItem, 'classification' | 'action'>): boolean;
 type Defaulted = 'facts' | 'commands' | 'investigationParts' | 'requires' | 'deletable';
 /** Build an item, defaulting the collection fields and `deletable: true`. */
 export declare function makeItem(partial: Omit<SweepItem, Defaulted> & Partial<Pick<SweepItem, Defaulted>>): SweepItem;

package/dist/types.js

@@ -48,7 +48,14 @@ export function emptyScan() {
     return { containers: 0, directoriesScanned: 0, depthLimited: 0, checkoutsFound: 0 };
 }
 export function emptyBucket() {
-    return { total: 0, merged: 0, 'safe-to-delete': 0, 'safe-to-keep': 0, 'needs-investigation': 0 };
+    return {
+        total: 0,
+        merged: 0,
+        'safe-to-delete': 0,
+        prune: 0,
+        'safe-to-keep': 0,
+        'needs-investigation': 0,
+    };
 }
 /** Per-category counts over `items`. */
 export function summarize(items) {
@@ -58,10 +65,16 @@ export function summarize(items) {
         bucket.total += 1;
         if (item.facts['merged'] === true)
             bucket.merged += 1;
+        if (isPrune(item))
+            bucket.prune += 1;
         bucket[item.classification] += 1;
     }
     return out;
 }
+/** A row whose deletion only prunes a stale worktree link. */
+export function isPrune(item) {
+    return item.classification === 'safe-to-delete' && item.action === 'prune';
+}
 /** Build an item, defaulting the collection fields and `deletable: true`. */
 export function makeItem(partial) {
     return {

package/dist/version.generated.d.ts

@@ -1,2 +1,2 @@
 /** This package's version, from its package.json when it was built. */
-export declare const VERSION = "0.10.1";
+export declare const VERSION = "0.11.0";

package/dist/version.generated.js

@@ -1,3 +1,3 @@
 // Generated by cli-tool-stamp-version from package.json. Do not edit.
 /** This package's version, from its package.json when it was built. */
-export const VERSION = '0.10.1';
+export const VERSION = '0.11.0';

package/dist/worktrees.js

@@ -293,7 +293,7 @@ export function classifyWorktree(opts) {
             category: 'worktree',
             id: path,
             classification: 'safe-to-delete',
-            action: 'remove',
+            action: 'prune',
             reason: dirPresent
                 ? 'directory is no longer a checkout (no .git); prune the stale link, the directory stays'
                 : 'worktree directory no longer on disk; prune the stale link',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@osdlc/repo-cleaner",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "description": "What has been merged into the default branch, and what can go away. Inventories local branches, worktrees and remote branches across one repository or many, classifying each with the evidence behind the verdict and the command that would act on it. Plans and applies approved deletes, compare-and-swap.",
   "license": "MIT OR Apache-2.0",
   "author": "sksizer",
@@ -49,11 +49,11 @@
   },
   "dependencies": {
     "zod": "4.4.3",
-    "@osdlc/cli-tool": "^0.12.0",
-    "@osdlc/path-guard": "^0.3.1",
+    "@osdlc/cli-tool": "^0.13.0",
     "@osdlc/command-seam": "^0.14.0",
-    "@osdlc/typed-git": "^0.12.0",
+    "@osdlc/path-guard": "^0.3.1",
     "@osdlc/typed-gh": "^0.14.1",
+    "@osdlc/typed-git": "^0.12.0",
     "@osdlc/ux": "^0.1.1"
   },
   "devDependencies": {
@@ -63,8 +63,8 @@
     "prettier": "3.9.6",
     "typescript": "~6.0.3",
     "vitest": "^5.0.5",
-    "@osdlc/tsconfig": "^0.4.1",
-    "@osdlc/prettier-config": "^0.3.1"
+    "@osdlc/prettier-config": "^0.3.1",
+    "@osdlc/tsconfig": "^0.4.1"
   },
   "scripts": {
     "build": "cli-tool-stamp-version && tsc -p tsconfig.build.json",