@solaqua/gji 0.9.0 → 0.11.0

package/dist/new.js

@@ -1,28 +1,57 @@
 import { execFile } from "node:child_process";
-import { mkdir } from "node:fs/promises";
-import { basename, dirname } from "node:path";
+import { access, mkdir } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
 import { promisify } from "node:util";
-import { isCancel, text } from "@clack/prompts";
-import { loadEffectiveConfig, resolveConfigString } from "./config.js";
+import { confirm, isCancel, text } from "@clack/prompts";
+import { createBootstrapReporter } from "./bootstrap-output.js";
+import { createDependencyBootstrapPreview, formatDependencyBootstrapPreview, } from "./bootstrap-preview.js";
+import { loadEffectiveConfigResult, resolveConfigString, } from "./config.js";
 import { pathExists, promptForPathConflict, } from "./conflict.js";
+import { resolveDependencyBootstrapPolicy, } from "./dependency-bootstrap-prompt.js";
+import { cloneDir } from "./dir-clone.js";
 import { defaultSpawnEditor, EDITORS } from "./editor.js";
-import { syncFiles } from "./file-sync.js";
+import { formatBytes } from "./format-bytes.js";
+import { resolveRemoteBase, runGit } from "./git.js";
 import { isHeadless } from "./headless.js";
 import { recordWorktreeUsage } from "./history.js";
-import { extractHooks, runHook } from "./hooks.js";
-import { maybeRunInstallPrompt, } from "./install-prompt.js";
+import { createNavigationRepository, createNavigationTarget, } from "./navigation-output.js";
 import { detectRepository, resolveWorktreePath, validateBranchName, } from "./repo.js";
 import { writeShellOutput } from "./shell-handoff.js";
+import { estimateSyncDirectories } from "./sync-plan.js";
+import { bootstrapWorktree } from "./worktree-bootstrap.js";
 const execFileAsync = promisify(execFile);
 const NEW_OUTPUT_FILE_ENV = "GJI_NEW_OUTPUT_FILE";
 export function createNewCommand(dependencies = {}) {
     const createBranchPlaceholder = dependencies.createBranchPlaceholder ?? generateBranchPlaceholder;
+    const cloneDirectory = dependencies.cloneDir ?? cloneDir;
     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) {
+        if (options.copy && !options.take)
+            return emitNewError(options, "--copy requires --take");
+        if (options.detached && options.fromCurrent) {
+            const message = "--from-current cannot be used with --detached";
+            if (options.json) {
+                options.stderr(`${JSON.stringify({ error: message }, null, 2)}\n`);
+            }
+            else {
+                options.stderr(`gji new: ${message}\n`);
+            }
+            return 1;
+        }
         const repository = await detectRepository(options.cwd);
-        const config = await loadEffectiveConfig(repository.repoRoot, undefined, options.stderr);
+        let config;
+        let dependencyBootstrapExplicit;
+        try {
+            const loaded = await loadEffectiveConfigResult(repository.repoRoot, undefined, options.json ? undefined : options.stderr);
+            config = loaded.config;
+            dependencyBootstrapExplicit = loaded.dependencyBootstrapExplicit;
+        }
+        catch (error) {
+            return emitNewError(options, error instanceof Error ? error.message : String(error));
+        }
         const usesGeneratedDetachedName = options.detached && options.branch === undefined;
         if (options.editor && !options.open) {
             options.stderr("gji new: --editor has no effect without --open\n");
@@ -67,9 +96,11 @@ export function createNewCommand(dependencies = {}) {
         const configuredBasePath = rawBasePath?.startsWith("/") || rawBasePath?.startsWith("~")
             ? rawBasePath
             : undefined;
-        const worktreeName = options.detached
+        const worktreeName = options.mode
             ? rawBranch
-            : applyConfiguredBranchPrefix(rawBranch, config.branchPrefix);
+            : options.detached
+                ? rawBranch
+                : applyConfiguredBranchPrefix(rawBranch, config.branchPrefix);
         const worktreePath = usesGeneratedDetachedName
             ? await resolveUniqueDetachedWorktreePath(repository.repoRoot, worktreeName, configuredBasePath)
             : resolveWorktreePath(repository.repoRoot, worktreeName, configuredBasePath);
@@ -109,7 +140,7 @@ export function createNewCommand(dependencies = {}) {
                 }
                 else {
                     options.stderr(`gji new: ${message} in non-interactive mode (GJI_NO_TUI=1)\n`);
-                    options.stderr(`Hint: Use 'gji remove ${worktreeName}' or 'gji clean' to remove the existing worktree\n`);
+                    options.stderr(`Hint: Use 'gji done ${worktreeName}' or 'gji clean' to remove the existing worktree\n`);
                     options.stderr(`Hint: Use 'gji run-hook after-create' inside the worktree to re-run setup hooks\n`);
                 }
                 return 1;
@@ -118,16 +149,64 @@ export function createNewCommand(dependencies = {}) {
                 const choice = await prompt(worktreePath);
                 if (choice === "reuse") {
                     await recordWorktreeUsage(worktreePath, worktreeName);
-                    await writeOutput(worktreePath, options.stdout);
+                    await writeOutput(worktreePath, options.stdout, options.outputEnv);
                     return 0;
                 }
                 options.stderr(`Aborted because target worktree path already exists: ${worktreePath}\n`);
                 return 1;
             }
         }
+        const dependencyPolicy = await resolveDependencyBootstrapPolicy({
+            currentRoot: repository.currentRoot,
+            repoRoot: repository.repoRoot,
+            worktreePath,
+        }, config, dependencyBootstrapExplicit, {
+            dependencies,
+            dryRun: options.dryRun,
+            legacyInstallPromptConfigured: dependencies.promptForInstallChoice !== undefined,
+            nonInteractive: !!options.json,
+            stderr: options.stderr,
+        });
+        config = {
+            ...config,
+            dependencyBootstrap: dependencyPolicy.mode,
+        };
         if (options.dryRun) {
+            if (options.take) {
+                const changedFiles = await listTakeFiles(options.cwd);
+                const submoduleFiles = await listSubmoduleFiles(options.cwd, changedFiles);
+                const transferableFiles = changedFiles.filter((file) => !submoduleFiles.includes(file));
+                const ignoredFiles = await listIgnoredFiles(options.cwd);
+                if (transferableFiles.length === 0)
+                    return emitNewError(options, submoduleFiles.length > 0
+                        ? "nothing to take: submodule changes are not supported"
+                        : ignoredFiles.length > 0
+                            ? "nothing to take: ignored files are not moved"
+                            : "nothing to take: working tree is clean");
+                if (options.json)
+                    options.stdout(`${JSON.stringify({ branch: worktreeName, path: worktreePath, dryRun: true, take: transferableFiles, ignored: ignoredFiles, submodules: submoduleFiles }, null, 2)}\n`);
+                else {
+                    options.stdout(`Would take ${transferableFiles.length} changed file${transferableFiles.length === 1 ? "" : "s"} into ${worktreeName}${ignoredFiles.length > 0 ? ` (ignored files not moved: ${ignoredFiles.length})` : ""}${submoduleFiles.length > 0 ? ` (submodules not moved: ${submoduleFiles.length})` : ""}\n${transferableFiles.map((file) => `  ${file}\n`).join("")}`);
+                }
+                return 0;
+            }
+            const dryRunSyncDirs = await estimateSyncDirectories(repository.repoRoot, worktreePath, config.syncDirs ?? []);
+            const dryRunDependencyBootstrap = await createDependencyBootstrapPreview(config.dependencyBootstrap ?? "off", {
+                currentRoot: repository.currentRoot,
+                repoRoot: repository.repoRoot,
+                cargoBuildCommand: config.dependencyBuildCommand,
+                worktreePath,
+            });
             if (options.json) {
-                options.stdout(`${JSON.stringify({ branch: worktreeName, path: worktreePath, dryRun: true }, null, 2)}\n`);
+                const output = {
+                    ...createNavigationTarget(createNavigationRepository(repository.repoName, repository.repoRoot), worktreePath, worktreeName),
+                    dryRun: true,
+                };
+                if (dryRunSyncDirs.length > 0)
+                    output.syncDirs = dryRunSyncDirs;
+                if (dryRunDependencyBootstrap.targets.length > 0)
+                    output.dependencyBootstrap = dryRunDependencyBootstrap;
+                options.stdout(`${JSON.stringify(output, null, 2)}\n`);
             }
             else {
                 const resolvedEditor = options.open
@@ -136,42 +215,163 @@ export function createNewCommand(dependencies = {}) {
                 const openNote = resolvedEditor
                     ? `, then open in ${resolvedEditor}`
                     : "";
-                options.stdout(`Would create worktree at ${worktreePath} (branch: ${worktreeName}${openNote})\n`);
+                options.stdout(`Would create worktree at ${worktreePath} (branch: ${worktreeName}${openNote})\n${dryRunSyncDirs.map(({ dir, bytes }) => `Would clone ${dir} (${formatBytes(bytes)})\n`).join("")}${formatDependencyBootstrapPreview(dryRunDependencyBootstrap)}`);
             }
             return 0;
         }
         await mkdir(dirname(worktreePath), { recursive: true });
-        const gitArgs = options.detached
-            ? ["worktree", "add", "--detach", worktreePath]
-            : (await localBranchExists(repository.repoRoot, worktreeName))
-                ? ["worktree", "add", worktreePath, worktreeName]
-                : ["worktree", "add", "-b", worktreeName, worktreePath];
-        await execFileAsync("git", gitArgs, { cwd: repository.repoRoot });
-        // Sync files from main worktree before afterCreate so synced files are available to install scripts.
-        const syncPatterns = Array.isArray(config.syncFiles)
-            ? config.syncFiles.filter((p) => typeof p === "string")
+        const startPoint = options.fromCurrent && !options.detached
+            ? await resolveCurrentWorktreeHead(options.cwd)
+            : undefined;
+        const takeStartPoint = options.take
+            ? await resolveCurrentWorktreeHead(options.cwd)
+            : undefined;
+        const changedTakeFiles = options.take
+            ? await listTakeFiles(options.cwd)
             : [];
-        for (const pattern of syncPatterns) {
+        const submoduleFiles = options.take
+            ? await listSubmoduleFiles(options.cwd, changedTakeFiles)
+            : [];
+        const takeFiles = changedTakeFiles.filter((file) => !submoduleFiles.includes(file));
+        const takeUntracked = options.take
+            ? await countUntrackedFiles(options.cwd)
+            : 0;
+        if (options.take && takeFiles.length === 0)
+            return emitNewError(options, submoduleFiles.length > 0
+                ? "nothing to take: submodule changes are not supported"
+                : "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 shouldRefreshBase = !options.noFetch &&
+            !options.detached &&
+            !options.fromCurrent &&
+            !options.take &&
+            options.mode !== "track" &&
+            options.mode !== "checkout" &&
+            !existingLocalBranch;
+        const freshBaseRef = shouldRefreshBase
+            ? await resolveFreshBaseRef(repository.repoRoot, config, options, promptForFetchFailure)
+            : undefined;
+        if (freshBaseRef === null)
+            return 1;
+        let stashSha = null;
+        if (options.take) {
             try {
-                await syncFiles(repository.repoRoot, worktreePath, [pattern]);
+                const inProgressState = await detectInProgressGitState(options.cwd);
+                if (inProgressState)
+                    return emitNewError(options, `cannot take changes while Git is in progress (${inProgressState})`);
+                stashSha = await createTakeStash(options.cwd, worktreeName);
             }
             catch (error) {
-                options.stderr(`Warning: failed to sync file "${pattern}": ${error instanceof Error ? error.message : String(error)}\n`);
+                return emitNewError(options, `could not stash changes safely: ${toExecMessage(error)}`);
+            }
+        }
+        const gitArgs = options.detached
+            ? [
+                "worktree",
+                "add",
+                "--detach",
+                worktreePath,
+                ...(takeStartPoint ? [takeStartPoint] : []),
+            ]
+            : options.mode === "track"
+                ? [
+                    "worktree",
+                    "add",
+                    "--track",
+                    "-b",
+                    worktreeName,
+                    worktreePath,
+                    `${options.remote ?? "origin"}/${worktreeName}`,
+                ]
+                : options.mode === "checkout" || existingLocalBranch
+                    ? ["worktree", "add", worktreePath, worktreeName]
+                    : [
+                        "worktree",
+                        "add",
+                        "-b",
+                        worktreeName,
+                        worktreePath,
+                        ...(takeStartPoint
+                            ? [takeStartPoint]
+                            : startPoint
+                                ? [startPoint]
+                                : freshBaseRef
+                                    ? [freshBaseRef]
+                                    : []),
+                    ];
+        try {
+            await execFileAsync("git", gitArgs, { cwd: repository.repoRoot });
+        }
+        catch (error) {
+            if (stashSha)
+                await restoreTakeStash(options.cwd, stashSha, options.stderr);
+            return emitNewError(options, `failed to create worktree: ${toExecMessage(error)}`);
+        }
+        if (stashSha &&
+            !(await applyTakeStash(worktreePath, options.cwd, stashSha, !!options.copy, options.stderr))) {
+            try {
+                await execFileAsync("git", ["worktree", "remove", "--force", worktreePath], { cwd: repository.repoRoot });
             }
+            catch {
+                /* rollback best effort */
+            }
+            return emitNewError(options, `could not apply taken changes; your changes are safe in stash: ${stashSha}`);
         }
-        await maybeRunInstallPrompt(worktreePath, repository.repoRoot, config, options.stderr, dependencies, !!options.json);
-        const hooks = extractHooks(config);
-        await runHook(hooks["after-create"], worktreePath, {
+        const bootstrap = await bootstrapWorktree({
             branch: worktreeName,
-            path: worktreePath,
-            repo: basename(repository.repoRoot),
-        }, options.stderr);
+            cloneDirectory,
+            config,
+            currentRoot: repository.currentRoot,
+            nonInteractive: !!options.json,
+            repoRoot: repository.repoRoot,
+            reporter: createBootstrapReporter(options.stderr, !!options.json),
+            runCommand: dependencies.runInstallCommand,
+            commandStdout: options.json ? () => undefined : options.stdout,
+            commandStderr: options.json ? () => undefined : options.stderr,
+            json: options.json,
+            worktreePath,
+            installDependencies: dependencies,
+            dependencyBootstrapPolicy: dependencyPolicy,
+        });
+        if (!bootstrap.ready) {
+            return emitNewError(options, "worktree bootstrap failed", {
+                dependencyBootstrap: bootstrap.dependencyBootstrap,
+                path: worktreePath,
+                skipped: bootstrap.skippedDirs,
+                syncFiles: bootstrap.syncFileFailures,
+            });
+        }
         if (options.json) {
-            options.stdout(`${JSON.stringify({ branch: worktreeName, path: worktreePath }, null, 2)}\n`);
+            const navigation = createNavigationTarget(createNavigationRepository(repository.repoName, repository.repoRoot), worktreePath, worktreeName);
+            const output = options.take
+                ? {
+                    ...navigation,
+                    taken: {
+                        files: takeFiles.length,
+                        untracked: takeUntracked,
+                        submodules: submoduleFiles,
+                    },
+                }
+                : { ...navigation };
+            if (bootstrap.clonedDirs.length > 0) {
+                output.cloned = bootstrap.clonedDirs.map(({ dir, ms }) => ({
+                    dir,
+                    ms,
+                }));
+            }
+            if (bootstrap.skippedDirs.length > 0)
+                output.skipped = bootstrap.skippedDirs;
+            if (bootstrap.dependencyBootstrap.mode !== "off")
+                output.dependencyBootstrap = bootstrap.dependencyBootstrap;
+            options.stdout(`${JSON.stringify(output, null, 2)}\n`);
         }
         else {
+            if (options.take)
+                options.stderr(`✓ took ${takeFiles.length} changed file${takeFiles.length === 1 ? "" : "s"} (${takeUntracked} untracked) → ${worktreeName}\n`);
             await recordWorktreeUsage(worktreePath, worktreeName);
-            await writeOutput(worktreePath, options.stdout);
+            await writeOutput(worktreePath, options.stdout, options.outputEnv);
         }
         if (options.open) {
             const resolvedEditor = options.editor ?? resolveConfigString(config, "editor");
@@ -181,6 +381,60 @@ export function createNewCommand(dependencies = {}) {
     };
 }
 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");
+    try {
+        const remoteBase = await 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]);
+        return remoteBase.ref;
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        const message = `Could not refresh ${remote}: ${detail}`;
+        if (options.json || isHeadless()) {
+            emitNewError(options, `${message}. Use --no-fetch to create from the local repository HEAD.`);
+            return null;
+        }
+        const continueWithoutRefresh = await promptForFetchFailure(message);
+        if (!continueWithoutRefresh) {
+            options.stderr("Aborted\n");
+            return null;
+        }
+        if (baseBranch &&
+            (await localRefExists(repoRoot, `refs/remotes/${remote}/${baseBranch}`))) {
+            options.stderr(`Continuing with the cached ${remote}/${baseBranch}.\n`);
+            return `${remote}/${baseBranch}`;
+        }
+        options.stderr("Continuing from the local repository HEAD.\n");
+        return "HEAD";
+    }
+}
+async function defaultPromptForFetchFailure(message) {
+    const choice = await confirm({
+        active: "Continue",
+        inactive: "Abort",
+        initialValue: false,
+        message: `${message}. Continue without refreshing the remote base?`,
+    });
+    return !isCancel(choice) && choice;
+}
+async function localRefExists(repoRoot, ref) {
+    try {
+        await runGit(repoRoot, ["rev-parse", "--verify", "--quiet", ref]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 export function generateBranchPlaceholder(random = Math.random) {
     const roots = [
         "socrates",
@@ -333,8 +587,44 @@ async function localBranchExists(repoRoot, branchName) {
         return false;
     }
 }
-async function writeOutput(worktreePath, stdout) {
-    await writeShellOutput(NEW_OUTPUT_FILE_ENV, worktreePath, stdout);
+async function resolveCurrentWorktreeHead(cwd) {
+    return execFileAsync("git", ["rev-parse", "--verify", "HEAD"], { cwd }).then(({ stdout }) => stdout.trim());
+}
+async function createTakeStash(cwd, worktreeName) {
+    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
+        .split("\n")
+        .map((candidate) => candidate.split("\0"))
+        .find(([, subject]) => subject?.endsWith(message));
+    if (!line?.[0])
+        throw new Error("could not identify the stash created for --take");
+    return line[0];
+}
+async function detectInProgressGitState(cwd) {
+    const markers = [
+        ["MERGE_HEAD", "merge"],
+        ["rebase-merge", "rebase"],
+        ["rebase-apply", "rebase"],
+        ["CHERRY_PICK_HEAD", "cherry-pick"],
+        ["REVERT_HEAD", "revert"],
+        ["BISECT_LOG", "bisect"],
+    ];
+    for (const [marker, name] of markers) {
+        try {
+            const { stdout } = await execFileAsync("git", ["rev-parse", "--git-path", marker], { cwd });
+            await access(resolve(cwd, stdout.trim()));
+            return name;
+        }
+        catch {
+            /* marker is absent */
+        }
+    }
+    return null;
+}
+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);
@@ -368,3 +658,111 @@ async function openWorktree(worktreePath, editorCli, spawnFn, stderr) {
         stderr(`gji new: failed to open editor: ${message}\n`);
     }
 }
+async function listTakeFiles(cwd) {
+    try {
+        const { stdout } = await execFileAsync("git", ["status", "--porcelain=v1"], { cwd });
+        return stdout
+            .split("\n")
+            .filter((line) => line.length > 3)
+            .map((line) => line.slice(3).replace(/^"|"$/g, ""));
+    }
+    catch {
+        return [];
+    }
+}
+async function listIgnoredFiles(cwd) {
+    try {
+        const { stdout } = await execFileAsync("git", ["status", "--porcelain=v1", "--ignored", "--untracked-files=all"], { cwd });
+        return stdout
+            .split("\n")
+            .filter((line) => line.startsWith("!! "))
+            .map((line) => line.slice(3).replace(/^"|"$/g, ""));
+    }
+    catch {
+        return [];
+    }
+}
+async function listSubmoduleFiles(cwd, changedFiles) {
+    if (changedFiles.length === 0)
+        return [];
+    try {
+        const { stdout } = await execFileAsync("git", ["ls-files", "--stage"], {
+            cwd,
+        });
+        const submodules = new Set(stdout
+            .split("\n")
+            .filter((line) => line.startsWith("160000 "))
+            .map((line) => line.slice(line.indexOf("\t") + 1)));
+        return changedFiles.filter((file) => submodules.has(file));
+    }
+    catch {
+        return [];
+    }
+}
+async function countUntrackedFiles(cwd) {
+    try {
+        const { stdout } = await execFileAsync("git", ["status", "--porcelain=v1", "--untracked-files=all"], { cwd });
+        return stdout.split("\n").filter((line) => line.startsWith("?? ")).length;
+    }
+    catch {
+        return 0;
+    }
+}
+async function applyTakeStash(worktreePath, sourcePath, stashSha, copy, stderr) {
+    try {
+        await execFileAsync("git", ["stash", "apply", stashSha], {
+            cwd: worktreePath,
+        });
+    }
+    catch (error) {
+        stderr(`Warning: stash apply failed: ${toExecMessage(error)}\n`);
+        await restoreTakeStash(sourcePath, stashSha, stderr);
+        return false;
+    }
+    if (copy) {
+        try {
+            await execFileAsync("git", ["stash", "apply", stashSha], {
+                cwd: sourcePath,
+            });
+        }
+        catch (error) {
+            stderr(`Warning: could not restore copied changes to the source: ${toExecMessage(error)}\n`);
+            return false;
+        }
+    }
+    try {
+        const { stdout } = await execFileAsync("git", ["stash", "list", "--format=%H %gd"], { cwd: sourcePath });
+        const line = stdout
+            .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 });
+    }
+    catch {
+        /* preserving the stash is safer */
+    }
+    return true;
+}
+async function restoreTakeStash(sourcePath, stashSha, stderr) {
+    try {
+        await execFileAsync("git", ["stash", "apply", stashSha], {
+            cwd: sourcePath,
+        });
+    }
+    catch {
+        stderr(`Your changes are safe in stash: ${stashSha} — run "git stash apply ${stashSha}" to restore\n`);
+    }
+}
+function emitNewError(options, message, details) {
+    if (options.json)
+        options.stderr(`${JSON.stringify({ error: message, ...details }, null, 2)}\n`);
+    else {
+        const path = typeof details?.path === "string" ? details.path : undefined;
+        options.stderr(`gji new: ${message}${path ? ` at ${path}` : ""}\n`);
+        if (path) {
+            options.stderr(`Hint: inspect the worktree or remove it with 'gji done ${path}' before retrying\n`);
+        }
+    }
+    return 1;
+}

package/dist/open.d.ts

@@ -6,6 +6,7 @@ export interface OpenCommandOptions {
     cwd: string;
     editor?: string;
     save?: boolean;
+    select?: boolean;
     stderr: (chunk: string) => void;
     stdout: (chunk: string) => void;
     workspace?: boolean;

package/dist/open.js

@@ -16,6 +16,14 @@ export function createOpenCommand(dependencies = {}) {
     const promptForWorktree = dependencies.promptForWorktree ?? defaultPromptForWorktree;
     const spawnEditor = dependencies.spawnEditor ?? defaultSpawnEditor;
     return async function runOpenCommand(options) {
+        if (options.select && options.branch !== undefined) {
+            options.stderr("gji open: --select cannot be used with a branch\n");
+            return 1;
+        }
+        if (options.select && isHeadless()) {
+            options.stderr("gji open --select: selector is unavailable in non-interactive mode (GJI_NO_TUI=1)\n");
+            return 1;
+        }
         const [worktrees, repository] = await Promise.all([
             listWorktrees(options.cwd),
             detectRepository(options.cwd),
@@ -36,9 +44,13 @@ export function createOpenCommand(dependencies = {}) {
             targetPath = match.worktree.path;
             targetWorktree = match.worktree;
         }
-        else if (isHeadless()) {
+        else if (!options.select) {
             targetWorktree = worktrees.find((w) => w.isCurrent);
-            targetPath = targetWorktree?.path ?? options.cwd;
+            if (!targetWorktree) {
+                options.stderr("gji open: unable to identify the current worktree\n");
+                return 1;
+            }
+            targetPath = targetWorktree.path;
         }
         else {
             const entries = await buildWorktreePromptEntries(worktrees.map((worktree) => ({

package/dist/pr.d.ts

@@ -1,15 +1,19 @@
 import { type PathConflictChoice } from "./conflict.js";
-import { type InstallPromptDependencies } from "./install-prompt.js";
+import { type DependencyBootstrapPromptDependencies } from "./dependency-bootstrap-prompt.js";
+import type { CloneDirectory } from "./dir-clone.js";
+import type { InstallPromptDependencies } from "./install-prompt.js";
 export type { PathConflictChoice };
 export interface PrCommandOptions {
     cwd: string;
     dryRun?: boolean;
     json?: boolean;
     number: string;
+    outputEnv?: string;
     stderr: (chunk: string) => void;
     stdout: (chunk: string) => void;
 }
-export interface PrCommandDependencies extends InstallPromptDependencies {
+export interface PrCommandDependencies extends InstallPromptDependencies, DependencyBootstrapPromptDependencies {
+    cloneDir?: CloneDirectory;
     promptForPathConflict: (path: string) => Promise<PathConflictChoice>;
 }
 export declare function parsePrInput(input: string): string | null;