@solaqua/gji 0.14.0 → 0.16.0

package/dist/cli/commands/new.js

@@ -1,5 +1,5 @@
-import { access, mkdir } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
+import { access, mkdir, rmdir } from "node:fs/promises";
+import { basename, dirname, resolve } from "node:path";
 import { confirm, isCancel, text } from "@clack/prompts";
 import { resolveWorktreePath, validateBranchName, } from "../../domain/worktree/policy.js";
 import { createBootstrapReporter } from "../../presentation/bootstrap/output.js";
@@ -56,7 +56,7 @@ export function createNewCommand(dependencies = {}) {
                 options.stderr(`${JSON.stringify({ error: message }, null, 2)}\n`);
             }
             else {
-                options.stderr(`gji new: ${message} in non-interactive mode (GJI_NO_TUI=1)\n`);
+                options.stderr(`gji new: ${message} in non-interactive mode\n`);
             }
             return 1;
         }
@@ -103,7 +103,7 @@ export function createNewCommand(dependencies = {}) {
             if (options.force) {
                 if (!options.dryRun) {
                     try {
-                        await runtime.git.runGit(repository.repoRoot, [
+                        await runtime.git.runGitRetryingContention(repository.repoRoot, [
                             "worktree",
                             "remove",
                             "--force",
@@ -111,6 +111,8 @@ export function createNewCommand(dependencies = {}) {
                         ]);
                     }
                     catch (err) {
+                        // The worktree claims its path below, which an empty leftover would block.
+                        await rmdir(worktreePath).catch(() => undefined);
                         if (!isNotRegisteredWorktreeError(err)) {
                             const msg = `could not remove existing worktree at ${worktreePath}: ${toExecMessage(err)}`;
                             if (options.json) {
@@ -141,7 +143,7 @@ export function createNewCommand(dependencies = {}) {
                     options.stderr(`${JSON.stringify({ error: message }, null, 2)}\n`);
                 }
                 else {
-                    options.stderr(`gji new: ${message} in non-interactive mode (GJI_NO_TUI=1)\n`);
+                    options.stderr(`gji new: ${message} in non-interactive mode\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`);
                 }
@@ -229,13 +231,14 @@ export function createNewCommand(dependencies = {}) {
         if (options.take && submoduleFiles.length > 0)
             options.stderr(`Warning: submodule changes are not transferred: ${submoduleFiles.join(", ")}\n`);
         const existingLocalBranch = await localBranchExists(repository.repoRoot, worktreeName, runtime);
-        const shouldRefreshBase = !options.noFetch &&
-            !options.detached &&
-            !options.fromCurrent &&
-            !options.take &&
+        const createsBranch = !options.detached &&
             options.mode !== "track" &&
             options.mode !== "checkout" &&
             !existingLocalBranch;
+        const shouldRefreshBase = createsBranch &&
+            !options.noFetch &&
+            !options.fromCurrent &&
+            !options.take;
         const freshBaseRef = shouldRefreshBase
             ? await resolveFreshBaseRef(repository.repoRoot, config, options, promptForFetchFailure, runtime)
             : undefined;
@@ -253,42 +256,21 @@ export function createNewCommand(dependencies = {}) {
                 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]
-                                    : []),
-                    ];
+        const addsNewBranch = createsBranch || (!options.detached && options.mode === "track");
         try {
-            await runtime.git.runGit(repository.repoRoot, gitArgs);
+            await runtime.git.addWorktree(repository.repoRoot, worktreePath, options.detached
+                ? { detachedAt: takeStartPoint }
+                : addsNewBranch
+                    ? {
+                        branch: worktreeName,
+                        create: {
+                            startPoint: options.mode === "track"
+                                ? `${options.remote ?? "origin"}/${worktreeName}`
+                                : (takeStartPoint ?? startPoint ?? freshBaseRef),
+                            track: options.mode === "track",
+                        },
+                    }
+                    : { branch: worktreeName });
         }
         catch (error) {
             if (stashSha)
@@ -297,17 +279,7 @@ export function createNewCommand(dependencies = {}) {
         }
         if (stashSha &&
             !(await applyTakeStash(worktreePath, options.cwd, stashSha, !!options.copy, options.stderr, runtime.git.runGit))) {
-            try {
-                await runtime.git.runGit(repository.repoRoot, [
-                    "worktree",
-                    "remove",
-                    "--force",
-                    worktreePath,
-                ]);
-            }
-            catch {
-                /* rollback best effort */
-            }
+            await runtime.git.removeCreatedWorktree(repository.repoRoot, worktreePath, addsNewBranch ? worktreeName : undefined);
             return emitNewError(options, `could not apply taken changes; your changes are safe in stash: ${stashSha}`);
         }
         if (options.task !== undefined) {
@@ -338,6 +310,17 @@ export function createNewCommand(dependencies = {}) {
                 syncFiles: bootstrap.syncFileFailures,
             });
         }
+        if (createsBranch) {
+            await runNewHooks({
+                branch: worktreeName,
+                config,
+                hookNames: ["after-branch-create"],
+                options,
+                path: worktreePath,
+                repository,
+                runtime,
+            });
+        }
         if (options.json) {
             const navigation = createNavigationTarget(createNavigationRepository(repository.repoName, repository.repoRoot), worktreePath, worktreeName);
             const output = options.take
@@ -438,7 +421,7 @@ async function runBranchOnly(options, runtime, repository, config, rawBranch) {
     try {
         let startPoint = baseBranch;
         if (!options.noFetch) {
-            await runtime.git.runGit(repository.repoRoot, [
+            await runtime.git.runGitRetryingContention(repository.repoRoot, [
                 "fetch",
                 "--prune",
                 remote,
@@ -446,16 +429,29 @@ async function runBranchOnly(options, runtime, repository, config, rawBranch) {
             ]);
             startPoint = `${remote}/${baseBranch}`;
         }
-        await runtime.git.runGit(options.cwd, [
-            "switch",
-            "-c",
-            branchName,
+        await runtime.git.createBranch(repository.repoRoot, branchName, {
             startPoint,
-        ]);
+        });
+        try {
+            await runtime.git.runGit(options.cwd, ["switch", branchName]);
+        }
+        catch (error) {
+            await runtime.git.deleteCreatedBranch(repository.repoRoot, branchName);
+            throw error;
+        }
     }
     catch (error) {
         return emitNewError(options, `failed to create branch in the current worktree: ${toExecMessage(error)}`);
     }
+    await runNewHooks({
+        branch: branchName,
+        config,
+        hookNames: ["after-branch-create", "after-switch"],
+        options,
+        path: repository.currentRoot,
+        repository,
+        runtime,
+    });
     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`);
@@ -467,6 +463,18 @@ async function runBranchOnly(options, runtime, repository, config, rawBranch) {
     }
     return 0;
 }
+async function runNewHooks({ branch, config, hookNames, options, path, repository, runtime, }) {
+    const hooks = runtime.hooks.extractHooks(config);
+    const context = {
+        branch,
+        path,
+        repo: basename(repository.repoRoot),
+        slot: await runtime.slots.getWorktreeSlot(path),
+    };
+    for (const hookName of hookNames) {
+        await runtime.hooks.runHook(hooks[hookName], path, context, options.json ? () => undefined : options.stderr, options.json ? () => undefined : options.stdout);
+    }
+}
 export const runNewCommand = createNewCommand();
 async function resolveFreshBaseRef(repoRoot, config, options, promptForFetchFailure, runtime) {
     const remote = runtime.config.resolveConfigString(config, "syncRemote") ?? "origin";
@@ -480,7 +488,7 @@ async function resolveFreshBaseRef(repoRoot, config, options, promptForFetchFail
             throw new Error("the remote default branch is unknown");
         }
         baseBranch = remoteBase.branch;
-        await runtime.git.runGit(repoRoot, [
+        await runtime.git.runGitRetryingContention(repoRoot, [
             "fetch",
             "--prune",
             remote,
@@ -640,7 +648,7 @@ function generateBranchPlaceholderSuffix(random) {
     }
     return suffix;
 }
-function applyConfiguredBranchPrefix(branch, branchPrefix) {
+export function applyConfiguredBranchPrefix(branch, branchPrefix) {
     if (typeof branchPrefix !== "string" || branchPrefix.length === 0) {
         return branch;
     }

package/dist/cli/commands/open.js

@@ -26,7 +26,7 @@ export function createOpenCommand(dependencies = {}) {
             return 1;
         }
         if (options.select && isHeadless()) {
-            options.stderr("gji open --select: selector is unavailable in non-interactive mode (GJI_NO_TUI=1)\n");
+            options.stderr("gji open --select: selector is unavailable in non-interactive mode; pass a branch instead\n");
             return 1;
         }
         const [worktrees, repository] = await Promise.all([

package/dist/cli/commands/pr-open.js

@@ -23,7 +23,7 @@ export function createPrOpenCommand(dependencies = {}) {
             return 1;
         }
         if (options.select && isHeadless()) {
-            options.stderr("gji pr open --select: selector is unavailable in non-interactive mode (GJI_NO_TUI=1)\n");
+            options.stderr("gji pr open --select: selector is unavailable in non-interactive mode; pass a branch or PR number instead\n");
             return 1;
         }
         const repository = await detectRepository(options.cwd).catch((error) => {
@@ -236,7 +236,7 @@ async function openPullRequests(pullRequests, options, promptForPullRequest, ope
         return 1;
     }
     if (pullRequests.length > 1 && isHeadless()) {
-        options.stderr("gji pr open: multiple open PRs found; pass an explicit PR number in non-interactive mode (GJI_NO_TUI=1)\n");
+        options.stderr("gji pr open: multiple open PRs found; pass an explicit PR number in non-interactive mode\n");
         return 1;
     }
     const selected = pullRequests.length === 1

package/dist/cli/commands/pr.js

@@ -54,7 +54,7 @@ export function createPrCommand(dependencies = {}) {
                     options.stderr(`${JSON.stringify({ error: message }, null, 2)}\n`);
                 }
                 else {
-                    options.stderr(`gji pr: ${message} in non-interactive mode (GJI_NO_TUI=1)\n`);
+                    options.stderr(`gji pr: ${message} in non-interactive mode\n`);
                     options.stderr(`Hint: Use 'gji done pr/${prNumber}' or 'gji clean' to remove the existing worktree\n`);
                 }
                 return 1;
@@ -108,10 +108,21 @@ export function createPrCommand(dependencies = {}) {
         }
         await mkdir(dirname(worktreePath), { recursive: true });
         const branchAlreadyExists = await localBranchExists(repository.repoRoot, branchName, runtime);
-        const worktreeArgs = branchAlreadyExists
-            ? ["worktree", "add", worktreePath, branchName]
-            : ["worktree", "add", "-b", branchName, worktreePath, remoteRef];
-        await runtime.git.runGit(repository.repoRoot, worktreeArgs);
+        try {
+            await runtime.git.addWorktree(repository.repoRoot, worktreePath, branchAlreadyExists
+                ? { branch: branchName }
+                : { branch: branchName, create: { startPoint: remoteRef } });
+        }
+        catch (error) {
+            const message = `failed to create worktree: ${error instanceof Error ? error.message : String(error)}`;
+            if (options.json) {
+                options.stderr(`${JSON.stringify({ error: message }, null, 2)}\n`);
+            }
+            else {
+                options.stderr(`gji pr: ${message}\n`);
+            }
+            return 1;
+        }
         const bootstrap = await runtime.bootstrap.bootstrapWorktree({
             branch: branchName,
             config,
@@ -173,7 +184,7 @@ export const runPrCommand = createPrCommand();
 async function fetchPullRequestRef(repoRoot, input, prNumber, remoteRef, runtime) {
     for (const sourceRef of listPullRequestSourceRefs(input, prNumber)) {
         try {
-            await runtime.git.runGit(repoRoot, [
+            await runtime.git.runGitRetryingContention(repoRoot, [
                 "fetch",
                 "origin",
                 `${sourceRef}:${remoteRef}`,

package/dist/cli/commands/run-hook.js

@@ -1,12 +1,16 @@
 import { defaultCliDependencies } from "../dependencies.js";
 const VALID_HOOKS = [
+    "after-branch-create",
     "after-create",
     "after-enter",
+    "after-switch",
     "before-remove",
 ];
 const CAMEL_ALIASES = {
+    afterBranchCreate: "after-branch-create",
     afterCreate: "after-create",
     afterEnter: "after-enter",
+    afterSwitch: "after-switch",
     beforeRemove: "before-remove",
 };
 function isValidHook(hook) {

package/dist/cli/commands/undo.js

@@ -1,14 +1,11 @@
-import { access, mkdir, open, readFile, rename, stat, unlink, writeFile, } from "node:fs/promises";
+import { access, readFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { join, resolve } from "node:path";
 import { confirm, isCancel } from "@clack/prompts";
+import { withFileLock, writeJsonAtomic, } from "../../infrastructure/filesystem/locked-file.js";
 import { defaultCliDependencies, } from "../dependencies.js";
 import { isHeadless } from "../runtime/headless.js";
 const MAX_UNDO_RECORDS = 20;
-const UNDO_LOCK_STALE_AFTER_MS = 60_000;
-const UNDO_LOCK_RETRY_DELAY_MS = 5;
-const UNDO_LOCK_WAIT_TIMEOUT_MS = UNDO_LOCK_STALE_AFTER_MS + UNDO_LOCK_RETRY_DELAY_MS;
-const undoLogQueues = new Map();
 export function undoLogPath(home = homedir(), globalConfigDirectory = defaultCliDependencies.configStore
     .GLOBAL_CONFIG_DIRECTORY) {
     const configured = process.env.GJI_CONFIG_DIR;
@@ -65,16 +62,16 @@ export async function recordUndoOperation(op, repoRoot, worktrees, home = homedi
         timestamp,
         entries,
     };
-    return enqueueUndoLogWrite(home, async () => {
+    return withFileLock(undoLogPath(home, globalConfigDirectory), async () => {
         const existing = await loadUndoRecords(home, globalConfigDirectory);
         await writeUndoRecords(home, [record, ...existing].slice(0, MAX_UNDO_RECORDS), globalConfigDirectory);
         return record;
-    }, globalConfigDirectory);
+    });
 }
 export async function finalizeUndoOperation(record, removedWorktrees, home = homedir(), globalConfigDirectory = defaultCliDependencies.configStore
     .GLOBAL_CONFIG_DIRECTORY) {
     const removedPaths = new Set(removedWorktrees.map((worktree) => worktree.path));
-    await enqueueUndoLogWrite(home, async () => {
+    await withFileLock(undoLogPath(home, globalConfigDirectory), async () => {
         const records = await loadUndoRecords(home, globalConfigDirectory);
         const remaining = records.flatMap((candidate) => {
             if (candidate.id !== record.id)
@@ -83,7 +80,7 @@ export async function finalizeUndoOperation(record, removedWorktrees, home = hom
             return entries.length === 0 ? [] : [{ ...candidate, entries }];
         });
         await writeUndoRecords(home, remaining, globalConfigDirectory);
-    }, globalConfigDirectory);
+    });
 }
 export async function restoreUndoRecord(record, home = homedir(), runtime = defaultCliDependencies) {
     const globalConfigDirectory = runtime.configStore.GLOBAL_CONFIG_DIRECTORY;
@@ -104,7 +101,7 @@ export async function restoreUndoRecord(record, home = homedir(), runtime = defa
             unresolved.push(entry);
         }
     }
-    await enqueueUndoLogWrite(home, async () => {
+    await withFileLock(undoLogPath(home, globalConfigDirectory), async () => {
         const records = await loadUndoRecords(home, globalConfigDirectory);
         const remaining = records.flatMap((candidate) => {
             if (candidate.id !== record.id)
@@ -114,7 +111,7 @@ export async function restoreUndoRecord(record, home = homedir(), runtime = defa
             return [{ ...candidate, entries: unresolved }];
         });
         await writeUndoRecords(home, remaining, globalConfigDirectory);
-    }, globalConfigDirectory);
+    });
     return { restored, failed };
 }
 export async function runUndoCommand(options) {
@@ -292,70 +289,9 @@ async function assertCommitExists(repoRoot, headSha, runGit) {
         throw new Error("commit no longer exists (gc'd) — cannot restore");
     }
 }
-async function enqueueUndoLogWrite(home, operation, globalConfigDirectory = defaultCliDependencies.configStore
-    .GLOBAL_CONFIG_DIRECTORY) {
-    const path = undoLogPath(home, globalConfigDirectory);
-    await mkdir(dirname(path), { recursive: true });
-    const previous = undoLogQueues.get(path) ?? Promise.resolve();
-    const runLocked = async () => {
-        const release = await acquireUndoLogLock(path);
-        try {
-            return await operation();
-        }
-        finally {
-            await release();
-        }
-    };
-    const current = previous.then(runLocked, runLocked);
-    const settled = current.then(() => undefined, () => undefined);
-    undoLogQueues.set(path, settled);
-    try {
-        return await current;
-    }
-    finally {
-        if (undoLogQueues.get(path) === settled)
-            undoLogQueues.delete(path);
-    }
-}
-async function acquireUndoLogLock(path) {
-    const lockPath = `${path}.lock`;
-    const deadline = Date.now() + UNDO_LOCK_WAIT_TIMEOUT_MS;
-    while (Date.now() < deadline) {
-        try {
-            const handle = await open(lockPath, "wx");
-            return async () => {
-                await handle.close();
-                await unlink(lockPath).catch(() => undefined);
-            };
-        }
-        catch (error) {
-            if (!(error instanceof Error && "code" in error && error.code === "EEXIST"))
-                throw error;
-            const lockStat = await stat(lockPath).catch(() => null);
-            if (lockStat && Date.now() - lockStat.mtimeMs > UNDO_LOCK_STALE_AFTER_MS)
-                await unlink(lockPath).catch(() => undefined);
-            const remainingMs = deadline - Date.now();
-            if (remainingMs > 0)
-                await new Promise((resolve) => setTimeout(resolve, Math.min(UNDO_LOCK_RETRY_DELAY_MS, remainingMs)));
-        }
-    }
-    throw new Error("timed out waiting for the undo journal lock");
-}
 async function writeUndoRecords(home, records, globalConfigDirectory = defaultCliDependencies.configStore
     .GLOBAL_CONFIG_DIRECTORY) {
-    const path = undoLogPath(home, globalConfigDirectory);
-    await mkdir(dirname(path), { recursive: true });
-    const temporaryPath = `${path}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
-    try {
-        await writeFile(temporaryPath, `${JSON.stringify(records, null, 2)}\n`, {
-            encoding: "utf8",
-            flag: "wx",
-        });
-        await rename(temporaryPath, path);
-    }
-    finally {
-        await unlink(temporaryPath).catch(() => undefined);
-    }
+    await writeJsonAtomic(undoLogPath(home, globalConfigDirectory), records);
 }
 function isUndoRecord(value) {
     if (!value || typeof value !== "object")

package/dist/cli/dependencies.d.ts

@@ -12,7 +12,7 @@ import { clearTask, readTask, writeTask } from "../infrastructure/persistence/ta
 import { extractHooks, runHook } from "../infrastructure/process/hooks.js";
 import { loadRegistry, REGISTRY_FILE_PATH, registerRepo, removeMissingRegistryEntries } from "../infrastructure/repository/registry.js";
 import { readWorktreeInfo, readWorktreeInfos, serializeWorktreeInfo } from "../infrastructure/worktree/info.js";
-import { deleteBranch, forceDeleteBranch, forceRemoveWorktree, isBranchUnmergedError, isSubmoduleWorktreeRemovalError, isWorktreeDeletionError, isWorktreeForceRemovalError, removeWorktree } from "../infrastructure/worktree/lifecycle.js";
+import { addWorktree, createBranch, deleteBranch, deleteCreatedBranch, forceDeleteBranch, forceRemoveWorktree, isBranchUnmergedError, isSubmoduleWorktreeRemovalError, isWorktreeDeletionError, isWorktreeForceRemovalError, removeCreatedWorktree, removeWorktree } from "../infrastructure/worktree/lifecycle.js";
 import type { DependencyBootstrapPort, WorktreeBootstrapPort } from "../ports/bootstrap.js";
 import type { ConfigPort } from "../ports/config.js";
 import type { GitCommandPort } from "../ports/git.js";
@@ -42,6 +42,10 @@ export interface CliDependencies {
         runHook: typeof runHook;
     };
     git: GitCommandPort & {
+        addWorktree: typeof addWorktree;
+        createBranch: typeof createBranch;
+        deleteCreatedBranch: typeof deleteCreatedBranch;
+        removeCreatedWorktree: typeof removeCreatedWorktree;
         isDirtyWorktree: typeof isDirtyWorktree;
         readWorktreeHealth: typeof readWorktreeHealth;
         isBranchMergedInto: typeof isBranchMergedInto;

package/dist/cli/dependencies.js

@@ -2,7 +2,7 @@ import { prepareDependencyBootstrap, previewDependencyBootstrap, resolveDependen
 import { validateSyncFilePattern } from "../infrastructure/filesystem/file-sync.js";
 import { isDirtyWorktree, readWorktreeHealth, } from "../infrastructure/git/health.js";
 import { isBranchMergedInto, readBranchLastCommitTimestamp, resolveRemoteBase, resolveRemoteDefaultBranch, } from "../infrastructure/git/refs.js";
-import { runGit, runGitRaw } from "../infrastructure/git/runner.js";
+import { runGit, runGitRaw, runGitRetryingContention, } from "../infrastructure/git/runner.js";
 import { openBrowser } from "../infrastructure/integrations/browser.js";
 import { defaultSpawnEditor, EDITORS, } from "../infrastructure/integrations/editor.js";
 import { createPullRequestQuery } from "../infrastructure/integrations/pull-requests.js";
@@ -15,7 +15,7 @@ import { configPort, repositoryContextPort, repositoryRefPort, repositoryRegistr
 import { loadRegistry, REGISTRY_FILE_PATH, registerRepo, removeMissingRegistryEntries, } from "../infrastructure/repository/registry.js";
 import { bootstrapWorktree } from "../infrastructure/worktree/bootstrap.js";
 import { readWorktreeInfo, readWorktreeInfos, serializeWorktreeInfo, } from "../infrastructure/worktree/info.js";
-import { deleteBranch, forceDeleteBranch, forceRemoveWorktree, isBranchUnmergedError, isSubmoduleWorktreeRemovalError, isWorktreeDeletionError, isWorktreeForceRemovalError, removeWorktree, } from "../infrastructure/worktree/lifecycle.js";
+import { addWorktree, createBranch, deleteBranch, deleteCreatedBranch, forceDeleteBranch, forceRemoveWorktree, isBranchUnmergedError, isSubmoduleWorktreeRemovalError, isWorktreeDeletionError, isWorktreeForceRemovalError, removeCreatedWorktree, removeWorktree, } from "../infrastructure/worktree/lifecycle.js";
 import { formatLastCommit, formatRelativeAge, formatUpstreamState, } from "../presentation/worktree/format.js";
 export function createCliDependencies() {
     const pullRequests = createPullRequestQuery();
@@ -49,6 +49,11 @@ export function createCliDependencies() {
         git: {
             runGit,
             runGitRaw,
+            runGitRetryingContention,
+            addWorktree,
+            createBranch,
+            deleteCreatedBranch,
+            removeCreatedWorktree,
             isDirtyWorktree,
             readWorktreeHealth,
             isBranchMergedInto,

package/dist/cli/program.js

@@ -16,7 +16,6 @@ import { runNewCommand } from "./commands/new.js";
 import { runOpenCommand } from "./commands/open.js";
 import { runPrCommand } from "./commands/pr.js";
 import { createPrOpenCommand, } from "./commands/pr-open.js";
-import { runRemoveCommand } from "./commands/remove.js";
 import { runRootCommand } from "./commands/root.js";
 import { runHookCommand } from "./commands/run-hook.js";
 import { runStatusCommand } from "./commands/status.js";
@@ -24,7 +23,6 @@ import { runSyncCommand } from "./commands/sync.js";
 import { runSyncFilesCommand } from "./commands/sync-files-command.js";
 import { runTaskCommand } from "./commands/task-command.js";
 import { runUndoCommand } from "./commands/undo.js";
-import { runWarpCommand } from "./commands/warp.js";
 import { createCliDependencies } from "./dependencies.js";
 import { isHeadless } from "./runtime/headless.js";
 export function createProgram() {
@@ -295,30 +293,15 @@ function registerCommands(program) {
         .description("interactively prune linked worktrees")
         .option("-f, --force", "bypass prompts, force-remove dirty worktrees, and force-delete unmerged branches")
         .option("--stale", "only target clean worktrees whose upstream is gone and branch is merged into the default branch")
+        .option("--path <pattern>", "only target worktrees under a directory or matching a path glob (repeatable)", collectOption)
         .option("--dry-run", "show what would be deleted without removing anything")
         .option("--json", "emit JSON on success or error instead of human-readable output")
         .action(notImplemented("clean"));
-    program
-        .command("remove [branch]")
-        .alias("rm")
-        .description("deprecated: use gji done for one worktree or gji clean for bulk cleanup")
-        .option("-f, --force", "bypass prompts, force-remove a dirty worktree, and force-delete an unmerged branch")
-        .option("--dry-run", "show what would be deleted without removing anything")
-        .option("--json", "emit JSON on success or error instead of human-readable output")
-        .action(notImplemented("remove"));
     program
         .command("run-hook <hook>")
         .alias("trigger-hook")
-        .description("run a named hook (after-create, after-enter, before-remove) in the current worktree")
+        .description("run a named hook (after-branch-create, after-create, after-enter, after-switch, before-remove) in the current worktree")
         .action(notImplemented("run-hook"));
-    program
-        .command("warp [branch]")
-        .description("deprecated: use gji go (press Tab for all known repos)")
-        // --print is the shell-wrapper bypass signal (see SHELL_WRAPPED_COMMANDS in init.ts).
-        // The shell omits GJI_WARP_OUTPUT_FILE, so writeShellOutput falls through to stdout.
-        .option("--print", "print the resolved worktree path without changing directory")
-        .option("--json", "emit JSON on success or error instead of human-readable output")
-        .action(notImplemented("warp"));
     const configCommand = program
         .command("config")
         .description("manage global config defaults")
@@ -638,6 +621,7 @@ function attachCommandActions(program, options) {
             dryRun: commandOptions.dryRun,
             force: commandOptions.force,
             json: commandOptions.json,
+            paths: commandOptions.path,
             stale: commandOptions.stale,
             runtime: options.dependencies,
             stderr: options.stderr,
@@ -647,27 +631,6 @@ function attachCommandActions(program, options) {
             throw commanderExit(exitCode);
         }
     });
-    const runRemovalCommand = async (branch, commandOptions = {}) => {
-        const exitCode = await runRemoveCommand({
-            branch,
-            cwd: options.cwd,
-            dryRun: commandOptions.dryRun,
-            force: commandOptions.force,
-            json: commandOptions.json,
-            runtime: options.dependencies,
-            stderr: options.stderr,
-            stdout: options.stdout,
-        });
-        if (exitCode !== 0) {
-            throw commanderExit(exitCode);
-        }
-    };
-    requireCommand(program, "remove").action(async (branch, commandOptions) => {
-        if (!commandOptions.json) {
-            options.stderr("gji remove is deprecated; use 'gji done' for one worktree or 'gji clean' for bulk cleanup.\n");
-        }
-        return runRemovalCommand(branch, commandOptions);
-    });
     requireCommand(program, "run-hook").action(async (hook) => {
         const exitCode = await runHookCommand({
             cwd: options.cwd,
@@ -679,22 +642,6 @@ function attachCommandActions(program, options) {
             throw commanderExit(exitCode);
         }
     });
-    requireCommand(program, "warp").action(async (branch, commandOptions) => {
-        if (!commandOptions.json) {
-            options.stderr("gji warp is deprecated; use 'gji go' (press Tab for all repositories).\n");
-        }
-        const exitCode = await runWarpCommand({
-            branch,
-            cwd: options.cwd,
-            json: commandOptions.json,
-            runtime: options.dependencies,
-            stderr: options.stderr,
-            stdout: options.stdout,
-        });
-        if (exitCode !== 0) {
-            throw commanderExit(exitCode);
-        }
-    });
     const configCommand = requireCommand(program, "config");
     configCommand.action(async () => {
         const exitCode = await runConfigCommand({
@@ -752,6 +699,9 @@ function requireCommand(parent, name) {
     }
     return command;
 }
+function collectOption(value, previous = []) {
+    return [...previous, value];
+}
 function notImplemented(commandName) {
     return () => {
         throw new Error(`'${commandName}' is not implemented yet.`);

package/dist/cli/runtime/headless.d.ts

@@ -1,6 +1,6 @@
 /**
- * Returns true when running in a non-interactive (headless) environment.
- * Set GJI_NO_TUI=1 to disable all interactive prompts.
- * Commands that would otherwise hang waiting for input must fail fast instead.
+ * Returns true when no one can answer a prompt: GJI_NO_TUI=1 is set, or stdin
+ * or stdout is not a terminal.
+ * Commands that would otherwise wait for input must fail fast instead.
  */
 export declare function isHeadless(): boolean;

package/dist/cli/runtime/headless.js

@@ -1,8 +1,10 @@
 /**
- * Returns true when running in a non-interactive (headless) environment.
- * Set GJI_NO_TUI=1 to disable all interactive prompts.
- * Commands that would otherwise hang waiting for input must fail fast instead.
+ * Returns true when no one can answer a prompt: GJI_NO_TUI=1 is set, or stdin
+ * or stdout is not a terminal.
+ * Commands that would otherwise wait for input must fail fast instead.
  */
 export function isHeadless() {
-    return process.env.GJI_NO_TUI === "1";
+    return (process.env.GJI_NO_TUI === "1" ||
+        process.stdin.isTTY !== true ||
+        process.stdout.isTTY !== true);
 }