@solaqua/gji 0.1.0-beta.9 → 0.2.0

package/dist/pr.js

@@ -1,8 +1,13 @@
 import { mkdir } from 'node:fs/promises';
-import { dirname } from 'node:path';
+import { basename, dirname } from 'node:path';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
+import { loadEffectiveConfig } from './config.js';
+import { syncFiles } from './file-sync.js';
 import { pathExists, promptForPathConflict } from './conflict.js';
+import { extractHooks, runHook } from './hooks.js';
+import { isHeadless } from './headless.js';
+import { maybeRunInstallPrompt } from './install-prompt.js';
 import { detectRepository, resolveWorktreePath } from './repo.js';
 import { writeShellOutput } from './shell-handoff.js';
 const execFileAsync = promisify(execFile);
@@ -23,14 +28,31 @@ export function createPrCommand(dependencies = {}) {
     return async function runPrCommand(options) {
         const prNumber = parsePrInput(options.number);
         if (!prNumber) {
-            options.stderr(`Invalid PR reference: ${options.number}\n`);
+            const message = `Invalid PR reference: ${options.number}`;
+            if (options.json) {
+                options.stderr(`${JSON.stringify({ error: message }, null, 2)}\n`);
+            }
+            else {
+                options.stderr(`${message}\n`);
+            }
             return 1;
         }
         const repository = await detectRepository(options.cwd);
+        const config = await loadEffectiveConfig(repository.repoRoot);
         const branchName = `pr/${prNumber}`;
         const remoteRef = `refs/remotes/origin/pull/${prNumber}/head`;
         const worktreePath = resolveWorktreePath(repository.repoRoot, branchName);
         if (await pathExists(worktreePath)) {
+            if (options.json || isHeadless()) {
+                const message = `target worktree path already exists: ${worktreePath}`;
+                if (options.json) {
+                    options.stderr(`${JSON.stringify({ error: message }, null, 2)}\n`);
+                }
+                else {
+                    options.stderr(`gji pr: ${message} in non-interactive mode (GJI_NO_TUI=1)\n`);
+                }
+                return 1;
+            }
             const choice = await prompt(worktreePath);
             if (choice === 'reuse') {
                 await writeOutput(worktreePath, options.stdout);
@@ -43,7 +65,13 @@ export function createPrCommand(dependencies = {}) {
             await execFileAsync('git', ['fetch', 'origin', `refs/pull/${prNumber}/head:${remoteRef}`], { cwd: repository.repoRoot });
         }
         catch {
-            options.stderr(`Failed to fetch PR #${prNumber} from origin\n`);
+            const message = `Failed to fetch PR #${prNumber} from origin`;
+            if (options.json) {
+                options.stderr(`${JSON.stringify({ error: message }, null, 2)}\n`);
+            }
+            else {
+                options.stderr(`${message}\n`);
+            }
             return 1;
         }
         await mkdir(dirname(worktreePath), { recursive: true });
@@ -52,7 +80,27 @@ export function createPrCommand(dependencies = {}) {
             ? ['worktree', 'add', worktreePath, branchName]
             : ['worktree', 'add', '-b', branchName, worktreePath, remoteRef];
         await execFileAsync('git', worktreeArgs, { cwd: repository.repoRoot });
-        await writeOutput(worktreePath, options.stdout);
+        // 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')
+            : [];
+        for (const pattern of syncPatterns) {
+            try {
+                await syncFiles(repository.repoRoot, worktreePath, [pattern]);
+            }
+            catch (error) {
+                options.stderr(`Warning: failed to sync file "${pattern}": ${error instanceof Error ? error.message : String(error)}\n`);
+            }
+        }
+        await maybeRunInstallPrompt(worktreePath, repository.repoRoot, config, options.stderr, dependencies, !!options.json);
+        const hooks = extractHooks(config);
+        await runHook(hooks.afterCreate, worktreePath, { branch: branchName, path: worktreePath, repo: basename(repository.repoRoot) }, options.stderr);
+        if (options.json) {
+            options.stdout(`${JSON.stringify({ branch: branchName, path: worktreePath }, null, 2)}\n`);
+        }
+        else {
+            await writeOutput(worktreePath, options.stdout);
+        }
         return 0;
     };
 }

package/dist/remove.d.ts

@@ -2,10 +2,14 @@ import type { WorktreeEntry } from './repo.js';
 export interface RemoveCommandOptions {
     branch?: string;
     cwd: string;
+    force?: boolean;
+    json?: boolean;
     stderr: (chunk: string) => void;
     stdout: (chunk: string) => void;
 }
 export interface RemoveCommandDependencies {
+    confirmForceDeleteBranch: (branch: string) => Promise<boolean>;
+    confirmForceRemoveWorktree: (worktreePath: string) => Promise<boolean>;
     confirmRemoval: (worktree: WorktreeEntry) => Promise<boolean>;
     promptForWorktree: (worktrees: WorktreeEntry[]) => Promise<string | null>;
 }

package/dist/remove.js

@@ -1,14 +1,31 @@
+import { basename } from 'node:path';
 import { confirm, isCancel, select } from '@clack/prompts';
-import { deleteBranch, loadLinkedWorktrees, removeWorktree, } from './worktree-management.js';
+import { loadEffectiveConfig } from './config.js';
+import { extractHooks, runHook } from './hooks.js';
+import { isHeadless } from './headless.js';
+import { deleteBranch, forceDeleteBranch, forceRemoveWorktree, isBranchUnmergedError, isWorktreeDirtyError, loadLinkedWorktrees, removeWorktree, } from './worktree-management.js';
+import { defaultConfirmForceDeleteBranch, defaultConfirmForceRemoveWorktree } from './worktree-prompts.js';
 import { writeShellOutput } from './shell-handoff.js';
 const REMOVE_OUTPUT_FILE_ENV = 'GJI_REMOVE_OUTPUT_FILE';
 export function createRemoveCommand(dependencies = {}) {
     const promptForWorktree = dependencies.promptForWorktree ?? defaultPromptForWorktree;
     const confirmRemoval = dependencies.confirmRemoval ?? defaultConfirmRemoval;
+    const confirmForceRemoveWorktree = dependencies.confirmForceRemoveWorktree ?? defaultConfirmForceRemoveWorktree;
+    const confirmForceDeleteBranch = dependencies.confirmForceDeleteBranch ?? defaultConfirmForceDeleteBranch;
     return async function runRemoveCommand(options) {
         const { linkedWorktrees, repository } = await loadLinkedWorktrees(options.cwd);
         if (linkedWorktrees.length === 0) {
-            options.stderr('No linked worktrees to finish\n');
+            emitError(options, 'No linked worktrees to finish');
+            return 1;
+        }
+        if (!options.branch && (options.json || isHeadless())) {
+            const message = 'branch argument is required';
+            if (options.json) {
+                emitError(options, message);
+            }
+            else {
+                options.stderr(`gji remove: ${message} in non-interactive mode (GJI_NO_TUI=1)\n`);
+            }
             return 1;
         }
         const selection = options.branch ?? (await promptForWorktree(linkedWorktrees));
@@ -18,18 +35,72 @@ export function createRemoveCommand(dependencies = {}) {
         }
         const worktree = linkedWorktrees.find((entry) => entry.branch === selection || entry.path === selection);
         if (!worktree) {
-            options.stderr(`No linked worktree found for branch: ${selection}\n`);
+            emitError(options, `No linked worktree found for branch: ${selection}`);
             return 1;
         }
-        if (!(await confirmRemoval(worktree))) {
+        if (!options.force && (options.json || isHeadless())) {
+            const message = '--force is required';
+            if (options.json) {
+                emitError(options, message);
+            }
+            else {
+                options.stderr(`gji remove: ${message} in non-interactive mode (GJI_NO_TUI=1)\n`);
+            }
+            return 1;
+        }
+        if (!options.force && !(await confirmRemoval(worktree))) {
             options.stderr('Aborted\n');
             return 1;
         }
-        await removeWorktree(repository.repoRoot, worktree.path);
+        const config = await loadEffectiveConfig(repository.repoRoot);
+        const hooks = extractHooks(config);
+        await runHook(hooks.beforeRemove, worktree.path, { branch: worktree.branch ?? undefined, path: worktree.path, repo: basename(repository.repoRoot) }, options.stderr);
+        try {
+            await removeWorktree(repository.repoRoot, worktree.path);
+        }
+        catch (error) {
+            if (!isWorktreeDirtyError(error)) {
+                throw error;
+            }
+            if (!options.force && !(await confirmForceRemoveWorktree(worktree.path))) {
+                options.stderr('Aborted\n');
+                return 1;
+            }
+            try {
+                await forceRemoveWorktree(repository.repoRoot, worktree.path);
+            }
+            catch (forceError) {
+                emitError(options, `Failed to remove worktree at ${worktree.path}: ${toMessage(forceError)}`);
+                return 1;
+            }
+        }
         if (worktree.branch) {
-            await deleteBranch(repository.repoRoot, worktree.branch);
+            try {
+                await deleteBranch(repository.repoRoot, worktree.branch);
+            }
+            catch (error) {
+                if (!isBranchUnmergedError(error)) {
+                    throw error;
+                }
+                if (options.force || (await confirmForceDeleteBranch(worktree.branch))) {
+                    try {
+                        await forceDeleteBranch(repository.repoRoot, worktree.branch);
+                    }
+                    catch (forceError) {
+                        options.stderr(`Failed to delete branch ${worktree.branch}: ${toMessage(forceError)}\n`);
+                    }
+                }
+                else {
+                    options.stderr(`Branch ${worktree.branch} was not deleted (has unmerged commits)\n`);
+                }
+            }
+        }
+        if (options.json) {
+            options.stdout(`${JSON.stringify({ branch: worktree.branch, path: worktree.path, deleted: true }, null, 2)}\n`);
+        }
+        else {
+            await writeOutput(repository.repoRoot, options.stdout);
         }
-        await writeOutput(repository.repoRoot, options.stdout);
         return 0;
     };
 }
@@ -59,3 +130,14 @@ async function defaultConfirmRemoval(worktree) {
 async function writeOutput(repoRoot, stdout) {
     await writeShellOutput(REMOVE_OUTPUT_FILE_ENV, repoRoot, stdout);
 }
+function emitError(options, message) {
+    if (options.json) {
+        options.stderr(`${JSON.stringify({ error: message }, null, 2)}\n`);
+    }
+    else {
+        options.stderr(`${message}\n`);
+    }
+}
+function toMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/worktree-management.d.ts

@@ -5,4 +5,8 @@ export interface LinkedWorktreeContext {
 }
 export declare function loadLinkedWorktrees(cwd: string): Promise<LinkedWorktreeContext>;
 export declare function removeWorktree(repoRoot: string, worktreePath: string): Promise<void>;
+export declare function forceRemoveWorktree(repoRoot: string, worktreePath: string): Promise<void>;
 export declare function deleteBranch(repoRoot: string, branch: string): Promise<void>;
+export declare function forceDeleteBranch(repoRoot: string, branch: string): Promise<void>;
+export declare function isWorktreeDirtyError(error: unknown): boolean;
+export declare function isBranchUnmergedError(error: unknown): boolean;

package/dist/worktree-management.js

@@ -2,6 +2,8 @@ import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { detectRepository, listWorktrees } from './repo.js';
 const execFileAsync = promisify(execFile);
+// Force English output so error message string matching is locale-independent.
+const GIT_ENV = { ...process.env, LC_ALL: 'C' };
 export async function loadLinkedWorktrees(cwd) {
     const repository = await detectRepository(cwd);
     const linkedWorktrees = (await listWorktrees(cwd)).filter((worktree) => worktree.path !== repository.repoRoot);
@@ -11,8 +13,23 @@ export async function loadLinkedWorktrees(cwd) {
     };
 }
 export async function removeWorktree(repoRoot, worktreePath) {
-    await execFileAsync('git', ['worktree', 'remove', worktreePath], { cwd: repoRoot });
+    await execFileAsync('git', ['worktree', 'remove', worktreePath], { cwd: repoRoot, env: GIT_ENV });
+}
+export async function forceRemoveWorktree(repoRoot, worktreePath) {
+    await execFileAsync('git', ['worktree', 'remove', '--force', worktreePath], { cwd: repoRoot, env: GIT_ENV });
 }
 export async function deleteBranch(repoRoot, branch) {
-    await execFileAsync('git', ['branch', '-d', branch], { cwd: repoRoot });
+    await execFileAsync('git', ['branch', '-d', branch], { cwd: repoRoot, env: GIT_ENV });
+}
+export async function forceDeleteBranch(repoRoot, branch) {
+    await execFileAsync('git', ['branch', '-D', branch], { cwd: repoRoot, env: GIT_ENV });
+}
+export function isWorktreeDirtyError(error) {
+    return hasStderr(error) && error.stderr.includes('contains modified or untracked files');
+}
+export function isBranchUnmergedError(error) {
+    return hasStderr(error) && error.stderr.includes('is not fully merged');
+}
+function hasStderr(error) {
+    return error instanceof Error && 'stderr' in error && typeof error.stderr === 'string';
 }

package/dist/worktree-prompts.d.ts

@@ -0,0 +1,2 @@
+export declare function defaultConfirmForceRemoveWorktree(worktreePath: string): Promise<boolean>;
+export declare function defaultConfirmForceDeleteBranch(branch: string): Promise<boolean>;

package/dist/worktree-prompts.js

@@ -0,0 +1,19 @@
+import { confirm, isCancel } from '@clack/prompts';
+export async function defaultConfirmForceRemoveWorktree(worktreePath) {
+    const choice = await confirm({
+        active: 'Yes',
+        inactive: 'No',
+        initialValue: false,
+        message: `Worktree at ${worktreePath} has untracked or modified files. Force remove?`,
+    });
+    return !isCancel(choice) && choice;
+}
+export async function defaultConfirmForceDeleteBranch(branch) {
+    const choice = await confirm({
+        active: 'Yes',
+        inactive: 'No',
+        initialValue: false,
+        message: `Branch ${branch} has unmerged commits. Force delete?`,
+    });
+    return !isCancel(choice) && choice;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solaqua/gji",
-  "version": "0.1.0-beta.9",
+  "version": "0.2.0",
   "description": "Git worktree CLI for fast context switching.",
   "license": "MIT",
   "author": "sjquant",