@solaqua/gji 0.12.4 → 0.13.0

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

@@ -1,5 +1,6 @@
-import { type EditorDefinition } from "./editor.js";
-import { type QueryWorktreePullRequests, type WorktreePromptEntry } from "./worktree-picker.js";
+import type { EditorDefinition } from "../../ports/editor.js";
+import { type QueryWorktreePullRequests, type WorktreePromptEntry } from "../../presentation/worktree/picker.js";
+import { type CliRuntime } from "../dependencies.js";
 export type { EditorDefinition };
 export interface OpenCommandOptions {
     branch?: string;
@@ -7,6 +8,7 @@ export interface OpenCommandOptions {
     editor?: string;
     save?: boolean;
     select?: boolean;
+    runtime?: CliRuntime<"history" | "config" | "repositoryContext" | "worktrees" | "integrations" | "configStore" | "worktreeCatalog">;
     stderr: (chunk: string) => void;
     stdout: (chunk: string) => void;
     workspace?: boolean;

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

@@ -3,19 +3,24 @@ import { access, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { promisify } from "node:util";
 import { isCancel, select } from "@clack/prompts";
-import { loadEffectiveConfig, resolveConfigString, updateGlobalConfigKey, } from "./config.js";
-import { defaultSpawnEditor, EDITORS, } from "./editor.js";
-import { isHeadless } from "./headless.js";
-import { recordWorktreeUsage } from "./history.js";
-import { detectRepository, listWorktrees } from "./repo.js";
-import { buildWorktreePromptEntries, promptForSingleWorktree, resolveWorktreeQuery, } from "./worktree-picker.js";
+import { resolveWorktreeQuery } from "../../domain/worktree/matching.js";
+import { buildWorktreePromptEntries, promptForSingleWorktree, } from "../../presentation/worktree/picker.js";
+import { defaultCliDependencies, withPullRequestQueries, } from "../dependencies.js";
+import { isHeadless } from "../runtime/headless.js";
 const execFileAsync = promisify(execFile);
 export function createOpenCommand(dependencies = {}) {
-    const detectEditors = dependencies.detectEditors ?? detectInstalledEditors;
     const promptForEditor = dependencies.promptForEditor ?? defaultPromptForEditor;
     const promptForWorktree = dependencies.promptForWorktree ?? defaultPromptForWorktree;
-    const spawnEditor = dependencies.spawnEditor ?? defaultSpawnEditor;
     return async function runOpenCommand(options) {
+        const runtime = options.runtime ?? defaultCliDependencies;
+        const { recordWorktreeUsage } = runtime.history;
+        const { detectRepository } = runtime.repositoryContext;
+        const { listWorktrees } = runtime.worktrees;
+        const { defaultSpawnEditor, EDITORS } = runtime.integrations;
+        const detectEditors = dependencies.detectEditors ?? (() => detectInstalledEditors(EDITORS));
+        const { loadEffectiveConfig, resolveConfigString } = runtime.config;
+        const { updateGlobalConfigKey } = runtime.configStore;
+        const spawnEditorWithRuntime = dependencies.spawnEditor ?? defaultSpawnEditor;
         if (options.select && options.branch !== undefined) {
             options.stderr("gji open: --select cannot be used with a branch\n");
             return 1;
@@ -57,7 +62,9 @@ export function createOpenCommand(dependencies = {}) {
                 repoRoot: repository.repoRoot,
                 repoName: repository.repoName,
                 worktree,
-            })), { queryPullRequests: dependencies.queryPullRequests });
+            })), {
+                catalog: withPullRequestQueries(runtime, dependencies.queryPullRequests),
+            });
             const chosen = await promptForWorktree(entries);
             if (!chosen) {
                 options.stderr("Aborted\n");
@@ -118,7 +125,7 @@ export function createOpenCommand(dependencies = {}) {
         }
         args.push(openTarget);
         try {
-            await spawnEditor(editorCli, args);
+            await spawnEditorWithRuntime(editorCli, args);
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -132,8 +139,8 @@ export function createOpenCommand(dependencies = {}) {
     };
 }
 export const runOpenCommand = createOpenCommand();
-async function detectInstalledEditors() {
-    const results = await Promise.all(EDITORS.map(async (editor) => ({
+async function detectInstalledEditors(editors) {
+    const results = await Promise.all(editors.map(async (editor) => ({
         editor,
         available: await isCommandAvailable(editor.cli),
     })));

package/dist/{pr-open.d.ts → cli/commands/pr-open.d.ts}

@@ -1,11 +1,13 @@
-import { type PullRequestInfo } from "./pull-requests.js";
-import { type QueryRepositoryPullRequests, type QueryWorktreePullRequests, type WorktreePromptEntry } from "./worktree-picker.js";
+import type { PullRequestInfo } from "../../ports/pull-requests.js";
+import { type QueryRepositoryPullRequests, type QueryWorktreePullRequests, type WorktreePromptEntry } from "../../presentation/worktree/picker.js";
+import { type CliRuntime } from "../dependencies.js";
 export interface PrOpenCommandOptions {
     cwd: string;
     stderr: (chunk: string) => void;
     stdout: (chunk: string) => void;
     select?: boolean;
     target?: string;
+    runtime?: CliRuntime<"pullRequests" | "repositoryContext" | "worktrees" | "integrations" | "worktreeCatalog">;
 }
 export interface PrOpenCommandDependencies {
     findOpenPullRequest: (repoRoot: string, number: number) => Promise<PullRequestInfo | null>;

package/dist/{pr-open.js → cli/commands/pr-open.js}

@@ -1,21 +1,23 @@
 import { isCancel, select } from "@clack/prompts";
-import { openBrowser } from "./browser.js";
-import { isHeadless } from "./headless.js";
-import { createPullRequestQuery, } from "./pull-requests.js";
-import { detectRepository, listWorktrees } from "./repo.js";
-import { buildWorktreePromptEntries, promptForSingleWorktree, resolveWorktreeQuery, } from "./worktree-picker.js";
+import { resolveWorktreeQuery } from "../../domain/worktree/matching.js";
+import { buildWorktreePromptEntries, promptForSingleWorktree, } from "../../presentation/worktree/picker.js";
+import { defaultCliDependencies, withPullRequestQueries, } from "../dependencies.js";
+import { isHeadless } from "../runtime/headless.js";
 export function createPrOpenCommand(dependencies = {}) {
-    const query = createPullRequestQuery();
-    const findOpenPullRequest = dependencies.findOpenPullRequest ?? query.findOpenPullRequest;
-    const openInBrowser = dependencies.openBrowser ?? openBrowser;
     const promptForPullRequest = dependencies.promptForPullRequest ?? defaultPromptForPullRequest;
     const promptForWorktree = dependencies.promptForWorktree ?? defaultPromptForWorktree;
-    const queryPullRequests = dependencies.queryPullRequests ?? query.listOpenPullRequests;
-    const queryRepositoryPullRequests = dependencies.queryRepositoryPullRequests ??
-        (dependencies.queryPullRequests === undefined
-            ? query.listOpenPullRequestsForRepository
-            : undefined);
     return async function runPrOpenCommand(options) {
+        const runtime = options.runtime ?? defaultCliDependencies;
+        const query = runtime.pullRequests;
+        const { detectRepository } = runtime.repositoryContext;
+        const { listWorktrees } = runtime.worktrees;
+        const openInBrowser = dependencies.openBrowser ?? runtime.integrations.openBrowser;
+        const findOpenPullRequest = dependencies.findOpenPullRequest ?? query.findOpenPullRequest;
+        const queryPullRequests = dependencies.queryPullRequests ?? query.listOpenPullRequests;
+        const queryRepositoryPullRequests = dependencies.queryRepositoryPullRequests ??
+            (dependencies.queryPullRequests === undefined
+                ? query.listOpenPullRequestsForRepository
+                : undefined);
         if (options.select && options.target !== undefined) {
             options.stderr("gji pr open: --select cannot be used with a target\n");
             return 1;
@@ -32,9 +34,9 @@ export function createPrOpenCommand(dependencies = {}) {
             return 1;
         if (options.target === undefined) {
             if (!options.select) {
-                return openCurrentWorktree(repository.repoRoot, options, queryPullRequests, promptForPullRequest, openInBrowser);
+                return openCurrentWorktree(repository.repoRoot, options, listWorktrees, queryPullRequests, promptForPullRequest, openInBrowser);
             }
-            return openFromWorktreeSelector(repository.repoRoot, repository.repoName, options, promptForWorktree, promptForPullRequest, queryPullRequests, queryRepositoryPullRequests, openInBrowser);
+            return openFromWorktreeSelector(repository.repoRoot, repository.repoName, options, listWorktrees, promptForWorktree, promptForPullRequest, queryPullRequests, queryRepositoryPullRequests, openInBrowser, runtime);
         }
         const number = parsePrNumberTarget(options.target);
         if (number !== null) {
@@ -59,7 +61,7 @@ export function createPrOpenCommand(dependencies = {}) {
     };
 }
 export const runPrOpenCommand = createPrOpenCommand();
-async function openCurrentWorktree(repoRoot, options, queryPullRequests, promptForPullRequest, openInBrowser) {
+async function openCurrentWorktree(repoRoot, options, listWorktrees, queryPullRequests, promptForPullRequest, openInBrowser) {
     const worktrees = await listWorktrees(options.cwd).catch((error) => {
         options.stderr(`gji pr open: unable to list worktrees: ${formatError(error)}\n`);
         return null;
@@ -91,7 +93,7 @@ async function openCurrentWorktree(repoRoot, options, queryPullRequests, promptF
     }
     return openPullRequests(pullRequests, options, promptForPullRequest, openInBrowser);
 }
-async function openFromWorktreeSelector(repoRoot, repoName, options, promptForWorktree, promptForPullRequest, queryPullRequests, queryRepositoryPullRequests, openInBrowser) {
+async function openFromWorktreeSelector(repoRoot, repoName, options, listWorktrees, promptForWorktree, promptForPullRequest, queryPullRequests, queryRepositoryPullRequests, openInBrowser, runtime) {
     const worktrees = await listWorktrees(options.cwd).catch((error) => {
         options.stderr(`gji pr open: unable to list worktrees: ${formatError(error)}\n`);
         return null;
@@ -128,7 +130,7 @@ async function openFromWorktreeSelector(repoRoot, repoName, options, promptForWo
     }
     const { pullRequestsByBranch, sources } = connectedWorktrees;
     const entries = await buildWorktreePromptEntries(sources, {
-        queryPullRequests: async (_root, branch) => pullRequestsByBranch.get(branch) ?? [],
+        catalog: withPullRequestQueries(runtime, async (_root, branch) => pullRequestsByBranch.get(branch) ?? []),
     });
     const connectedEntries = entries.filter((entry) => (entry.pullRequests?.length ?? 0) > 0);
     if (connectedEntries.length === 0) {

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

@@ -1,5 +1,6 @@
-import { type PathConflictChoice } from "./conflict.js";
-import { type BootstrapCommandRunner } from "./dependency-bootstrap.js";
+import type { CommandRunner as BootstrapCommandRunner } from "../../ports/process.js";
+import { type PathConflictChoice } from "../../presentation/prompts/path-conflict.js";
+import { type CliRuntime } from "../dependencies.js";
 export type { PathConflictChoice };
 export interface PrCommandOptions {
     cwd: string;
@@ -10,11 +11,12 @@ export interface PrCommandOptions {
     outputEnv?: string;
     stderr: (chunk: string) => void;
     stdout: (chunk: string) => void;
+    runtime?: PrRuntime;
 }
+type PrRuntime = CliRuntime<"bootstrap" | "config" | "git" | "history" | "repositoryContext">;
 export interface PrCommandDependencies {
     promptForPathConflict: (path: string) => Promise<PathConflictChoice>;
     runCommand: BootstrapCommandRunner;
 }
-export declare function parsePrInput(input: string): string | null;
 export declare function createPrCommand(dependencies?: Partial<PrCommandDependencies>): (options: PrCommandOptions) => Promise<number>;
 export declare const runPrCommand: (options: PrCommandOptions) => Promise<number>;

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

@@ -1,34 +1,19 @@
-import { execFile } from "node:child_process";
 import { mkdir } from "node:fs/promises";
 import { dirname } from "node:path";
-import { promisify } from "node:util";
-import { createBootstrapReporter } from "./bootstrap-output.js";
-import { createDependencyBootstrapPreview, formatDependencyBootstrapPreview, } from "./bootstrap-preview.js";
-import { loadEffectiveConfig, resolveConfigString, } from "./config.js";
-import { pathExists, promptForPathConflict, } from "./conflict.js";
-import { resolveDependencyBootstrapMode, } from "./dependency-bootstrap.js";
-import { isHeadless } from "./headless.js";
-import { recordWorktreeUsage } from "./history.js";
-import { createNavigationRepository, createNavigationTarget, } from "./navigation-output.js";
-import { detectRepository, resolveWorktreePath } from "./repo.js";
-import { writeShellOutput } from "./shell-handoff.js";
-import { bootstrapWorktree } from "./worktree-bootstrap.js";
-const execFileAsync = promisify(execFile);
+import { resolveWorktreePath } from "../../domain/worktree/policy.js";
+import { parsePrInput } from "../../domain/worktree/pr-reference.js";
+import { createBootstrapReporter } from "../../presentation/bootstrap/output.js";
+import { formatDependencyBootstrapPreview } from "../../presentation/bootstrap/preview.js";
+import { pathExists, promptForPathConflict, } from "../../presentation/prompts/path-conflict.js";
+import { writeShellOutput } from "../../presentation/shell/handoff.js";
+import { createNavigationRepository, createNavigationTarget, } from "../../presentation/terminal/navigation.js";
+import { defaultCliDependencies, } from "../dependencies.js";
+import { isHeadless } from "../runtime/headless.js";
 const PR_OUTPUT_FILE_ENV = "GJI_PR_OUTPUT_FILE";
-export function parsePrInput(input) {
-    if (/^\d+$/.test(input))
-        return input;
-    const hashMatch = input.match(/^#(\d+)$/);
-    if (hashMatch)
-        return hashMatch[1];
-    const urlMatch = input.match(/\/(?:pull|pull-requests|merge_requests)\/(\d+)/);
-    if (urlMatch)
-        return urlMatch[1];
-    return null;
-}
 export function createPrCommand(dependencies = {}) {
     const prompt = dependencies.promptForPathConflict ?? promptForPathConflict;
     return async function runPrCommand(options) {
+        const runtime = options.runtime ?? defaultCliDependencies;
         const prNumber = parsePrInput(options.number);
         if (!prNumber) {
             const message = `Invalid PR reference: ${options.number}`;
@@ -40,10 +25,10 @@ export function createPrCommand(dependencies = {}) {
             }
             return 1;
         }
-        const repository = await detectRepository(options.cwd);
+        const repository = await runtime.repositoryContext.detectRepository(options.cwd);
         let config;
         try {
-            config = await loadEffectiveConfig(repository.repoRoot, undefined, options.json ? undefined : options.stderr);
+            config = await runtime.config.loadEffectiveConfig(repository.repoRoot, undefined, options.json ? undefined : options.stderr);
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -57,7 +42,7 @@ export function createPrCommand(dependencies = {}) {
         }
         const branchName = `pr/${prNumber}`;
         const remoteRef = `refs/remotes/origin/pull/${prNumber}/head`;
-        const rawBasePath = resolveConfigString(config, "worktreePath");
+        const rawBasePath = runtime.config.resolveConfigString(config, "worktreePath");
         const configuredBasePath = rawBasePath?.startsWith("/") || rawBasePath?.startsWith("~")
             ? rawBasePath
             : undefined;
@@ -76,16 +61,16 @@ export function createPrCommand(dependencies = {}) {
             }
             const choice = await prompt(worktreePath);
             if (choice === "reuse") {
-                await recordWorktreeUsage(worktreePath, branchName);
+                await runtime.history.recordWorktreeUsage(worktreePath, branchName);
                 await writeOutput(worktreePath, options.stdout, options.outputEnv);
                 return 0;
             }
             options.stderr(`Aborted because target worktree path already exists: ${worktreePath}\n`);
             return 1;
         }
-        const dependencyMode = resolveDependencyBootstrapMode(config.dependencyBootstrap, options.noInstall);
+        const dependencyMode = runtime.bootstrap.resolveMode(config.dependencyBootstrap, options.noInstall);
         const dryRunDependencyBootstrap = options.dryRun
-            ? await createDependencyBootstrapPreview(dependencyMode, {
+            ? await runtime.bootstrap.preview(dependencyMode, {
                 currentRoot: repository.currentRoot,
                 repoRoot: repository.repoRoot,
                 cargoBuildCommand: config.dependencyBuildCommand,
@@ -108,7 +93,7 @@ export function createPrCommand(dependencies = {}) {
             return 0;
         }
         try {
-            await fetchPullRequestRef(repository.repoRoot, options.number, prNumber, remoteRef);
+            await fetchPullRequestRef(repository.repoRoot, options.number, prNumber, remoteRef, runtime);
         }
         catch {
             const message = `Failed to fetch PR #${prNumber} from origin`;
@@ -122,12 +107,12 @@ export function createPrCommand(dependencies = {}) {
             return 1;
         }
         await mkdir(dirname(worktreePath), { recursive: true });
-        const branchAlreadyExists = await localBranchExists(repository.repoRoot, branchName);
+        const branchAlreadyExists = await localBranchExists(repository.repoRoot, branchName, runtime);
         const worktreeArgs = branchAlreadyExists
             ? ["worktree", "add", worktreePath, branchName]
             : ["worktree", "add", "-b", branchName, worktreePath, remoteRef];
-        await execFileAsync("git", worktreeArgs, { cwd: repository.repoRoot });
-        const bootstrap = await bootstrapWorktree({
+        await runtime.git.runGit(repository.repoRoot, worktreeArgs);
+        const bootstrap = await runtime.bootstrap.bootstrapWorktree({
             branch: branchName,
             config,
             currentRoot: repository.currentRoot,
@@ -138,7 +123,6 @@ export function createPrCommand(dependencies = {}) {
             runCommand: dependencies.runCommand,
             commandStdout: options.json ? () => undefined : options.stdout,
             commandStderr: options.json ? () => undefined : options.stderr,
-            json: options.json,
             worktreePath,
         });
         if (!bootstrap.ready) {
@@ -165,15 +149,20 @@ export function createPrCommand(dependencies = {}) {
             options.stdout(`${JSON.stringify(output, null, 2)}\n`);
         }
         else {
-            await recordWorktreeUsage(worktreePath, branchName);
+            await runtime.history.recordWorktreeUsage(worktreePath, branchName);
             await writeOutput(worktreePath, options.stdout, options.outputEnv);
         }
         return 0;
     };
 }
-async function localBranchExists(repoRoot, branchName) {
+async function localBranchExists(repoRoot, branchName, runtime) {
     try {
-        await execFileAsync("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`], { cwd: repoRoot });
+        await runtime.git.runGit(repoRoot, [
+            "show-ref",
+            "--verify",
+            "--quiet",
+            `refs/heads/${branchName}`,
+        ]);
         return true;
     }
     catch {
@@ -181,10 +170,14 @@ async function localBranchExists(repoRoot, branchName) {
     }
 }
 export const runPrCommand = createPrCommand();
-async function fetchPullRequestRef(repoRoot, input, prNumber, remoteRef) {
+async function fetchPullRequestRef(repoRoot, input, prNumber, remoteRef, runtime) {
     for (const sourceRef of listPullRequestSourceRefs(input, prNumber)) {
         try {
-            await execFileAsync("git", ["fetch", "origin", `${sourceRef}:${remoteRef}`], { cwd: repoRoot });
+            await runtime.git.runGit(repoRoot, [
+                "fetch",
+                "origin",
+                `${sourceRef}:${remoteRef}`,
+            ]);
             return;
         }
         catch {

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

@@ -1,11 +1,13 @@
-import type { WorktreeEntry } from "./repo.js";
-import { type WorktreePromptEntry } from "./worktree-picker.js";
+import type { WorktreeEntry } from "../../domain/worktree/types.js";
+import { type WorktreePromptEntry } from "../../presentation/worktree/picker.js";
+import { type CliRuntime } from "../dependencies.js";
 export interface RemoveCommandOptions {
     branch?: string;
     cwd: string;
     dryRun?: boolean;
     force?: boolean;
     json?: boolean;
+    runtime?: CliRuntime<"git" | "config" | "configStore" | "slots" | "hooks" | "repositoryContext" | "repositoryRegistry" | "worktrees" | "worktreeLifecycle" | "worktreeCatalog">;
     stderr: (chunk: string) => void;
     stdout: (chunk: string) => void;
 }

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

@@ -1,14 +1,12 @@
 import { basename } from "node:path";
 import { confirm, isCancel } from "@clack/prompts";
-import { loadEffectiveConfig } from "./config.js";
-import { isHeadless } from "./headless.js";
-import { extractHooks, runHook } from "./hooks.js";
-import { writeShellOutput } from "./shell-handoff.js";
-import { releaseWorktreeSlot } from "./slots.js";
+import { loadLinkedWorktrees } from "../../application/worktree/catalog.js";
+import { writeShellOutput } from "../../presentation/shell/handoff.js";
+import { buildWorktreePromptEntries, promptForSingleWorktree, } 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 { deleteBranch, forceDeleteBranch, forceRemoveWorktree, isBranchUnmergedError, isWorktreeForceRemovalError, loadLinkedWorktrees, removeWorktree, } from "./worktree-management.js";
-import { buildWorktreePromptEntries, promptForSingleWorktree, } from "./worktree-picker.js";
-import { defaultConfirmForceDeleteBranch, defaultConfirmForceRemoveWorktree, } from "./worktree-prompts.js";
 const REMOVE_OUTPUT_FILE_ENV = "GJI_REMOVE_OUTPUT_FILE";
 export function createRemoveCommand(dependencies = {}) {
     const promptForWorktree = dependencies.promptForWorktree ?? defaultPromptForWorktree;
@@ -17,7 +15,17 @@ export function createRemoveCommand(dependencies = {}) {
         defaultConfirmForceRemoveWorktree;
     const confirmForceDeleteBranch = dependencies.confirmForceDeleteBranch ?? defaultConfirmForceDeleteBranch;
     return async function runRemoveCommand(options) {
-        const { linkedWorktrees, repository } = await loadLinkedWorktrees(options.cwd);
+        const runtime = options.runtime ?? defaultCliDependencies;
+        const { loadEffectiveConfig } = runtime.config;
+        const { releaseWorktreeSlot } = runtime.slots;
+        const { extractHooks, runHook } = runtime.hooks;
+        const sourceDependencies = {
+            ...runtime.repositoryContext,
+            ...runtime.repositoryRegistry,
+            ...runtime.worktrees,
+        };
+        const { deleteBranch, forceDeleteBranch, forceRemoveWorktree, isBranchUnmergedError, isWorktreeForceRemovalError, removeWorktree, } = runtime.worktreeLifecycle;
+        const { linkedWorktrees, repository } = await loadLinkedWorktrees(options.cwd, sourceDependencies);
         if (linkedWorktrees.length === 0) {
             emitError(options, "No linked worktrees to finish");
             return 1;
@@ -36,7 +44,7 @@ export function createRemoveCommand(dependencies = {}) {
             (await promptForWorktree(await buildWorktreePromptEntries(linkedWorktrees.map((worktree) => ({
                 repoName: repository.repoName,
                 worktree,
-            })))));
+            })), { catalog: runtime.worktreeCatalog })));
         if (!selection) {
             options.stderr("Aborted\n");
             return 1;
@@ -78,9 +86,7 @@ export function createRemoveCommand(dependencies = {}) {
         const hooks = extractHooks(config);
         let journal;
         try {
-            journal = await recordUndoOperation("remove", repository.repoRoot, [
-                worktree,
-            ]);
+            journal = await recordUndoOperation("remove", repository.repoRoot, [worktree], undefined, runtime);
         }
         catch (error) {
             emitError(options, `could not write undo journal; no worktree was removed: ${toMessage(error)}`);
@@ -100,12 +106,12 @@ export function createRemoveCommand(dependencies = {}) {
         }
         catch (error) {
             if (!isWorktreeForceRemovalError(error)) {
-                await finalizeUndoOperation(journal, []);
+                await finalizeUndoOperation(journal, [], undefined, runtime.configStore.GLOBAL_CONFIG_DIRECTORY);
                 throw error;
             }
             if (!options.force &&
                 !(await confirmForceRemoveWorktree(worktree.path))) {
-                await finalizeUndoOperation(journal, []);
+                await finalizeUndoOperation(journal, [], undefined, runtime.configStore.GLOBAL_CONFIG_DIRECTORY);
                 options.stderr("Aborted\n");
                 return 1;
             }
@@ -113,12 +119,12 @@ export function createRemoveCommand(dependencies = {}) {
                 await forceRemoveWorktree(repository.repoRoot, worktree.path);
             }
             catch (forceError) {
-                await finalizeUndoOperation(journal, []);
+                await finalizeUndoOperation(journal, [], undefined, runtime.configStore.GLOBAL_CONFIG_DIRECTORY);
                 emitError(options, `Failed to remove worktree at ${worktree.path}: ${toMessage(forceError)}`);
                 return 1;
             }
         }
-        await finalizeUndoOperation(journal, [worktree]);
+        await finalizeUndoOperation(journal, [worktree], undefined, runtime.configStore.GLOBAL_CONFIG_DIRECTORY);
         await releaseWorktreeSlot(worktree.path);
         if (worktree.branch) {
             try {

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

@@ -1,6 +1,8 @@
+import { type CliRuntime } from "../dependencies.js";
 export interface RootCommandOptions {
     cwd: string;
     print?: boolean;
+    runtime?: CliRuntime<"repositoryContext">;
     stdout: (chunk: string) => void;
 }
 export declare function runRootCommand(options: RootCommandOptions): Promise<number>;

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

@@ -1,7 +1,9 @@
-import { detectRepository } from "./repo.js";
-import { writeShellOutput } from "./shell-handoff.js";
+import { writeShellOutput } from "../../presentation/shell/handoff.js";
+import { defaultCliDependencies } from "../dependencies.js";
 const ROOT_OUTPUT_FILE_ENV = "GJI_ROOT_OUTPUT_FILE";
 export async function runRootCommand(options) {
+    const { detectRepository } = (options.runtime ?? defaultCliDependencies)
+        .repositoryContext;
     const repository = await detectRepository(options.cwd);
     if (!options.print && process.env[ROOT_OUTPUT_FILE_ENV]) {
         await writeShellOutput(ROOT_OUTPUT_FILE_ENV, repository.repoRoot, options.stdout);

package/dist/{run-hook.d.ts → cli/commands/run-hook.d.ts}

@@ -1,6 +1,8 @@
+import { type CliRuntime } from "../dependencies.js";
 export interface RunHookCommandOptions {
     cwd: string;
     hook: string;
+    runtime?: CliRuntime<"config" | "slots" | "hooks" | "repositoryContext" | "worktrees">;
     stderr: (chunk: string) => void;
 }
 export declare function runHookCommand(options: RunHookCommandOptions): Promise<number>;

package/dist/{run-hook.js → cli/commands/run-hook.js}

@@ -1,7 +1,4 @@
-import { loadEffectiveConfig } from "./config.js";
-import { extractHooks, runHook } from "./hooks.js";
-import { detectRepository, listWorktrees } from "./repo.js";
-import { getWorktreeSlot } from "./slots.js";
+import { defaultCliDependencies } from "../dependencies.js";
 const VALID_HOOKS = [
     "after-create",
     "after-enter",
@@ -16,6 +13,12 @@ function isValidHook(hook) {
     return VALID_HOOKS.includes(hook);
 }
 export async function runHookCommand(options) {
+    const runtime = options.runtime ?? defaultCliDependencies;
+    const { loadEffectiveConfig } = runtime.config;
+    const { getWorktreeSlot } = runtime.slots;
+    const { extractHooks, runHook } = runtime.hooks;
+    const { detectRepository } = runtime.repositoryContext;
+    const { listWorktrees } = runtime.worktrees;
     const normalized = CAMEL_ALIASES[options.hook] ?? options.hook;
     if (!isValidHook(normalized)) {
         options.stderr(`gji run-hook: unknown hook '${options.hook}'. Valid hooks: ${VALID_HOOKS.join(", ")}\n`);

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

@@ -1,6 +1,8 @@
+import { type CliRuntime } from "../dependencies.js";
 export interface StatusCommandOptions {
     cwd: string;
     json?: boolean;
+    runtime?: CliRuntime<"repositoryContext" | "worktrees" | "slots" | "tasks" | "git">;
     stdout: (chunk: string) => void;
 }
 interface WorktreeStatusRow {

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

@@ -1,12 +1,15 @@
-import { readWorktreeHealth } from "./git.js";
-import { comparePaths } from "./paths.js";
-import { detectRepository, listWorktrees } from "./repo.js";
-import { getWorktreeSlot } from "./slots.js";
-import { readTask } from "./task.js";
+import { comparePaths } from "../../domain/shared/paths.js";
+import { defaultCliDependencies, } from "../dependencies.js";
 export async function runStatusCommand(options) {
+    const runtime = options.runtime ?? defaultCliDependencies;
+    const { detectRepository } = runtime.repositoryContext;
+    const { listWorktrees } = runtime.worktrees;
+    const { getWorktreeSlot } = runtime.slots;
+    const { readTask } = runtime.tasks;
+    const { readWorktreeHealth } = runtime.git;
     const repository = await detectRepository(options.cwd);
     const worktrees = sortWorktreesByPath(await listWorktrees(options.cwd));
-    const rows = await Promise.all(worktrees.map(async (worktree) => buildStatusRow(worktree)));
+    const rows = await Promise.all(worktrees.map(async (worktree) => buildStatusRow(worktree, readWorktreeHealth, getWorktreeSlot, readTask)));
     if (options.json) {
         options.stdout(`${JSON.stringify(formatStatusJson(repository.repoRoot, repository.currentRoot, rows), null, 2)}\n`);
         return 0;
@@ -37,7 +40,7 @@ export function formatStatusJson(repoRoot, currentRoot, rows) {
         worktrees: rows,
     };
 }
-async function buildStatusRow(worktree) {
+async function buildStatusRow(worktree, readWorktreeHealth, getWorktreeSlot, readTask) {
     const [health, slot, task] = await Promise.all([
         readWorktreeHealth(worktree.path),
         getWorktreeSlot(worktree.path),

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

@@ -1,9 +1,11 @@
+import { type CliRuntime } from "../dependencies.js";
 export interface SyncFilesCommandOptions {
     action?: string;
     cwd: string;
     home?: string;
     json?: boolean;
     paths?: string[];
+    runtime?: CliRuntime<"filesystem" | "configStore" | "repositoryContext">;
     stderr: (chunk: string) => void;
     stdout: (chunk: string) => void;
 }

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

@@ -1,9 +1,11 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { loadGlobalConfig, saveGlobalConfig, } from "./config.js";
-import { validateSyncFilePattern } from "./file-sync.js";
-import { detectRepository } from "./repo.js";
+import { defaultCliDependencies, } from "../dependencies.js";
 export async function runSyncFilesCommand(options) {
+    const runtime = options.runtime ?? defaultCliDependencies;
+    const { validateSyncFilePattern } = runtime.filesystem;
+    const { loadGlobalConfig, saveGlobalConfig } = runtime.configStore;
+    const { detectRepository } = runtime.repositoryContext;
     const repository = await detectRepository(options.cwd);
     const home = options.home ?? homedir();
     const loaded = await loadGlobalConfig(home);
@@ -16,22 +18,22 @@ export async function runSyncFilesCommand(options) {
             return 0;
         }
         case "add": {
-            const paths = validatePaths(options.paths ?? [], options);
+            const paths = validatePaths(options.paths ?? [], options, validateSyncFilePattern);
             if (!paths)
                 return 1;
             const nextFiles = mergeSyncFiles(readSyncFiles(repoConfig), paths);
-            await saveRepoSyncFiles(loaded.config, repoEntry?.key ?? repository.repoRoot, nextFiles, home);
+            await saveRepoSyncFiles(loaded.config, repoEntry?.key ?? repository.repoRoot, nextFiles, home, saveGlobalConfig);
             writeSyncFiles(options.stdout, nextFiles, !!options.json);
             return 0;
         }
         case "remove": {
-            const paths = validatePaths(options.paths ?? [], options);
+            const paths = validatePaths(options.paths ?? [], options, validateSyncFilePattern);
             if (!paths)
                 return 1;
             const existingFiles = readSyncFiles(repoConfig);
             const nextFiles = removeSyncFiles(existingFiles, paths);
             if (repoEntry && nextFiles.length !== existingFiles.length) {
-                await saveRepoSyncFiles(loaded.config, repoEntry.key, nextFiles, home);
+                await saveRepoSyncFiles(loaded.config, repoEntry.key, nextFiles, home, saveGlobalConfig);
             }
             writeSyncFiles(options.stdout, nextFiles, !!options.json);
             return 0;
@@ -68,7 +70,7 @@ function writeSyncFiles(stdout, files, json) {
     }
     stdout(`${files.join("\n")}\n`);
 }
-function validatePaths(paths, options) {
+function validatePaths(paths, options, validateSyncFilePattern) {
     if (paths.length === 0) {
         writeError(options, "at least one path is required");
         return null;
@@ -98,7 +100,7 @@ function removeSyncFiles(existing, removals) {
     const removalSet = new Set(removals);
     return existing.filter((path) => !removalSet.has(path));
 }
-async function saveRepoSyncFiles(config, repoKey, syncFiles, home) {
+async function saveRepoSyncFiles(config, repoKey, syncFiles, home, saveGlobalConfig) {
     const repos = isPlainObject(config.repos) ? { ...config.repos } : {};
     const repoConfig = isPlainObject(repos[repoKey])
         ? repos[repoKey]