@solaqua/gji 0.3.0 → 0.4.1

package/dist/index.js

@@ -1,8 +1,19 @@
 #!/usr/bin/env node
+import { homedir } from 'node:os';
+import { loadGlobalConfig } from './config.js';
 import { runCli } from './cli.js';
 async function main() {
     try {
-        const result = await runCli(process.argv.slice(2), {
+        const argv = process.argv.slice(2);
+        // Warn once (until fixed) when shell integration hasn't been set up.
+        // Only shown in interactive terminals — suppressed in pipes and after gji init --write.
+        const isMetaArg = argv[0] === 'init'
+            || argv[0] === '--version' || argv[0] === '-V'
+            || argv[0] === '--help' || argv[0] === '-h';
+        if (process.stderr.isTTY === true && !isMetaArg) {
+            await warnIfMissingShellIntegration();
+        }
+        const result = await runCli(argv, {
             stderr: (chunk) => process.stderr.write(chunk),
             stdout: (chunk) => process.stdout.write(chunk),
         });
@@ -14,4 +25,17 @@ async function main() {
         process.exitCode = 1;
     }
 }
+async function warnIfMissingShellIntegration() {
+    try {
+        const { config } = await loadGlobalConfig(homedir());
+        if (!config.shellIntegration) {
+            const shellBin = (process.env.SHELL ?? '').split('/').at(-1);
+            const shellArg = shellBin && ['bash', 'zsh', 'fish'].includes(shellBin) ? ` ${shellBin}` : '';
+            process.stderr.write(`gji: shell integration not set up — run \`gji init${shellArg} --write\` to enable automatic cd.\n`);
+        }
+    }
+    catch {
+        // best-effort; never block the command
+    }
+}
 void main();

package/dist/init.d.ts

@@ -1,9 +1,19 @@
-export type SupportedShell = 'bash' | 'fish' | 'zsh';
+import { type SupportedShell } from './shell.js';
 export type InstallSaveTarget = 'local' | 'global';
+export interface SetupWizardResult {
+    branchPrefix?: string;
+    hooks?: {
+        afterCreate?: string;
+        afterEnter?: string;
+        beforeRemove?: string;
+    };
+    installSaveTarget: InstallSaveTarget;
+    worktreePath?: string;
+}
 export interface InitCommandOptions {
     cwd: string;
     home?: string;
-    promptForInstallSaveTarget?: () => Promise<InstallSaveTarget | null>;
+    promptForSetup?: () => Promise<SetupWizardResult | null>;
     shell?: string;
     stderr?: (chunk: string) => void;
     stdout: (chunk: string) => void;

package/dist/init.js

@@ -1,8 +1,9 @@
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
-import { isCancel, select } from '@clack/prompts';
-import { loadGlobalConfig, updateGlobalConfigKey } from './config.js';
+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 = [
@@ -43,7 +44,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');
@@ -60,19 +61,21 @@ export async function runInitCommand(options) {
     const next = upsertShellIntegration(current, script);
     await writeFile(rcPath, next, 'utf8');
     options.stdout(`${rcPath}\n`);
-    // After the shell integration is in place, ask once where to save hooks/prefs.
-    // Skip if already configured. When using the default interactive prompt, also
-    // require a real TTY so we don't block in piped/headless environments.
+    // Run the setup wizard on the first-ever init (not on subsequent re-runs).
     const { config: globalConfig } = await loadGlobalConfig(home);
-    const hasCustomPrompt = options.promptForInstallSaveTarget !== undefined;
+    const alreadyConfigured = 'shellIntegration' in globalConfig || 'installSaveTarget' in globalConfig;
+    const hasCustomPrompt = options.promptForSetup !== undefined;
     const canPrompt = hasCustomPrompt || process.stdout.isTTY === true;
-    if (!('installSaveTarget' in globalConfig) && canPrompt) {
-        const prompt = options.promptForInstallSaveTarget ?? defaultPromptForInstallSaveTarget;
-        const target = await prompt();
-        if (target) {
-            await updateGlobalConfigKey('installSaveTarget', target, home);
+    if (!alreadyConfigured && canPrompt) {
+        const prompt = options.promptForSetup ?? defaultPromptForSetup;
+        const result = await prompt();
+        if (result) {
+            await updateGlobalConfigKey('installSaveTarget', result.installSaveTarget, home);
+            await saveWizardConfig(result, options.cwd, home);
         }
     }
+    // Mark shell integration as installed so the first-run nudge is suppressed.
+    await updateGlobalConfigKey('shellIntegration', true, home);
     return 0;
 }
 export function renderShellIntegration(shell) {
@@ -111,25 +114,30 @@ export function upsertShellIntegration(existingConfig, script) {
     }
     return ensureTrailingNewline(`${prefix}\n\n${trimmedScript}`);
 }
-function resolveShell(requestedShell, detectedShell) {
-    const requested = normalizeShell(requestedShell);
-    if (requested) {
-        return requested;
+async function saveWizardConfig(result, cwd, home) {
+    const values = {};
+    if (result.branchPrefix)
+        values.branchPrefix = result.branchPrefix;
+    if (result.worktreePath)
+        values.worktreePath = result.worktreePath;
+    const hooks = {};
+    if (result.hooks?.afterCreate)
+        hooks.afterCreate = result.hooks.afterCreate;
+    if (result.hooks?.afterEnter)
+        hooks.afterEnter = result.hooks.afterEnter;
+    if (result.hooks?.beforeRemove)
+        hooks.beforeRemove = result.hooks.beforeRemove;
+    if (Object.keys(hooks).length > 0)
+        values.hooks = hooks;
+    if (Object.keys(values).length === 0)
+        return;
+    if (result.installSaveTarget === 'local') {
+        const loaded = await loadConfig(cwd);
+        await saveLocalConfig(cwd, { ...loaded.config, ...values });
     }
-    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;
+    else {
+        const { config: existing } = await loadGlobalConfig(home);
+        await saveGlobalConfig({ ...existing, ...values }, home);
     }
 }
 function resolveShellConfigPath(shell, home) {
@@ -211,16 +219,71 @@ function indentBlock(value, spaces) {
         .map((line) => line.length === 0 ? '' : `${prefix}${line}`)
         .join('\n');
 }
-async function defaultPromptForInstallSaveTarget() {
-    const choice = await select({
-        message: 'Where should saved hooks and preferences be stored by default?',
+async function defaultPromptForSetup() {
+    intro('gji setup');
+    const installSaveTarget = await select({
+        message: 'Where should preferences be saved?',
         options: [
-            { value: 'local', label: '.gji.json', hint: 'local — committed, shared with the team' },
-            { value: 'global', label: '~/.config/gji/config.json', hint: 'global — personal, never committed' },
+            { value: 'global', label: '~/.config/gji/config.json', hint: 'personal — never committed' },
+            { value: 'local', label: '.gji.json', hint: 'repo — committed with the project' },
         ],
     });
-    if (isCancel(choice)) {
+    if (isCancel(installSaveTarget)) {
+        outro('Setup skipped.');
+        return null;
+    }
+    const branchPrefix = await text({
+        message: 'Default branch prefix?',
+        placeholder: 'e.g. feat/ or fix/ — leave blank to skip',
+    });
+    if (isCancel(branchPrefix)) {
+        outro('Setup skipped.');
+        return null;
+    }
+    const worktreePath = await text({
+        message: 'Worktree base path?',
+        placeholder: 'leave blank to use the default path',
+    });
+    if (isCancel(worktreePath)) {
+        outro('Setup skipped.');
+        return null;
+    }
+    const afterCreate = await text({
+        message: 'afterCreate hook — run after creating a worktree?',
+        placeholder: 'e.g. pnpm install — leave blank to skip',
+    });
+    if (isCancel(afterCreate)) {
+        outro('Setup skipped.');
+        return null;
+    }
+    const afterEnter = await text({
+        message: 'afterEnter hook — run after entering a worktree?',
+        placeholder: 'e.g. nvm use — leave blank to skip',
+    });
+    if (isCancel(afterEnter)) {
+        outro('Setup skipped.');
+        return null;
+    }
+    const beforeRemove = await text({
+        message: 'beforeRemove hook — run before removing a worktree?',
+        placeholder: 'leave blank to skip',
+    });
+    if (isCancel(beforeRemove)) {
+        outro('Setup skipped.');
         return null;
     }
-    return choice;
+    outro('Setup complete!');
+    const hooks = {};
+    if (afterCreate)
+        hooks.afterCreate = afterCreate;
+    if (afterEnter)
+        hooks.afterEnter = afterEnter;
+    if (beforeRemove)
+        hooks.beforeRemove = beforeRemove;
+    return {
+        branchPrefix: branchPrefix || undefined,
+        hooks: Object.keys(hooks).length > 0 ? hooks : undefined,
+        installSaveTarget,
+        worktreePath: worktreePath || undefined,
+    };
 }

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/pr.js

@@ -74,7 +74,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`;
@@ -127,6 +127,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;