@solaqua/gji 0.12.4 → 0.13.0

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

@@ -1,9 +1,11 @@
-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 type NewWorktreeMode = "create" | "checkout" | "track";
 export interface NewCommandOptions {
     branch?: string;
+    branchOnly?: boolean;
     copy?: boolean;
     cwd: string;
     detached?: boolean;
@@ -22,7 +24,9 @@ export interface NewCommandOptions {
     stderr: (chunk: string) => void;
     stdout: (chunk: string) => void;
     task?: string;
+    runtime?: NewRuntime;
 }
+type NewRuntime = CliRuntime<"bootstrap" | "config" | "git" | "history" | "integrations" | "repositoryContext" | "tasks">;
 export interface NewCommandDependencies {
     createBranchPlaceholder: () => string;
     promptForBranch: (placeholder: string) => Promise<string | null>;

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

@@ -1,33 +1,31 @@
-import { execFile } from "node:child_process";
 import { access, mkdir } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
-import { promisify } from "node:util";
 import { confirm, isCancel, text } from "@clack/prompts";
-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 { defaultSpawnEditor, EDITORS } from "./editor.js";
-import { resolveRemoteBase, runGit } from "./git.js";
-import { isHeadless } from "./headless.js";
-import { recordWorktreeUsage } from "./history.js";
-import { createNavigationRepository, createNavigationTarget, } from "./navigation-output.js";
-import { detectRepository, resolveWorktreePath, validateBranchName, } from "./repo.js";
-import { writeShellOutput } from "./shell-handoff.js";
-import { writeTask } from "./task.js";
-import { bootstrapWorktree } from "./worktree-bootstrap.js";
-const execFileAsync = promisify(execFile);
+import { resolveWorktreePath, validateBranchName, } from "../../domain/worktree/policy.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 NEW_OUTPUT_FILE_ENV = "GJI_NEW_OUTPUT_FILE";
 export function createNewCommand(dependencies = {}) {
     const createBranchPlaceholder = dependencies.createBranchPlaceholder ?? generateBranchPlaceholder;
     const promptForBranch = dependencies.promptForBranch ?? defaultPromptForBranch;
     const promptForFetchFailure = dependencies.promptForFetchFailure ?? defaultPromptForFetchFailure;
     const prompt = dependencies.promptForPathConflict ?? promptForPathConflict;
-    const spawnEditor = dependencies.spawnEditor ?? defaultSpawnEditor;
     return async function runNewCommand(options) {
+        const runtime = options.runtime ?? defaultCliDependencies;
+        const spawnEditor = dependencies.spawnEditor ?? runtime.integrations.defaultSpawnEditor;
         if (options.copy && !options.take)
             return emitNewError(options, "--copy requires --take");
+        if (options.branchOnly) {
+            const incompatibleOption = findBranchOnlyIncompatibleOption(options);
+            if (incompatibleOption) {
+                return emitNewError(options, `${incompatibleOption} cannot be used with --branch-only`);
+            }
+        }
         if (options.detached && options.fromCurrent) {
             const message = "--from-current cannot be used with --detached";
             if (options.json) {
@@ -38,10 +36,10 @@ export function createNewCommand(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) {
             return emitNewError(options, error instanceof Error ? error.message : String(error));
@@ -86,7 +84,10 @@ export function createNewCommand(dependencies = {}) {
                 return 1;
             }
         }
-        const rawBasePath = resolveConfigString(config, "worktreePath");
+        if (options.branchOnly) {
+            return runBranchOnly(options, runtime, repository, config, rawBranch);
+        }
+        const rawBasePath = runtime.config.resolveConfigString(config, "worktreePath");
         const configuredBasePath = rawBasePath?.startsWith("/") || rawBasePath?.startsWith("~")
             ? rawBasePath
             : undefined;
@@ -102,7 +103,12 @@ export function createNewCommand(dependencies = {}) {
             if (options.force) {
                 if (!options.dryRun) {
                     try {
-                        await execFileAsync("git", ["worktree", "remove", "--force", worktreePath], { cwd: repository.repoRoot });
+                        await runtime.git.runGit(repository.repoRoot, [
+                            "worktree",
+                            "remove",
+                            "--force",
+                            worktreePath,
+                        ]);
                     }
                     catch (err) {
                         if (!isNotRegisteredWorktreeError(err)) {
@@ -117,9 +123,11 @@ export function createNewCommand(dependencies = {}) {
                     }
                     if (!options.detached) {
                         try {
-                            await execFileAsync("git", ["branch", "-D", worktreeName], {
-                                cwd: repository.repoRoot,
-                            });
+                            await runtime.git.runGit(repository.repoRoot, [
+                                "branch",
+                                "-D",
+                                worktreeName,
+                            ]);
                         }
                         catch {
                             // Branch may not exist; proceed anyway.
@@ -142,7 +150,7 @@ export function createNewCommand(dependencies = {}) {
             else {
                 const choice = await prompt(worktreePath);
                 if (choice === "reuse") {
-                    await recordWorktreeUsage(worktreePath, worktreeName);
+                    await runtime.history.recordWorktreeUsage(worktreePath, worktreeName);
                     await writeOutput(worktreePath, options.stdout, options.outputEnv);
                     return 0;
                 }
@@ -150,13 +158,13 @@ export function createNewCommand(dependencies = {}) {
                 return 1;
             }
         }
-        const dependencyMode = resolveDependencyBootstrapMode(config.dependencyBootstrap, options.noInstall);
+        const dependencyMode = runtime.bootstrap.resolveMode(config.dependencyBootstrap, options.noInstall);
         if (options.dryRun) {
             if (options.take) {
-                const changedFiles = await listTakeFiles(options.cwd);
-                const submoduleFiles = await listSubmoduleFiles(options.cwd, changedFiles);
+                const changedFiles = await listTakeFiles(options.cwd, runtime.git.runGitRaw);
+                const submoduleFiles = await listSubmoduleFiles(options.cwd, changedFiles, runtime.git.runGitRaw);
                 const transferableFiles = changedFiles.filter((file) => !submoduleFiles.includes(file));
-                const ignoredFiles = await listIgnoredFiles(options.cwd);
+                const ignoredFiles = await listIgnoredFiles(options.cwd, runtime.git.runGitRaw);
                 if (transferableFiles.length === 0)
                     return emitNewError(options, submoduleFiles.length > 0
                         ? "nothing to take: submodule changes are not supported"
@@ -170,7 +178,7 @@ export function createNewCommand(dependencies = {}) {
                 }
                 return 0;
             }
-            const dryRunDependencyBootstrap = await createDependencyBootstrapPreview(dependencyMode, {
+            const dryRunDependencyBootstrap = await runtime.bootstrap.preview(dependencyMode, {
                 currentRoot: repository.currentRoot,
                 repoRoot: repository.repoRoot,
                 cargoBuildCommand: config.dependencyBuildCommand,
@@ -187,7 +195,8 @@ export function createNewCommand(dependencies = {}) {
             }
             else {
                 const resolvedEditor = options.open
-                    ? (options.editor ?? resolveConfigString(config, "editor"))
+                    ? (options.editor ??
+                        runtime.config.resolveConfigString(config, "editor"))
                     : undefined;
                 const openNote = resolvedEditor
                     ? `, then open in ${resolvedEditor}`
@@ -198,20 +207,20 @@ export function createNewCommand(dependencies = {}) {
         }
         await mkdir(dirname(worktreePath), { recursive: true });
         const startPoint = options.fromCurrent && !options.detached
-            ? await resolveCurrentWorktreeHead(options.cwd)
+            ? await resolveCurrentWorktreeHead(options.cwd, runtime.git.runGit)
             : undefined;
         const takeStartPoint = options.take
-            ? await resolveCurrentWorktreeHead(options.cwd)
+            ? await resolveCurrentWorktreeHead(options.cwd, runtime.git.runGit)
             : undefined;
         const changedTakeFiles = options.take
-            ? await listTakeFiles(options.cwd)
+            ? await listTakeFiles(options.cwd, runtime.git.runGitRaw)
             : [];
         const submoduleFiles = options.take
-            ? await listSubmoduleFiles(options.cwd, changedTakeFiles)
+            ? await listSubmoduleFiles(options.cwd, changedTakeFiles, runtime.git.runGitRaw)
             : [];
         const takeFiles = changedTakeFiles.filter((file) => !submoduleFiles.includes(file));
         const takeUntracked = options.take
-            ? await countUntrackedFiles(options.cwd)
+            ? await countUntrackedFiles(options.cwd, runtime.git.runGitRaw)
             : 0;
         if (options.take && takeFiles.length === 0)
             return emitNewError(options, submoduleFiles.length > 0
@@ -219,7 +228,7 @@ export function createNewCommand(dependencies = {}) {
                 : "nothing to take: working tree is clean");
         if (options.take && submoduleFiles.length > 0)
             options.stderr(`Warning: submodule changes are not transferred: ${submoduleFiles.join(", ")}\n`);
-        const existingLocalBranch = await localBranchExists(repository.repoRoot, worktreeName);
+        const existingLocalBranch = await localBranchExists(repository.repoRoot, worktreeName, runtime);
         const shouldRefreshBase = !options.noFetch &&
             !options.detached &&
             !options.fromCurrent &&
@@ -228,17 +237,17 @@ export function createNewCommand(dependencies = {}) {
             options.mode !== "checkout" &&
             !existingLocalBranch;
         const freshBaseRef = shouldRefreshBase
-            ? await resolveFreshBaseRef(repository.repoRoot, config, options, promptForFetchFailure)
+            ? await resolveFreshBaseRef(repository.repoRoot, config, options, promptForFetchFailure, runtime)
             : undefined;
         if (freshBaseRef === null)
             return 1;
         let stashSha = null;
         if (options.take) {
             try {
-                const inProgressState = await detectInProgressGitState(options.cwd);
+                const inProgressState = await detectInProgressGitState(options.cwd, runtime.git.runGit);
                 if (inProgressState)
                     return emitNewError(options, `cannot take changes while Git is in progress (${inProgressState})`);
-                stashSha = await createTakeStash(options.cwd, worktreeName);
+                stashSha = await createTakeStash(options.cwd, worktreeName, runtime.git.runGit);
             }
             catch (error) {
                 return emitNewError(options, `could not stash changes safely: ${toExecMessage(error)}`);
@@ -279,17 +288,22 @@ export function createNewCommand(dependencies = {}) {
                                     : []),
                     ];
         try {
-            await execFileAsync("git", gitArgs, { cwd: repository.repoRoot });
+            await runtime.git.runGit(repository.repoRoot, gitArgs);
         }
         catch (error) {
             if (stashSha)
-                await restoreTakeStash(options.cwd, stashSha, options.stderr);
+                await restoreTakeStash(options.cwd, stashSha, options.stderr, runtime.git.runGit);
             return emitNewError(options, `failed to create worktree: ${toExecMessage(error)}`);
         }
         if (stashSha &&
-            !(await applyTakeStash(worktreePath, options.cwd, stashSha, !!options.copy, options.stderr))) {
+            !(await applyTakeStash(worktreePath, options.cwd, stashSha, !!options.copy, options.stderr, runtime.git.runGit))) {
             try {
-                await execFileAsync("git", ["worktree", "remove", "--force", worktreePath], { cwd: repository.repoRoot });
+                await runtime.git.runGit(repository.repoRoot, [
+                    "worktree",
+                    "remove",
+                    "--force",
+                    worktreePath,
+                ]);
             }
             catch {
                 /* rollback best effort */
@@ -298,13 +312,13 @@ export function createNewCommand(dependencies = {}) {
         }
         if (options.task !== undefined) {
             try {
-                await writeTask(worktreePath, options.task);
+                await runtime.tasks.writeTask(worktreePath, options.task);
             }
             catch (error) {
                 options.stderr(`Warning: could not save task metadata: ${error instanceof Error ? error.message : String(error)}\n`);
             }
         }
-        const bootstrap = await bootstrapWorktree({
+        const bootstrap = await runtime.bootstrap.bootstrapWorktree({
             branch: worktreeName,
             config,
             currentRoot: repository.currentRoot,
@@ -315,7 +329,6 @@ export function createNewCommand(dependencies = {}) {
             runCommand: dependencies.runCommand,
             commandStdout: options.json ? () => undefined : options.stdout,
             commandStderr: options.json ? () => undefined : options.stderr,
-            json: options.json,
             worktreePath,
         });
         if (!bootstrap.ready) {
@@ -344,30 +357,135 @@ export function createNewCommand(dependencies = {}) {
         else {
             if (options.take)
                 options.stderr(`✓ took ${takeFiles.length} changed file${takeFiles.length === 1 ? "" : "s"} (${takeUntracked} untracked) → ${worktreeName}\n`);
-            await recordWorktreeUsage(worktreePath, worktreeName);
+            await runtime.history.recordWorktreeUsage(worktreePath, worktreeName);
             await writeOutput(worktreePath, options.stdout, options.outputEnv);
         }
         if (options.open) {
-            const resolvedEditor = options.editor ?? resolveConfigString(config, "editor");
-            await openWorktree(worktreePath, resolvedEditor, spawnEditor, options.stderr);
+            const resolvedEditor = options.editor ?? runtime.config.resolveConfigString(config, "editor");
+            await openWorktree(worktreePath, resolvedEditor, spawnEditor, options.stderr, runtime.integrations.EDITORS);
         }
         return 0;
     };
 }
+function findBranchOnlyIncompatibleOption(options) {
+    if (options.detached)
+        return "--detached";
+    if (options.fromCurrent)
+        return "--from-current";
+    if (options.take)
+        return "--take";
+    if (options.copy)
+        return "--copy";
+    if (options.task !== undefined)
+        return "--task";
+    if (options.force)
+        return "--force";
+    if (options.open)
+        return "--open";
+    if (options.editor)
+        return "--editor";
+    return null;
+}
+async function runBranchOnly(options, runtime, repository, config, rawBranch) {
+    const branchName = applyConfiguredBranchPrefix(rawBranch, config.branchPrefix);
+    const remote = runtime.config.resolveConfigString(config, "syncRemote") ?? "origin";
+    const configuredBaseBranch = runtime.config.resolveConfigString(config, "syncDefaultBranch");
+    if (options.dryRun) {
+        const baseDescription = configuredBaseBranch
+            ? configuredBaseBranch
+            : `the default branch from ${remote}`;
+        if (options.json) {
+            const navigation = createNavigationTarget(createNavigationRepository(repository.repoName, repository.repoRoot), repository.currentRoot, branchName);
+            options.stdout(`${JSON.stringify({ ...navigation, baseBranch: configuredBaseBranch ?? null, branchOnly: true, dryRun: true }, null, 2)}\n`);
+        }
+        else {
+            const sourceDescription = configuredBaseBranch
+                ? options.noFetch
+                    ? `local ${configuredBaseBranch}`
+                    : `${remote}/${configuredBaseBranch}`
+                : baseDescription;
+            options.stdout(`Would create branch ${branchName} from ${sourceDescription} in the current worktree\n`);
+        }
+        return 0;
+    }
+    if (await localBranchExists(repository.repoRoot, branchName, runtime)) {
+        return emitNewError(options, `branch already exists: ${branchName}`);
+    }
+    if (await runtime.git.isDirtyWorktree(options.cwd)) {
+        return emitNewError(options, "current worktree has uncommitted changes; commit or stash them before using --branch-only");
+    }
+    const inProgressState = await detectInProgressGitState(options.cwd, runtime.git.runGit);
+    if (inProgressState) {
+        return emitNewError(options, `cannot create a branch while Git is in progress (${inProgressState})`);
+    }
+    let baseBranch = configuredBaseBranch;
+    if (!baseBranch || !options.noFetch) {
+        try {
+            const remoteBase = await runtime.git.resolveRemoteBase(repository.repoRoot, remote, configuredBaseBranch);
+            baseBranch = remoteBase?.branch ?? baseBranch;
+        }
+        catch (error) {
+            return emitNewError(options, `could not determine the default branch: ${toExecMessage(error)}`);
+        }
+    }
+    if (!baseBranch) {
+        return emitNewError(options, `could not determine the default branch; configure syncDefaultBranch or add a remote named ${remote}`);
+    }
+    if (options.noFetch &&
+        !(await localBranchExists(repository.repoRoot, baseBranch, runtime))) {
+        return emitNewError(options, `base branch does not exist locally: ${baseBranch}`);
+    }
+    try {
+        let startPoint = baseBranch;
+        if (!options.noFetch) {
+            await runtime.git.runGit(repository.repoRoot, [
+                "fetch",
+                "--prune",
+                remote,
+                baseBranch,
+            ]);
+            startPoint = `${remote}/${baseBranch}`;
+        }
+        await runtime.git.runGit(options.cwd, [
+            "switch",
+            "-c",
+            branchName,
+            startPoint,
+        ]);
+    }
+    catch (error) {
+        return emitNewError(options, `failed to create branch in the current worktree: ${toExecMessage(error)}`);
+    }
+    if (options.json) {
+        const navigation = createNavigationTarget(createNavigationRepository(repository.repoName, repository.repoRoot), repository.currentRoot, branchName);
+        options.stdout(`${JSON.stringify({ ...navigation, baseBranch, branchOnly: true }, null, 2)}\n`);
+    }
+    else {
+        options.stderr(`✓ created ${branchName} from ${options.noFetch ? baseBranch : `${remote}/${baseBranch}`} in the current worktree\n`);
+        await runtime.history.recordWorktreeUsage(repository.currentRoot, branchName);
+        await writeOutput(repository.currentRoot, options.stdout, options.outputEnv);
+    }
+    return 0;
+}
 export const runNewCommand = createNewCommand();
-async function resolveFreshBaseRef(repoRoot, config, options, promptForFetchFailure) {
-    const remote = resolveConfigString(config, "syncRemote") ?? "origin";
-    const configuredRemote = resolveConfigString(config, "syncRemote");
-    let baseBranch = resolveConfigString(config, "syncDefaultBranch");
+async function resolveFreshBaseRef(repoRoot, config, options, promptForFetchFailure, runtime) {
+    const remote = runtime.config.resolveConfigString(config, "syncRemote") ?? "origin";
+    const configuredRemote = runtime.config.resolveConfigString(config, "syncRemote");
+    let baseBranch = runtime.config.resolveConfigString(config, "syncDefaultBranch");
     try {
-        const remoteBase = await resolveRemoteBase(repoRoot, remote, baseBranch);
+        const remoteBase = await runtime.git.resolveRemoteBase(repoRoot, remote, baseBranch);
         if (!remoteBase) {
             if (!configuredRemote)
                 return "HEAD";
             throw new Error("the remote default branch is unknown");
         }
         baseBranch = remoteBase.branch;
-        await runGit(repoRoot, ["fetch", "--prune", remote, remoteBase.branch]);
+        await runtime.git.runGit(repoRoot, [
+            "fetch",
+            "--prune",
+            remote,
+            remoteBase.branch,
+        ]);
         return remoteBase.ref;
     }
     catch (error) {
@@ -383,7 +501,7 @@ async function resolveFreshBaseRef(repoRoot, config, options, promptForFetchFail
             return null;
         }
         if (baseBranch &&
-            (await localRefExists(repoRoot, `refs/remotes/${remote}/${baseBranch}`))) {
+            (await localRefExists(repoRoot, `refs/remotes/${remote}/${baseBranch}`, runtime))) {
             options.stderr(`Continuing with the cached ${remote}/${baseBranch}.\n`);
             return `${remote}/${baseBranch}`;
         }
@@ -400,9 +518,14 @@ async function defaultPromptForFetchFailure(message) {
     });
     return !isCancel(choice) && choice;
 }
-async function localRefExists(repoRoot, ref) {
+async function localRefExists(repoRoot, ref, runtime) {
     try {
-        await runGit(repoRoot, ["rev-parse", "--verify", "--quiet", ref]);
+        await runtime.git.runGit(repoRoot, [
+            "rev-parse",
+            "--verify",
+            "--quiet",
+            ref,
+        ]);
         return true;
     }
     catch {
@@ -552,23 +675,28 @@ async function defaultPromptForBranch(placeholder) {
     }
     return choice.trim();
 }
-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 {
         return false;
     }
 }
-async function resolveCurrentWorktreeHead(cwd) {
-    return execFileAsync("git", ["rev-parse", "--verify", "HEAD"], { cwd }).then(({ stdout }) => stdout.trim());
+async function resolveCurrentWorktreeHead(cwd, runGit) {
+    return runGit(cwd, ["rev-parse", "--verify", "HEAD"]);
 }
-async function createTakeStash(cwd, worktreeName) {
+async function createTakeStash(cwd, worktreeName, runGit) {
     const message = `gji-take: ${worktreeName}:${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-    await execFileAsync("git", ["stash", "push", "--include-untracked", "-m", message], { cwd });
-    const { stdout } = await execFileAsync("git", ["stash", "list", "--format=%H%x00%s"], { cwd });
-    const line = stdout
+    await runGit(cwd, ["stash", "push", "--include-untracked", "-m", message]);
+    const output = await runGit(cwd, ["stash", "list", "--format=%H%x00%s"]);
+    const line = output
         .split("\n")
         .map((candidate) => candidate.split("\0"))
         .find(([, subject]) => subject?.endsWith(message));
@@ -576,7 +704,7 @@ async function createTakeStash(cwd, worktreeName) {
         throw new Error("could not identify the stash created for --take");
     return line[0];
 }
-async function detectInProgressGitState(cwd) {
+async function detectInProgressGitState(cwd, runGit) {
     const markers = [
         ["MERGE_HEAD", "merge"],
         ["rebase-merge", "rebase"],
@@ -587,8 +715,8 @@ async function detectInProgressGitState(cwd) {
     ];
     for (const [marker, name] of markers) {
         try {
-            const { stdout } = await execFileAsync("git", ["rev-parse", "--git-path", marker], { cwd });
-            await access(resolve(cwd, stdout.trim()));
+            const gitPath = await runGit(cwd, ["rev-parse", "--git-path", marker]);
+            await access(resolve(cwd, gitPath));
             return name;
         }
         catch {
@@ -601,24 +729,19 @@ async function writeOutput(worktreePath, stdout, outputEnv) {
     await writeShellOutput(outputEnv ?? NEW_OUTPUT_FILE_ENV, worktreePath, stdout);
 }
 function isNotRegisteredWorktreeError(error) {
-    const stderr = hasExecStderr(error) ? error.stderr : String(error);
+    const stderr = error instanceof Error ? error.message : String(error);
     return (stderr.includes("is not a working tree") ||
         stderr.includes("not a linked working tree"));
 }
-function hasExecStderr(error) {
-    return (error instanceof Error &&
-        "stderr" in error &&
-        typeof error.stderr === "string");
-}
 function toExecMessage(error) {
-    return hasExecStderr(error) ? error.stderr.trim() : String(error);
+    return error instanceof Error ? error.message : String(error);
 }
-async function openWorktree(worktreePath, editorCli, spawnFn, stderr) {
+async function openWorktree(worktreePath, editorCli, spawnFn, stderr, editors) {
     if (!editorCli) {
         stderr("gji new: --open requires --editor <cli> or a saved editor in config\n");
         return;
     }
-    const editorDef = EDITORS.find((e) => e.cli === editorCli);
+    const editorDef = editors.find((e) => e.cli === editorCli);
     const args = [];
     if (editorDef?.newWindowFlag) {
         args.push(editorDef.newWindowFlag);
@@ -632,10 +755,10 @@ async function openWorktree(worktreePath, editorCli, spawnFn, stderr) {
         stderr(`gji new: failed to open editor: ${message}\n`);
     }
 }
-async function listTakeFiles(cwd) {
+async function listTakeFiles(cwd, runGit) {
     try {
-        const { stdout } = await execFileAsync("git", ["status", "--porcelain=v1"], { cwd });
-        return stdout
+        const output = await runGit(cwd, ["status", "--porcelain=v1"]);
+        return output
             .split("\n")
             .filter((line) => line.length > 3)
             .map((line) => line.slice(3).replace(/^"|"$/g, ""));
@@ -644,10 +767,15 @@ async function listTakeFiles(cwd) {
         return [];
     }
 }
-async function listIgnoredFiles(cwd) {
+async function listIgnoredFiles(cwd, runGit) {
     try {
-        const { stdout } = await execFileAsync("git", ["status", "--porcelain=v1", "--ignored", "--untracked-files=all"], { cwd });
-        return stdout
+        const output = await runGit(cwd, [
+            "status",
+            "--porcelain=v1",
+            "--ignored",
+            "--untracked-files=all",
+        ]);
+        return output
             .split("\n")
             .filter((line) => line.startsWith("!! "))
             .map((line) => line.slice(3).replace(/^"|"$/g, ""));
@@ -656,14 +784,12 @@ async function listIgnoredFiles(cwd) {
         return [];
     }
 }
-async function listSubmoduleFiles(cwd, changedFiles) {
+async function listSubmoduleFiles(cwd, changedFiles, runGit) {
     if (changedFiles.length === 0)
         return [];
     try {
-        const { stdout } = await execFileAsync("git", ["ls-files", "--stage"], {
-            cwd,
-        });
-        const submodules = new Set(stdout
+        const output = await runGit(cwd, ["ls-files", "--stage"]);
+        const submodules = new Set(output
             .split("\n")
             .filter((line) => line.startsWith("160000 "))
             .map((line) => line.slice(line.indexOf("\t") + 1)));
@@ -673,31 +799,31 @@ async function listSubmoduleFiles(cwd, changedFiles) {
         return [];
     }
 }
-async function countUntrackedFiles(cwd) {
+async function countUntrackedFiles(cwd, runGit) {
     try {
-        const { stdout } = await execFileAsync("git", ["status", "--porcelain=v1", "--untracked-files=all"], { cwd });
-        return stdout.split("\n").filter((line) => line.startsWith("?? ")).length;
+        const output = await runGit(cwd, [
+            "status",
+            "--porcelain=v1",
+            "--untracked-files=all",
+        ]);
+        return output.split("\n").filter((line) => line.startsWith("?? ")).length;
     }
     catch {
         return 0;
     }
 }
-async function applyTakeStash(worktreePath, sourcePath, stashSha, copy, stderr) {
+async function applyTakeStash(worktreePath, sourcePath, stashSha, copy, stderr, runGit) {
     try {
-        await execFileAsync("git", ["stash", "apply", stashSha], {
-            cwd: worktreePath,
-        });
+        await runGit(worktreePath, ["stash", "apply", stashSha]);
     }
     catch (error) {
         stderr(`Warning: stash apply failed: ${toExecMessage(error)}\n`);
-        await restoreTakeStash(sourcePath, stashSha, stderr);
+        await restoreTakeStash(sourcePath, stashSha, stderr, runGit);
         return false;
     }
     if (copy) {
         try {
-            await execFileAsync("git", ["stash", "apply", stashSha], {
-                cwd: sourcePath,
-            });
+            await runGit(sourcePath, ["stash", "apply", stashSha]);
         }
         catch (error) {
             stderr(`Warning: could not restore copied changes to the source: ${toExecMessage(error)}\n`);
@@ -705,24 +831,26 @@ async function applyTakeStash(worktreePath, sourcePath, stashSha, copy, stderr)
         }
     }
     try {
-        const { stdout } = await execFileAsync("git", ["stash", "list", "--format=%H %gd"], { cwd: sourcePath });
-        const line = stdout
+        const output = await runGit(sourcePath, [
+            "stash",
+            "list",
+            "--format=%H %gd",
+        ]);
+        const line = output
             .split("\n")
             .find((candidate) => candidate.startsWith(stashSha));
         const ref = line?.trim().split(/\s+/).at(1);
         if (ref)
-            await execFileAsync("git", ["stash", "drop", ref], { cwd: sourcePath });
+            await runGit(sourcePath, ["stash", "drop", ref]);
     }
     catch {
         /* preserving the stash is safer */
     }
     return true;
 }
-async function restoreTakeStash(sourcePath, stashSha, stderr) {
+async function restoreTakeStash(sourcePath, stashSha, stderr, runGit) {
     try {
-        await execFileAsync("git", ["stash", "apply", stashSha], {
-            cwd: sourcePath,
-        });
+        await runGit(sourcePath, ["stash", "apply", stashSha]);
     }
     catch {
         stderr(`Your changes are safe in stash: ${stashSha} — run "git stash apply ${stashSha}" to restore\n`);