@solaqua/gji 0.8.1 → 0.10.0

package/dist/go.d.ts

@@ -1,4 +1,4 @@
-import { type WorktreePromptEntry } from "./worktree-picker.js";
+import { type QueryWorktreePullRequests, type WorktreePromptEntry } from "./worktree-picker.js";
 export interface GoCommandOptions {
     branch?: string;
     cwd: string;
@@ -8,6 +8,7 @@ export interface GoCommandOptions {
 }
 export interface GoCommandDependencies {
     promptForWorktree: (worktrees: WorktreePromptEntry[]) => Promise<string | null>;
+    queryPullRequests: QueryWorktreePullRequests;
 }
 export declare function createGoCommand(dependencies?: Partial<GoCommandDependencies>): (options: GoCommandOptions) => Promise<number>;
 export declare const runGoCommand: (options: GoCommandOptions) => Promise<number>;

package/dist/go.js

@@ -40,12 +40,15 @@ export function createGoCommand(dependencies = {}) {
             return 1;
         }
         const promptSources = worktrees.map((worktree) => ({
+            repoRoot: repository.repoRoot,
             repoName: repository.repoName,
             worktree,
         }));
         const promptEntries = options.branch
             ? []
-            : await buildWorktreePromptEntries(promptSources);
+            : await buildWorktreePromptEntries(promptSources, {
+                queryPullRequests: dependencies.queryPullRequests,
+            });
         const queried = options.branch
             ? resolveWorktreeQuery(promptSources, options.branch)
             : null;

package/dist/index.js

@@ -2,11 +2,12 @@
 import { homedir } from "node:os";
 import { runCli } from "./cli.js";
 import { loadGlobalConfig } from "./config.js";
+import { isHeadless } from "./headless.js";
 async function main() {
     try {
         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.
+        // Only shown in interactive terminals — suppressed in pipes and after gji init.
         const isMetaArg = argv[0] === "init" ||
             argv[0] === "--version" ||
             argv[0] === "-V" ||
@@ -31,15 +32,20 @@ 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`);
+            const setupCommand = isHeadless()
+                ? legacyShellSetupCommand()
+                : "gji init";
+            process.stderr.write(`gji: shell integration not set up — run \`${setupCommand}\` to enable automatic cd.\n`);
         }
     }
     catch {
         // best-effort; never block the command
     }
 }
+function legacyShellSetupCommand() {
+    const shell = (process.env.SHELL ?? "").split("/").at(-1);
+    return shell && ["bash", "fish", "zsh"].includes(shell)
+        ? `gji init ${shell} --write`
+        : "gji init <shell> --write";
+}
 void main();

package/dist/init.d.ts

@@ -1,5 +1,6 @@
 import { type SupportedShell } from "./shell.js";
 export type InstallSaveTarget = "local" | "global";
+export type ShellIntegrationChoice = "existing" | "install" | "skip";
 export interface SetupWizardResult {
     branchPrefix?: string;
     hooks?: {
@@ -10,9 +11,22 @@ export interface SetupWizardResult {
     installSaveTarget: InstallSaveTarget;
     worktreePath?: string;
 }
+export interface InitOnboardingResult {
+    editor?: string;
+    installCompletion: boolean;
+    shellIntegration: ShellIntegrationChoice;
+    shell: SupportedShell;
+}
+interface InitOnboardingContext {
+    detectedShell: SupportedShell | null;
+    home: string;
+}
 export interface InitCommandOptions {
     cwd: string;
     home?: string;
+    interactive?: boolean;
+    json?: boolean;
+    promptForOnboarding?: (context: InitOnboardingContext) => Promise<InitOnboardingResult | null>;
     promptForSetup?: () => Promise<SetupWizardResult | null>;
     shell?: string;
     stderr?: (chunk: string) => void;
@@ -22,3 +36,4 @@ export interface InitCommandOptions {
 export declare function runInitCommand(options: InitCommandOptions): Promise<number>;
 export declare function renderShellIntegration(shell: SupportedShell): string;
 export declare function upsertShellIntegration(existingConfig: string, script: string): string;
+export {};

package/dist/init.js

@@ -1,11 +1,15 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { constants } from "node:fs";
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-import { intro, isCancel, outro, select, text } from "@clack/prompts";
+import { dirname } from "node:path";
+import { confirm, intro, isCancel, log, outro, select, text, } from "@clack/prompts";
 import { loadConfig, loadGlobalConfig, saveGlobalConfig, saveLocalConfig, updateGlobalConfigKey, } from "./config.js";
+import { EDITORS } from "./editor.js";
+import { isHeadless } from "./headless.js";
 import { resolveSupportedShell } from "./shell.js";
-const START_MARKER = "# >>> gji init >>>";
-const END_MARKER = "# <<< gji init <<<";
+import { renderShellCompletion } from "./shell-completion.js";
+import { SHELL_INTEGRATION_END_MARKER as END_MARKER, executableExists, hasShellIntegration, ONBOARDING_SHELL_INTEGRATION_END_MARKER as ONBOARDING_END_MARKER, ONBOARDING_SHELL_INTEGRATION_START_MARKER as ONBOARDING_START_MARKER, resolveCompletionPath, resolveShellConfigPath, SHELL_INTEGRATION_START_MARKER as START_MARKER, } from "./shell-setup.js";
+const ZSH_COMPLETION_PATH_LINE = "fpath=(~/.zsh/completions $fpath)";
 const SHELL_WRAPPED_COMMANDS = [
     {
         bypassOptions: ["--help"],
@@ -58,6 +62,228 @@ const SHELL_WRAPPED_COMMANDS = [
     },
 ];
 export async function runInitCommand(options) {
+    if (options.shell === undefined) {
+        return runOnboardingInitCommand(options);
+    }
+    return runLegacyInitCommand(options);
+}
+async function runOnboardingInitCommand(options) {
+    if (options.json || isHeadless() || !canRunOnboarding(options)) {
+        return writeNonInteractiveInitError(options);
+    }
+    const home = options.home ?? homedir();
+    const context = {
+        detectedShell: resolveSupportedShell(undefined, process.env.SHELL),
+        home,
+    };
+    if (options.promptForOnboarding === undefined) {
+        return runDefaultOnboarding(context);
+    }
+    const result = await options.promptForOnboarding(context);
+    if (!result) {
+        options.stderr?.("Aborted.\n");
+        return 1;
+    }
+    await applyOnboardingResult(result, home);
+    return 0;
+}
+function canRunOnboarding(options) {
+    return (options.interactive ??
+        (options.promptForOnboarding !== undefined ||
+            (process.stdin.isTTY === true && process.stdout.isTTY === true)));
+}
+function writeNonInteractiveInitError(options) {
+    const error = "run `gji init <shell> --write` in non-interactive mode";
+    options.stderr?.(options.json ? `${JSON.stringify({ error })}\n` : `${error}\n`);
+    return 1;
+}
+async function runDefaultOnboarding(context) {
+    intro("gji init");
+    const shell = await select({
+        message: "Which shell should gji configure?",
+        initialValue: context.detectedShell ?? "zsh",
+        options: [
+            { value: "zsh", label: "zsh" },
+            { value: "bash", label: "bash" },
+            { value: "fish", label: "fish" },
+        ],
+    });
+    if (isCancel(shell))
+        return abortDefaultOnboarding();
+    const rcPath = resolveShellConfigPath(shell, context.home);
+    const currentConfig = await readExistingConfig(rcPath);
+    const shellIntegration = await promptForShellIntegration(currentConfig, rcPath, shell);
+    if (shellIntegration === null)
+        return abortDefaultOnboarding();
+    const completionPath = resolveCompletionPath(shell, context.home);
+    const completionAlreadyInstalled = await fileExists(completionPath);
+    await applyShellIntegration(shell, shellIntegration, context.home);
+    const installCompletion = await promptForCompletion(shell, completionPath);
+    if (installCompletion === null)
+        return abortDefaultOnboarding();
+    if (installCompletion) {
+        await mkdir(dirname(completionPath), { recursive: true });
+        await writeFile(completionPath, renderShellCompletion(shell), "utf8");
+    }
+    if (shell === "zsh" && (completionAlreadyInstalled || installCompletion)) {
+        await ensureZshCompletionPath(rcPath);
+    }
+    const editor = await promptForEditor();
+    if (editor === null)
+        return abortDefaultOnboarding();
+    if (editor) {
+        await updateGlobalConfigKey("editor", editor, context.home);
+    }
+    outro(`Setup complete. Restart your shell or run: source ${rcPath}\nVerify with: gji doctor`);
+    return 0;
+}
+async function applyShellIntegration(shell, choice, home) {
+    if (choice === "install") {
+        await installOnboardingShellIntegration(shell, home);
+    }
+    if (choice !== "skip") {
+        await updateGlobalConfigKey("shellIntegration", true, home);
+    }
+}
+function abortDefaultOnboarding() {
+    outro("Aborted.");
+    return 1;
+}
+async function promptForShellIntegration(currentConfig, rcPath, shell) {
+    if (currentConfig.includes(ONBOARDING_START_MARKER) &&
+        currentConfig.includes(ONBOARDING_END_MARKER)) {
+        log.success(`Shell integration marker found in ${rcPath}; refreshing it.`);
+        return "install";
+    }
+    if (hasShellIntegration(currentConfig, shell)) {
+        log.success(`Shell integration already installed in ${rcPath} ✓`);
+        return "existing";
+    }
+    const confirmed = await confirm({
+        message: `Install shell integration in ${rcPath}?`,
+        initialValue: true,
+    });
+    if (isCancel(confirmed))
+        return null;
+    return confirmed ? "install" : "skip";
+}
+async function promptForCompletion(shell, completionPath) {
+    if (await fileExists(completionPath)) {
+        log.success(`${shell} completion already installed at ${completionPath} ✓`);
+        return false;
+    }
+    const confirmed = await confirm({
+        message: `Install ${shell} completion at ${completionPath}?`,
+        initialValue: true,
+    });
+    if (isCancel(confirmed))
+        return null;
+    return confirmed;
+}
+async function promptForEditor() {
+    const availableEditors = await findAvailableEditors();
+    if (availableEditors.length === 0) {
+        log.info("No supported editor CLIs found on PATH; skipping editor setup.");
+        return undefined;
+    }
+    const skipValue = "__gji_skip_editor__";
+    const selected = await select({
+        message: "Which editor should gji use?",
+        options: [
+            ...availableEditors.map(({ cli, name }) => ({
+                value: cli,
+                label: name,
+                hint: cli,
+            })),
+            { value: skipValue, label: "Skip" },
+        ],
+    });
+    if (isCancel(selected))
+        return null;
+    return selected === skipValue ? undefined : selected;
+}
+async function findAvailableEditors() {
+    const availableEditors = [];
+    for (const editor of EDITORS) {
+        if (await executableExists(editor.cli)) {
+            availableEditors.push(editor);
+        }
+    }
+    return availableEditors;
+}
+async function applyOnboardingResult(result, home) {
+    const rcPath = resolveShellConfigPath(result.shell, home);
+    const completionPath = resolveCompletionPath(result.shell, home);
+    const completionAlreadyInstalled = await fileExists(completionPath);
+    await applyShellIntegration(result.shell, result.shellIntegration, home);
+    if (result.installCompletion) {
+        await mkdir(dirname(completionPath), { recursive: true });
+        await writeFile(completionPath, renderShellCompletion(result.shell), "utf8");
+    }
+    if (result.shell === "zsh" &&
+        (completionAlreadyInstalled || result.installCompletion)) {
+        await ensureZshCompletionPath(rcPath);
+    }
+    if (result.editor) {
+        await updateGlobalConfigKey("editor", result.editor, home);
+    }
+}
+async function installOnboardingShellIntegration(shell, home) {
+    const rcPath = resolveShellConfigPath(shell, home);
+    await mkdir(dirname(rcPath), { recursive: true });
+    const current = await readExistingConfig(rcPath);
+    if (shell === "fish") {
+        await writeFile(rcPath, upsertShellIntegration(current, renderShellIntegration(shell)), "utf8");
+        return;
+    }
+    await writeFile(rcPath, upsertOnboardingShellIntegration(current, shell), "utf8");
+}
+function upsertOnboardingShellIntegration(existingConfig, shell) {
+    const script = renderOnboardingShellIntegration(shell).trimEnd();
+    const blockPattern = new RegExp(`${escapeForRegExp(ONBOARDING_START_MARKER)}[\\s\\S]*?${escapeForRegExp(ONBOARDING_END_MARKER)}\\n?`, "m");
+    if (blockPattern.test(existingConfig)) {
+        return ensureTrailingNewline(existingConfig.replace(blockPattern, `${script}\n`));
+    }
+    const prefix = existingConfig.trimEnd();
+    if (prefix.length === 0)
+        return ensureTrailingNewline(script);
+    return ensureTrailingNewline(`${prefix}\n\n${script}`);
+}
+function renderOnboardingShellIntegration(shell) {
+    return `${ONBOARDING_START_MARKER}
+eval "$(gji init ${shell})"
+${ONBOARDING_END_MARKER}
+`;
+}
+async function ensureZshCompletionPath(rcPath) {
+    const current = await readExistingConfig(rcPath);
+    const next = upsertZshCompletionPath(current);
+    if (next !== current) {
+        await writeFile(rcPath, next, "utf8");
+    }
+}
+function upsertZshCompletionPath(existingConfig) {
+    const configWithoutCompletionPath = existingConfig
+        .replace(/# >>> gji zsh completion path >>>[\s\S]*?# <<< gji zsh completion path <<<\n?/m, "")
+        .replace(new RegExp(`^[\\t ]*${escapeForRegExp(ZSH_COMPLETION_PATH_LINE)}[\\t ]*\\n?`, "gm"), "");
+    const suffix = configWithoutCompletionPath
+        .replace(/^(?:\r?\n)+/, "")
+        .trimEnd();
+    // Frameworks can invoke compinit from a sourced file, so this must come first.
+    return ensureTrailingNewline(suffix.length === 0
+        ? ZSH_COMPLETION_PATH_LINE
+        : `${ZSH_COMPLETION_PATH_LINE}\n\n${suffix}`);
+}
+async function fileExists(path) {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function runLegacyInitCommand(options) {
     const shell = resolveSupportedShell(options.shell, process.env.SHELL);
     const home = options.home ?? homedir();
     if (!shell) {
@@ -79,7 +305,7 @@ export async function runInitCommand(options) {
     const { config: globalConfig } = await loadGlobalConfig(home);
     const alreadyConfigured = "shellIntegration" in globalConfig || "installSaveTarget" in globalConfig;
     const hasCustomPrompt = options.promptForSetup !== undefined;
-    const canPrompt = hasCustomPrompt || process.stdout.isTTY === true;
+    const canPrompt = !isHeadless() && (hasCustomPrompt || process.stdout.isTTY === true);
     if (!alreadyConfigured && canPrompt) {
         const prompt = options.promptForSetup ?? defaultPromptForSetup;
         const result = await prompt();
@@ -154,16 +380,6 @@ async function saveWizardConfig(result, cwd, home) {
         await saveGlobalConfig({ ...existing, ...values }, home);
     }
 }
-function resolveShellConfigPath(shell, home) {
-    switch (shell) {
-        case "bash":
-            return join(home, ".bashrc");
-        case "fish":
-            return join(home, ".config", "fish", "config.fish");
-        case "zsh":
-            return join(home, ".zshrc");
-    }
-}
 async function readExistingConfig(path) {
     try {
         return await readFile(path, "utf8");

package/dist/new.d.ts

@@ -7,6 +7,7 @@ export interface NewCommandOptions {
     detached?: boolean;
     dryRun?: boolean;
     editor?: string;
+    fromCurrent?: boolean;
     force?: boolean;
     json?: boolean;
     open?: boolean;

package/dist/new.js

@@ -21,6 +21,16 @@ export function createNewCommand(dependencies = {}) {
     const prompt = dependencies.promptForPathConflict ?? promptForPathConflict;
     const spawnEditor = dependencies.spawnEditor ?? defaultSpawnEditor;
     return async function runNewCommand(options) {
+        if (options.detached && options.fromCurrent) {
+            const message = "--from-current cannot be used with --detached";
+            if (options.json) {
+                options.stderr(`${JSON.stringify({ error: message }, null, 2)}\n`);
+            }
+            else {
+                options.stderr(`gji new: ${message}\n`);
+            }
+            return 1;
+        }
         const repository = await detectRepository(options.cwd);
         const config = await loadEffectiveConfig(repository.repoRoot, undefined, options.stderr);
         const usesGeneratedDetachedName = options.detached && options.branch === undefined;
@@ -141,11 +151,21 @@ export function createNewCommand(dependencies = {}) {
             return 0;
         }
         await mkdir(dirname(worktreePath), { recursive: true });
+        const startPoint = options.fromCurrent && !options.detached
+            ? await resolveCurrentWorktreeHead(options.cwd)
+            : undefined;
         const gitArgs = options.detached
             ? ["worktree", "add", "--detach", worktreePath]
             : (await localBranchExists(repository.repoRoot, worktreeName))
                 ? ["worktree", "add", worktreePath, worktreeName]
-                : ["worktree", "add", "-b", worktreeName, worktreePath];
+                : [
+                    "worktree",
+                    "add",
+                    "-b",
+                    worktreeName,
+                    worktreePath,
+                    ...(startPoint ? [startPoint] : []),
+                ];
         await execFileAsync("git", gitArgs, { cwd: repository.repoRoot });
         // Sync files from main worktree before afterCreate so synced files are available to install scripts.
         const syncPatterns = Array.isArray(config.syncFiles)
@@ -333,6 +353,9 @@ async function localBranchExists(repoRoot, branchName) {
         return false;
     }
 }
+async function resolveCurrentWorktreeHead(cwd) {
+    return execFileAsync("git", ["rev-parse", "--verify", "HEAD"], { cwd }).then(({ stdout }) => stdout.trim());
+}
 async function writeOutput(worktreePath, stdout) {
     await writeShellOutput(NEW_OUTPUT_FILE_ENV, worktreePath, stdout);
 }

package/dist/open.d.ts

@@ -1,11 +1,12 @@
 import { type EditorDefinition } from "./editor.js";
-import { type WorktreePromptEntry } from "./worktree-picker.js";
+import { type QueryWorktreePullRequests, type WorktreePromptEntry } from "./worktree-picker.js";
 export type { EditorDefinition };
 export interface OpenCommandOptions {
     branch?: string;
     cwd: string;
     editor?: string;
     save?: boolean;
+    select?: boolean;
     stderr: (chunk: string) => void;
     stdout: (chunk: string) => void;
     workspace?: boolean;
@@ -14,6 +15,7 @@ export interface OpenCommandDependencies {
     detectEditors: () => Promise<EditorDefinition[]>;
     promptForEditor: (editors: EditorDefinition[]) => Promise<string | null>;
     promptForWorktree: (worktrees: WorktreePromptEntry[]) => Promise<string | null>;
+    queryPullRequests: QueryWorktreePullRequests;
     spawnEditor: (cli: string, args: string[]) => Promise<void>;
 }
 export declare function createOpenCommand(dependencies?: Partial<OpenCommandDependencies>): (options: OpenCommandOptions) => Promise<number>;

package/dist/open.js

@@ -16,6 +16,14 @@ export function createOpenCommand(dependencies = {}) {
     const promptForWorktree = dependencies.promptForWorktree ?? defaultPromptForWorktree;
     const spawnEditor = dependencies.spawnEditor ?? defaultSpawnEditor;
     return async function runOpenCommand(options) {
+        if (options.select && options.branch !== undefined) {
+            options.stderr("gji open: --select cannot be used with a branch\n");
+            return 1;
+        }
+        if (options.select && isHeadless()) {
+            options.stderr("gji open --select: selector is unavailable in non-interactive mode (GJI_NO_TUI=1)\n");
+            return 1;
+        }
         const [worktrees, repository] = await Promise.all([
             listWorktrees(options.cwd),
             detectRepository(options.cwd),
@@ -36,15 +44,20 @@ export function createOpenCommand(dependencies = {}) {
             targetPath = match.worktree.path;
             targetWorktree = match.worktree;
         }
-        else if (isHeadless()) {
+        else if (!options.select) {
             targetWorktree = worktrees.find((w) => w.isCurrent);
-            targetPath = targetWorktree?.path ?? options.cwd;
+            if (!targetWorktree) {
+                options.stderr("gji open: unable to identify the current worktree\n");
+                return 1;
+            }
+            targetPath = targetWorktree.path;
         }
         else {
             const entries = await buildWorktreePromptEntries(worktrees.map((worktree) => ({
+                repoRoot: repository.repoRoot,
                 repoName: repository.repoName,
                 worktree,
-            })));
+            })), { queryPullRequests: dependencies.queryPullRequests });
             const chosen = await promptForWorktree(entries);
             if (!chosen) {
                 options.stderr("Aborted\n");

package/dist/pr-open.d.ts

@@ -0,0 +1,19 @@
+import { type PullRequestInfo } from "./pull-requests.js";
+import { type QueryRepositoryPullRequests, type QueryWorktreePullRequests, type WorktreePromptEntry } from "./worktree-picker.js";
+export interface PrOpenCommandOptions {
+    cwd: string;
+    stderr: (chunk: string) => void;
+    stdout: (chunk: string) => void;
+    select?: boolean;
+    target?: string;
+}
+export interface PrOpenCommandDependencies {
+    findOpenPullRequest: (repoRoot: string, number: number) => Promise<PullRequestInfo | null>;
+    openBrowser: (url: string) => Promise<void>;
+    promptForPullRequest: (pullRequests: PullRequestInfo[]) => Promise<PullRequestInfo | null>;
+    promptForWorktree: (worktrees: WorktreePromptEntry[]) => Promise<string | null>;
+    queryPullRequests: QueryWorktreePullRequests;
+    queryRepositoryPullRequests?: QueryRepositoryPullRequests;
+}
+export declare function createPrOpenCommand(dependencies?: Partial<PrOpenCommandDependencies>): (options: PrOpenCommandOptions) => Promise<number>;
+export declare const runPrOpenCommand: (options: PrOpenCommandOptions) => Promise<number>;