@osdlc/repo-cleaner 0.11.0 → 0.14.0

package/dist/render.js

@@ -6,6 +6,7 @@
  * find. JSON carries everything the text report elides, including the facts
  * behind every verdict.
  */
+import { ansiColors, paint, stripControls } from '@osdlc/ux';
 import { emptyBucket, isPrune, isUnfetched, summarize, } from "./types.js";
 import { hasBlockers } from "./worktrees.js";
 /** Order categories consistently, whatever order they were gathered in. */
@@ -17,6 +18,27 @@ const ACTION_LABEL = {
     'needs-investigation': 'review',
     'safe-to-keep': 'keep',
 };
+const same = (text) => text;
+/** No color. */
+export const PLAIN = {
+    delete: same,
+    prune: same,
+    review: same,
+    keep: same,
+    muted: same,
+    strong: same,
+};
+// The 16 basic colors, so the terminal's own theme decides the shades.
+const ANSI = ansiColors('ansi16', 'dark');
+/** The basic terminal colors: red to delete, blue to prune, yellow to review, green to keep. */
+export const TERMINAL_STYLE = {
+    delete: (t) => paint(t, ANSI['status-error']),
+    prune: (t) => paint(t, ANSI.accent),
+    review: (t) => paint(t, ANSI['status-warning']),
+    keep: (t) => paint(t, ANSI['status-success']),
+    muted: (t) => paint(t, ANSI['text-muted']),
+    strong: (t) => `\x1b[1m${t}\x1b[22m`,
+};
 function pad(s, width) {
     return s.length >= width ? s : s + ' '.repeat(width - s.length);
 }
@@ -54,11 +76,22 @@ function repoHeader(sweep) {
     ];
     return `${name}  (${bits.filter((b) => b !== null).join(', ')})`;
 }
+/** The color of a row's action word. */
+function actionStyle(style, action) {
+    if (action === 'delete')
+        return style.delete;
+    if (action === 'prune')
+        return style.prune;
+    if (action === 'review')
+        return style.review;
+    return style.keep;
+}
 /** One repository's rows, indented under its header. */
 export function renderRepo(sweep, opts = {}) {
-    const lines = [repoHeader(sweep)];
+    const style = opts.style ?? PLAIN;
+    const lines = [style.strong(repoHeader(sweep))];
     if (sweep.error !== null) {
-        lines.push(`  error: ${sweep.error}`);
+        lines.push(`  ${style.delete('error')}: ${sweep.error}`);
         return lines.join('\n');
     }
     const shown = sortItems(sweep.items).filter((item) => opts.keep === true || item.classification !== 'safe-to-keep');
@@ -73,11 +106,11 @@ export function renderRepo(sweep, opts = {}) {
             ? '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}` : ''}`);
+        lines.push(`  ${pad(item.category, categoryWidth)}  ${pad(ellipsize(item.id, 38), idWidth)}  ${actionStyle(style, action)(pad(action, 6))}  ${item.reason}${note ? `; ${note}` : ''}`);
         // A blocked row has no commands; what to do about each blocker goes there instead.
         const detail = hasBlockers(item) ? item.investigationParts : item.commands;
         for (const line of detail)
-            lines.push(`  ${' '.repeat(categoryWidth)}  ${line}`);
+            lines.push(`  ${' '.repeat(categoryWidth)}  ${style.muted(line)}`);
     }
     return lines.join('\n');
 }
@@ -124,7 +157,7 @@ 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) {
+export function renderSummary(result, style = PLAIN) {
     const counts = totals(result);
     const repos = `${result.repos.length} ${result.repos.length === 1 ? 'repository' : 'repositories'}`;
     const errors = result.repos.filter((sweep) => sweep.error !== null).length;
@@ -135,8 +168,10 @@ export function renderSummary(result) {
         tail.push(`${result.unresolved.length} ${result.unresolved.length === 1 ? 'entry' : 'entries'} unresolved`);
     }
     const suffix = tail.length > 0 ? ` (${tail.join(', ')})` : '';
-    const prune = counts.prune > 0 ? `${counts.prune} to prune, ` : '';
-    return `${deleteOnly(counts)} to delete, ${prune}${counts['needs-investigation']} to review, across ${repos}${suffix}.`;
+    const prune = counts.prune > 0 ? `${style.prune(`${counts.prune} to prune`)}, ` : '';
+    const del = style.delete(`${deleteOnly(counts)} to delete`);
+    const review = style.review(`${counts['needs-investigation']} to review`);
+    return `${del}, ${prune}${review}, across ${repos}${suffix}.`;
 }
 const COUNT_LABEL = {
     local_branch: 'local branches',
@@ -174,7 +209,7 @@ export function renderCounts(sweep) {
     return lines.join('\n');
 }
 /** The whole run as counts: a table per repository, then the one-line summary. */
-export function renderCountsText(result) {
+export function renderCountsText(result, style = PLAIN) {
     const blocks = result.repos.map(renderCounts);
     if (result.unresolved.length > 0) {
         const lines = ['unresolved'];
@@ -184,7 +219,8 @@ export function renderCountsText(result) {
         blocks.push(lines.join('\n'));
     }
     const scan = renderScan(result);
-    blocks.push(scan === null ? renderSummary(result) : `${scan}\n${renderSummary(result)}`);
+    const summary = renderSummary(result, style);
+    blocks.push(scan === null ? summary : `${scan}\n${summary}`);
     return blocks.join('\n\n') + '\n';
 }
 /** The whole run's counts as JSON: no rows, no facts. */
@@ -228,7 +264,8 @@ export function renderText(result, opts = {}) {
         blocks.push(lines.join('\n'));
     }
     const scan = renderScan(result);
-    blocks.push(scan === null ? renderSummary(result) : `${scan}\n${renderSummary(result)}`);
+    const summary = renderSummary(result, opts.style);
+    blocks.push(scan === null ? summary : `${scan}\n${summary}`);
     return blocks.join('\n\n') + '\n';
 }
 /**
@@ -290,7 +327,9 @@ export function summarizeReceipt(receipt) {
         if (s.row === null)
             continue;
         if (s.result === 'pending') {
-            if (s.action !== 'unlock-worktree')
+            // Rows not reached are rows a run would have deleted; an unlock or a
+            // tip check deletes nothing.
+            if (s.action !== 'unlock-worktree' && s.action !== 'verify-remote')
                 out.notRun += 1;
             continue;
         }
@@ -340,22 +379,96 @@ export function renderApplySummary(receipt) {
     }
     return lines;
 }
+/** The word a preview shows for a step: what it does to the row. */
+export const STEP_VERB = {
+    'verify-remote': 'verify',
+    'unlock-worktree': 'unlock',
+    'remove-worktree': 'delete',
+    'delete-local': 'delete',
+    'delete-remote': 'delete',
+    'prune-worktrees': 'prune',
+};
+/** A step's result word, colored by what it says about the run. */
+function resultWord(step, style) {
+    const word = step.result.padEnd(8);
+    if (step.result === 'failed')
+        return style.delete(word);
+    if (step.result === 'ok')
+        return style.keep(word);
+    if (step.result === 'pending')
+        return style.muted(word);
+    return step.action === 'prune-worktrees' ? style.prune(word) : style.delete(word);
+}
+/**
+ * What `apply` is about to do, for the person asked to approve it: per
+ * repository, each row and the command that deletes it, the rows it will
+ * skip and why, then the counts. Terminal controls are stripped from what it
+ * shows, so a path or name cannot hide part of what is approved.
+ */
+export function renderPreview(receipt, style = PLAIN) {
+    const repos = [
+        ...new Set([...receipt.steps.map((s) => s.repo), ...receipt.dropped.map((d) => d.repo)]),
+    ];
+    const rows = [
+        ...receipt.steps.flatMap((s) => (s.row === null ? [] : [s.row])),
+        ...receipt.dropped,
+    ];
+    const categoryWidth = Math.max(0, ...rows.map((r) => r.category.length));
+    const row = (r) => r === null ? '' : `${pad(r.category, categoryWidth)}  ${ellipsize(stripControls(r.id), 60)}`;
+    const blocks = [];
+    for (const repo of repos) {
+        const lines = [style.strong(stripControls(repo))];
+        for (const s of receipt.steps.filter((s) => s.repo === repo)) {
+            const verb = STEP_VERB[s.action];
+            const color = actionStyle(style, verb === 'unlock' ? 'review' : verb);
+            lines.push(s.row === null ? `  ${color(verb)}` : `  ${color(pad(verb, 6))}  ${row(s.row)}`);
+            lines.push(`          ${style.muted(stripControls(s.command))}`);
+        }
+        for (const d of receipt.dropped.filter((d) => d.repo === repo)) {
+            lines.push(`  ${style.review(pad('skip', 6))}  ${row(d)}`);
+            lines.push(`          ${d.reason}: ${stripControls(d.detail)}`);
+        }
+        blocks.push(lines.join('\n'));
+    }
+    const [counts = '', ...rest] = renderApplySummary(receipt);
+    blocks.push([style.strong(counts), ...rest.map(style.review)].join('\n'));
+    return blocks.join('\n\n') + '\n';
+}
+/** Rows dropped by a live run's own re-check, after the preview: each with why. */
+export function renderPreviewDrops(dropped, style = PLAIN) {
+    return dropped
+        .map((d) => `  ${style.review('skip')}  ${stripControls(`${d.category}  ${ellipsize(d.id, 60)}`)}\n      ${style.review(stripControls(`${d.reason}: ${d.detail}`))}\n`)
+        .join('');
+}
+/**
+ * A failed step for a run shown live: `✗`, the row, and the error in full,
+ * which the step's row on the board is too narrow to hold.
+ */
+export function renderStepFailure(step, style = PLAIN) {
+    const verb = STEP_VERB[step.action];
+    const row = step.row === null ? '' : `${step.row.category}  ${ellipsize(step.row.id, 60)}`;
+    const line = stripControls(`${pad(verb, 6)}  ${row}`.trimEnd());
+    return `  ${style.delete('✗')} ${line}\n      ${style.delete(stripControls(step.error ?? 'failed'))}`;
+}
 /** An apply run as text: dropped rows, each step, a summary, then where the receipt is. */
-export function renderReceipt(receipt, receiptPath) {
+export function renderReceipt(receipt, receiptPath, style = PLAIN, opts = {}) {
     const lines = [];
-    for (const d of receipt.dropped) {
-        lines.push(`dropped  ${d.category}:${d.id} — ${d.reason} (${d.detail})`);
+    // A run shown live has printed its dropped rows and steps already.
+    for (const d of opts.steps === false ? [] : receipt.dropped) {
+        const shown = stripControls(`${d.category}:${d.id} — ${d.reason} (${d.detail})`);
+        lines.push(`${style.review('dropped  ')}${shown}`);
     }
-    for (const s of receipt.steps) {
+    for (const s of opts.steps === false ? [] : receipt.steps) {
         const what = s.row === null ? s.command : `${s.row.category}:${s.row.id} — ${s.command}`;
         const tail = s.error ?? s.verification;
-        lines.push(`${s.result.padEnd(8)} ${what}${tail ? ` (${tail})` : ''}`);
+        lines.push(`${resultWord(s, style)} ${stripControls(`${what}${tail ? ` (${tail})` : ''}`)}`);
     }
     if (lines.length > 0)
         lines.push('');
-    lines.push(...renderApplySummary(receipt));
-    lines.push(receiptPath === null
+    const [counts = '', ...rest] = renderApplySummary(receipt);
+    lines.push(style.strong(counts), ...rest.map(style.review));
+    lines.push(style.muted(receiptPath === null
         ? `status: ${receipt.status}`
-        : `receipt: ${receiptPath} (${receipt.status})`);
+        : `receipt: ${stripControls(receiptPath)} (${receipt.status})`));
     return lines.join('\n') + '\n';
 }

package/dist/status-line.d.ts

@@ -5,12 +5,14 @@
  */
 import type { Step } from './receipt.ts';
 import type { SweepProgress } from './types.ts';
+/** A bar `width` cells wide, filled for `done` of `total`, e.g. `█████░░░░░`. */
+export declare function progressBar(done: number, total: number, width?: number): string;
 /**
- * A sweep step as one line, e.g. `[2/5] checking remote branches 37/427 · ~/work/api`.
+ * A sweep step as one line, e.g. `[2/5] checking remote branches ████░░░░ 37/427 · ~/work/api`.
  * The path goes last, so a line cut to the terminal's width loses its tail first.
  */
 export declare function describeSweep(p: SweepProgress, home?: string): string;
-/** An apply step as one line, e.g. `deleting 3/7: delete-remote origin/feat/x`. */
+/** An apply step as one line, e.g. `deleting ██████░░░░ 3/7: delete-remote origin/feat/x`. */
 export declare function describeStep(index: number, total: number, step: Step): string;
 export interface StatusLine {
     /** Replace the line with `text`. */

package/dist/status-line.js

@@ -17,19 +17,29 @@ const STEP_TEXT = {
 function tilde(path, home) {
     return path === home ? '~' : path.startsWith(`${home}/`) ? `~${path.slice(home.length)}` : path;
 }
+/** A bar `width` cells wide, filled for `done` of `total`, e.g. `█████░░░░░`. */
+export function progressBar(done, total, width = 20) {
+    const filled = total <= 0 ? width : Math.min(width, Math.round((done / total) * width));
+    return '█'.repeat(filled) + '░'.repeat(width - filled);
+}
 /**
- * A sweep step as one line, e.g. `[2/5] checking remote branches 37/427 · ~/work/api`.
+ * A sweep step as one line, e.g. `[2/5] checking remote branches ████░░░░ 37/427 · ~/work/api`.
  * The path goes last, so a line cut to the terminal's width loses its tail first.
  */
 export function describeSweep(p, home = homedir()) {
     const where = p.of > 1 ? `[${p.index}/${p.of}] ` : '';
-    const count = p.done === undefined ? '' : ` ${p.done + 1}/${p.total}`;
-    return `${where}${STEP_TEXT[p.step]}${count} · ${tilde(p.repo, home)}`;
+    const count = p.done === undefined || p.total === undefined
+        ? ''
+        : ` ${progressBar(p.done, p.total)} ${p.done + 1}/${p.total}`;
+    const text = p.step === 'prs' && p.tool !== undefined
+        ? `listing pull requests (${p.tool})`
+        : STEP_TEXT[p.step];
+    return `${where}${text}${count} · ${tilde(p.repo, home)}`;
 }
-/** An apply step as one line, e.g. `deleting 3/7: delete-remote origin/feat/x`. */
+/** An apply step as one line, e.g. `deleting ██████░░░░ 3/7: delete-remote origin/feat/x`. */
 export function describeStep(index, total, step) {
     const what = step.row === null ? step.repo : step.row.id;
-    return `deleting ${index + 1}/${total}: ${step.action} ${what}`;
+    return `deleting ${progressBar(index, total)} ${index + 1}/${total}: ${step.action} ${what}`;
 }
 /** A line drawn with `\r` and erase-line, controls stripped, cut to `columns() - 1` display columns so it never wraps. */
 export function statusLine(write, columns) {

package/dist/step-board.d.ts

@@ -0,0 +1,34 @@
+/**
+ * `apply`'s steps as a vertical list redrawn in place on a terminal: one row
+ * per step with its own bar, empty while it waits, half full while it runs,
+ * full and ticked when it is done, and a bar for the whole run under the
+ * list. The run is synchronous, so the board moves between steps, not on a
+ * timer.
+ */
+import type { Step } from './receipt.ts';
+import { type Style } from './render.ts';
+/**
+ * The board's lines, each at most `width` columns, and at most `height - 1`
+ * of them: the cursor sits on the row under the last line, which must stay
+ * on screen. That is the run's bar under the rows that fit; a list longer
+ * than that shows a window that keeps the running step in view, with a line
+ * for the rows above and below it when there is room for one.
+ */
+export declare function boardLines(steps: readonly Step[], running: number | null, size: {
+    width: number;
+    height: number;
+}, style?: Style): string[];
+export interface StepBoard {
+    /** Draw with `running` as the step under way, or null between steps. */
+    draw(running: number | null): void;
+}
+/**
+ * A board on `write`. The first draw prints its lines; each later one moves
+ * the cursor back to the board's first line and rewrites them, erasing any
+ * line an earlier, taller frame left below. Lines are cut to one column
+ * short of the width, so none wraps and the line count stays right.
+ */
+export declare function stepBoard(write: (text: string) => void, steps: readonly Step[], size: () => {
+    width: number;
+    height: number;
+}, style?: Style): StepBoard;

package/dist/step-board.js

@@ -0,0 +1,101 @@
+/**
+ * `apply`'s steps as a vertical list redrawn in place on a terminal: one row
+ * per step with its own bar, empty while it waits, half full while it runs,
+ * full and ticked when it is done, and a bar for the whole run under the
+ * list. The run is synchronous, so the board moves between steps, not on a
+ * timer.
+ */
+import { fitWidth, stripControls } from '@osdlc/ux';
+import { PLAIN, STEP_VERB } from "./render.js";
+import { progressBar } from "./status-line.js";
+/** A step bar's cells, and the run bar's at most. */
+const BAR = 10;
+const TOTAL_BAR = 30;
+function label(step) {
+    const verb = STEP_VERB[step.action];
+    if (step.row === null)
+        return verb;
+    return stripControls(`${verb.padEnd(6)}  ${step.row.category}  ${step.row.id}`);
+}
+/**
+ * One step's row, cut to `width` columns before it is colored, so the color
+ * codes never count against the width and the row never wraps.
+ */
+function stepRow(step, running, width, style) {
+    const [bar, mark, color, text] = step.result === 'ok'
+        ? ['█'.repeat(BAR), '✓', style.keep, (t) => t]
+        : step.result === 'failed'
+            ? ['█'.repeat(BAR), '✗', style.delete, (t) => t]
+            : running
+                ? ['█'.repeat(BAR / 2) + '░'.repeat(BAR / 2), '›', style.review, style.strong]
+                : ['░'.repeat(BAR), ' ', style.muted, style.muted];
+    const head = `  ${bar} ${mark} `;
+    if (width <= head.length)
+        return color(fitWidth(head, width));
+    return `  ${color(bar)} ${color(mark)} ${text(fitWidth(label(step), width - head.length))}`;
+}
+/** The run's bar and count, shrunk to fit `width` columns. */
+function totalRow(done, total, failed, width, style) {
+    const count = ` ${done}/${total}`;
+    const cells = Math.min(TOTAL_BAR, width - 2 - count.length);
+    const line = cells > 0
+        ? `  ${progressBar(done, total, cells)}${count}`
+        : fitWidth(`  ${count.trim()}`, width);
+    return failed ? style.delete(line) : style.strong(line);
+}
+/**
+ * The board's lines, each at most `width` columns, and at most `height - 1`
+ * of them: the cursor sits on the row under the last line, which must stay
+ * on screen. That is the run's bar under the rows that fit; a list longer
+ * than that shows a window that keeps the running step in view, with a line
+ * for the rows above and below it when there is room for one.
+ */
+export function boardLines(steps, running, size, style = PLAIN) {
+    const width = Math.max(1, size.width);
+    const room = Math.max(1, size.height - 2);
+    let first = 0;
+    let last = steps.length;
+    const windowed = steps.length > room;
+    // The above and below notes need a row each, and a row for a step besides.
+    const notes = windowed && room >= 3;
+    if (windowed) {
+        const at = running ?? steps.findIndex((s) => s.result === 'pending');
+        const focus = at < 0 ? steps.length - 1 : at;
+        const shown = notes ? room - 2 : room;
+        first = Math.min(Math.max(0, focus - Math.floor(shown / 3)), steps.length - shown);
+        last = first + shown;
+    }
+    const note = (text) => style.muted(fitWidth(text, width));
+    const lines = [];
+    if (notes)
+        lines.push(note(`  … ${first} above`));
+    for (let i = first; i < last; i++)
+        lines.push(stepRow(steps[i], i === running, width, style));
+    if (notes)
+        lines.push(note(`  … ${steps.length - last} below`));
+    const done = steps.filter((s) => s.result === 'ok' || s.result === 'failed').length;
+    const failed = steps.some((s) => s.result === 'failed');
+    lines.push(totalRow(done, steps.length, failed, width, style));
+    return lines;
+}
+/**
+ * A board on `write`. The first draw prints its lines; each later one moves
+ * the cursor back to the board's first line and rewrites them, erasing any
+ * line an earlier, taller frame left below. Lines are cut to one column
+ * short of the width, so none wraps and the line count stays right.
+ */
+export function stepBoard(write, steps, size, style = PLAIN) {
+    let drawn = 0;
+    return {
+        draw(running) {
+            const { width, height } = size();
+            const lines = boardLines(steps, running, { width: width - 1, height }, style);
+            // A frame shorter than the last one blanks the rows the last one used.
+            while (lines.length < drawn)
+                lines.push('');
+            const up = drawn > 0 ? `\x1b[${drawn}A` : '';
+            write(up + lines.map((l) => `\r\x1b[2K${l}\n`).join(''));
+            drawn = lines.length;
+        },
+    };
+}

package/dist/sweep.d.ts

@@ -7,14 +7,20 @@
  */
 import type { CommandRunner } from '@osdlc/command-seam';
 import { type ProcessProbe } from './processes.ts';
+import { type ProviderChoice } from './providers/index.ts';
 import { type RepoSweep, type Scope, type SweepProgress, type SweepResult } from './types.ts';
 export interface SweepOptions {
     /** Which categories to gather. Defaults to all of them. */
     scope?: Iterable<Scope | string>;
     /** Remote to measure against. Defaults to `origin`, then the first one. */
     remote?: string | null;
-    /** Skip `gh` entirely and classify on git evidence alone. */
-    noGh?: boolean;
+    /** Ask no provider and classify on git evidence alone. Same as `provider: 'none'`, and wins over it. */
+    noProvider?: boolean;
+    /**
+     * Which provider to ask for pull requests: `github` (`gh`), `gitlab`
+     * (`glab`), `none`, or `auto`, which reads the remote's host. Defaults to `auto`.
+     */
+    provider?: ProviderChoice | undefined;
     /**
      * Run `git fetch --prune <remote>` before classifying, so ancestry is read
      * against fresh remote-tracking refs. A failed fetch makes the repository
@@ -34,9 +40,10 @@ export interface SweepOptions {
      * when that worktree is blocked or cannot be removed.
      */
     branch?: string | undefined;
-    /** Injected runners. Defaults spawn the real `git` and `gh`. */
+    /** Injected runners. Defaults spawn the real `git`, `gh` and `glab`. */
     git?: CommandRunner | undefined;
     gh?: CommandRunner | undefined;
+    glab?: CommandRunner | undefined;
     /**
      * Answers whether a worktree lock's owner is alive and which processes work
      * inside a worktree. Defaults to {@link defaultProcessProbe}, one per

package/dist/sweep.js

@@ -11,6 +11,7 @@ import { gatherLocalBranches, gatherRemoteBranches } from "./branches.js";
 import { DiscoveryFailed, discoverRepo } from "./discover.js";
 import { defaultProcessProbe } from "./processes.js";
 import { fetchPrs } from "./prs.js";
+import { providers } from "./providers/index.js";
 import { resolveEntries } from "./resolve.js";
 import { ALL_SCOPES, findDuplicateCheckouts, } from "./types.js";
 import { gatherWorktrees } from "./worktrees.js";
@@ -33,13 +34,15 @@ function clients(path, opts) {
 export function sweepRepo(path, opts = {}) {
     const scope = scopeSet(opts.scope);
     const { git, gh } = clients(path, opts);
+    const known = providers({ gh, glab: opts.glab });
     const only = opts.branch;
     const at = opts.position ?? { index: 1, of: 1 };
-    const report = (step, done, total) => opts.onProgress?.({
+    const report = (step, done, total, tool) => opts.onProgress?.({
         repo: path,
         ...at,
         step,
         ...(done === undefined || total === undefined ? {} : { done, total }),
+        ...(tool === undefined ? {} : { tool }),
     });
     const ticker = (step) => (done, total) => report(step, done, total);
     report('discover');
@@ -47,9 +50,11 @@ export function sweepRepo(path, opts = {}) {
     try {
         repo = discoverRepo(path, {
             remote: opts.remote ?? null,
-            allowGh: opts.noGh !== true,
+            allowProvider: opts.noProvider !== true,
+            provider: opts.provider,
             git,
             gh,
+            providers: known,
         });
     }
     catch (err) {
@@ -77,9 +82,10 @@ export function sweepRepo(path, opts = {}) {
         repo = { ...repo, fetched: true };
     }
     try {
-        if (repo.hasGh && repo.ghAuthenticated)
-            report('prs');
-        const prs = fetchPrs(repo, gh, only);
+        const status = repo.provider ?? null;
+        if (status?.authenticated === true)
+            report('prs', undefined, undefined, status.tool);
+        const prs = status === null ? new Map() : fetchPrs(repo, known[status.name], only);
         const items = [];
         // Worktrees are gathered whenever local branches are, even if they are not
         // reported: a branch checked out in one must not be judged on its own.

package/dist/types.d.ts

@@ -5,6 +5,7 @@
  * by `category` rather than reading a different type, and a host that adds its
  * own knowledge (an issue tracker's linkage, say) rewrites rows in place.
  */
+import type { ProviderStatus } from './providers/types.ts';
 /** What the sweep concluded about an item. */
 export type Classification = 'safe-to-delete' | 'safe-to-keep' | 'needs-investigation';
 /** The kinds of thing a sweep inventories. */
@@ -21,6 +22,8 @@ export interface SweepProgress {
     step: 'discover' | 'fetch' | 'prs' | 'worktrees' | 'local-branches' | 'remote-branches';
     done?: number;
     total?: number;
+    /** The CLI asked during the `prs` step: `gh`, `glab`. */
+    tool?: string;
 }
 /** Which categories to gather. */
 export declare const ALL_SCOPES: readonly ["local-branches", "worktrees", "remote-branches"];
@@ -47,8 +50,12 @@ export interface RepoInfo {
     mainBranch: string;
     remote: string | null;
     currentBranch: string;
-    hasGh: boolean;
-    ghAuthenticated: boolean;
+    /**
+     * The provider asked for pull requests and what its probe found: whether
+     * its CLI is installed and signed in. Null when none was asked
+     * (`--provider none`, `--no-gh`, or a sweep without `--remotes`).
+     */
+    provider: ProviderStatus | null;
     /** True when the sweep fetched the remote before classifying. */
     fetched: boolean;
 }

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.11.0";
+export declare const VERSION = "0.14.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.11.0';
+export const VERSION = '0.14.0';

package/dist/worktrees.d.ts

@@ -46,3 +46,15 @@ export declare function classifyWorktree(opts: {
     /** Answers lock-owner and working-directory questions. One per sweep: it caches the process table. */
     probe: ProcessProbe;
 }): SweepItem;
+/** How a branch shows it was worked on, for a worktree merged by ancestry alone. */
+export type BranchUse = 'commits' | 'upstream';
+/**
+ * The sign that `branch` was worked on, or null for a branch that looks
+ * freshly made. `commits`: its reflog records work (see {@link isWorkEntry}). `upstream`: it tracks a branch on a remote, and not
+ * the default branch (`mainBranch`) of any remote, so someone pushed it as
+ * its own branch. A branch with neither, such as one `git worktree add -b`
+ * just made from the default branch, with or without `--track`, reads as
+ * null: removing its worktree could lose ignored files from work about to
+ * start.
+ */
+export declare function branchUse(git: Git, branch: string, mainBranch: string): BranchUse | null;

package/dist/worktrees.js

@@ -360,6 +360,24 @@ export function classifyWorktree(opts) {
     }
     if (pr && pr.state === 'OPEN')
         return keep(`open PR #${pr.number}`, { requires });
+    // Merged by ancestry alone: a worktree just made from the default branch is
+    // merged that way too, so ancestry needs a sign the branch was worked on.
+    if (facts['merged'] === true && branch && head !== null) {
+        const used = branchUse(git.at(repo.root), branch, repo.mainBranch);
+        facts['branch_used'] = used;
+        if (used !== null) {
+            return makeItem({
+                category: 'worktree',
+                id: path,
+                classification: 'safe-to-delete',
+                action: 'remove',
+                reason: `clean; merged into ${landedRef(repo)}, and ${USE_REASON[used]}`,
+                facts,
+                commands: safeRemove,
+                requires,
+            });
+        }
+    }
     const parts = [`Worktree \`${path}\` is clean.`];
     if (branch)
         parts.push(`Branch: \`${branch}\`.`);
@@ -380,3 +398,42 @@ export function classifyWorktree(opts) {
         requires,
     });
 }
+const USE_REASON = {
+    commits: 'the branch has commits made on it',
+    upstream: 'the branch was pushed to its own upstream',
+};
+/**
+ * Reflog entries that put work on a branch: a commit, a cherry-pick, an `am`,
+ * or a merge or pull that made a merge commit. A fast-forward merge or pull,
+ * a rebase, a reset or a rename only moves a branch, which a fresh branch
+ * tracking the default branch does on its first `git pull`.
+ */
+function isWorkEntry(entry) {
+    if (/^(commit|cherry-pick|am)\b/.test(entry))
+        return true;
+    return /^(merge|pull)\b/.test(entry) && !/Fast-forward/.test(entry);
+}
+/**
+ * The sign that `branch` was worked on, or null for a branch that looks
+ * freshly made. `commits`: its reflog records work (see {@link isWorkEntry}). `upstream`: it tracks a branch on a remote, and not
+ * the default branch (`mainBranch`) of any remote, so someone pushed it as
+ * its own branch. A branch with neither, such as one `git worktree add -b`
+ * just made from the default branch, with or without `--track`, reads as
+ * null: removing its worktree could lose ignored files from work about to
+ * start.
+ */
+export function branchUse(git, branch, mainBranch) {
+    // `raw`: a branch with no reflog (core.logAllRefUpdates off) exits non-zero.
+    const reflog = git.raw(['reflog', 'show', '--format=%gs', `refs/heads/${branch}`, '--']);
+    if (reflog.exitCode === 0 && reflog.stdout.split('\n').some(isWorkEntry)) {
+        return 'commits';
+    }
+    // From the branch's own config, not the resolved name: a branch tracking a
+    // local branch has remote `.`, and one tracking `upstream/main` merges the
+    // default branch however its remote is spelled.
+    const remote = git.configGet(`branch.${branch}.remote`);
+    const merge = git.configGet(`branch.${branch}.merge`);
+    if (remote && remote !== '.' && merge && merge !== `refs/heads/${mainBranch}`)
+        return 'upstream';
+    return null;
+}