@solaqua/gji 0.13.0 → 0.15.0

package/dist/cli/commands/clean.js

@@ -1,10 +1,25 @@
+import { realpath } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
 import { confirm, isCancel } from "@clack/prompts";
-import { loadLinkedWorktrees } from "../../application/worktree/catalog.js";
+import { loadLinkedWorktrees, } from "../../application/worktree/catalog.js";
+import { deduplicateWorktreeSources, listRegisteredWorktreeSources, } from "../../application/worktree/sources.js";
+import { mapWithConcurrency } from "../../domain/shared/concurrency.js";
+import { createWorktreePathFilter, escapePathPattern, findGlobIndex, unescapePathPattern, } from "../../domain/worktree/path-filter.js";
+import { expandTildeInPath } from "../../domain/worktree/policy.js";
 import { buildWorktreePromptEntries, promptForMultipleWorktrees, } from "../../presentation/worktree/picker.js";
 import { defaultConfirmForceDeleteBranch, defaultConfirmForceRemoveWorktree, } from "../../presentation/worktree/prompts.js";
 import { defaultCliDependencies, } from "../dependencies.js";
 import { isHeadless } from "../runtime/headless.js";
-import { finalizeUndoOperation, recordUndoOperation } from "./undo.js";
+import { finalizeUndoOperation, recordUndoOperation, } from "./undo.js";
+function toPromptSource(candidate) {
+    return {
+        repoName: candidate.repoName,
+        repoRoot: candidate.repoRoot,
+        worktree: candidate.worktree,
+    };
+}
+const MAX_CLEAN_REPOSITORY_CONCURRENCY = 4;
+const MAX_CLEAN_WORKTREE_CONCURRENCY = 8;
 export function createCleanCommand(dependencies = {}) {
     const promptForWorktrees = dependencies.promptForWorktrees ?? defaultPromptForWorktrees;
     const confirmRemoval = dependencies.confirmRemoval ?? defaultConfirmRemoval;
@@ -13,7 +28,7 @@ export function createCleanCommand(dependencies = {}) {
     const confirmForceDeleteBranch = dependencies.confirmForceDeleteBranch ?? defaultConfirmForceDeleteBranch;
     return async function runCleanCommand(options) {
         const runtime = options.runtime ?? defaultCliDependencies;
-        const { readWorktreeHealth, isBranchMergedInto, resolveRemoteDefaultBranch, runGit, } = runtime.git;
+        const { readWorktreeHealth, isBranchMergedInto, resolveRemoteBase, runGit, } = runtime.git;
         const { loadEffectiveConfig } = runtime.config;
         const { releaseWorktreeSlot } = runtime.slots;
         const sourceDependencies = {
@@ -24,20 +39,115 @@ export function createCleanCommand(dependencies = {}) {
         const { formatLastCommit, formatUpstreamState, readWorktreeInfos, serializeWorktreeInfo, } = runtime.worktreeInfo;
         const { deleteBranch, forceDeleteBranch, forceRemoveWorktree, isBranchUnmergedError, isSubmoduleWorktreeRemovalError, isWorktreeDeletionError, isWorktreeForceRemovalError, removeWorktree, } = runtime.worktreeLifecycle;
         const { linkedWorktrees, repository } = await loadLinkedWorktrees(options.cwd, sourceDependencies);
-        const linkedCleanupCandidates = linkedWorktrees.filter((worktree) => worktree.path !== repository.currentRoot);
-        const staleBaseRef = options.stale
-            ? await resolveStaleBaseRef(repository.repoRoot, options.stderr, loadEffectiveConfig, resolveRemoteDefaultBranch, runGit)
-            : null;
-        const cleanupCandidates = options.stale
-            ? await filterStaleCleanupCandidates(repository.repoRoot, linkedCleanupCandidates, staleBaseRef, readWorktreeHealth, isBranchMergedInto)
-            : linkedCleanupCandidates;
-        if (cleanupCandidates.length === 0) {
+        const pathPatterns = await canonicalizePathPatterns(options.cwd, options.paths ?? []);
+        const matchesPathFilter = createWorktreePathFilter(pathPatterns);
+        // An explicit path may point at another registered repository, so
+        // --path starts in the all-repositories scope.
+        const searchAllRepositories = pathPatterns.length > 0;
+        let allSourceCount = 0;
+        const emitNoCandidates = (sourceCount) => {
+            if (pathPatterns.length > 0 && sourceCount === 0) {
+                emitError(options, "No linked worktrees match --path");
+                return 1;
+            }
             if (options.stale) {
                 emitNoStaleCandidates(options);
                 return 0;
             }
             emitError(options, "No linked worktrees to clean");
             return 1;
+        };
+        const currentSources = linkedWorktrees
+            .filter((worktree) => worktree.path !== repository.currentRoot &&
+            matchesPathFilter(worktree.path))
+            .map((worktree) => ({
+            repoName: repository.repoName,
+            repoRoot: repository.repoRoot,
+            worktree,
+        }));
+        const cleanupDependencies = {
+            isBranchMergedInto,
+            loadEffectiveConfig,
+            readWorktreeHealth,
+            resolveRemoteBase,
+            runGit,
+        };
+        const currentCandidates = await resolveCleanupCandidates({
+            sources: currentSources,
+            stale: options.stale,
+            stderr: options.stderr,
+        }, cleanupDependencies);
+        let activeCandidates = currentCandidates;
+        let allCandidates = null;
+        let currentScope = true;
+        const interactiveSelection = !options.force && !options.json && !isHeadless();
+        const skippedRepositories = [];
+        const loadAllCandidates = async (signal) => {
+            throwIfAborted(signal);
+            if (allCandidates !== null)
+                return allCandidates;
+            const registered = await listRegisteredWorktreeSources({
+                cwd: options.cwd,
+                repositoryPort: sourceDependencies,
+                signal,
+            });
+            skippedRepositories.push(...registered.skipped);
+            if (registered.skipped.length > 0) {
+                reportSkippedRepositories(skippedRepositories, options.stderr);
+            }
+            const sources = deduplicateWorktreeSources([
+                ...currentSources,
+                ...registered.sources,
+            ]).filter((source) => source.repoRoot !== undefined &&
+                source.worktree.path !== source.repoRoot &&
+                source.worktree.path !== repository.currentRoot &&
+                matchesPathFilter(source.worktree.path));
+            allSourceCount = sources.length;
+            const otherRepositorySources = sources.filter((source) => source.repoRoot !== repository.repoRoot);
+            const otherRepositoryCandidates = await resolveCleanupCandidates({
+                sources: otherRepositorySources,
+                stale: options.stale,
+                stderr: options.stderr,
+                signal,
+            }, cleanupDependencies);
+            allCandidates = [...currentCandidates, ...otherRepositoryCandidates];
+            throwIfAborted(signal);
+            return allCandidates;
+        };
+        const scope = {
+            label: "current repository",
+            toggleLabel: "all repositories",
+            toggle: async (signal) => {
+                const nextCurrentScope = !currentScope;
+                const nextCandidates = nextCurrentScope
+                    ? currentCandidates
+                    : await loadAllCandidates(signal);
+                throwIfAborted(signal);
+                currentScope = nextCurrentScope;
+                activeCandidates = nextCandidates;
+                return {
+                    sources: nextCandidates.map(toPromptSource),
+                    metadata: nextCurrentScope ? "full" : "fast",
+                    label: nextCurrentScope ? "current repository" : "all repositories",
+                    toggleLabel: nextCurrentScope
+                        ? "all repositories"
+                        : "current repository",
+                };
+            },
+        };
+        if (searchAllRepositories ||
+            (interactiveSelection && currentCandidates.length === 0)) {
+            const loadedAllCandidates = await loadAllCandidates();
+            if (loadedAllCandidates.length === 0) {
+                return emitNoCandidates(allSourceCount);
+            }
+            currentScope = false;
+            activeCandidates = loadedAllCandidates;
+            scope.label = "all repositories";
+            scope.toggleLabel = "current repository";
+        }
+        else if (currentCandidates.length === 0) {
+            return emitNoCandidates(currentSources.length);
         }
         if (!options.dryRun && !options.force && (options.json || isHeadless())) {
             const message = "--force is required";
@@ -53,20 +163,21 @@ export function createCleanCommand(dependencies = {}) {
         const shouldSelectAll = options.force ||
             (options.dryRun && (options.stale || options.json || isHeadless()));
         const selections = shouldSelectAll
-            ? cleanupCandidates.map((w) => w.path)
-            : await promptForWorktrees(await buildWorktreePromptEntries(cleanupCandidates.map((worktree) => ({
-                repoName: repository.repoName,
-                worktree,
-            })), { catalog: runtime.worktreeCatalog }));
+            ? activeCandidates.map(({ worktree }) => worktree.path)
+            : await promptForWorktrees(await buildWorktreePromptEntries(activeCandidates, {
+                metadata: currentScope ? "full" : "fast",
+                catalog: runtime.worktreeCatalog,
+            }), scope, runtime.worktreeCatalog);
         if (!selections || selections.length === 0) {
             options.stderr("Aborted\n");
             return 1;
         }
-        const selectedWorktrees = resolveSelectedWorktrees(cleanupCandidates, selections);
-        if (selectedWorktrees.length !== selections.length) {
+        const selectedCandidates = resolveSelectedCandidates(activeCandidates, selections);
+        if (selectedCandidates.length !== selections.length) {
             options.stderr("Selected worktree no longer exists\n");
             return 1;
         }
+        const selectedWorktrees = selectedCandidates.map(({ worktree }) => worktree);
         const selectedWorktreeInfos = await readWorktreeInfos(selectedWorktrees);
         const selectedInfoByPath = new Map(selectedWorktreeInfos.map((info) => [info.path, info]));
         if (!options.dryRun &&
@@ -87,28 +198,35 @@ export function createCleanCommand(dependencies = {}) {
             }
             return 0;
         }
-        const removedWorktrees = [];
+        const candidatesByRepository = groupCandidatesByRepository(selectedCandidates);
+        const journals = new Map();
         const failures = [];
-        let journal;
         try {
-            journal = await recordUndoOperation("clean", repository.repoRoot, selectedWorktrees, undefined, runtime);
+            for (const [repoRoot, candidates] of candidatesByRepository) {
+                const journal = await recordUndoOperation("clean", repoRoot, candidates.map(({ worktree }) => worktree), undefined, runtime);
+                if (!journal) {
+                    await discardUndoRecords(journals.values(), runtime.configStore.GLOBAL_CONFIG_DIRECTORY);
+                    emitError(options, "could not capture undo state; no worktrees were removed");
+                    return 1;
+                }
+                journals.set(repoRoot, journal);
+            }
         }
         catch (error) {
+            await discardUndoRecords(journals.values(), runtime.configStore.GLOBAL_CONFIG_DIRECTORY);
             emitError(options, `could not write undo journal; no worktrees were removed: ${toMessage(error)}`);
             return 1;
         }
-        if (!journal) {
-            emitError(options, "could not capture undo state; no worktrees were removed");
-            return 1;
-        }
-        for (const worktree of selectedWorktrees) {
+        const removedCandidates = [];
+        for (const candidate of selectedCandidates) {
+            const { repoRoot, staleBaseRef, worktree } = candidate;
             if (options.stale &&
-                !(await isStaleCleanupCandidate(repository.repoRoot, worktree, staleBaseRef, readWorktreeHealth, isBranchMergedInto))) {
+                !(await isStaleCleanupCandidate({ repoRoot, worktree, baseBranch: staleBaseRef }, cleanupDependencies))) {
                 options.stderr(`Skipped ${worktree.path}: no longer a safe stale cleanup candidate\n`);
                 continue;
             }
             try {
-                await removeWorktree(repository.repoRoot, worktree.path);
+                await removeWorktree(repoRoot, worktree.path);
             }
             catch (error) {
                 if (!isWorktreeForceRemovalError(error)) {
@@ -135,7 +253,7 @@ export function createCleanCommand(dependencies = {}) {
                     continue;
                 }
                 try {
-                    await forceRemoveWorktree(repository.repoRoot, worktree.path);
+                    await forceRemoveWorktree(repoRoot, worktree.path);
                 }
                 catch (forceError) {
                     failures.push({
@@ -146,10 +264,10 @@ export function createCleanCommand(dependencies = {}) {
                     continue;
                 }
             }
-            removedWorktrees.push(worktree);
+            removedCandidates.push(candidate);
             if (worktree.branch) {
                 try {
-                    await deleteBranch(repository.repoRoot, worktree.branch);
+                    await deleteBranch(repoRoot, worktree.branch);
                 }
                 catch (error) {
                     if (!isBranchUnmergedError(error)) {
@@ -163,7 +281,7 @@ export function createCleanCommand(dependencies = {}) {
                     if (options.force ||
                         (await confirmForceDeleteBranch(worktree.branch))) {
                         try {
-                            await forceDeleteBranch(repository.repoRoot, worktree.branch);
+                            await forceDeleteBranch(repoRoot, worktree.branch);
                         }
                         catch (forceError) {
                             options.stderr(`Failed to delete branch ${worktree.branch}: ${toMessage(forceError)}\n`);
@@ -175,56 +293,172 @@ export function createCleanCommand(dependencies = {}) {
                 }
             }
         }
-        await finalizeUndoOperation(journal, removedWorktrees, undefined, runtime.configStore.GLOBAL_CONFIG_DIRECTORY);
-        await Promise.all(removedWorktrees.map((worktree) => releaseWorktreeSlot(worktree.path)));
+        for (const [repoRoot, journal] of journals) {
+            await finalizeUndoOperation(journal, removedCandidates
+                .filter((candidate) => candidate.repoRoot === repoRoot)
+                .map(({ worktree }) => worktree), undefined, runtime.configStore.GLOBAL_CONFIG_DIRECTORY);
+        }
+        const undoRecords = remainingUndoRecords(journals.values(), removedCandidates);
+        await Promise.all(removedCandidates.map(({ worktree }) => releaseWorktreeSlot(worktree.path)));
         if (options.json) {
-            const removed = removedWorktrees.map((worktree) => {
+            const removed = removedCandidates.map(({ worktree }) => {
                 const info = selectedInfoByPath.get(worktree.path);
                 return info === undefined
                     ? { branch: worktree.branch, path: worktree.path }
                     : serializeWorktreeInfo(info);
             });
-            const payload = failures.length === 0 ? { removed } : { removed, failed: failures };
+            const payload = {
+                removed,
+                ...(failures.length === 0 ? {} : { failed: failures }),
+                ...(needsExplicitUndoIds(undoRecords, repository.repoRoot)
+                    ? {
+                        undo: undoRecords.map(({ id, repoRoot }) => ({ id, repoRoot })),
+                    }
+                    : {}),
+            };
             options.stdout(`${JSON.stringify(payload, null, 2)}\n`);
         }
         else if (failures.length > 0) {
             reportCleanFailures(failures, options.stderr);
+            emitUndoHints(undoRecords, repository.repoRoot, options.stderr);
         }
         else {
-            options.stderr("undo: gji undo\n");
-            options.stdout(`${repository.repoRoot}\n`);
+            emitUndoHints(undoRecords, repository.repoRoot, options.stderr);
+            options.stdout(`${[...new Set(selectedCandidates.map(({ repoRoot }) => repoRoot))].join("\n")}\n`);
         }
         return failures.length === 0 ? 0 : 1;
     };
 }
 export const runCleanCommand = createCleanCommand();
-async function filterStaleCleanupCandidates(repoRoot, worktrees, baseBranch, readWorktreeHealth, isBranchMergedInto) {
+async function canonicalizePathPatterns(cwd, patterns) {
+    return Promise.all(patterns.map((pattern) => canonicalizeLiteralPrefix(resolve(cwd, expandTildeInPath(pattern)))));
+}
+// Git records canonical worktree paths, so resolve symlinks in the pattern's
+// longest existing literal prefix before matching.
+async function canonicalizeLiteralPrefix(pattern) {
+    const globIndex = findGlobIndex(pattern);
+    let prefix = globIndex === -1 ? pattern : dirname(`${pattern.slice(0, globIndex)}x`);
+    let suffix = pattern.slice(prefix.length);
+    for (;;) {
+        try {
+            const canonicalPrefix = escapePathPattern(await realpath(unescapePathPattern(prefix)));
+            return `${canonicalPrefix}${suffix}`.replace(/^\/\//, "/");
+        }
+        catch {
+            const parent = dirname(prefix);
+            if (parent === prefix)
+                return pattern;
+            suffix = join("/", basename(prefix), suffix);
+            prefix = parent;
+        }
+    }
+}
+async function resolveCleanupCandidates(options, dependencies) {
+    const { sources, stale, stderr, signal } = options;
+    const grouped = new Map();
+    for (const source of sources) {
+        if (source.repoRoot === undefined)
+            continue;
+        const existing = grouped.get(source.repoRoot);
+        if (existing === undefined) {
+            grouped.set(source.repoRoot, {
+                repoName: source.repoName,
+                worktrees: [source.worktree],
+            });
+        }
+        else {
+            existing.worktrees.push(source.worktree);
+        }
+    }
+    const results = await mapWithConcurrency([...grouped.entries()], MAX_CLEAN_REPOSITORY_CONCURRENCY, async ([repoRoot, group]) => {
+        throwIfAborted(signal);
+        const staleBaseRef = stale
+            ? await resolveStaleBaseRef({ repoRoot, stderr }, dependencies)
+            : null;
+        const worktrees = stale
+            ? await filterStaleCleanupCandidates({
+                repoRoot,
+                worktrees: group.worktrees,
+                baseBranch: staleBaseRef,
+                signal,
+            }, dependencies)
+            : group.worktrees;
+        return worktrees.map((worktree) => ({
+            repoName: group.repoName,
+            repoRoot,
+            staleBaseRef,
+            worktree,
+        }));
+    }, signal);
+    return results.flat();
+}
+function resolveSelectedCandidates(candidates, selections) {
+    const selected = [];
+    const seenPaths = new Set();
+    for (const selection of selections) {
+        const candidate = candidates.find((entry) => entry.worktree.path === selection ||
+            entry.worktree.branch === selection);
+        if (candidate === undefined || seenPaths.has(candidate.worktree.path)) {
+            continue;
+        }
+        selected.push(candidate);
+        seenPaths.add(candidate.worktree.path);
+    }
+    return selected;
+}
+function groupCandidatesByRepository(candidates) {
+    const grouped = new Map();
+    for (const candidate of candidates) {
+        const existing = grouped.get(candidate.repoRoot);
+        if (existing === undefined)
+            grouped.set(candidate.repoRoot, [candidate]);
+        else
+            existing.push(candidate);
+    }
+    return grouped;
+}
+function remainingUndoRecords(records, removedCandidates) {
+    return [...records].filter((record) => removedCandidates.some((candidate) => candidate.repoRoot === record.repoRoot &&
+        record.entries.some((entry) => entry.path === candidate.worktree.path)));
+}
+async function discardUndoRecords(records, globalConfigDirectory) {
+    await Promise.all([...records].map((record) => finalizeUndoOperation(record, [], undefined, globalConfigDirectory)));
+}
+async function filterStaleCleanupCandidates(options, dependencies) {
+    const { repoRoot, worktrees, baseBranch, signal } = options;
+    throwIfAborted(signal);
     if (baseBranch === null) {
         return [];
     }
-    const results = await Promise.all(worktrees.map((worktree) => isStaleCleanupCandidate(repoRoot, worktree, baseBranch, readWorktreeHealth, isBranchMergedInto)));
+    const results = await mapWithConcurrency(worktrees, MAX_CLEAN_WORKTREE_CONCURRENCY, (worktree) => isStaleCleanupCandidate({ repoRoot, worktree, baseBranch }, dependencies), signal);
+    throwIfAborted(signal);
     return worktrees.filter((_, index) => results[index]);
 }
-async function resolveStaleBaseRef(repoRoot, stderr, loadEffectiveConfig, resolveRemoteDefaultBranch, runGit) {
-    const config = await loadEffectiveConfig(repoRoot, undefined, stderr);
+async function resolveStaleBaseRef(options, dependencies) {
+    const { repoRoot, stderr } = options;
+    const config = await dependencies.loadEffectiveConfig(repoRoot, undefined, stderr);
     const remote = resolveConfiguredString(config.syncRemote) ?? "origin";
     const configuredDefaultBranch = resolveConfiguredString(config.syncDefaultBranch);
-    if (configuredDefaultBranch) {
-        return await resolveFetchedRemoteRef(repoRoot, remote, configuredDefaultBranch, runGit);
-    }
     try {
-        const remoteDefaultBranch = await resolveRemoteDefaultBranch(repoRoot, remote);
-        return remoteDefaultBranch === null
+        const remoteBase = await dependencies.resolveRemoteBase(repoRoot, remote, configuredDefaultBranch ?? undefined);
+        return remoteBase === null
             ? null
-            : await resolveFetchedRemoteRef(repoRoot, remote, remoteDefaultBranch, runGit);
+            : resolveFetchedRemoteRef({ branch: remoteBase.branch, remote, repoRoot }, dependencies.runGit);
     }
     catch {
         return null;
     }
 }
-async function resolveFetchedRemoteRef(repoRoot, remote, branch, runGit) {
+async function resolveFetchedRemoteRef(options, runGit) {
+    const { repoRoot, remote, branch } = options;
     try {
         await runGit(repoRoot, ["fetch", "--prune", remote]);
+        await runGit(repoRoot, [
+            "rev-parse",
+            "--verify",
+            "--quiet",
+            `${remote}/${branch}`,
+        ]);
         return `${remote}/${branch}`;
     }
     catch {
@@ -234,31 +468,37 @@ async function resolveFetchedRemoteRef(repoRoot, remote, branch, runGit) {
 function resolveConfiguredString(value) {
     return typeof value === "string" && value.length > 0 ? value : null;
 }
-async function isStaleCleanupCandidate(repoRoot, worktree, baseBranch, readWorktreeHealth, isBranchMergedInto) {
+async function isStaleCleanupCandidate(options, dependencies) {
+    const { repoRoot, worktree, baseBranch } = options;
     if (baseBranch === null) {
         return false;
     }
     if (worktree.branch === null) {
         return false;
     }
-    const health = await readWorktreeHealth(worktree.path);
+    const health = await dependencies.readWorktreeHealth(worktree.path);
     if (health.status !== "clean" || !health.upstreamGone) {
         return false;
     }
-    return isBranchMergedInto(repoRoot, worktree.branch, baseBranch);
+    if (await dependencies.isBranchMergedInto(repoRoot, worktree.branch, baseBranch)) {
+        return true;
+    }
+    return isBranchPatchEquivalentInto({ baseBranch, repoRoot, worktreeBranch: worktree.branch }, dependencies.runGit);
 }
-function resolveSelectedWorktrees(worktrees, selections) {
-    const selectedWorktrees = [];
-    const seenPaths = new Set();
-    for (const selection of selections) {
-        const worktree = worktrees.find((entry) => entry.path === selection || entry.branch === selection);
-        if (!worktree || seenPaths.has(worktree.path)) {
-            continue;
-        }
-        selectedWorktrees.push(worktree);
-        seenPaths.add(worktree.path);
+async function isBranchPatchEquivalentInto(options, runGit) {
+    const { repoRoot, worktreeBranch, baseBranch } = options;
+    try {
+        const output = await runGit(repoRoot, [
+            "cherry",
+            baseBranch,
+            worktreeBranch,
+        ]);
+        const lines = output.split("\n").filter(Boolean);
+        return lines.length > 0 && lines.every((line) => line.startsWith("-"));
+    }
+    catch {
+        return false;
     }
-    return selectedWorktrees;
 }
 function reportCleanFailures(failures, stderr) {
     const noun = failures.length === 1 ? "worktree" : "worktrees";
@@ -268,6 +508,36 @@ function reportCleanFailures(failures, stderr) {
         stderr(`- ${failure.path} (${branch}): ${failure.message}\n`);
     }
 }
+function emitUndoHints(records, currentRepositoryRoot, stderr) {
+    if (records.length === 0)
+        return;
+    if (!needsExplicitUndoIds(records, currentRepositoryRoot)) {
+        stderr("undo: gji undo\n");
+        return;
+    }
+    const message = records.length === 1
+        ? "undo: restore with:"
+        : "undo: restore each repository with:";
+    stderr(`${message}\n`);
+    for (const record of records) {
+        stderr(`  gji undo --id ${record.id} (${record.repoRoot})\n`);
+    }
+}
+function needsExplicitUndoIds(records, currentRepositoryRoot) {
+    return (records.length > 1 ||
+        records.some((record) => record.repoRoot !== currentRepositoryRoot));
+}
+function reportSkippedRepositories(repositories, stderr) {
+    const noun = repositories.length === 1 ? "repository" : "repositories";
+    stderr(`Skipped ${repositories.length} registered ${noun} because worktrees could not be listed:\n`);
+    for (const repository of repositories) {
+        stderr(`- ${repository.name} (${repository.path})\n`);
+    }
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted)
+        throw new Error("Operation cancelled");
+}
 function formatCleanInfo(info, formatLastCommit, formatUpstreamState) {
     const branch = info.branch === null ? "detached" : `branch: ${info.branch}`;
     const status = `status: ${info.status}`;
@@ -296,8 +566,11 @@ function emitNoStaleCandidates(options) {
 function toMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
-async function defaultPromptForWorktrees(worktrees) {
-    return promptForMultipleWorktrees("Choose worktrees to clean", worktrees);
+async function defaultPromptForWorktrees(worktrees, scope, catalog) {
+    return promptForMultipleWorktrees("Choose worktrees to clean", worktrees, {
+        catalog,
+        scope,
+    });
 }
 async function defaultConfirmRemoval(worktrees) {
     const branchCount = worktrees.filter((worktree) => worktree.branch !== null).length;

package/dist/cli/commands/go.d.ts

@@ -1,3 +1,4 @@
+import type { WorktreeCatalogDependencies } from "../../application/worktree/catalog.js";
 import { type QueryWorktreePullRequests, type WorktreePromptEntry, type WorktreePromptScope } from "../../presentation/worktree/picker.js";
 import { type CliRuntime } from "../dependencies.js";
 export interface GoCommandOptions {
@@ -14,7 +15,7 @@ export interface GoCommandOptions {
 type GoRuntime = CliRuntime<"bootstrap" | "config" | "contextCard" | "git" | "history" | "historyStore" | "hooks" | "integrations" | "repositoryContext" | "repositoryRefs" | "repositoryRegistry" | "slots" | "tasks" | "worktrees" | "worktreeCatalog">;
 export interface GoCommandDependencies {
     confirmBranchCreation: (branch: string) => Promise<boolean>;
-    promptForWorktree: (worktrees: WorktreePromptEntry[], scope?: WorktreePromptScope) => Promise<string | null>;
+    promptForWorktree: (worktrees: WorktreePromptEntry[], scope?: WorktreePromptScope, catalog?: WorktreeCatalogDependencies) => Promise<string | null>;
     queryPullRequests: QueryWorktreePullRequests;
     runtime: GoRuntime;
 }

package/dist/cli/commands/go.js

@@ -49,13 +49,16 @@ export function createGoCommand(dependencies = {}) {
             let promptSources = currentSources;
             const loadAllSources = async () => {
                 if (registeredSources === null) {
-                    registeredSources = await listRegisteredWorktreeSources(options.cwd, {
-                        ...runtime.repositoryContext,
-                        ...runtime.repositoryRegistry,
-                        ...runtime.worktrees,
-                    }, () => {
-                        skippedRegisteredRepos++;
+                    const registered = await listRegisteredWorktreeSources({
+                        cwd: options.cwd,
+                        repositoryPort: {
+                            ...runtime.repositoryContext,
+                            ...runtime.repositoryRegistry,
+                            ...runtime.worktrees,
+                        },
                     });
+                    registeredSources = registered.sources;
+                    skippedRegisteredRepos = registered.skipped.length;
                 }
                 return deduplicateSources([...currentSources, ...registeredSources]);
             };
@@ -79,10 +82,8 @@ export function createGoCommand(dependencies = {}) {
                         currentRepositoryScope = nextCurrentRepositoryScope;
                         promptSources = nextSources;
                         return {
-                            entries: await buildWorktreePromptEntries(promptSources, {
-                                metadata: currentRepositoryScope ? "full" : "fast",
-                                catalog: withPullRequestQueries(runtime, dependencies.queryPullRequests),
-                            }),
+                            sources: promptSources,
+                            metadata: currentRepositoryScope ? "full" : "fast",
                             label: currentRepositoryScope
                                 ? "current repository"
                                 : "all repositories",
@@ -97,7 +98,7 @@ export function createGoCommand(dependencies = {}) {
                 metadata: repository ? "full" : "fast",
                 catalog: withPullRequestQueries(runtime, dependencies.queryPullRequests),
             });
-            const selectedPath = await prompt(promptEntries, scope);
+            const selectedPath = await prompt(promptEntries, scope, withPullRequestQueries(runtime, dependencies.queryPullRequests));
             if (!selectedPath) {
                 options.stderr("Aborted\n");
                 return 1;
@@ -304,6 +305,9 @@ async function defaultConfirmBranchCreation(branch) {
     });
     return !isCancel(choice) && choice;
 }
-async function promptForWorktree(worktrees, scope) {
-    return promptForSingleWorktree("Choose a worktree", worktrees, { scope });
+async function promptForWorktree(worktrees, scope, catalog) {
+    return promptForSingleWorktree("Choose a worktree", worktrees, {
+        catalog,
+        scope,
+    });
 }

package/dist/cli/commands/hub.js

@@ -18,7 +18,10 @@ export async function buildHubData(cwd, dependencies = {}, runtime = defaultCliD
     const queryRepositoryPullRequests = dependencies.queryRepositoryPullRequests ??
         runtime.pullRequests.listOpenPullRequestsForRepository;
     const currentRepository = await detectRepository(cwd).catch(() => null);
-    const sources = await listDiscoverableWorktreeSources(cwd, sourceDependencies);
+    const { sources } = await listDiscoverableWorktreeSources({
+        cwd,
+        repositoryPort: sourceDependencies,
+    });
     const groups = new Map();
     for (const source of sources) {
         if (!source.repoRoot)

package/dist/cli/commands/warp.js

@@ -65,10 +65,12 @@ export async function resolveWarpTarget(options) {
         emitError("not in a git repository and no repos registered yet.", "Use any gji command inside a repository to register it.\n");
         return null;
     }
-    let skippedRegisteredRepos = 0;
-    const allItems = (await listRegisteredWorktreeSources(options.cwd, sourceDependencies, () => {
-        skippedRegisteredRepos++;
-    })).filter((item) => item.repoRoot !== options.excludeRepoRoot);
+    const registered = await listRegisteredWorktreeSources({
+        cwd: options.cwd,
+        repositoryPort: sourceDependencies,
+    });
+    const skippedRegisteredRepos = registered.skipped.length;
+    const allItems = registered.sources.filter((item) => item.repoRoot !== options.excludeRepoRoot);
     if (allItems.length === 0) {
         emitError("no accessible worktrees found in any registered repo.", skippedRegisteredRepos > 0
             ? "Hint: Run 'gji doctor' to inspect stale repository entries.\n"