@solaqua/gji 0.9.0 → 0.11.0

package/dist/go-resolver.d.ts

@@ -0,0 +1,35 @@
+import { type RepositoryContext } from "./repo.js";
+import type { WorktreeSource } from "./worktree-source.js";
+export type GoBranchResolution = {
+    kind: "existing";
+    source: WorktreeSource;
+} | {
+    kind: "ambiguous";
+    matches: WorktreeSource[];
+} | {
+    kind: "create";
+    repository: RepositoryContext;
+    branch: string;
+    mode: "checkout" | "track";
+    remote?: string;
+} | {
+    kind: "pull-request";
+    repository: RepositoryContext;
+    input: string;
+} | {
+    kind: "no-repository";
+    staleRegisteredRepos: boolean;
+} | {
+    kind: "no-match";
+    staleRegisteredRepos: boolean;
+} | {
+    kind: "error";
+    message: string;
+};
+export declare function resolveGoBranch(options: {
+    branch: string;
+    configStderr?: (chunk: string) => void;
+    cwd: string;
+    currentSources: WorktreeSource[];
+    repository: RepositoryContext | null;
+}): Promise<GoBranchResolution>;

package/dist/go-resolver.js

@@ -0,0 +1,185 @@
+import { loadEffectiveConfig, resolveConfigString } from "./config.js";
+import { parsePrInput } from "./pr.js";
+import { getRepositoryRemoteUrl, hasLocalBranch, hasRemoteBranch, } from "./repo.js";
+import { resolveExactWorktreeQueryMatches, resolveWorktreeQuery, resolveWorktreeQueryMatches, } from "./worktree-picker.js";
+import { listRegisteredWorktreeSources } from "./worktree-sources.js";
+export async function resolveGoBranch(options) {
+    const { branch, configStderr, cwd, currentSources, repository } = options;
+    const pullRequestNumber = parsePrInput(branch);
+    const exactCurrentMatches = resolveExistingExactWorktreeMatches(currentSources, branch, false);
+    if (exactCurrentMatches.length === 1) {
+        return { kind: "existing", source: exactCurrentMatches[0] };
+    }
+    const localBranch = repository
+        ? await hasLocalBranch(repository.repoRoot, branch)
+        : false;
+    if (!repository && pullRequestNumber !== null) {
+        return {
+            kind: "error",
+            message: "PR references must be resolved from inside a git repository",
+        };
+    }
+    let remote;
+    let remoteBranch = false;
+    let configError = null;
+    const configWarnings = [];
+    if (repository) {
+        try {
+            const config = await loadEffectiveConfig(repository.repoRoot, undefined, configStderr === undefined
+                ? undefined
+                : (warning) => configWarnings.push(warning));
+            remote = resolveConfigString(config, "syncRemote") ?? "origin";
+            remoteBranch = await hasRemoteBranch(repository.repoRoot, remote, branch);
+        }
+        catch (error) {
+            configError = {
+                kind: "error",
+                message: `could not load repository config: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    const flushConfigWarnings = () => {
+        if (configStderr === undefined)
+            return;
+        for (const warning of configWarnings)
+            configStderr(warning);
+    };
+    const pullRequestBelongsToRepository = repository && pullRequestNumber !== null
+        ? await isPullRequestForRepository(repository.repoRoot, branch)
+        : true;
+    if (pullRequestNumber !== null &&
+        !localBranch &&
+        !remoteBranch &&
+        pullRequestBelongsToRepository) {
+        const pullRequestMatches = resolveExistingExactWorktreeMatches(currentSources, branch, true);
+        if (pullRequestMatches.length === 1) {
+            return { kind: "existing", source: pullRequestMatches[0] };
+        }
+    }
+    let skippedRegisteredRepos = 0;
+    const registeredSources = await listRegisteredWorktreeSources(cwd, () => {
+        skippedRegisteredRepos++;
+    });
+    const crossRepoSources = registeredSources.filter((source) => source.repoRoot !== repository?.repoRoot);
+    const crossMatches = await resolveExistingWorktreeMatches(crossRepoSources, branch, (!localBranch && !remoteBranch) || isPullRequestUrl(branch));
+    if (crossMatches.length === 1) {
+        return { kind: "existing", source: crossMatches[0] };
+    }
+    if (crossMatches.length > 1) {
+        return { kind: "ambiguous", matches: crossMatches };
+    }
+    if (!repository) {
+        return registeredSources.length === 0
+            ? {
+                kind: "no-repository",
+                staleRegisteredRepos: skippedRegisteredRepos > 0,
+            }
+            : { kind: "no-match", staleRegisteredRepos: skippedRegisteredRepos > 0 };
+    }
+    if (localBranch) {
+        if (configError)
+            return configError;
+        flushConfigWarnings();
+        return { kind: "create", repository, branch, mode: "checkout" };
+    }
+    if (remoteBranch) {
+        flushConfigWarnings();
+        return { kind: "create", repository, branch, mode: "track", remote };
+    }
+    const localMatch = !pullRequestNumber || !isPullRequestUrl(branch)
+        ? resolveWorktreeQuery(currentSources, branch)
+        : null;
+    if (localMatch) {
+        return { kind: "existing", source: localMatch };
+    }
+    if (configError)
+        return configError;
+    if (pullRequestNumber !== null && !pullRequestBelongsToRepository) {
+        flushConfigWarnings();
+        return {
+            kind: "error",
+            message: "PR URL does not belong to this repository; run gji go from the matching checkout",
+        };
+    }
+    if (pullRequestNumber !== null) {
+        flushConfigWarnings();
+        return { kind: "pull-request", repository, input: branch };
+    }
+    flushConfigWarnings();
+    return { kind: "no-match", staleRegisteredRepos: skippedRegisteredRepos > 0 };
+}
+function resolveExistingExactWorktreeMatches(sources, query, allowPullRequestFallback) {
+    const exactMatches = resolveExactWorktreeQueryMatches(sources, query);
+    if (exactMatches.length > 0 || !allowPullRequestFallback)
+        return exactMatches;
+    const pullRequestNumber = parsePrInput(query);
+    return pullRequestNumber === null
+        ? []
+        : resolveExactWorktreeQueryMatches(sources, `pr/${pullRequestNumber}`);
+}
+async function resolveExistingWorktreeMatches(sources, query, allowPullRequestFallback) {
+    const exactMatches = resolveExactWorktreeQueryMatches(sources, query);
+    if (exactMatches.length > 0)
+        return exactMatches;
+    const pullRequestNumber = parsePrInput(query);
+    if (pullRequestNumber === null) {
+        return resolveWorktreeQueryMatches(sources, query);
+    }
+    if (!allowPullRequestFallback)
+        return [];
+    const ownershipByRepository = new Map();
+    const eligibleSources = await Promise.all(sources.map(async (source) => {
+        const repoRoot = source.repoRoot ?? source.worktree.path;
+        let ownership = ownershipByRepository.get(repoRoot);
+        if (ownership === undefined) {
+            ownership = isPullRequestForRepository(repoRoot, query);
+            ownershipByRepository.set(repoRoot, ownership);
+        }
+        return (await ownership) ? source : null;
+    }));
+    const pullRequestMatches = resolveExactWorktreeQueryMatches(eligibleSources.filter((source) => source !== null), `pr/${pullRequestNumber}`);
+    if (pullRequestMatches.length > 0 || isPullRequestUrl(query)) {
+        return pullRequestMatches;
+    }
+    return resolveWorktreeQueryMatches(sources, query);
+}
+function isPullRequestUrl(input) {
+    return /^[a-z][a-z\d+.-]*:\/\//i.test(input);
+}
+async function isPullRequestForRepository(repoRoot, input) {
+    if (/^\d+$/.test(input) || /^#\d+$/.test(input))
+        return true;
+    let pullRequestUrl;
+    try {
+        pullRequestUrl = new URL(input);
+    }
+    catch {
+        return true;
+    }
+    const remoteUrl = await getRepositoryRemoteUrl(repoRoot, "origin");
+    if (!remoteUrl)
+        return true;
+    return (normalizeRepositoryUrl(remoteUrl) ===
+        normalizeRepositoryUrl(pullRequestUrl.href));
+}
+function normalizeRepositoryUrl(value) {
+    return normalizeRemoteUrl(value).replace(/\/(?:pull|pull-requests|(?:-\/)?merge_requests)\/\d+(?:\/.*)?$/, "");
+}
+function normalizeRemoteUrl(value) {
+    const trimmed = value.trim();
+    const sshMatch = trimmed.match(/^(?:[^@]+@)?([^:]+):(.+)$/);
+    if (sshMatch && !trimmed.includes("://")) {
+        return `${sshMatch[1]}/${sshMatch[2]}`
+            .replace(/\.git$/, "")
+            .replace(/\/$/, "");
+    }
+    try {
+        const url = new URL(trimmed);
+        return `${url.host}${url.pathname}`
+            .replace(/\.git$/, "")
+            .replace(/\/$/, "");
+    }
+    catch {
+        return trimmed.replace(/\.git$/, "").replace(/\/$/, "");
+    }
+}

package/dist/go.d.ts

@@ -1,13 +1,16 @@
-import { type QueryWorktreePullRequests, type WorktreePromptEntry } from "./worktree-picker.js";
+import { type QueryWorktreePullRequests, type WorktreePromptEntry, type WorktreePromptScope } from "./worktree-picker.js";
 export interface GoCommandOptions {
     branch?: string;
     cwd: string;
+    json?: boolean;
     print?: boolean;
+    root?: boolean;
     stderr: (chunk: string) => void;
     stdout: (chunk: string) => void;
 }
 export interface GoCommandDependencies {
-    promptForWorktree: (worktrees: WorktreePromptEntry[]) => Promise<string | null>;
+    confirmBranchCreation: (branch: string) => Promise<boolean>;
+    promptForWorktree: (worktrees: WorktreePromptEntry[], scope?: WorktreePromptScope) => Promise<string | null>;
     queryPullRequests: QueryWorktreePullRequests;
 }
 export declare function createGoCommand(dependencies?: Partial<GoCommandDependencies>): (options: GoCommandOptions) => Promise<number>;

package/dist/go.js

@@ -1,85 +1,285 @@
 import { basename } from "node:path";
+import { confirm, isCancel } from "@clack/prompts";
+import { runBackCommand } from "./back.js";
 import { loadEffectiveConfig } from "./config.js";
+import { resolveGoBranch } from "./go-resolver.js";
 import { isHeadless } from "./headless.js";
 import { recordWorktreeUsage } from "./history.js";
 import { extractHooks, runHook } from "./hooks.js";
-import { detectRepository, listWorktrees } from "./repo.js";
+import { createNavigationRepository, createNavigationTarget, } from "./navigation-output.js";
+import { runNewCommand } from "./new.js";
+import { runPrCommand } from "./pr.js";
+import { detectRepository, listWorktrees, } from "./repo.js";
 import { writeShellOutput } from "./shell-handoff.js";
-import { resolveWarpTarget } from "./warp.js";
-import { buildWorktreePromptEntries, promptForSingleWorktree, resolveWorktreeQuery, } from "./worktree-picker.js";
+import { buildWorktreePromptEntries, promptForSingleWorktree, } from "./worktree-picker.js";
+import { listRegisteredWorktreeSources } from "./worktree-sources.js";
 const GO_OUTPUT_FILE_ENV = "GJI_GO_OUTPUT_FILE";
 export function createGoCommand(dependencies = {}) {
+    const confirmBranchCreation = dependencies.confirmBranchCreation ?? defaultConfirmBranchCreation;
     const prompt = dependencies.promptForWorktree ?? promptForWorktree;
     return async function runGoCommand(options) {
-        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;
+        if (options.root) {
+            if (options.branch !== undefined) {
+                return emitError(options, "--root cannot be combined with a branch");
             }
-            const target = await resolveWarpTarget({
-                ...options,
+            return navigateToRepositoryRoot(options);
+        }
+        if (options.branch === "-") {
+            return runBackCommand({
                 commandName: "gji go",
+                cwd: options.cwd,
+                json: options.json,
+                outputEnv: GO_OUTPUT_FILE_ENV,
+                stderr: options.stderr,
+                stdout: options.stdout,
             });
-            if (!target)
-                return 1;
-            await recordWorktreeUsage(target.path, target.branch);
-            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;
         }
-        const promptSources = worktrees.map((worktree) => ({
-            repoRoot: repository.repoRoot,
-            repoName: repository.repoName,
-            worktree,
-        }));
-        const promptEntries = options.branch
-            ? []
-            : await buildWorktreePromptEntries(promptSources, {
+        const [repository, currentWorktrees] = await readCurrentRepository(options.cwd);
+        const currentSources = repository
+            ? toPromptSources(repository.repoRoot, repository.repoName, currentWorktrees)
+            : [];
+        if (!options.branch) {
+            if (options.json || isHeadless()) {
+                return emitError(options, "branch argument is required in non-interactive mode (GJI_NO_TUI=1)");
+            }
+            let skippedRegisteredRepos = 0;
+            let registeredSources = null;
+            let promptSources = currentSources;
+            const loadAllSources = async () => {
+                if (registeredSources === null) {
+                    registeredSources = await listRegisteredWorktreeSources(options.cwd, () => {
+                        skippedRegisteredRepos++;
+                    });
+                }
+                return deduplicateSources([...currentSources, ...registeredSources]);
+            };
+            if (!repository) {
+                promptSources = await loadAllSources();
+            }
+            if (promptSources.length === 0 && !repository) {
+                return emitNoRepositoryError(options, skippedRegisteredRepos > 0);
+            }
+            let currentRepositoryScope = true;
+            let scope;
+            if (repository) {
+                scope = {
+                    label: "current repository",
+                    toggleLabel: "all repositories",
+                    toggle: async () => {
+                        const nextCurrentRepositoryScope = !currentRepositoryScope;
+                        const nextSources = nextCurrentRepositoryScope
+                            ? currentSources
+                            : await loadAllSources();
+                        currentRepositoryScope = nextCurrentRepositoryScope;
+                        promptSources = nextSources;
+                        return {
+                            entries: await buildWorktreePromptEntries(promptSources, {
+                                metadata: currentRepositoryScope ? "full" : "fast",
+                                queryPullRequests: dependencies.queryPullRequests,
+                            }),
+                            label: currentRepositoryScope
+                                ? "current repository"
+                                : "all repositories",
+                            toggleLabel: currentRepositoryScope
+                                ? "all repositories"
+                                : "current repository",
+                        };
+                    },
+                };
+            }
+            const promptEntries = await buildWorktreePromptEntries(promptSources, {
+                metadata: repository ? "full" : "fast",
                 queryPullRequests: dependencies.queryPullRequests,
             });
-        const queried = options.branch
-            ? resolveWorktreeQuery(promptSources, options.branch)
-            : null;
-        const prompted = options.branch ? null : await prompt(promptEntries);
-        const resolvedPath = options.branch
-            ? queried?.worktree.path
-            : (prompted ?? undefined);
-        if (!resolvedPath) {
-            if (options.branch) {
-                options.stderr(`No worktree found for branch: ${options.branch}\n`);
-                options.stderr(`Hint: Use 'gji ls' to see available worktrees\n`);
-            }
-            else {
+            const selectedPath = await prompt(promptEntries, scope);
+            if (!selectedPath) {
                 options.stderr("Aborted\n");
+                return 1;
             }
-            return 1;
+            const selected = promptSources.find((source) => source.worktree.path === selectedPath);
+            return navigateToExistingWorktree(options, selectedPath, selected?.worktree);
         }
-        const chosenWorktree = worktrees.find((w) => w.path === resolvedPath);
-        const config = await loadEffectiveConfig(repository.repoRoot, undefined, options.stderr);
-        const hooks = extractHooks(config);
-        await runHook(hooks["after-enter"], resolvedPath, {
-            branch: chosenWorktree?.branch ?? undefined,
-            path: resolvedPath,
-            repo: basename(repository.repoRoot),
-        }, options.stderr);
-        await recordWorktreeUsage(resolvedPath, chosenWorktree?.branch ?? null);
-        await writeShellOutput(GO_OUTPUT_FILE_ENV, resolvedPath, options.stdout);
-        return 0;
+        const resolution = await resolveGoBranch({
+            branch: options.branch,
+            configStderr: options.json ? undefined : options.stderr,
+            cwd: options.cwd,
+            currentSources,
+            repository,
+        });
+        return handleGoBranchResolution(options, resolution, confirmBranchCreation, prompt, dependencies.queryPullRequests);
     };
 }
 export const runGoCommand = createGoCommand();
-async function promptForWorktree(worktrees) {
-    return promptForSingleWorktree("Choose a worktree", worktrees);
+async function handleGoBranchResolution(options, resolution, confirmBranchCreation, prompt, queryPullRequests) {
+    switch (resolution.kind) {
+        case "existing":
+            return navigateToExistingWorktree(options, resolution.source.worktree.path, resolution.source.worktree);
+        case "ambiguous": {
+            if (options.json || isHeadless() || options.print) {
+                return emitAmbiguousCrossRepoError(options, resolution.matches);
+            }
+            const candidates = await buildWorktreePromptEntries(resolution.matches, {
+                metadata: "fast",
+                queryPullRequests,
+            });
+            const selectedPath = await prompt(candidates);
+            if (!selectedPath) {
+                options.stderr("Aborted\n");
+                return 1;
+            }
+            const selected = resolution.matches.find((source) => source.worktree.path === selectedPath);
+            return navigateToExistingWorktree(options, selectedPath, selected?.worktree);
+        }
+        case "create":
+            return createExistingBranchWorktree(options, confirmBranchCreation, resolution.repository, resolution.branch, resolution.mode, resolution.remote);
+        case "pull-request":
+            if (options.json || isHeadless() || options.print) {
+                return emitError(options, "PR navigation creates a worktree; use `gji pr <ref>` in an interactive shell");
+            }
+            return runPrCommand({
+                cwd: resolution.repository.repoRoot,
+                number: resolution.input,
+                outputEnv: GO_OUTPUT_FILE_ENV,
+                stderr: options.stderr,
+                stdout: options.stdout,
+            });
+        case "no-repository":
+            return emitNoRepositoryError(options, resolution.staleRegisteredRepos);
+        case "no-match":
+            return emitNoMatchError(options, resolution.staleRegisteredRepos);
+        case "error":
+            return emitError(options, resolution.message);
+    }
+}
+async function readCurrentRepository(cwd) {
+    try {
+        const [repository, worktrees] = await Promise.all([
+            detectRepository(cwd),
+            listWorktrees(cwd),
+        ]);
+        return [repository, worktrees];
+    }
+    catch {
+        return [null, []];
+    }
+}
+function toPromptSources(repoRoot, repoName, worktrees) {
+    return worktrees.map((worktree) => ({ repoName, repoRoot, worktree }));
+}
+function deduplicateSources(sources) {
+    const seen = new Set();
+    const deduplicated = [];
+    for (const source of sources) {
+        if (seen.has(source.worktree.path))
+            continue;
+        seen.add(source.worktree.path);
+        deduplicated.push(source);
+    }
+    return deduplicated;
+}
+async function createExistingBranchWorktree(options, confirmBranchCreation, repository, branch, mode, remote) {
+    if (options.json || isHeadless() || options.print) {
+        return emitError(options, `branch "${branch}" exists but has no worktree; use interactive gji go ${branch} to create one`);
+    }
+    if (!(await confirmBranchCreation(branch))) {
+        options.stderr("Aborted\n");
+        return 1;
+    }
+    return runNewCommand({
+        branch,
+        cwd: repository.repoRoot,
+        mode,
+        outputEnv: GO_OUTPUT_FILE_ENV,
+        remote,
+        stderr: options.stderr,
+        stdout: options.stdout,
+    });
+}
+async function navigateToExistingWorktree(options, path, worktree) {
+    const repository = await detectRepository(path);
+    if (options.json) {
+        options.stdout(`${JSON.stringify(createNavigationTarget(createNavigationRepository(repository.repoName, repository.repoRoot), path, worktree?.branch ?? null), null, 2)}\n`);
+        return 0;
+    }
+    const config = await loadEffectiveConfig(repository.repoRoot, undefined, options.stderr);
+    const hooks = extractHooks(config);
+    await runHook(hooks["after-enter"], path, {
+        branch: worktree?.branch ?? undefined,
+        path,
+        repo: basename(repository.repoRoot),
+    }, options.stderr);
+    await recordWorktreeUsage(path, worktree?.branch ?? null);
+    await writeShellOutput(GO_OUTPUT_FILE_ENV, path, options.stdout);
+    return 0;
+}
+async function navigateToRepositoryRoot(options) {
+    let repository;
+    try {
+        repository = await detectRepository(options.cwd);
+    }
+    catch {
+        return emitError(options, "not inside a git repository");
+    }
+    if (options.json) {
+        const rootWorktree = (await listWorktrees(repository.repoRoot)).find((worktree) => worktree.path === repository.repoRoot);
+        options.stdout(`${JSON.stringify(createNavigationTarget(createNavigationRepository(repository.repoName, repository.repoRoot), repository.repoRoot, rootWorktree?.branch ?? null), null, 2)}\n`);
+        return 0;
+    }
+    if (options.print) {
+        options.stdout(`${repository.repoRoot}\n`);
+        return 0;
+    }
+    await writeShellOutput(GO_OUTPUT_FILE_ENV, repository.repoRoot, options.stdout);
+    return 0;
+}
+function emitAmbiguousCrossRepoError(options, matches) {
+    const candidates = matches
+        .map((match) => `${match.repoName}/${match.worktree.branch ?? "(detached)"}`)
+        .join(", ");
+    return emitError(options, `multiple worktrees match "${options.branch}": ${candidates}`);
+}
+function emitNoRepositoryError(options, staleRegisteredRepos) {
+    if (options.json) {
+        return emitError(options, "not in a git repository and no accessible worktrees are registered");
+    }
+    options.stderr("gji go: not in a git repository and no repos registered yet.\n");
+    options.stderr("Use any gji command inside a repository to register it.\n");
+    if (staleRegisteredRepos) {
+        options.stderr("Hint: Run 'gji doctor' to inspect stale repository entries.\n");
+    }
+    return 1;
+}
+function emitNoMatchError(options, staleRegisteredRepos = false) {
+    if (options.json) {
+        return emitError(options, `nothing matched "${options.branch}"`);
+    }
+    options.stderr(`No worktree found for branch: ${options.branch}\n`);
+    options.stderr(`gji go: nothing matched "${options.branch}"\n`);
+    options.stderr("Hint: Use 'gji ls' to see available worktrees\n");
+    options.stderr("  · no worktree or branch named that query in this repository\n" +
+        "  · no matching worktree in registered repositories\n" +
+        `  · create it: gji new ${options.branch}\n`);
+    if (staleRegisteredRepos) {
+        options.stderr("Hint: Run 'gji doctor' to inspect stale repository entries.\n");
+    }
+    return 1;
+}
+function emitError(options, message) {
+    if (options.json) {
+        options.stderr(`${JSON.stringify({ error: message }, null, 2)}\n`);
+    }
+    else {
+        options.stderr(`gji go: ${message}\n`);
+    }
+    return 1;
+}
+async function defaultConfirmBranchCreation(branch) {
+    const choice = await confirm({
+        message: `branch "${branch}" exists but has no worktree. Create one?`,
+        initialValue: true,
+    });
+    return !isCancel(choice) && choice;
+}
+async function promptForWorktree(worktrees, scope) {
+    return promptForSingleWorktree("Choose a worktree", worktrees, { scope });
 }

package/dist/hooks.d.ts

@@ -9,6 +9,6 @@ export interface HookContext {
     path: string;
     repo: string;
 }
-export declare function runHook(hookCmd: GjiHookCommand | 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, stdout?: (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

@@ -1,14 +1,14 @@
 import { spawn } from "node:child_process";
-export async function runHook(hookCmd, cwd, context, stderr) {
+export async function runHook(hookCmd, cwd, context, stderr, stdout = (chunk) => process.stdout.write(chunk)) {
     if (!hookCmd)
         return;
     if (Array.isArray(hookCmd)) {
-        await runArgvHook(hookCmd, cwd, context, stderr);
+        await runArgvHook(hookCmd, cwd, context, stderr, stdout);
         return;
     }
-    await runShellHook(hookCmd, cwd, context, stderr);
+    await runShellHook(hookCmd, cwd, context, stderr, stdout);
 }
-async function runArgvHook(hookCmd, cwd, context, stderr) {
+async function runArgvHook(hookCmd, cwd, context, stderr, stdout) {
     const [command, ...args] = hookCmd.map((arg) => interpolate(arg, context));
     if (!command) {
         stderr("gji: hook argv command must include a non-empty command\n");
@@ -18,9 +18,12 @@ async function runArgvHook(hookCmd, cwd, context, stderr) {
         const child = spawn(command, args, {
             cwd,
             shell: false,
-            stdio: ["ignore", "inherit", "pipe"],
+            stdio: ["ignore", "pipe", "pipe"],
             env: hookEnvironment(context),
         });
+        child.stdout.on("data", (chunk) => {
+            stdout(chunk.toString());
+        });
         child.stderr.on("data", (chunk) => {
             stderr(chunk.toString());
         });
@@ -36,15 +39,18 @@ async function runArgvHook(hookCmd, cwd, context, stderr) {
         });
     });
 }
-async function runShellHook(hookCmd, cwd, context, stderr) {
+async function runShellHook(hookCmd, cwd, context, stderr, stdout) {
     const interpolated = interpolate(hookCmd, context);
     await new Promise((resolve) => {
         const child = spawn(interpolated, {
             cwd,
             shell: true,
-            stdio: ["ignore", "inherit", "pipe"],
+            stdio: ["ignore", "pipe", "pipe"],
             env: hookEnvironment(context),
         });
+        child.stdout.on("data", (chunk) => {
+            stdout(chunk.toString());
+        });
         child.stderr.on("data", (chunk) => {
             stderr(chunk.toString());
         });