@solaqua/gji 0.5.0 → 0.6.0

package/dist/go.js

@@ -7,14 +7,32 @@ 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;

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,47 +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',
     },
     {
-        bypassOption: '--print',
+        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);
@@ -178,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
@@ -202,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,6 +4,7 @@ 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';
@@ -18,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) {
@@ -119,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;
         }
@@ -152,6 +161,10 @@ export function createNewCommand(dependencies = {}) {
             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;
     };
 }
@@ -259,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/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>;

package/dist/repo-registry.js

@@ -0,0 +1,52 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { basename, dirname, join, resolve } from 'node:path';
+import { GLOBAL_CONFIG_DIRECTORY } from './config.js';
+const REGISTRY_FILE_NAME = 'repos.json';
+const MAX_REGISTRY_ENTRIES = 100;
+export function REGISTRY_FILE_PATH(home = homedir()) {
+    const configDir = process.env.GJI_CONFIG_DIR;
+    if (configDir) {
+        return join(resolve(configDir), REGISTRY_FILE_NAME);
+    }
+    return join(home, GLOBAL_CONFIG_DIRECTORY, REGISTRY_FILE_NAME);
+}
+export async function loadRegistry(home = homedir()) {
+    const path = REGISTRY_FILE_PATH(home);
+    try {
+        const raw = await readFile(path, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.filter(isRegistryEntry);
+    }
+    catch {
+        return [];
+    }
+}
+export async function registerRepo(repoPath, home = homedir()) {
+    const registryPath = REGISTRY_FILE_PATH(home);
+    const existing = await loadRegistry(home);
+    // Skip write if this repo is already the most-recently-used entry (common case).
+    if (existing.length > 0 && existing[0].path === repoPath)
+        return;
+    const entry = {
+        lastUsed: Date.now(),
+        name: basename(repoPath),
+        path: repoPath,
+    };
+    const filtered = existing.filter((e) => e.path !== repoPath);
+    const next = [entry, ...filtered].slice(0, MAX_REGISTRY_ENTRIES);
+    await mkdir(dirname(registryPath), { recursive: true });
+    await writeFile(registryPath, `${JSON.stringify(next, null, 2)}\n`, 'utf8');
+}
+function isRegistryEntry(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'path' in value &&
+        typeof value.path === 'string' &&
+        'name' in value &&
+        typeof value.name === 'string' &&
+        'lastUsed' in value &&
+        typeof value.lastUsed === 'number');
+}

package/dist/warp.d.ts

@@ -0,0 +1,20 @@
+export interface WarpCommandOptions {
+    branch?: string;
+    cwd: string;
+    json?: boolean;
+    newWorktree?: boolean;
+    stderr: (chunk: string) => void;
+    stdout: (chunk: string) => void;
+}
+export declare function runWarpCommand(options: WarpCommandOptions): Promise<number>;
+export interface WarpTarget {
+    branch: string | null;
+    path: string;
+}
+export declare function resolveWarpTarget(options: {
+    branch?: string;
+    commandName?: string;
+    cwd: string;
+    json?: boolean;
+    stderr: (chunk: string) => void;
+}): Promise<WarpTarget | null>;