@solaqua/gji 0.13.0 → 0.15.0

package/dist/application/worktree/go-resolution.js

@@ -46,10 +46,12 @@ export async function resolveGoBranch(options) {
             return finish({ kind: "existing", source: pullRequestMatches[0] }, false);
         }
     }
-    let skippedRegisteredRepos = 0;
-    const registeredSources = await listRegisteredWorktreeSources(cwd, sourceDependencies, () => {
-        skippedRegisteredRepos++;
+    const registered = await listRegisteredWorktreeSources({
+        cwd,
+        repositoryPort: sourceDependencies,
     });
+    const registeredSources = registered.sources;
+    const skippedRegisteredRepos = registered.skipped.length;
     const crossRepoSources = registeredSources.filter((source) => source.repoRoot !== repository?.repoRoot);
     const crossMatches = await resolveExistingWorktreeMatches(crossRepoSources, branch, (!localBranch && !remoteBranch) || isPullRequestUrl(branch), repositoryPort);
     if (crossMatches.length === 1) {

package/dist/application/worktree/sources.d.ts

@@ -1,7 +1,16 @@
 import type { RepoRegistryEntry } from "../../domain/repository/registry.js";
 import type { WorktreeSource } from "../../domain/worktree/source.js";
 import type { RepositoryContextPort, RepositoryRegistryPort, WorktreePort } from "../../ports/repository.js";
-type WorktreeSourceDependencies = RepositoryContextPort & RepositoryRegistryPort & WorktreePort;
-export declare function listRegisteredWorktreeSources(cwd: string, repositoryPort: WorktreeSourceDependencies, onSkipped?: (entry: RepoRegistryEntry) => void): Promise<WorktreeSource[]>;
-export declare function listDiscoverableWorktreeSources(cwd: string, repositoryPort: WorktreeSourceDependencies, onSkipped?: (entry: RepoRegistryEntry) => void): Promise<WorktreeSource[]>;
-export {};
+export type WorktreeSourceDependencies = RepositoryContextPort & RepositoryRegistryPort & WorktreePort;
+export interface WorktreeSourceDiscovery {
+    skipped: RepoRegistryEntry[];
+    sources: WorktreeSource[];
+}
+export interface ListWorktreeSourcesOptions {
+    cwd: string;
+    repositoryPort: WorktreeSourceDependencies;
+    signal?: AbortSignal;
+}
+export declare function listRegisteredWorktreeSources(options: ListWorktreeSourcesOptions): Promise<WorktreeSourceDiscovery>;
+export declare function listDiscoverableWorktreeSources(options: ListWorktreeSourcesOptions): Promise<WorktreeSourceDiscovery>;
+export declare function deduplicateWorktreeSources(sources: WorktreeSource[]): WorktreeSource[];

package/dist/application/worktree/sources.js

@@ -1,25 +1,31 @@
 import { mapWithConcurrency } from "../../domain/shared/concurrency.js";
 const MAX_REPOSITORY_DISCOVERY_CONCURRENCY = 4;
-export async function listRegisteredWorktreeSources(cwd, repositoryPort, onSkipped) {
+export async function listRegisteredWorktreeSources(options) {
+    const { cwd, repositoryPort, signal } = options;
+    throwIfAborted(signal);
     const registry = await repositoryPort.loadRegistry();
     const currentRoot = await repositoryPort
         .detectRepository(cwd)
         .then((repository) => repository.currentRoot)
         .catch(() => null);
+    throwIfAborted(signal);
     const results = await mapWithConcurrency(registry, MAX_REPOSITORY_DISCOVERY_CONCURRENCY, async (entry) => {
+        throwIfAborted(signal);
         try {
             const worktrees = await repositoryPort.listWorktrees(entry.path);
-            return { entry, worktrees };
+            return { entry, skipped: false, worktrees };
         }
         catch {
-            onSkipped?.(entry);
-            return null;
+            return { entry, skipped: true, worktrees: [] };
         }
-    });
+    }, signal);
     const allItems = [];
+    const skipped = [];
     for (const result of results) {
-        if (result === null)
+        if (result.skipped) {
+            skipped.push(result.entry);
             continue;
+        }
         const { entry, worktrees } = result;
         for (const worktree of worktrees) {
             allItems.push({
@@ -32,15 +38,20 @@ export async function listRegisteredWorktreeSources(cwd, repositoryPort, onSkipp
             });
         }
     }
-    return allItems;
+    return { skipped, sources: allItems };
 }
-export async function listDiscoverableWorktreeSources(cwd, repositoryPort, onSkipped) {
+export async function listDiscoverableWorktreeSources(options) {
+    const { cwd, repositoryPort } = options;
     const currentRepository = await repositoryPort
         .detectRepository(cwd)
         .catch(() => null);
-    const registeredSources = await listRegisteredWorktreeSources(cwd, repositoryPort, onSkipped);
-    if (currentRepository === null)
-        return dedupeSources(registeredSources);
+    const registered = await listRegisteredWorktreeSources(options);
+    if (currentRepository === null) {
+        return {
+            skipped: registered.skipped,
+            sources: deduplicateWorktreeSources(registered.sources),
+        };
+    }
     let currentSources = [];
     try {
         currentSources = (await repositoryPort.listWorktrees(cwd)).map((worktree) => ({
@@ -52,9 +63,15 @@ export async function listDiscoverableWorktreeSources(cwd, repositoryPort, onSki
     catch {
         // Registered repositories remain discoverable when the current checkout is transiently unavailable.
     }
-    return dedupeSources([...currentSources, ...registeredSources]);
+    return {
+        skipped: registered.skipped,
+        sources: deduplicateWorktreeSources([
+            ...currentSources,
+            ...registered.sources,
+        ]),
+    };
 }
-function dedupeSources(sources) {
+export function deduplicateWorktreeSources(sources) {
     const seen = new Set();
     return sources.filter((source) => {
         if (seen.has(source.worktree.path))
@@ -63,3 +80,7 @@ function dedupeSources(sources) {
         return true;
     });
 }
+function throwIfAborted(signal) {
+    if (signal?.aborted)
+        throw new Error("Operation cancelled");
+}

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

@@ -1,11 +1,13 @@
+import { type WorktreeCatalogDependencies } from "../../application/worktree/catalog.js";
 import type { WorktreeEntry } from "../../domain/worktree/types.js";
-import { type WorktreePromptEntry } from "../../presentation/worktree/picker.js";
+import { type WorktreePromptEntry, type WorktreePromptScope } from "../../presentation/worktree/picker.js";
 import { type CliRuntime } from "../dependencies.js";
 export interface CleanCommandOptions {
     cwd: string;
     dryRun?: boolean;
     force?: boolean;
     json?: boolean;
+    paths?: string[];
     stale?: boolean;
     runtime?: CliRuntime<"git" | "config" | "configStore" | "slots" | "repositoryContext" | "repositoryRegistry" | "worktrees" | "worktreeInfo" | "worktreeLifecycle" | "worktreeCatalog">;
     stderr: (chunk: string) => void;
@@ -15,7 +17,7 @@ export interface CleanCommandDependencies {
     confirmForceDeleteBranch: (branch: string) => Promise<boolean>;
     confirmForceRemoveWorktree: (worktreePath: string) => Promise<boolean>;
     confirmRemoval: (worktrees: WorktreeEntry[]) => Promise<boolean>;
-    promptForWorktrees: (worktrees: WorktreePromptEntry[]) => Promise<string[] | null>;
+    promptForWorktrees: (worktrees: WorktreePromptEntry[], scope?: WorktreePromptScope, catalog?: WorktreeCatalogDependencies) => Promise<string[] | null>;
 }
 export declare function createCleanCommand(dependencies?: Partial<CleanCommandDependencies>): (options: CleanCommandOptions) => Promise<number>;
 export declare const runCleanCommand: (options: CleanCommandOptions) => Promise<number>;