@solaqua/gji 0.12.4 → 0.13.0

package/dist/{sync.d.ts → cli/commands/sync.d.ts}

@@ -1,7 +1,9 @@
+import { type CliRuntime } from "../dependencies.js";
 export interface SyncCommandOptions {
     all?: boolean;
     cwd: string;
     json?: boolean;
+    runtime?: CliRuntime<"git" | "config" | "repositoryContext" | "worktrees">;
     stderr: (chunk: string) => void;
     stdout: (chunk: string) => void;
 }

package/dist/{sync.js → cli/commands/sync.js}

@@ -1,8 +1,11 @@
-import { loadEffectiveConfig } from "./config.js";
-import { isDirtyWorktree, resolveRemoteBase, runGit, } from "./git.js";
-import { comparePaths } from "./paths.js";
-import { detectRepository, listWorktrees } from "./repo.js";
+import { comparePaths } from "../../domain/shared/paths.js";
+import { defaultCliDependencies } from "../dependencies.js";
 export async function runSyncCommand(options) {
+    const runtime = options.runtime ?? defaultCliDependencies;
+    const { isDirtyWorktree, resolveRemoteBase, runGit } = runtime.git;
+    const { loadEffectiveConfig } = runtime.config;
+    const { detectRepository } = runtime.repositoryContext;
+    const { listWorktrees } = runtime.worktrees;
     const repository = await detectRepository(options.cwd);
     const config = await loadEffectiveConfig(repository.repoRoot, undefined, options.stderr);
     const worktrees = await listWorktrees(options.cwd);

package/dist/{task-command.d.ts → cli/commands/task-command.d.ts}

@@ -1,8 +1,10 @@
+import { type CliRuntime } from "../dependencies.js";
 export interface TaskCommandOptions {
     clear?: boolean;
     cwd: string;
     json?: boolean;
     task?: string;
+    runtime?: CliRuntime<"tasks" | "repositoryContext">;
     stderr: (chunk: string) => void;
     stdout: (chunk: string) => void;
 }

package/dist/{task-command.js → cli/commands/task-command.js}

@@ -1,6 +1,8 @@
-import { detectRepository } from "./repo.js";
-import { clearTask, readTask, writeTask } from "./task.js";
+import { defaultCliDependencies } from "../dependencies.js";
 export async function runTaskCommand(options) {
+    const runtime = options.runtime ?? defaultCliDependencies;
+    const { clearTask, readTask, writeTask } = runtime.tasks;
+    const { detectRepository } = runtime.repositoryContext;
     const repository = await detectRepository(options.cwd);
     if (options.clear && options.task !== undefined)
         return emitTaskError(options, "--clear cannot be combined with a task");

package/dist/{undo.d.ts → cli/commands/undo.d.ts}

@@ -1,4 +1,5 @@
-import { type WorktreeEntry } from "./repo.js";
+import type { WorktreeEntry } from "../../domain/worktree/types.js";
+import { type CliRuntime } from "../dependencies.js";
 export type UndoOperation = "remove" | "clean" | "done";
 export interface UndoEntry {
     branch: string | null;
@@ -25,12 +26,13 @@ export interface UndoCommandOptions {
     id?: string;
     list?: boolean;
     json?: boolean;
+    runtime?: CliRuntime<"git" | "configStore" | "repositoryContext">;
     stderr: (chunk: string) => void;
     stdout: (chunk: string) => void;
 }
-export declare function undoLogPath(home?: string): string;
-export declare function loadUndoRecords(home?: string): Promise<UndoRecord[]>;
-export declare function recordUndoOperation(op: UndoOperation, repoRoot: string, worktrees: WorktreeEntry[], home?: string): Promise<UndoRecord | null>;
-export declare function finalizeUndoOperation(record: UndoRecord, removedWorktrees: WorktreeEntry[], home?: string): Promise<void>;
-export declare function restoreUndoRecord(record: UndoRecord, home?: string): Promise<UndoRestoreResult>;
+export declare function undoLogPath(home?: string, globalConfigDirectory?: ".config/gji"): string;
+export declare function loadUndoRecords(home?: string, globalConfigDirectory?: ".config/gji"): Promise<UndoRecord[]>;
+export declare function recordUndoOperation(op: UndoOperation, repoRoot: string, worktrees: WorktreeEntry[], home?: string, runtime?: CliRuntime<"git" | "configStore">): Promise<UndoRecord | null>;
+export declare function finalizeUndoOperation(record: UndoRecord, removedWorktrees: WorktreeEntry[], home?: string, globalConfigDirectory?: ".config/gji"): Promise<void>;
+export declare function restoreUndoRecord(record: UndoRecord, home?: string, runtime?: CliRuntime<"git" | "configStore">): Promise<UndoRestoreResult>;
 export declare function runUndoCommand(options: UndoCommandOptions): Promise<number>;

package/dist/{undo.js → cli/commands/undo.js}

@@ -2,29 +2,31 @@ import { access, mkdir, open, readFile, rename, stat, unlink, writeFile, } from
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { confirm, isCancel } from "@clack/prompts";
-import { GLOBAL_CONFIG_DIRECTORY } from "./config.js";
-import { isDirtyWorktree, runGit } from "./git.js";
-import { isHeadless } from "./headless.js";
-import { detectRepository } from "./repo.js";
+import { defaultCliDependencies, } from "../dependencies.js";
+import { isHeadless } from "../runtime/headless.js";
 const MAX_UNDO_RECORDS = 20;
 const UNDO_LOCK_STALE_AFTER_MS = 60_000;
 const UNDO_LOCK_RETRY_DELAY_MS = 5;
 const UNDO_LOCK_WAIT_TIMEOUT_MS = UNDO_LOCK_STALE_AFTER_MS + UNDO_LOCK_RETRY_DELAY_MS;
 const undoLogQueues = new Map();
-export function undoLogPath(home = homedir()) {
+export function undoLogPath(home = homedir(), globalConfigDirectory = defaultCliDependencies.configStore
+    .GLOBAL_CONFIG_DIRECTORY) {
     const configured = process.env.GJI_CONFIG_DIR;
-    return join(configured ? resolve(configured) : join(home, GLOBAL_CONFIG_DIRECTORY), "undo-log.json");
+    return join(configured ? resolve(configured) : join(home, globalConfigDirectory), "undo-log.json");
 }
-export async function loadUndoRecords(home = homedir()) {
+export async function loadUndoRecords(home = homedir(), globalConfigDirectory = defaultCliDependencies.configStore
+    .GLOBAL_CONFIG_DIRECTORY) {
     try {
-        const parsed = JSON.parse(await readFile(undoLogPath(home), "utf8"));
+        const parsed = JSON.parse(await readFile(undoLogPath(home, globalConfigDirectory), "utf8"));
         return Array.isArray(parsed) ? parsed.filter(isUndoRecord) : [];
     }
     catch {
         return [];
     }
 }
-export async function recordUndoOperation(op, repoRoot, worktrees, home = homedir()) {
+export async function recordUndoOperation(op, repoRoot, worktrees, home = homedir(), runtime = defaultCliDependencies) {
+    const globalConfigDirectory = runtime.configStore.GLOBAL_CONFIG_DIRECTORY;
+    const { isDirtyWorktree, runGit } = runtime.git;
     const entries = [];
     for (const worktree of worktrees) {
         try {
@@ -64,31 +66,33 @@ export async function recordUndoOperation(op, repoRoot, worktrees, home = homedi
         entries,
     };
     return enqueueUndoLogWrite(home, async () => {
-        const existing = await loadUndoRecords(home);
-        await writeUndoRecords(home, [record, ...existing].slice(0, MAX_UNDO_RECORDS));
+        const existing = await loadUndoRecords(home, globalConfigDirectory);
+        await writeUndoRecords(home, [record, ...existing].slice(0, MAX_UNDO_RECORDS), globalConfigDirectory);
         return record;
-    });
+    }, globalConfigDirectory);
 }
-export async function finalizeUndoOperation(record, removedWorktrees, home = homedir()) {
+export async function finalizeUndoOperation(record, removedWorktrees, home = homedir(), globalConfigDirectory = defaultCliDependencies.configStore
+    .GLOBAL_CONFIG_DIRECTORY) {
     const removedPaths = new Set(removedWorktrees.map((worktree) => worktree.path));
     await enqueueUndoLogWrite(home, async () => {
-        const records = await loadUndoRecords(home);
+        const records = await loadUndoRecords(home, globalConfigDirectory);
         const remaining = records.flatMap((candidate) => {
             if (candidate.id !== record.id)
                 return [candidate];
             const entries = candidate.entries.filter((entry) => removedPaths.has(entry.path));
             return entries.length === 0 ? [] : [{ ...candidate, entries }];
         });
-        await writeUndoRecords(home, remaining);
-    });
+        await writeUndoRecords(home, remaining, globalConfigDirectory);
+    }, globalConfigDirectory);
 }
-export async function restoreUndoRecord(record, home = homedir()) {
+export async function restoreUndoRecord(record, home = homedir(), runtime = defaultCliDependencies) {
+    const globalConfigDirectory = runtime.configStore.GLOBAL_CONFIG_DIRECTORY;
     const restored = [];
     const failed = [];
     const unresolved = [];
     for (const entry of record.entries) {
         try {
-            const upstreamFailure = await restoreUndoEntry(record.repoRoot, entry);
+            const upstreamFailure = await restoreUndoEntry(record.repoRoot, entry, runtime.git.runGit);
             restored.push(entry);
             if (upstreamFailure) {
                 failed.push({ ...entry, message: upstreamFailure });
@@ -101,7 +105,7 @@ export async function restoreUndoRecord(record, home = homedir()) {
         }
     }
     await enqueueUndoLogWrite(home, async () => {
-        const records = await loadUndoRecords(home);
+        const records = await loadUndoRecords(home, globalConfigDirectory);
         const remaining = records.flatMap((candidate) => {
             if (candidate.id !== record.id)
                 return [candidate];
@@ -109,14 +113,17 @@ export async function restoreUndoRecord(record, home = homedir()) {
                 return [];
             return [{ ...candidate, entries: unresolved }];
         });
-        await writeUndoRecords(home, remaining);
-    });
+        await writeUndoRecords(home, remaining, globalConfigDirectory);
+    }, globalConfigDirectory);
     return { restored, failed };
 }
 export async function runUndoCommand(options) {
-    if (await hasMalformedUndoLog())
+    const runtime = options.runtime ?? defaultCliDependencies;
+    const globalConfigDirectory = runtime.configStore.GLOBAL_CONFIG_DIRECTORY;
+    const { detectRepository } = runtime.repositoryContext;
+    if (await hasMalformedUndoLog(globalConfigDirectory))
         options.stderr("Warning: undo journal is invalid; starting with an empty journal\n");
-    const records = await loadUndoRecords();
+    const records = await loadUndoRecords(homedir(), globalConfigDirectory);
     if (options.list) {
         if (options.json)
             options.stdout(`${JSON.stringify(records, null, 2)}\n`);
@@ -167,7 +174,7 @@ export async function runUndoCommand(options) {
     }
     if (!record)
         return emitUndoError(options, `undo record not found: ${options.id}`);
-    const result = await restoreUndoRecord(record);
+    const result = await restoreUndoRecord(record, homedir(), runtime);
     if (options.json)
         options.stdout(`${JSON.stringify({ restored: result.restored.map((entry) => ({ branch: entry.branch, path: entry.path })), failed: result.failed.map((entry) => ({ branch: entry.branch, path: entry.path, error: entry.message })) }, null, 2)}\n`);
     else {
@@ -181,9 +188,10 @@ export async function runUndoCommand(options) {
     }
     return result.failed.length === 0 ? 0 : 1;
 }
-async function hasMalformedUndoLog() {
+async function hasMalformedUndoLog(globalConfigDirectory = defaultCliDependencies.configStore
+    .GLOBAL_CONFIG_DIRECTORY) {
     try {
-        const parsed = JSON.parse(await readFile(undoLogPath(), "utf8"));
+        const parsed = JSON.parse(await readFile(undoLogPath(homedir(), globalConfigDirectory), "utf8"));
         return (!Array.isArray(parsed) || parsed.some((entry) => !isUndoRecord(entry)));
     }
     catch (error) {
@@ -192,7 +200,7 @@ async function hasMalformedUndoLog() {
             error.code !== "ENOENT");
     }
 }
-async function restoreUndoEntry(repoRoot, entry) {
+async function restoreUndoEntry(repoRoot, entry, runGit) {
     try {
         await access(entry.path);
         throw new Error(`path already exists: ${entry.path}`);
@@ -203,7 +211,7 @@ async function restoreUndoEntry(repoRoot, entry) {
             throw error;
     }
     if (entry.branch === null) {
-        await assertCommitExists(repoRoot, entry.headSha);
+        await assertCommitExists(repoRoot, entry.headSha, runGit);
         await runGit(repoRoot, [
             "worktree",
             "add",
@@ -242,7 +250,7 @@ async function restoreUndoEntry(repoRoot, entry) {
             throw new Error(`branch ${entry.branch} already tracks ${existingUpstream}; refusing to overwrite it`);
     }
     else {
-        await assertCommitExists(repoRoot, entry.headSha);
+        await assertCommitExists(repoRoot, entry.headSha, runGit);
         await runGit(repoRoot, ["branch", entry.branch, entry.headSha]);
     }
     try {
@@ -276,7 +284,7 @@ async function restoreUndoEntry(repoRoot, entry) {
     }
     return null;
 }
-async function assertCommitExists(repoRoot, headSha) {
+async function assertCommitExists(repoRoot, headSha, runGit) {
     try {
         await runGit(repoRoot, ["cat-file", "-e", `${headSha}^{commit}`]);
     }
@@ -284,8 +292,9 @@ async function assertCommitExists(repoRoot, headSha) {
         throw new Error("commit no longer exists (gc'd) — cannot restore");
     }
 }
-async function enqueueUndoLogWrite(home, operation) {
-    const path = undoLogPath(home);
+async function enqueueUndoLogWrite(home, operation, globalConfigDirectory = defaultCliDependencies.configStore
+    .GLOBAL_CONFIG_DIRECTORY) {
+    const path = undoLogPath(home, globalConfigDirectory);
     await mkdir(dirname(path), { recursive: true });
     const previous = undoLogQueues.get(path) ?? Promise.resolve();
     const runLocked = async () => {
@@ -332,8 +341,9 @@ async function acquireUndoLogLock(path) {
     }
     throw new Error("timed out waiting for the undo journal lock");
 }
-async function writeUndoRecords(home, records) {
-    const path = undoLogPath(home);
+async function writeUndoRecords(home, records, globalConfigDirectory = defaultCliDependencies.configStore
+    .GLOBAL_CONFIG_DIRECTORY) {
+    const path = undoLogPath(home, globalConfigDirectory);
     await mkdir(dirname(path), { recursive: true });
     const temporaryPath = `${path}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
     try {

package/dist/{warp.d.ts → cli/commands/warp.d.ts}

@@ -1,10 +1,12 @@
-import { type NavigationRepository } from "./navigation-output.js";
-import { type QueryWorktreePullRequests } from "./worktree-picker.js";
+import { type NavigationRepository } from "../../presentation/terminal/navigation.js";
+import { type QueryWorktreePullRequests } from "../../presentation/worktree/picker.js";
+import { type CliRuntime } from "../dependencies.js";
 export interface WarpCommandOptions {
     branch?: string;
     cwd: string;
     json?: boolean;
     queryPullRequests?: QueryWorktreePullRequests;
+    runtime?: CliRuntime<"history" | "repositoryContext" | "repositoryRegistry" | "worktrees" | "worktreeCatalog">;
     stderr: (chunk: string) => void;
     stdout: (chunk: string) => void;
 }
@@ -21,5 +23,6 @@ export declare function resolveWarpTarget(options: {
     excludeRepoRoot?: string;
     json?: boolean;
     queryPullRequests?: QueryWorktreePullRequests;
+    runtime?: CliRuntime<"history" | "repositoryContext" | "repositoryRegistry" | "worktrees" | "worktreeCatalog">;
     stderr: (chunk: string) => void;
 }): Promise<WarpTarget | null>;

package/dist/{warp.js → cli/commands/warp.js}

@@ -1,16 +1,17 @@
-import { isHeadless } from "./headless.js";
-import { recordWorktreeUsage } from "./history.js";
-import { createNavigationRepository, createNavigationTarget, } from "./navigation-output.js";
-import { detectRepository } from "./repo.js";
-import { loadRegistry } from "./repo-registry.js";
-import { writeShellOutput } from "./shell-handoff.js";
-import { buildWorktreePromptEntries, promptForSingleWorktree, resolveWorktreeQuery, } from "./worktree-picker.js";
-import { listRegisteredWorktreeSources } from "./worktree-sources.js";
+import { listRegisteredWorktreeSources } from "../../application/worktree/sources.js";
+import { resolveWorktreeQuery } from "../../domain/worktree/matching.js";
+import { writeShellOutput } from "../../presentation/shell/handoff.js";
+import { createNavigationRepository, createNavigationTarget, } from "../../presentation/terminal/navigation.js";
+import { buildWorktreePromptEntries, promptForSingleWorktree, } from "../../presentation/worktree/picker.js";
+import { defaultCliDependencies, withPullRequestQueries, } from "../dependencies.js";
+import { isHeadless } from "../runtime/headless.js";
 const WARP_OUTPUT_FILE_ENV = "GJI_WARP_OUTPUT_FILE";
 export async function runWarpCommand(options) {
     return runWarpNavigate(options);
 }
 async function runWarpNavigate(options) {
+    const runtime = options.runtime ?? defaultCliDependencies;
+    const { recordWorktreeUsage } = runtime.history;
     if ((isHeadless() || options.json) && !options.branch) {
         const message = "branch argument is required";
         if (options.json) {
@@ -26,6 +27,7 @@ async function runWarpNavigate(options) {
         commandName: "gji warp",
         json: options.json,
         queryPullRequests: options.queryPullRequests,
+        runtime,
     });
     if (!target)
         return 1;
@@ -40,6 +42,14 @@ async function runWarpNavigate(options) {
 }
 export async function resolveWarpTarget(options) {
     const cmd = options.commandName ?? "gji";
+    const runtime = options.runtime ?? defaultCliDependencies;
+    const { detectRepository } = runtime.repositoryContext;
+    const { loadRegistry } = runtime.repositoryRegistry;
+    const sourceDependencies = {
+        ...runtime.repositoryContext,
+        ...runtime.repositoryRegistry,
+        ...runtime.worktrees,
+    };
     const emitError = (message, hint) => {
         if (options.json) {
             options.stderr(`${JSON.stringify({ error: message }, null, 2)}\n`);
@@ -56,7 +66,7 @@ export async function resolveWarpTarget(options) {
         return null;
     }
     let skippedRegisteredRepos = 0;
-    const allItems = (await listRegisteredWorktreeSources(options.cwd, () => {
+    const allItems = (await listRegisteredWorktreeSources(options.cwd, sourceDependencies, () => {
         skippedRegisteredRepos++;
     })).filter((item) => item.repoRoot !== options.excludeRepoRoot);
     if (allItems.length === 0) {
@@ -87,7 +97,7 @@ export async function resolveWarpTarget(options) {
     }
     const promptEntries = await buildWorktreePromptEntries(promptSources, {
         metadata: "fast",
-        queryPullRequests: options.queryPullRequests,
+        catalog: withPullRequestQueries(runtime, options.queryPullRequests),
     });
     const path = await promptForWarpTarget(promptEntries);
     if (!path) {

package/dist/cli/dependencies.d.ts

@@ -0,0 +1,114 @@
+import type { WorktreeCatalogDependencies } from "../application/worktree/catalog.js";
+import type { ContextCardDependencies } from "../application/worktree/context-card.js";
+import { validateSyncFilePattern } from "../infrastructure/filesystem/file-sync.js";
+import { isDirtyWorktree, readWorktreeHealth } from "../infrastructure/git/health.js";
+import { isBranchMergedInto, readBranchLastCommitTimestamp, resolveRemoteBase, resolveRemoteDefaultBranch } from "../infrastructure/git/refs.js";
+import { openBrowser } from "../infrastructure/integrations/browser.js";
+import { defaultSpawnEditor, EDITORS } from "../infrastructure/integrations/editor.js";
+import { GLOBAL_CONFIG_DIRECTORY, GLOBAL_CONFIG_FILE_PATH, KNOWN_CONFIG_KEYS, KNOWN_GLOBAL_CONFIG_KEYS, loadConfig, loadGlobalConfig, parseConfigValue, saveGlobalConfig, saveLocalConfig, unsetGlobalConfigKey, updateGlobalConfigKey } from "../infrastructure/persistence/config.js";
+import { appendHistory, loadHistory, recordWorktreeUsage } from "../infrastructure/persistence/history.js";
+import { assignWorktreeSlot, getWorktreeSlot, loadSlots, releaseWorktreeSlot } from "../infrastructure/persistence/slots.js";
+import { clearTask, readTask, writeTask } from "../infrastructure/persistence/task.js";
+import { extractHooks, runHook } from "../infrastructure/process/hooks.js";
+import { loadRegistry, REGISTRY_FILE_PATH, registerRepo, removeMissingRegistryEntries } from "../infrastructure/repository/registry.js";
+import { readWorktreeInfo, readWorktreeInfos, serializeWorktreeInfo } from "../infrastructure/worktree/info.js";
+import { deleteBranch, forceDeleteBranch, forceRemoveWorktree, isBranchUnmergedError, isSubmoduleWorktreeRemovalError, isWorktreeDeletionError, isWorktreeForceRemovalError, removeWorktree } from "../infrastructure/worktree/lifecycle.js";
+import type { DependencyBootstrapPort, WorktreeBootstrapPort } from "../ports/bootstrap.js";
+import type { ConfigPort } from "../ports/config.js";
+import type { GitCommandPort } from "../ports/git.js";
+import type { PullRequestPort } from "../ports/pull-requests.js";
+import type { RepositoryContextPort, RepositoryRefPort, RepositoryRegistryPort, WorktreePort } from "../ports/repository.js";
+import { formatLastCommit, formatRelativeAge, formatUpstreamState } from "../presentation/worktree/format.js";
+export interface CliDependencies {
+    config: ConfigPort;
+    repositoryContext: RepositoryContextPort;
+    repositoryRefs: RepositoryRefPort;
+    repositoryRegistry: RepositoryRegistryPort;
+    worktrees: WorktreePort;
+    worktreeCatalog: WorktreeCatalogDependencies;
+    contextCard: ContextCardDependencies;
+    pullRequests: PullRequestPort;
+    history: {
+        recordWorktreeUsage: typeof recordWorktreeUsage;
+    };
+    slots: {
+        getWorktreeSlot: typeof getWorktreeSlot;
+        loadSlots: typeof loadSlots;
+        assignWorktreeSlot: typeof assignWorktreeSlot;
+        releaseWorktreeSlot: typeof releaseWorktreeSlot;
+    };
+    hooks: {
+        extractHooks: typeof extractHooks;
+        runHook: typeof runHook;
+    };
+    git: GitCommandPort & {
+        isDirtyWorktree: typeof isDirtyWorktree;
+        readWorktreeHealth: typeof readWorktreeHealth;
+        isBranchMergedInto: typeof isBranchMergedInto;
+        readBranchLastCommitTimestamp: typeof readBranchLastCommitTimestamp;
+        resolveRemoteBase: typeof resolveRemoteBase;
+        resolveRemoteDefaultBranch: typeof resolveRemoteDefaultBranch;
+    };
+    configStore: {
+        loadConfig: typeof loadConfig;
+        loadGlobalConfig: typeof loadGlobalConfig;
+        saveGlobalConfig: typeof saveGlobalConfig;
+        saveLocalConfig: typeof saveLocalConfig;
+        updateGlobalConfigKey: typeof updateGlobalConfigKey;
+        parseConfigValue: typeof parseConfigValue;
+        unsetGlobalConfigKey: typeof unsetGlobalConfigKey;
+        GLOBAL_CONFIG_FILE_PATH: typeof GLOBAL_CONFIG_FILE_PATH;
+        GLOBAL_CONFIG_DIRECTORY: typeof GLOBAL_CONFIG_DIRECTORY;
+        CONFIG_FILE_NAME: typeof import("../infrastructure/persistence/config.js").CONFIG_FILE_NAME;
+        KNOWN_CONFIG_KEYS: typeof KNOWN_CONFIG_KEYS;
+        KNOWN_GLOBAL_CONFIG_KEYS: typeof KNOWN_GLOBAL_CONFIG_KEYS;
+    };
+    tasks: {
+        readTask: typeof readTask;
+        writeTask: typeof writeTask;
+        clearTask: typeof clearTask;
+    };
+    historyStore: {
+        loadHistory: typeof loadHistory;
+        appendHistory: typeof appendHistory;
+    };
+    registry: {
+        loadRegistry: typeof loadRegistry;
+        registerRepo: typeof registerRepo;
+        REGISTRY_FILE_PATH: typeof REGISTRY_FILE_PATH;
+        removeMissingRegistryEntries: typeof removeMissingRegistryEntries;
+    };
+    worktreeLifecycle: {
+        deleteBranch: typeof deleteBranch;
+        forceDeleteBranch: typeof forceDeleteBranch;
+        forceRemoveWorktree: typeof forceRemoveWorktree;
+        removeWorktree: typeof removeWorktree;
+        isBranchUnmergedError: typeof isBranchUnmergedError;
+        isSubmoduleWorktreeRemovalError: typeof isSubmoduleWorktreeRemovalError;
+        isWorktreeDeletionError: typeof isWorktreeDeletionError;
+        isWorktreeForceRemovalError: typeof isWorktreeForceRemovalError;
+    };
+    worktreeInfo: {
+        readWorktreeInfo: typeof readWorktreeInfo;
+        readWorktreeInfos: typeof readWorktreeInfos;
+        serializeWorktreeInfo: typeof serializeWorktreeInfo;
+        formatLastCommit: typeof formatLastCommit;
+        formatRelativeAge: typeof formatRelativeAge;
+        formatUpstreamState: typeof formatUpstreamState;
+    };
+    bootstrap: {
+        bootstrapWorktree: WorktreeBootstrapPort["bootstrapWorktree"];
+    } & DependencyBootstrapPort;
+    integrations: {
+        openBrowser: typeof openBrowser;
+        defaultSpawnEditor: typeof defaultSpawnEditor;
+        EDITORS: typeof EDITORS;
+    };
+    filesystem: {
+        validateSyncFilePattern: typeof validateSyncFilePattern;
+    };
+}
+export type CliRuntime<Keys extends keyof CliDependencies> = Pick<CliDependencies, Keys>;
+export declare function createCliDependencies(): CliDependencies;
+export declare const defaultCliDependencies: CliDependencies;
+export declare function withPullRequestQueries(dependencies: CliRuntime<"worktreeCatalog">, queryPullRequests?: WorktreeCatalogDependencies["queryPullRequests"], queryRepositoryPullRequests?: WorktreeCatalogDependencies["queryRepositoryPullRequests"]): WorktreeCatalogDependencies;

package/dist/cli/dependencies.js

@@ -0,0 +1,118 @@
+import { prepareDependencyBootstrap, previewDependencyBootstrap, resolveDependencyBootstrapMode, } from "../infrastructure/bootstrap/dependency-bootstrap.js";
+import { validateSyncFilePattern } from "../infrastructure/filesystem/file-sync.js";
+import { isDirtyWorktree, readWorktreeHealth, } from "../infrastructure/git/health.js";
+import { isBranchMergedInto, readBranchLastCommitTimestamp, resolveRemoteBase, resolveRemoteDefaultBranch, } from "../infrastructure/git/refs.js";
+import { runGit, runGitRaw } from "../infrastructure/git/runner.js";
+import { openBrowser } from "../infrastructure/integrations/browser.js";
+import { defaultSpawnEditor, EDITORS, } from "../infrastructure/integrations/editor.js";
+import { createPullRequestQuery } from "../infrastructure/integrations/pull-requests.js";
+import { CONFIG_FILE_NAME, GLOBAL_CONFIG_DIRECTORY, GLOBAL_CONFIG_FILE_PATH, KNOWN_CONFIG_KEYS, KNOWN_GLOBAL_CONFIG_KEYS, loadConfig, loadGlobalConfig, parseConfigValue, saveGlobalConfig, saveLocalConfig, unsetGlobalConfigKey, updateGlobalConfigKey, } from "../infrastructure/persistence/config.js";
+import { appendHistory, loadHistory, recordWorktreeUsage, } from "../infrastructure/persistence/history.js";
+import { assignWorktreeSlot, getWorktreeSlot, loadSlots, releaseWorktreeSlot, } from "../infrastructure/persistence/slots.js";
+import { clearTask, readTask, writeTask, } from "../infrastructure/persistence/task.js";
+import { extractHooks, runHook } from "../infrastructure/process/hooks.js";
+import { configPort, repositoryContextPort, repositoryRefPort, repositoryRegistryPort, worktreePort, } from "../infrastructure/repository/adapters.js";
+import { loadRegistry, REGISTRY_FILE_PATH, registerRepo, removeMissingRegistryEntries, } from "../infrastructure/repository/registry.js";
+import { bootstrapWorktree } from "../infrastructure/worktree/bootstrap.js";
+import { readWorktreeInfo, readWorktreeInfos, serializeWorktreeInfo, } from "../infrastructure/worktree/info.js";
+import { deleteBranch, forceDeleteBranch, forceRemoveWorktree, isBranchUnmergedError, isSubmoduleWorktreeRemovalError, isWorktreeDeletionError, isWorktreeForceRemovalError, removeWorktree, } from "../infrastructure/worktree/lifecycle.js";
+import { formatLastCommit, formatRelativeAge, formatUpstreamState, } from "../presentation/worktree/format.js";
+export function createCliDependencies() {
+    const pullRequests = createPullRequestQuery();
+    return {
+        config: configPort,
+        repositoryContext: repositoryContextPort,
+        repositoryRefs: repositoryRefPort,
+        repositoryRegistry: repositoryRegistryPort,
+        worktrees: worktreePort,
+        worktreeCatalog: {
+            loadHistory: () => loadHistory(),
+            readTask,
+            readWorktreeInfos,
+            queryPullRequests: pullRequests.listOpenPullRequests,
+            queryRepositoryPullRequests: pullRequests.listOpenPullRequestsForRepository,
+        },
+        contextCard: {
+            listWorktrees: worktreePort.listWorktrees,
+            readTask,
+            readWorktreeInfo,
+        },
+        pullRequests,
+        history: { recordWorktreeUsage },
+        slots: {
+            getWorktreeSlot,
+            loadSlots,
+            assignWorktreeSlot,
+            releaseWorktreeSlot,
+        },
+        hooks: { extractHooks, runHook },
+        git: {
+            runGit,
+            runGitRaw,
+            isDirtyWorktree,
+            readWorktreeHealth,
+            isBranchMergedInto,
+            readBranchLastCommitTimestamp,
+            resolveRemoteBase,
+            resolveRemoteDefaultBranch,
+        },
+        configStore: {
+            loadConfig,
+            loadGlobalConfig,
+            saveGlobalConfig,
+            saveLocalConfig,
+            updateGlobalConfigKey,
+            parseConfigValue,
+            unsetGlobalConfigKey,
+            GLOBAL_CONFIG_FILE_PATH,
+            GLOBAL_CONFIG_DIRECTORY,
+            CONFIG_FILE_NAME,
+            KNOWN_CONFIG_KEYS,
+            KNOWN_GLOBAL_CONFIG_KEYS,
+        },
+        tasks: { readTask, writeTask, clearTask },
+        historyStore: { loadHistory, appendHistory },
+        registry: {
+            loadRegistry,
+            registerRepo,
+            REGISTRY_FILE_PATH,
+            removeMissingRegistryEntries,
+        },
+        worktreeLifecycle: {
+            deleteBranch,
+            forceDeleteBranch,
+            forceRemoveWorktree,
+            removeWorktree,
+            isBranchUnmergedError,
+            isSubmoduleWorktreeRemovalError,
+            isWorktreeDeletionError,
+            isWorktreeForceRemovalError,
+        },
+        worktreeInfo: {
+            readWorktreeInfo,
+            readWorktreeInfos,
+            serializeWorktreeInfo,
+            formatLastCommit,
+            formatRelativeAge,
+            formatUpstreamState,
+        },
+        bootstrap: {
+            bootstrapWorktree,
+            resolveMode: resolveDependencyBootstrapMode,
+            preview: async (mode, context) => previewDependencyBootstrap(await prepareDependencyBootstrap(mode, context)),
+        },
+        integrations: { openBrowser, defaultSpawnEditor, EDITORS },
+        filesystem: { validateSyncFilePattern },
+    };
+}
+export const defaultCliDependencies = createCliDependencies();
+export function withPullRequestQueries(dependencies, queryPullRequests, queryRepositoryPullRequests) {
+    return {
+        ...dependencies.worktreeCatalog,
+        queryPullRequests: queryPullRequests ?? dependencies.worktreeCatalog.queryPullRequests,
+        queryRepositoryPullRequests: queryRepositoryPullRequests ??
+            (queryPullRequests === undefined
+                ? dependencies.worktreeCatalog.queryRepositoryPullRequests
+                : undefined),
+    };
+}

package/dist/{cli.d.ts → cli/program.d.ts}

@@ -1,6 +1,7 @@
 import { Command } from "commander";
-import { type HubCommandDependencies } from "./hub.js";
-import { type PrOpenCommandDependencies } from "./pr-open.js";
+import { type HubCommandDependencies } from "./commands/hub.js";
+import { type PrOpenCommandDependencies } from "./commands/pr-open.js";
+import { type CliDependencies } from "./dependencies.js";
 export interface RunCliOptions {
     columns?: number;
     cwd?: string;
@@ -9,6 +10,7 @@ export interface RunCliOptions {
     hubDependencies?: Partial<HubCommandDependencies>;
     stderr?: (chunk: string) => void;
     stdout?: (chunk: string) => void;
+    dependencies?: CliDependencies;
 }
 export interface RunCliResult {
     exitCode: number;