@solaqua/gji 0.4.1 → 0.6.0

package/dist/go.js

@@ -4,16 +4,35 @@ 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';
+import { resolveWarpTarget } from './warp.js';
 const GO_OUTPUT_FILE_ENV = 'GJI_GO_OUTPUT_FILE';
 export function createGoCommand(dependencies = {}) {
     const prompt = dependencies.promptForWorktree ?? promptForWorktree;
     return async function runGoCommand(options) {
-        const [worktrees, repository] = await Promise.all([
-            listWorktrees(options.cwd),
-            detectRepository(options.cwd),
-        ]);
+        let worktrees;
+        let repository;
+        try {
+            [worktrees, repository] = await Promise.all([
+                listWorktrees(options.cwd),
+                detectRepository(options.cwd),
+            ]);
+        }
+        catch {
+            // Not inside a git repo — fall back to cross-repo navigation.
+            if (isHeadless() && !options.branch) {
+                options.stderr('gji go: branch argument is required in non-interactive mode (GJI_NO_TUI=1)\n');
+                return 1;
+            }
+            const target = await resolveWarpTarget({ ...options, commandName: 'gji go' });
+            if (!target)
+                return 1;
+            appendHistory(target.path, target.branch).catch(() => undefined);
+            await writeShellOutput(GO_OUTPUT_FILE_ENV, target.path, options.stdout);
+            return 0;
+        }
         if (!options.branch && isHeadless()) {
             options.stderr('gji go: branch argument is required in non-interactive mode (GJI_NO_TUI=1)\n');
             return 1;
@@ -36,6 +55,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/hooks.d.ts

@@ -1,13 +1,14 @@
+export type GjiHookCommand = string | string[];
 export interface GjiHooks {
-    afterCreate?: string;
-    afterEnter?: string;
-    beforeRemove?: string;
+    afterCreate?: GjiHookCommand;
+    afterEnter?: GjiHookCommand;
+    beforeRemove?: GjiHookCommand;
 }
 export interface HookContext {
     branch?: string;
     path: string;
     repo: string;
 }
-export declare function runHook(hookCmd: string | undefined, cwd: string, context: HookContext, stderr: (chunk: string) => void): Promise<void>;
+export declare function runHook(hookCmd: GjiHookCommand | undefined, cwd: string, context: HookContext, stderr: (chunk: string) => void): Promise<void>;
 export declare function interpolate(template: string, context: HookContext): string;
 export declare function extractHooks(config: Record<string, unknown>): GjiHooks;

package/dist/hooks.js

@@ -2,18 +2,48 @@ import { spawn } from 'node:child_process';
 export async function runHook(hookCmd, cwd, context, stderr) {
     if (!hookCmd)
         return;
+    if (Array.isArray(hookCmd)) {
+        await runArgvHook(hookCmd, cwd, context, stderr);
+        return;
+    }
+    await runShellHook(hookCmd, cwd, context, stderr);
+}
+async function runArgvHook(hookCmd, cwd, context, stderr) {
+    const [command, ...args] = hookCmd.map((arg) => interpolate(arg, context));
+    if (!command) {
+        stderr('gji: hook argv command must include a non-empty command\n');
+        return;
+    }
+    await new Promise((resolve) => {
+        const child = spawn(command, args, {
+            cwd,
+            shell: false,
+            stdio: ['ignore', 'inherit', 'pipe'],
+            env: hookEnvironment(context),
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr(chunk.toString());
+        });
+        child.on('close', (code) => {
+            if (code !== 0) {
+                stderr(`gji: hook exited with code ${code}: ${formatArgvHook(command, args)}\n`);
+            }
+            resolve();
+        });
+        child.on('error', (err) => {
+            stderr(`gji: hook failed to start: ${err.message}\n`);
+            resolve();
+        });
+    });
+}
+async function runShellHook(hookCmd, cwd, context, stderr) {
     const interpolated = interpolate(hookCmd, context);
     await new Promise((resolve) => {
         const child = spawn(interpolated, {
             cwd,
             shell: true,
             stdio: ['ignore', 'inherit', 'pipe'],
-            env: {
-                ...process.env,
-                GJI_BRANCH: context.branch ?? '',
-                GJI_PATH: context.path,
-                GJI_REPO: context.repo,
-            },
+            env: hookEnvironment(context),
         });
         child.stderr.on('data', (chunk) => {
             stderr(chunk.toString());
@@ -30,6 +60,17 @@ export async function runHook(hookCmd, cwd, context, stderr) {
         });
     });
 }
+function hookEnvironment(context) {
+    return {
+        ...process.env,
+        GJI_BRANCH: context.branch ?? '',
+        GJI_PATH: context.path,
+        GJI_REPO: context.repo,
+    };
+}
+function formatArgvHook(command, args) {
+    return JSON.stringify([command, ...args]);
+}
 export function interpolate(template, context) {
     return template
         .replace(/\{\{branch\}\}/g, context.branch ?? '')
@@ -43,8 +84,19 @@ export function extractHooks(config) {
     }
     const hooks = raw;
     return {
-        afterCreate: typeof hooks.afterCreate === 'string' ? hooks.afterCreate : undefined,
-        afterEnter: typeof hooks.afterEnter === 'string' ? hooks.afterEnter : undefined,
-        beforeRemove: typeof hooks.beforeRemove === 'string' ? hooks.beforeRemove : undefined,
+        afterCreate: parseHookCommand(hooks.afterCreate),
+        afterEnter: parseHookCommand(hooks.afterEnter),
+        beforeRemove: parseHookCommand(hooks.beforeRemove),
     };
 }
+function parseHookCommand(value) {
+    if (typeof value === 'string')
+        return value;
+    if (Array.isArray(value) &&
+        value.length > 0 &&
+        value[0] !== '' &&
+        value.every((item) => typeof item === 'string')) {
+        return value;
+    }
+    return undefined;
+}

package/dist/init.js

@@ -8,40 +8,54 @@ const START_MARKER = '# >>> gji init >>>';
 const END_MARKER = '# <<< gji init <<<';
 const SHELL_WRAPPED_COMMANDS = [
     {
-        bypassOption: '--help',
+        bypassOptions: ['--help'],
         commandName: 'new',
         envVar: 'GJI_NEW_OUTPUT_FILE',
         names: ['new'],
         tempPrefix: 'gji-new',
     },
     {
-        bypassOption: '--help',
+        bypassOptions: ['--help'],
         commandName: 'pr',
         envVar: 'GJI_PR_OUTPUT_FILE',
         names: ['pr'],
         tempPrefix: 'gji-pr',
     },
     {
-        bypassOption: '--print',
+        bypassOptions: ['--print'],
+        commandName: 'back',
+        envVar: 'GJI_BACK_OUTPUT_FILE',
+        names: ['back'],
+        tempPrefix: 'gji-back',
+    },
+    {
+        bypassOptions: ['--print'],
         commandName: 'go',
         envVar: 'GJI_GO_OUTPUT_FILE',
-        names: ['go'],
+        names: ['go', 'jump'],
         tempPrefix: 'gji-go',
     },
     {
-        bypassOption: '--print',
+        bypassOptions: ['--print'],
         commandName: 'root',
         envVar: 'GJI_ROOT_OUTPUT_FILE',
         names: ['root'],
         tempPrefix: 'gji-root',
     },
     {
-        bypassOption: '--help',
+        bypassOptions: ['--help'],
         commandName: 'remove',
         envVar: 'GJI_REMOVE_OUTPUT_FILE',
         names: ['remove', 'rm'],
         tempPrefix: 'gji-remove',
     },
+    {
+        bypassOptions: ['--print', '--json'],
+        commandName: 'warp',
+        envVar: 'GJI_WARP_OUTPUT_FILE',
+        names: ['warp'],
+        tempPrefix: 'gji-warp',
+    },
 ];
 export async function runInitCommand(options) {
     const shell = resolveSupportedShell(options.shell, process.env.SHELL);
@@ -171,10 +185,17 @@ function isMissingFileError(error) {
     return error instanceof Error && 'code' in error && error.code === 'ENOENT';
 }
 function renderFishWrapper(command) {
-    const tests = command.names.map((name) => `test $argv[1] = ${name}`).join('; or ');
-    return `if test (count $argv) -gt 0; and ${tests}
+    const nameTests = command.names.map((name) => `test $argv[1] = ${name}`);
+    const nameCondition = nameTests.length === 1
+        ? nameTests[0]
+        : `begin; ${nameTests.join('; or ')}; end`;
+    const bypassTests = command.bypassOptions.map((opt) => `test $argv[1] = ${opt}`);
+    const bypassCondition = bypassTests.length === 1
+        ? bypassTests[0]
+        : `begin; ${bypassTests.join('; or ')}; end`;
+    return `if test (count $argv) -gt 0; and ${nameCondition}
     set -e argv[1]
-    if test (count $argv) -gt 0; and test $argv[1] = ${command.bypassOption}
+    if test (count $argv) -gt 0; and ${bypassCondition}
         command gji ${command.commandName} $argv
         return $status
     end
@@ -195,9 +216,10 @@ end`;
 }
 function renderPosixWrapper(command) {
     const tests = command.names.map((name) => `[ "$1" = "${name}" ]`).join(' || ');
+    const bypassTests = command.bypassOptions.map((opt) => `[ "\${1:-}" = "${opt}" ]`).join(' || ');
     return `if ${tests}; then
   shift
-  if [ "\${1:-}" = "${command.bypassOption}" ]; then
+  if ${bypassTests}; then
     command gji ${command.commandName} "$@"
     return $?
   fi

package/dist/install-prompt.js

@@ -10,7 +10,7 @@ export async function maybeRunInstallPrompt(worktreePath, repoRoot, config, stde
     }
     // Skip if afterCreate hook is already configured in effective config.
     const hooks = isPlainObject(config.hooks) ? config.hooks : null;
-    if (typeof hooks?.afterCreate === 'string' && hooks.afterCreate.length > 0) {
+    if (isConfiguredHookCommand(hooks?.afterCreate)) {
         return;
     }
     // Skip if user has permanently opted out of install prompts.
@@ -120,3 +120,11 @@ async function defaultPromptForInstallChoice(pm) {
 function isPlainObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
+function isConfiguredHookCommand(value) {
+    if (typeof value === 'string')
+        return value.length > 0;
+    return (Array.isArray(value) &&
+        value.length > 0 &&
+        value[0] !== '' &&
+        value.every((item) => typeof item === 'string'));
+}

package/dist/new.d.ts

@@ -6,8 +6,10 @@ export interface NewCommandOptions {
     cwd: string;
     detached?: boolean;
     dryRun?: boolean;
+    editor?: string;
     force?: boolean;
     json?: boolean;
+    open?: boolean;
     stderr: (chunk: string) => void;
     stdout: (chunk: string) => void;
 }
@@ -15,6 +17,7 @@ export interface NewCommandDependencies extends InstallPromptDependencies {
     createBranchPlaceholder: () => string;
     promptForBranch: (placeholder: string) => Promise<string | null>;
     promptForPathConflict: (path: string) => Promise<PathConflictChoice>;
+    spawnEditor: (cli: string, args: string[]) => Promise<void>;
 }
 export declare function createNewCommand(dependencies?: Partial<NewCommandDependencies>): (options: NewCommandOptions) => Promise<number>;
 export declare const runNewCommand: (options: NewCommandOptions) => Promise<number>;

package/dist/new.js

@@ -4,8 +4,10 @@ import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { isCancel, text } from '@clack/prompts';
 import { loadEffectiveConfig, resolveConfigString } from './config.js';
+import { defaultSpawnEditor, EDITORS } from './editor.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';
@@ -17,10 +19,14 @@ export function createNewCommand(dependencies = {}) {
     const createBranchPlaceholder = dependencies.createBranchPlaceholder ?? generateBranchPlaceholder;
     const promptForBranch = dependencies.promptForBranch ?? defaultPromptForBranch;
     const prompt = dependencies.promptForPathConflict ?? promptForPathConflict;
+    const spawnEditor = dependencies.spawnEditor ?? defaultSpawnEditor;
     return async function runNewCommand(options) {
         const repository = await detectRepository(options.cwd);
         const config = await loadEffectiveConfig(repository.repoRoot, undefined, options.stderr);
         const usesGeneratedDetachedName = options.detached && options.branch === undefined;
+        if (options.editor && !options.open) {
+            options.stderr('gji new: --editor has no effect without --open\n');
+        }
         if (!options.detached && !options.branch && (options.json || isHeadless())) {
             const message = 'branch argument is required';
             if (options.json) {
@@ -105,6 +111,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;
                 }
@@ -117,7 +124,11 @@ export function createNewCommand(dependencies = {}) {
                 options.stdout(`${JSON.stringify({ branch: worktreeName, path: worktreePath, dryRun: true }, null, 2)}\n`);
             }
             else {
-                options.stdout(`Would create worktree at ${worktreePath} (branch: ${worktreeName})\n`);
+                const resolvedEditor = options.open
+                    ? (options.editor ?? resolveConfigString(config, 'editor'))
+                    : undefined;
+                const openNote = resolvedEditor ? `, then open in ${resolvedEditor}` : '';
+                options.stdout(`Would create worktree at ${worktreePath} (branch: ${worktreeName}${openNote})\n`);
             }
             return 0;
         }
@@ -147,8 +158,13 @@ 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);
         }
+        if (options.open) {
+            const resolvedEditor = options.editor ?? resolveConfigString(config, 'editor');
+            await openWorktree(worktreePath, resolvedEditor, spawnEditor, options.stderr);
+        }
         return 0;
     };
 }
@@ -256,3 +272,22 @@ function hasExecStderr(error) {
 function toExecMessage(error) {
     return hasExecStderr(error) ? error.stderr.trim() : String(error);
 }
+async function openWorktree(worktreePath, editorCli, spawnFn, stderr) {
+    if (!editorCli) {
+        stderr('gji new: --open requires --editor <cli> or a saved editor in config\n');
+        return;
+    }
+    const editorDef = EDITORS.find((e) => e.cli === editorCli);
+    const args = [];
+    if (editorDef?.newWindowFlag) {
+        args.push(editorDef.newWindowFlag);
+    }
+    args.push(worktreePath);
+    try {
+        await spawnFn(editorCli, args);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        stderr(`gji new: failed to open editor: ${message}\n`);
+    }
+}

package/dist/open.d.ts

@@ -0,0 +1,20 @@
+import { type EditorDefinition } from './editor.js';
+import { type WorktreeEntry } from './repo.js';
+export type { EditorDefinition };
+export interface OpenCommandOptions {
+    branch?: string;
+    cwd: string;
+    editor?: string;
+    save?: boolean;
+    stderr: (chunk: string) => void;
+    stdout: (chunk: string) => void;
+    workspace?: boolean;
+}
+export interface OpenCommandDependencies {
+    detectEditors: () => Promise<EditorDefinition[]>;
+    promptForEditor: (editors: EditorDefinition[]) => Promise<string | null>;
+    promptForWorktree: (worktrees: WorktreeEntry[]) => Promise<string | null>;
+    spawnEditor: (cli: string, args: string[]) => Promise<void>;
+}
+export declare function createOpenCommand(dependencies?: Partial<OpenCommandDependencies>): (options: OpenCommandOptions) => Promise<number>;
+export declare const runOpenCommand: (options: OpenCommandOptions) => Promise<number>;

package/dist/open.js

@@ -0,0 +1,155 @@
+import { execFile } from 'node:child_process';
+import { access, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+import { isCancel, select } from '@clack/prompts';
+import { loadEffectiveConfig, resolveConfigString, updateGlobalConfigKey } from './config.js';
+import { defaultSpawnEditor, EDITORS } from './editor.js';
+import { isHeadless } from './headless.js';
+import { detectRepository, listWorktrees, sortByCurrentFirst } from './repo.js';
+const execFileAsync = promisify(execFile);
+export function createOpenCommand(dependencies = {}) {
+    const detectEditors = dependencies.detectEditors ?? detectInstalledEditors;
+    const promptForEditor = dependencies.promptForEditor ?? defaultPromptForEditor;
+    const promptForWorktree = dependencies.promptForWorktree ?? defaultPromptForWorktree;
+    const spawnEditor = dependencies.spawnEditor ?? defaultSpawnEditor;
+    return async function runOpenCommand(options) {
+        const [worktrees, repository] = await Promise.all([
+            listWorktrees(options.cwd),
+            detectRepository(options.cwd),
+        ]);
+        // Resolve target worktree path.
+        let targetPath;
+        if (options.branch) {
+            const entry = worktrees.find((w) => w.branch === options.branch);
+            if (!entry) {
+                options.stderr(`gji open: no worktree found for branch: ${options.branch}\n`);
+                options.stderr(`Hint: Use 'gji ls' to see available worktrees\n`);
+                return 1;
+            }
+            targetPath = entry.path;
+        }
+        else if (isHeadless()) {
+            targetPath = worktrees.find((w) => w.isCurrent)?.path ?? options.cwd;
+        }
+        else {
+            const chosen = await promptForWorktree(sortByCurrentFirst(worktrees));
+            if (!chosen) {
+                options.stderr('Aborted\n');
+                return 1;
+            }
+            targetPath = chosen;
+        }
+        // Resolve which editor to use.
+        const config = await loadEffectiveConfig(repository.repoRoot, undefined, options.stderr);
+        const savedEditor = resolveConfigString(config, 'editor');
+        let editorCli;
+        if (options.editor) {
+            editorCli = options.editor;
+        }
+        else if (savedEditor) {
+            editorCli = savedEditor;
+        }
+        else {
+            const installed = await detectEditors();
+            if (installed.length === 0) {
+                options.stderr('gji open: no supported editor detected. Use --editor <code|cursor|zed|...> to specify one.\n');
+                return 1;
+            }
+            if (installed.length === 1 || isHeadless()) {
+                editorCli = installed[0].cli;
+            }
+            else {
+                const chosen = await promptForEditor(installed);
+                if (!chosen) {
+                    options.stderr('Aborted\n');
+                    return 1;
+                }
+                editorCli = chosen;
+            }
+        }
+        // Persist editor choice when requested.
+        if (options.save && editorCli !== savedEditor) {
+            await updateGlobalConfigKey('editor', editorCli);
+            const displayName = EDITORS.find((e) => e.cli === editorCli)?.name ?? editorCli;
+            options.stdout(`Saved editor "${displayName}" to global config\n`);
+        }
+        // Build open args.
+        const editorDef = EDITORS.find((e) => e.cli === editorCli);
+        let openTarget = targetPath;
+        if (options.workspace) {
+            if (editorDef?.supportsWorkspace) {
+                openTarget = await ensureWorkspaceFile(targetPath, repository.repoName);
+            }
+            else {
+                const displayName = editorDef?.name ?? editorCli;
+                options.stderr(`gji open: --workspace is not supported for ${displayName}, ignoring\n`);
+            }
+        }
+        const args = [];
+        if (editorDef?.newWindowFlag) {
+            args.push(editorDef.newWindowFlag);
+        }
+        args.push(openTarget);
+        try {
+            await spawnEditor(editorCli, args);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            options.stderr(`gji open: failed to launch editor: ${message}\n`);
+            return 1;
+        }
+        const displayName = editorDef?.name ?? editorCli;
+        options.stdout(`Opened ${targetPath} in ${displayName}\n`);
+        return 0;
+    };
+}
+export const runOpenCommand = createOpenCommand();
+async function detectInstalledEditors() {
+    const results = await Promise.all(EDITORS.map(async (editor) => ({ editor, available: await isCommandAvailable(editor.cli) })));
+    return results.filter((r) => r.available).map((r) => r.editor);
+}
+async function isCommandAvailable(command) {
+    try {
+        await execFileAsync('which', [command]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function defaultPromptForWorktree(worktrees) {
+    const choice = await select({
+        message: 'Choose a worktree to open',
+        options: worktrees.map((w) => ({
+            value: w.path,
+            label: w.branch ?? '(detached)',
+            hint: w.isCurrent ? `${w.path} (current)` : w.path,
+        })),
+    });
+    if (isCancel(choice))
+        return null;
+    return choice;
+}
+async function defaultPromptForEditor(editors) {
+    const choice = await select({
+        message: 'Choose an editor',
+        options: editors.map((e) => ({ value: e.cli, label: e.name })),
+    });
+    if (isCancel(choice))
+        return null;
+    return choice;
+}
+async function ensureWorkspaceFile(worktreePath, repoName) {
+    const workspacePath = join(worktreePath, `${repoName}.code-workspace`);
+    try {
+        await access(workspacePath);
+        return workspacePath;
+    }
+    catch {
+        // File doesn't exist yet — create it.
+    }
+    const workspace = { folders: [{ path: '.' }], settings: {} };
+    await writeFile(workspacePath, `${JSON.stringify(workspace, null, 2)}\n`, 'utf8');
+    return workspacePath;
+}

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

package/dist/repo-registry.d.ts

@@ -0,0 +1,8 @@
+export interface RepoRegistryEntry {
+    lastUsed: number;
+    name: string;
+    path: string;
+}
+export declare function REGISTRY_FILE_PATH(home?: string): string;
+export declare function loadRegistry(home?: string): Promise<RepoRegistryEntry[]>;
+export declare function registerRepo(repoPath: string, home?: string): Promise<void>;