@solaqua/gji 0.4.0 → 0.5.0

package/dist/go.js

@@ -4,6 +4,7 @@ import { loadEffectiveConfig } from './config.js';
 import { readWorktreeHealth } from './git.js';
 import { isHeadless } from './headless.js';
 import { extractHooks, runHook } from './hooks.js';
+import { appendHistory } from './history.js';
 import { detectRepository, listWorktrees, sortByCurrentFirst } from './repo.js';
 import { writeShellOutput } from './shell-handoff.js';
 const GO_OUTPUT_FILE_ENV = 'GJI_GO_OUTPUT_FILE';
@@ -36,6 +37,7 @@ export function createGoCommand(dependencies = {}) {
         const config = await loadEffectiveConfig(repository.repoRoot, undefined, options.stderr);
         const hooks = extractHooks(config);
         await runHook(hooks.afterEnter, resolvedPath, { branch: chosenWorktree?.branch ?? undefined, path: resolvedPath, repo: basename(repository.repoRoot) }, options.stderr);
+        appendHistory(resolvedPath, chosenWorktree?.branch ?? null).catch(() => undefined);
         await writeShellOutput(GO_OUTPUT_FILE_ENV, resolvedPath, options.stdout);
         return 0;
     };

package/dist/history-command.d.ts

@@ -0,0 +1,7 @@
+export interface HistoryCommandOptions {
+    cwd: string;
+    home?: string;
+    json?: boolean;
+    stdout: (chunk: string) => void;
+}
+export declare function runHistoryCommand(options: HistoryCommandOptions): Promise<number>;

package/dist/history-command.js

@@ -0,0 +1,15 @@
+import { loadHistory } from './history.js';
+import { formatHistoryList } from './back.js';
+export async function runHistoryCommand(options) {
+    const history = await loadHistory(options.home);
+    if (options.json) {
+        options.stdout(`${JSON.stringify(history, null, 2)}\n`);
+        return 0;
+    }
+    if (history.length === 0) {
+        options.stdout('No navigation history.\n');
+        return 0;
+    }
+    options.stdout(formatHistoryList(history, options.cwd));
+    return 0;
+}

package/dist/history.d.ts

@@ -0,0 +1,9 @@
+export declare const HISTORY_FILE_NAME = "history.json";
+export interface HistoryEntry {
+    branch: string | null;
+    path: string;
+    timestamp: number;
+}
+export declare function HISTORY_FILE_PATH(home?: string): string;
+export declare function loadHistory(home?: string): Promise<HistoryEntry[]>;
+export declare function appendHistory(path: string, branch: string | null, home?: string): Promise<void>;

package/dist/history.js

@@ -0,0 +1,46 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { GLOBAL_CONFIG_DIRECTORY } from './config.js';
+export const HISTORY_FILE_NAME = 'history.json';
+const MAX_HISTORY_ENTRIES = 50;
+export function HISTORY_FILE_PATH(home = homedir()) {
+    const configDir = process.env.GJI_CONFIG_DIR;
+    if (configDir) {
+        return join(resolve(configDir), HISTORY_FILE_NAME);
+    }
+    return join(home, GLOBAL_CONFIG_DIRECTORY, HISTORY_FILE_NAME);
+}
+export async function loadHistory(home = homedir()) {
+    const path = HISTORY_FILE_PATH(home);
+    try {
+        const raw = await readFile(path, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.filter(isHistoryEntry);
+    }
+    catch {
+        return [];
+    }
+}
+export async function appendHistory(path, branch, home = homedir()) {
+    const historyPath = HISTORY_FILE_PATH(home);
+    const existing = await loadHistory(home);
+    // Skip if the most recent entry is the same path (no-op navigation)
+    if (existing.length > 0 && existing[0].path === path) {
+        return;
+    }
+    const entry = { branch, path, timestamp: Date.now() };
+    const next = [entry, ...existing].slice(0, MAX_HISTORY_ENTRIES);
+    await mkdir(dirname(historyPath), { recursive: true });
+    await writeFile(historyPath, `${JSON.stringify(next, null, 2)}\n`, 'utf8');
+}
+function isHistoryEntry(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'path' in value &&
+        typeof value.path === 'string' &&
+        'timestamp' in value &&
+        typeof value.timestamp === 'number');
+}

package/dist/init.d.ts

@@ -1,4 +1,4 @@
-export type SupportedShell = 'bash' | 'fish' | 'zsh';
+import { type SupportedShell } from './shell.js';
 export type InstallSaveTarget = 'local' | 'global';
 export interface SetupWizardResult {
     branchPrefix?: string;

package/dist/init.js

@@ -3,6 +3,7 @@ import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { intro, isCancel, outro, select, text } from '@clack/prompts';
 import { loadConfig, loadGlobalConfig, saveGlobalConfig, saveLocalConfig, updateGlobalConfigKey } from './config.js';
+import { resolveSupportedShell } from './shell.js';
 const START_MARKER = '# >>> gji init >>>';
 const END_MARKER = '# <<< gji init <<<';
 const SHELL_WRAPPED_COMMANDS = [
@@ -20,6 +21,13 @@ const SHELL_WRAPPED_COMMANDS = [
         names: ['pr'],
         tempPrefix: 'gji-pr',
     },
+    {
+        bypassOption: '--print',
+        commandName: 'back',
+        envVar: 'GJI_BACK_OUTPUT_FILE',
+        names: ['back'],
+        tempPrefix: 'gji-back',
+    },
     {
         bypassOption: '--print',
         commandName: 'go',
@@ -43,7 +51,7 @@ const SHELL_WRAPPED_COMMANDS = [
     },
 ];
 export async function runInitCommand(options) {
-    const shell = resolveShell(options.shell, process.env.SHELL);
+    const shell = resolveSupportedShell(options.shell, process.env.SHELL);
     const home = options.home ?? homedir();
     if (!shell) {
         options.stderr?.('Unable to detect a supported shell. Specify one explicitly: bash, fish, or zsh.\n');
@@ -139,27 +147,6 @@ async function saveWizardConfig(result, cwd, home) {
         await saveGlobalConfig({ ...existing, ...values }, home);
     }
 }
-function resolveShell(requestedShell, detectedShell) {
-    const requested = normalizeShell(requestedShell);
-    if (requested) {
-        return requested;
-    }
-    return normalizeShell(detectedShell);
-}
-function normalizeShell(value) {
-    if (!value) {
-        return null;
-    }
-    const candidate = value.split('/').at(-1)?.toLowerCase();
-    switch (candidate) {
-        case 'bash':
-        case 'fish':
-        case 'zsh':
-            return candidate;
-        default:
-            return null;
-    }
-}
 function resolveShellConfigPath(shell, home) {
     switch (shell) {
         case 'bash':

package/dist/ls.d.ts

@@ -1,8 +1,11 @@
 import { type WorktreeEntry } from './repo.js';
+import { type WorktreeInfo } from './worktree-info.js';
 export interface LsCommandOptions {
+    compact?: boolean;
     cwd: string;
     json?: boolean;
     stdout: (chunk: string) => void;
 }
 export declare function runLsCommand(options: LsCommandOptions): Promise<number>;
+export declare function formatDetailedWorktreeTable(worktrees: WorktreeInfo[]): string;
 export declare function formatWorktreeTable(worktrees: WorktreeEntry[]): string;

package/dist/ls.js

@@ -1,14 +1,58 @@
 import { listWorktrees } from './repo.js';
 import { comparePaths } from './paths.js';
+import { formatLastCommit, formatUpstreamState, readWorktreeInfos, } from './worktree-info.js';
 export async function runLsCommand(options) {
     const worktrees = sortWorktrees(await listWorktrees(options.cwd));
+    if (options.compact) {
+        if (options.json) {
+            options.stdout(`${JSON.stringify(worktrees, null, 2)}\n`);
+            return 0;
+        }
+        options.stdout(`${formatWorktreeTable(worktrees)}\n`);
+        return 0;
+    }
+    const infos = await readWorktreeInfos(worktrees);
     if (options.json) {
-        options.stdout(`${JSON.stringify(worktrees, null, 2)}\n`);
+        options.stdout(`${JSON.stringify(infos, null, 2)}\n`);
         return 0;
     }
-    options.stdout(`${formatWorktreeTable(worktrees)}\n`);
+    options.stdout(`${formatDetailedWorktreeTable(infos)}\n`);
     return 0;
 }
+export function formatDetailedWorktreeTable(worktrees) {
+    const rows = worktrees.map((worktree) => ({
+        branch: worktree.branch ?? '(detached)',
+        isCurrent: worktree.isCurrent,
+        lastCommit: formatLastCommit(worktree.lastCommitTimestamp),
+        path: worktree.path,
+        status: worktree.status,
+        upstream: formatUpstreamState(worktree.upstream),
+    }));
+    const branchWidth = Math.max('BRANCH'.length, ...rows.map((row) => row.branch.length));
+    const statusWidth = Math.max('STATUS'.length, ...rows.map((row) => row.status.length));
+    const upstreamWidth = Math.max('UPSTREAM'.length, ...rows.map((row) => row.upstream.length));
+    const lastCommitWidth = Math.max('LAST'.length, ...rows.map((row) => row.lastCommit.length));
+    const lines = [
+        '  '
+            + 'BRANCH'.padEnd(branchWidth, ' ')
+            + ' '
+            + 'STATUS'.padEnd(statusWidth, ' ')
+            + ' '
+            + 'UPSTREAM'.padEnd(upstreamWidth, ' ')
+            + ' '
+            + 'LAST'.padEnd(lastCommitWidth, ' ')
+            + ' PATH',
+    ];
+    for (const row of rows) {
+        lines.push(`${row.isCurrent ? '*' : ' '} `
+            + `${row.branch.padEnd(branchWidth, ' ')} `
+            + `${row.status.padEnd(statusWidth, ' ')} `
+            + `${row.upstream.padEnd(upstreamWidth, ' ')} `
+            + `${row.lastCommit.padEnd(lastCommitWidth, ' ')} `
+            + row.path);
+    }
+    return lines.join('\n');
+}
 export function formatWorktreeTable(worktrees) {
     const rows = worktrees.map((worktree) => ({
         branch: worktree.branch ?? '(detached)',

package/dist/new.js

@@ -6,6 +6,7 @@ import { isCancel, text } from '@clack/prompts';
 import { loadEffectiveConfig, resolveConfigString } from './config.js';
 import { syncFiles } from './file-sync.js';
 import { extractHooks, runHook } from './hooks.js';
+import { appendHistory } from './history.js';
 import { isHeadless } from './headless.js';
 import { maybeRunInstallPrompt } from './install-prompt.js';
 import { pathExists, promptForPathConflict } from './conflict.js';
@@ -105,6 +106,7 @@ export function createNewCommand(dependencies = {}) {
             else {
                 const choice = await prompt(worktreePath);
                 if (choice === 'reuse') {
+                    appendHistory(worktreePath, worktreeName).catch(() => undefined);
                     await writeOutput(worktreePath, options.stdout);
                     return 0;
                 }
@@ -147,6 +149,7 @@ export function createNewCommand(dependencies = {}) {
             options.stdout(`${JSON.stringify({ branch: worktreeName, path: worktreePath }, null, 2)}\n`);
         }
         else {
+            await appendHistory(worktreePath, worktreeName);
             await writeOutput(worktreePath, options.stdout);
         }
         return 0;

package/dist/pr.js

@@ -6,6 +6,7 @@ import { loadEffectiveConfig, resolveConfigString } from './config.js';
 import { syncFiles } from './file-sync.js';
 import { pathExists, promptForPathConflict } from './conflict.js';
 import { extractHooks, runHook } from './hooks.js';
+import { appendHistory } from './history.js';
 import { isHeadless } from './headless.js';
 import { maybeRunInstallPrompt } from './install-prompt.js';
 import { detectRepository, resolveWorktreePath } from './repo.js';
@@ -58,6 +59,7 @@ export function createPrCommand(dependencies = {}) {
             }
             const choice = await prompt(worktreePath);
             if (choice === 'reuse') {
+                appendHistory(worktreePath, branchName).catch(() => undefined);
                 await writeOutput(worktreePath, options.stdout);
                 return 0;
             }
@@ -74,7 +76,7 @@ export function createPrCommand(dependencies = {}) {
             return 0;
         }
         try {
-            await execFileAsync('git', ['fetch', 'origin', `refs/pull/${prNumber}/head:${remoteRef}`], { cwd: repository.repoRoot });
+            await fetchPullRequestRef(repository.repoRoot, options.number, prNumber, remoteRef);
         }
         catch {
             const message = `Failed to fetch PR #${prNumber} from origin`;
@@ -112,6 +114,7 @@ export function createPrCommand(dependencies = {}) {
             options.stdout(`${JSON.stringify({ branch: branchName, path: worktreePath }, null, 2)}\n`);
         }
         else {
+            await appendHistory(worktreePath, branchName);
             await writeOutput(worktreePath, options.stdout);
         }
         return 0;
@@ -127,6 +130,48 @@ async function localBranchExists(repoRoot, branchName) {
     }
 }
 export const runPrCommand = createPrCommand();
+async function fetchPullRequestRef(repoRoot, input, prNumber, remoteRef) {
+    for (const sourceRef of listPullRequestSourceRefs(input, prNumber)) {
+        try {
+            await execFileAsync('git', ['fetch', 'origin', `${sourceRef}:${remoteRef}`], { cwd: repoRoot });
+            return;
+        }
+        catch {
+            // Try the next forge-specific ref namespace before failing the command.
+        }
+    }
+    throw new Error(`No pull request ref found for #${prNumber}`);
+}
+function listPullRequestSourceRefs(input, prNumber) {
+    const allForges = ['github', 'gitlab', 'bitbucket'];
+    const preferredForge = detectPullRequestForge(input);
+    const orderedForges = preferredForge === 'unknown'
+        ? allForges
+        : [preferredForge, ...allForges.filter((forge) => forge !== preferredForge)];
+    return orderedForges.map((forge) => sourceRefForForge(forge, prNumber));
+}
+function detectPullRequestForge(input) {
+    if (/\/pull-requests\/\d+/.test(input)) {
+        return 'bitbucket';
+    }
+    if (/\/merge_requests\/\d+/.test(input)) {
+        return 'gitlab';
+    }
+    if (/\/pull\/\d+/.test(input)) {
+        return 'github';
+    }
+    return 'unknown';
+}
+function sourceRefForForge(forge, prNumber) {
+    switch (forge) {
+        case 'bitbucket':
+            return `refs/pull-requests/${prNumber}/from`;
+        case 'github':
+            return `refs/pull/${prNumber}/head`;
+        case 'gitlab':
+            return `refs/merge-requests/${prNumber}/head`;
+    }
+}
 async function writeOutput(worktreePath, stdout) {
     await writeShellOutput(PR_OUTPUT_FILE_ENV, worktreePath, stdout);
 }

package/dist/shell-completion.d.ts

@@ -0,0 +1 @@
+export declare function renderShellCompletion(shell: 'bash' | 'fish' | 'zsh'): string;

package/dist/shell-completion.js

@@ -0,0 +1,284 @@
+const TOP_LEVEL_COMMANDS = [
+    { name: 'new', description: 'create a new branch or detached linked worktree' },
+    { name: 'init', description: 'print or install shell integration' },
+    { name: 'completion', description: 'print shell completion definitions' },
+    { name: 'pr', description: 'fetch a pull request into a linked worktree' },
+    { name: 'go', description: 'print or select a worktree path' },
+    { name: 'root', description: 'print the main repository root path' },
+    { name: 'status', description: 'summarize repository and worktree health' },
+    { name: 'sync', description: 'fetch and update one or all worktrees' },
+    { name: 'ls', description: 'list active worktrees' },
+    { name: 'clean', description: 'interactively prune linked worktrees' },
+    { name: 'remove', description: 'remove a linked worktree and delete its branch when present' },
+    { name: 'rm', description: 'alias of remove' },
+    { name: 'trigger-hook', description: 'run a named hook in the current worktree' },
+    { name: 'config', description: 'manage global config defaults' },
+];
+const SHELL_NAMES = ['bash', 'fish', 'zsh'];
+const HOOK_NAMES = ['afterCreate', 'afterEnter', 'beforeRemove'];
+const CONFIG_KEYS = [
+    'branchPrefix',
+    'syncRemote',
+    'syncDefaultBranch',
+    'syncFiles',
+    'skipInstallPrompt',
+    'installSaveTarget',
+    'hooks',
+    'repos',
+];
+export function renderShellCompletion(shell) {
+    switch (shell) {
+        case 'bash':
+            return renderBashCompletion();
+        case 'fish':
+            return renderFishCompletion();
+        case 'zsh':
+            return renderZshCompletion();
+    }
+}
+function renderBashCompletion() {
+    const topLevelCommands = TOP_LEVEL_COMMANDS.map((command) => command.name).join(' ');
+    const shells = SHELL_NAMES.join(' ');
+    const hooks = HOOK_NAMES.join(' ');
+    const configKeys = CONFIG_KEYS.join(' ');
+    return `__gji_worktree_branches() {
+  command gji ls --compact 2>/dev/null | awk 'NR > 1 { branch = ($1 == "*" ? $2 : $1); if (branch != "(detached)") print branch }'
+}
+
+_gji_completion() {
+  local cur command_name
+  COMPREPLY=()
+  cur="\${COMP_WORDS[COMP_CWORD]:-}"
+
+  if [ "$COMP_CWORD" -eq 1 ]; then
+    COMPREPLY=( $(compgen -W "${topLevelCommands}" -- "$cur") )
+    return 0
+  fi
+
+  command_name="\${COMP_WORDS[1]}"
+
+  case "$command_name" in
+    new)
+      COMPREPLY=( $(compgen -W "--detached --dry-run --json --help" -- "$cur") )
+      ;;
+    init)
+      COMPREPLY=( $(compgen -W "${shells} --write --help" -- "$cur") )
+      ;;
+    completion)
+      COMPREPLY=( $(compgen -W "${shells} --help" -- "$cur") )
+      ;;
+    pr)
+      COMPREPLY=( $(compgen -W "--dry-run --json --help" -- "$cur") )
+      ;;
+    go)
+      COMPREPLY=( $(compgen -W "$(__gji_worktree_branches) --print --help" -- "$cur") )
+      ;;
+    root)
+      COMPREPLY=( $(compgen -W "--print --help" -- "$cur") )
+      ;;
+    status)
+      COMPREPLY=( $(compgen -W "--json --help" -- "$cur") )
+      ;;
+    sync)
+      COMPREPLY=( $(compgen -W "--all --json --help" -- "$cur") )
+      ;;
+    ls)
+      COMPREPLY=( $(compgen -W "--compact --json --help" -- "$cur") )
+      ;;
+    clean)
+      COMPREPLY=( $(compgen -W "-f --force --stale --dry-run --json --help" -- "$cur") )
+      ;;
+    remove|rm)
+      COMPREPLY=( $(compgen -W "$(__gji_worktree_branches) -f --force --dry-run --json --help" -- "$cur") )
+      ;;
+    trigger-hook)
+      COMPREPLY=( $(compgen -W "${hooks} --help" -- "$cur") )
+      ;;
+    config)
+      if [ "$COMP_CWORD" -eq 2 ]; then
+        COMPREPLY=( $(compgen -W "get set unset" -- "$cur") )
+        return 0
+      fi
+
+      case "\${COMP_WORDS[2]}" in
+        get|unset)
+          if [ "$COMP_CWORD" -eq 3 ]; then
+            COMPREPLY=( $(compgen -W "${configKeys}" -- "$cur") )
+          fi
+          ;;
+        set)
+          if [ "$COMP_CWORD" -eq 3 ]; then
+            COMPREPLY=( $(compgen -W "${configKeys}" -- "$cur") )
+          fi
+          ;;
+      esac
+      ;;
+  esac
+}
+
+complete -F _gji_completion gji`;
+}
+function renderFishCompletion() {
+    const commandLines = TOP_LEVEL_COMMANDS.map((command) => `complete -c gji -n '__fish_use_subcommand' -a '${command.name}' -d '${escapeSingleQuotes(command.description)}'`).join('\n');
+    const shellLines = SHELL_NAMES.map((shell) => `complete -c gji -n '__fish_seen_subcommand_from init' -a '${shell}' -d 'shell'`).join('\n');
+    const hookLines = HOOK_NAMES.map((hook) => `complete -c gji -n '__fish_seen_subcommand_from trigger-hook' -a '${hook}' -d 'hook'`).join('\n');
+    const configKeyLines = CONFIG_KEYS.map((key) => `complete -c gji -n '__gji_should_complete_config_key' -a '${key}' -d 'config key'`).join('\n');
+    return `function __gji_worktree_branches
+    command gji ls --compact 2>/dev/null | awk 'NR > 1 { branch = ($1 == "*" ? $2 : $1); if (branch != "(detached)") print branch }'
+end
+
+function __gji_should_complete_config_action
+    set -l tokens (commandline -opc)
+    test (count $tokens) -eq 2
+end
+
+function __gji_should_complete_config_key
+    set -l tokens (commandline -opc)
+    if test (count $tokens) -ne 3
+        return 1
+    end
+
+    if test $tokens[2] != config
+        return 1
+    end
+
+    contains -- $tokens[3] get set unset
+end
+
+complete -c gji -f
+${commandLines}
+
+complete -c gji -n '__fish_seen_subcommand_from new' -l detached -d 'create a detached worktree without a branch'
+complete -c gji -n '__fish_seen_subcommand_from new' -l dry-run -d 'show what would be created without executing any git commands or writing files'
+complete -c gji -n '__fish_seen_subcommand_from new' -l json -d 'emit JSON on success or error instead of human-readable output'
+
+complete -c gji -n '__fish_seen_subcommand_from init' -l write -d 'write the integration to the shell config file'
+${shellLines}
+
+complete -c gji -n '__fish_seen_subcommand_from completion' -a 'bash' -d 'shell'
+complete -c gji -n '__fish_seen_subcommand_from completion' -a 'fish' -d 'shell'
+complete -c gji -n '__fish_seen_subcommand_from completion' -a 'zsh' -d 'shell'
+
+complete -c gji -n '__fish_seen_subcommand_from pr' -l dry-run -d 'show what would be created without executing any git commands or writing files'
+complete -c gji -n '__fish_seen_subcommand_from pr' -l json -d 'emit JSON on success or error instead of human-readable output'
+
+complete -c gji -n '__fish_seen_subcommand_from go' -l print -d 'print the resolved worktree path explicitly'
+complete -c gji -n '__fish_seen_subcommand_from go' -a '(__gji_worktree_branches)' -d 'worktree branch'
+
+complete -c gji -n '__fish_seen_subcommand_from root' -l print -d 'print the resolved repository root path explicitly'
+
+complete -c gji -n '__fish_seen_subcommand_from status' -l json -d 'print repository and worktree health as JSON'
+
+complete -c gji -n '__fish_seen_subcommand_from sync' -l all -d 'sync every worktree in the repository'
+complete -c gji -n '__fish_seen_subcommand_from sync' -l json -d 'emit JSON on success or error instead of human-readable output'
+
+complete -c gji -n '__fish_seen_subcommand_from ls' -l compact -d 'show only branch and path columns'
+complete -c gji -n '__fish_seen_subcommand_from ls' -l json -d 'print active worktrees as JSON'
+
+complete -c gji -n '__fish_seen_subcommand_from clean' -s f -l force -d 'bypass prompts, force-remove dirty worktrees, and force-delete unmerged branches'
+complete -c gji -n '__fish_seen_subcommand_from clean' -l stale -d 'only target clean worktrees whose upstream is gone and branch is merged into the default branch'
+complete -c gji -n '__fish_seen_subcommand_from clean' -l dry-run -d 'show what would be deleted without removing anything'
+complete -c gji -n '__fish_seen_subcommand_from clean' -l json -d 'emit JSON on success or error instead of human-readable output'
+
+complete -c gji -n '__fish_seen_subcommand_from remove rm' -s f -l force -d 'bypass prompts, force-remove a dirty worktree, and force-delete an unmerged branch'
+complete -c gji -n '__fish_seen_subcommand_from remove rm' -l dry-run -d 'show what would be deleted without removing anything'
+complete -c gji -n '__fish_seen_subcommand_from remove rm' -l json -d 'emit JSON on success or error instead of human-readable output'
+complete -c gji -n '__fish_seen_subcommand_from remove rm' -a '(__gji_worktree_branches)' -d 'worktree branch'
+
+${hookLines}
+
+complete -c gji -n '__fish_seen_subcommand_from config; and __gji_should_complete_config_action' -a 'get set unset' -d 'config action'
+${configKeyLines}`;
+}
+function renderZshCompletion() {
+    const commandLines = TOP_LEVEL_COMMANDS.map((command) => `'${command.name}:${escapeSingleQuotes(command.description)}'`).join('\n    ');
+    const configKeys = CONFIG_KEYS.join(' ');
+    const shells = SHELL_NAMES.join(' ');
+    const hooks = HOOK_NAMES.join(' ');
+    return `__gji_worktree_branches() {
+  command gji ls --compact 2>/dev/null | awk 'NR > 1 { branch = ($1 == "*" ? $2 : $1); if (branch != "(detached)") print branch }'
+}
+
+_gji_completion() {
+  local context state line
+  local -a commands worktree_branches
+
+  commands=(
+    ${commandLines}
+  )
+
+  if (( CURRENT == 2 )); then
+    _describe 'command' commands
+    return
+  fi
+
+  case "\${words[2]}" in
+    new)
+      _arguments '--detached[create a detached worktree without a branch]' '--dry-run[show what would be created without executing any git commands or writing files]' '--json[emit JSON on success or error instead of human-readable output]' '2:branch: '
+      ;;
+    init)
+      _arguments '--write[write the integration to the shell config file]' '2:shell:(${shells})'
+      ;;
+    completion)
+      _arguments '2:shell:(${shells})'
+      ;;
+    pr)
+      _arguments '--dry-run[show what would be created without executing any git commands or writing files]' '--json[emit JSON on success or error instead of human-readable output]' '2:ref: '
+      ;;
+    go)
+      _arguments '--print[print the resolved worktree path explicitly]' '2:branch:->worktrees'
+      ;;
+    root)
+      _arguments '--print[print the resolved repository root path explicitly]'
+      ;;
+    status)
+      _arguments '--json[print repository and worktree health as JSON]'
+      ;;
+    sync)
+      _arguments '--all[sync every worktree in the repository]' '--json[emit JSON on success or error instead of human-readable output]'
+      ;;
+    ls)
+      _arguments '--compact[show only branch and path columns]' '--json[print active worktrees as JSON]'
+      ;;
+    clean)
+      _arguments '(-f --force)'{-f,--force}'[bypass prompts, force-remove dirty worktrees, and force-delete unmerged branches]' '--stale[only target clean worktrees whose upstream is gone and branch is merged into the default branch]' '--dry-run[show what would be deleted without removing anything]' '--json[emit JSON on success or error instead of human-readable output]'
+      ;;
+    remove|rm)
+      _arguments '(-f --force)'{-f,--force}'[bypass prompts, force-remove a dirty worktree, and force-delete an unmerged branch]' '--dry-run[show what would be deleted without removing anything]' '--json[emit JSON on success or error instead of human-readable output]' '2:branch:->worktrees'
+      ;;
+    trigger-hook)
+      _arguments "2:hook:(${hooks})"
+      ;;
+    config)
+      if (( CURRENT == 3 )); then
+        _values 'config action' get set unset
+        return
+      fi
+
+      case "\${words[3]}" in
+        get|unset)
+          _arguments '3:key:->config_keys'
+          ;;
+        set)
+          _arguments '3:key:->config_keys' '4:value: '
+          ;;
+      esac
+      ;;
+  esac
+
+  case "$state" in
+    worktrees)
+      worktree_branches=(\${(@f)$(__gji_worktree_branches)})
+      _describe 'worktree branch' worktree_branches
+      ;;
+    config_keys)
+      _values 'config key' ${configKeys}
+      ;;
+  esac
+}
+
+compdef _gji_completion gji`;
+}
+function escapeSingleQuotes(value) {
+    return value.replace(/'/g, `'\\''`);
+}

package/dist/shell.d.ts

@@ -0,0 +1,2 @@
+export type SupportedShell = 'bash' | 'fish' | 'zsh';
+export declare function resolveSupportedShell(requestedShell: string | undefined, detectedShell: string | undefined): SupportedShell | null;

package/dist/shell.js

@@ -0,0 +1,21 @@
+export function resolveSupportedShell(requestedShell, detectedShell) {
+    const requested = normalizeShell(requestedShell);
+    if (requested) {
+        return requested;
+    }
+    return normalizeShell(detectedShell);
+}
+function normalizeShell(value) {
+    if (!value) {
+        return null;
+    }
+    const candidate = value.split('/').at(-1)?.toLowerCase();
+    switch (candidate) {
+        case 'bash':
+        case 'fish':
+        case 'zsh':
+            return candidate;
+        default:
+            return null;
+    }
+}