@solaqua/gji 0.15.0 → 0.16.0

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() {
@@ -299,27 +297,11 @@ function registerCommands(program) {
         .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")
@@ -649,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,
@@ -681,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({

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);
 }