@solaqua/gji 0.8.1 → 0.9.0

package/dist/shell-completion.js

@@ -4,7 +4,14 @@ const TOP_LEVEL_COMMANDS = [
         name: "new",
         description: "create a new branch or detached linked worktree",
     },
-    { name: "init", description: "print or install shell integration" },
+    {
+        name: "init",
+        description: "set up shell integration interactively or print a shell wrapper",
+    },
+    {
+        name: "doctor",
+        description: "check gji installation and configuration health",
+    },
     { name: "completion", description: "print shell completion definitions" },
     { name: "pr", description: "fetch a pull request into a linked worktree" },
     { name: "back", description: "navigate to the previously visited worktree" },
@@ -55,6 +62,67 @@ function renderBashCompletion() {
   command gji ls --compact 2>/dev/null | awk 'NR > 1 { branch = ($1 == "*" ? $2 : $1); if (branch != "(detached)") print branch }'
 }
 
+__gji_pr_targets_cache=""
+__gji_pr_targets_cache_at=0
+__gji_pr_targets_cache_loaded=0
+__gji_pr_targets_cache_repo=""
+
+__gji_run_bounded() {
+  local output_file pid status attempt
+  output_file=$(mktemp "\${TMPDIR:-/tmp}/gji-completion.XXXXXX") || return 124
+  "$@" >"$output_file" 2>/dev/null &
+  pid=$!
+  for ((attempt = 0; attempt < 20; attempt++)); do
+    if ! kill -0 "$pid" 2>/dev/null; then
+      wait "$pid"
+      status=$?
+      cat "$output_file"
+      rm -f "$output_file"
+      return "$status"
+    fi
+    sleep 0.1
+  done
+  kill "$pid" 2>/dev/null
+  wait "$pid" 2>/dev/null
+  rm -f "$output_file"
+  return 124
+}
+
+__gji_pr_targets() {
+  local now repo_key branches targets
+  now=$(date +%s)
+  repo_key=$(command git rev-parse --show-toplevel 2>/dev/null)
+  if [ "$__gji_pr_targets_cache_loaded" -eq 1 ] && [ "$repo_key" = "$__gji_pr_targets_cache_repo" ] && [ "$((now - __gji_pr_targets_cache_at))" -lt 30 ]; then
+    printf '%s\n' "$__gji_pr_targets_cache"
+    return
+  fi
+
+  branches="$(__gji_worktree_branches)"
+  targets=""
+  if [ -n "$repo_key" ] && command -v gh >/dev/null 2>&1; then
+    targets=$(__gji_run_bounded env GH_PROMPT_DISABLED=1 gh pr list --state open --json number --limit 100 |
+      tr '{},' '\\n' | sed -n 's/.*"number":[[:space:]]*\\([0-9][0-9]*\\).*/\\1/p')
+  elif [ -n "$repo_key" ] && command -v glab >/dev/null 2>&1; then
+    targets=$(__gji_run_bounded env GLAB_NON_INTERACTIVE=1 glab mr list --state opened --output json --per-page 100 |
+      tr '{},' '\\n' | sed -n 's/.*"iid":[[:space:]]*\\([0-9][0-9]*\\).*/\\1/p')
+  elif [ -n "$repo_key" ] && command -v bb >/dev/null 2>&1; then
+    targets=$(__gji_run_bounded bb pr list --state OPEN --format json |
+      tr '{},' '\\n' | sed -n 's/.*"id":[[:space:]]*\\([0-9][0-9]*\\).*/\\1/p')
+  fi
+
+  __gji_pr_targets_cache="$branches"
+  if [ -n "$targets" ]; then
+    if [ -n "$__gji_pr_targets_cache" ]; then
+      __gji_pr_targets_cache+=$'\n'
+    fi
+    __gji_pr_targets_cache+="$targets"
+  fi
+  __gji_pr_targets_cache_at="$now"
+  __gji_pr_targets_cache_loaded=1
+  __gji_pr_targets_cache_repo="$repo_key"
+  printf '%s\n' "$__gji_pr_targets_cache"
+}
+
 _gji_completion() {
   local cur command_name
   COMPREPLY=()
@@ -72,13 +140,37 @@ _gji_completion() {
       COMPREPLY=( $(compgen -W "--detached --force --open --editor --dry-run --json --help" -- "$cur") )
       ;;
     init)
-      COMPREPLY=( $(compgen -W "${shells} --write --help" -- "$cur") )
+      COMPREPLY=( $(compgen -W "${shells} --write --json --help" -- "$cur") )
+      ;;
+    doctor)
+      COMPREPLY=( $(compgen -W "--fix --yes --json --help" -- "$cur") )
       ;;
     completion)
       COMPREPLY=( $(compgen -W "${shells} --help" -- "$cur") )
       ;;
     pr)
-      COMPREPLY=( $(compgen -W "--dry-run --json --help" -- "$cur") )
+      if [ "$COMP_CWORD" -eq 2 ]; then
+        COMPREPLY=( $(compgen -W "open --dry-run --json --help" -- "$cur") )
+      elif [ "\${COMP_WORDS[2]}" = "open" ]; then
+        local has_select=0 has_target=0 word
+        for word in "\${COMP_WORDS[@]:3:$((COMP_CWORD - 3))}"; do
+          if [ "$word" = "--select" ]; then has_select=1; fi
+          if [[ "$word" != -* && "$word" != "" ]]; then has_target=1; fi
+        done
+        if [[ "$cur" == -* ]]; then
+          if [[ "$has_select" -eq 1 || "$has_target" -eq 1 ]]; then
+            COMPREPLY=( $(compgen -W "--help" -- "$cur") )
+          else
+            COMPREPLY=( $(compgen -W "--select --help" -- "$cur") )
+          fi
+        elif [[ "$has_select" -eq 1 || "$has_target" -eq 1 ]]; then
+          COMPREPLY=()
+        else
+          COMPREPLY=( $(compgen -W "$(__gji_pr_targets) --select --help" -- "$cur") )
+        fi
+      else
+        COMPREPLY=( $(compgen -W "--dry-run --json --help" -- "$cur") )
+      fi
       ;;
     back)
       COMPREPLY=( $(compgen -W "--print --help" -- "$cur") )
@@ -155,6 +247,101 @@ function renderFishCompletion() {
     command gji ls --compact 2>/dev/null | awk 'NR > 1 { branch = ($1 == "*" ? $2 : $1); if (branch != "(detached)") print branch }'
 end
 
+set -g __gji_pr_targets_cache
+set -g __gji_pr_targets_cache_at 0
+set -g __gji_pr_targets_cache_loaded 0
+set -g __gji_pr_targets_cache_repo
+
+function __gji_run_bounded
+    set -l output_file (mktemp "$TMPDIR/gji-completion.XXXXXX" 2>/dev/null)
+    if test -z "$output_file"
+        set output_file (mktemp "/tmp/gji-completion.XXXXXX" 2>/dev/null)
+    end
+    if test -z "$output_file"
+        return 124
+    end
+
+    command $argv >$output_file 2>/dev/null &
+    set -l pid $last_pid
+    for attempt in (seq 1 20)
+        if not kill -0 $pid 2>/dev/null
+            wait $pid
+            set -l exit_status $status
+            command cat $output_file
+            command rm -f $output_file
+            return $exit_status
+        end
+        sleep 0.1
+    end
+    kill $pid 2>/dev/null
+    wait $pid 2>/dev/null
+    command rm -f $output_file
+    return 124
+end
+
+function __gji_pr_targets
+    set -l now (date +%s)
+    set -l repo_key (command git rev-parse --show-toplevel 2>/dev/null)
+    if test $__gji_pr_targets_cache_loaded -eq 1; and test "$repo_key" = "$__gji_pr_targets_cache_repo"; and test (math $now - $__gji_pr_targets_cache_at) -lt 30
+        printf '%s\n' $__gji_pr_targets_cache
+        return
+    end
+
+    set -l branches (__gji_worktree_branches)
+    set -l targets
+    if test -n "$repo_key"; and command -q gh
+        set targets (__gji_run_bounded env GH_PROMPT_DISABLED=1 gh pr list --state open --json number --limit 100 |
+            string replace -a -r '[{},]' '\\n' |
+            string match -r '"number"[[:space:]]*:[[:space:]]*[0-9]+' | string replace -r '.*:[[:space:]]*' '')
+    else if test -n "$repo_key"; and command -q glab
+        set targets (__gji_run_bounded env GLAB_NON_INTERACTIVE=1 glab mr list --state opened --output json --per-page 100 |
+            string replace -a -r '[{},]' '\\n' |
+            string match -r '"iid"[[:space:]]*:[[:space:]]*[0-9]+' | string replace -r '.*:[[:space:]]*' '')
+    else if test -n "$repo_key"; and command -q bb
+        set targets (__gji_run_bounded bb pr list --state OPEN --format json |
+            string replace -a -r '[{},]' '\\n' |
+            string match -r '"id"[[:space:]]*:[[:space:]]*[0-9]+' | string replace -r '.*:[[:space:]]*' '')
+    end
+
+    set -g __gji_pr_targets_cache $branches $targets
+    set -g __gji_pr_targets_cache_at $now
+    set -g __gji_pr_targets_cache_loaded 1
+    set -g __gji_pr_targets_cache_repo $repo_key
+    printf '%s\n' $__gji_pr_targets_cache
+end
+
+function __gji_should_complete_pr_select
+    set -l tokens (commandline -opc)
+    if test (count $tokens) -lt 3; or test $tokens[2] != pr; or test $tokens[3] != open
+        return 1
+    end
+    for token in $tokens[4..-1]
+        if test $token = --select; or not string match -q -- '-*' $token
+            return 1
+        end
+    end
+    return 0
+end
+
+function __gji_should_complete_pr_target
+    set -l tokens (commandline -opc)
+    if test (count $tokens) -lt 3; or test $tokens[2] != pr; or test $tokens[3] != open
+        return 1
+    end
+    if string match -q -- '-*' (commandline -ct)
+        return 1
+    end
+    for token in $tokens[4..-1]
+        if test $token = --select
+            return 1
+        end
+        if not string match -q -- '-*' $token
+            return 1
+        end
+    end
+    return 0
+end
+
 function __gji_should_complete_config_action
     set -l tokens (commandline -opc)
     test (count $tokens) -eq 2
@@ -184,14 +371,22 @@ complete -c gji -n '__fish_seen_subcommand_from new' -l dry-run -d 'show what wo
 complete -c gji -n '__fish_seen_subcommand_from new' -l json -d 'emit JSON on success or error instead of human-readable output'
 
 complete -c gji -n '__fish_seen_subcommand_from init' -l write -d 'write the integration to the shell config file'
+complete -c gji -n '__fish_seen_subcommand_from init' -l json -d 'emit a JSON error in non-interactive mode'
 ${shellLines}
 
+complete -c gji -n '__fish_seen_subcommand_from doctor' -l fix -d 'apply safe automatic fixes after showing the plan'
+complete -c gji -n '__fish_seen_subcommand_from doctor' -l yes -d 'apply --fix without prompting'
+complete -c gji -n '__fish_seen_subcommand_from doctor' -l json -d 'emit diagnostic checks as JSON'
+
 complete -c gji -n '__fish_seen_subcommand_from completion' -a 'bash' -d 'shell'
 complete -c gji -n '__fish_seen_subcommand_from completion' -a 'fish' -d 'shell'
 complete -c gji -n '__fish_seen_subcommand_from completion' -a 'zsh' -d 'shell'
 
-complete -c gji -n '__fish_seen_subcommand_from pr' -l dry-run -d 'show what would be created without executing any git commands or writing files'
-complete -c gji -n '__fish_seen_subcommand_from pr' -l json -d 'emit JSON on success or error instead of human-readable output'
+complete -c gji -n '__fish_seen_subcommand_from pr; and test (commandline -opc)[3] != open' -l dry-run -d 'show what would be created without executing any git commands or writing files'
+complete -c gji -n '__fish_seen_subcommand_from pr; and test (commandline -opc)[3] != open' -l json -d 'emit JSON on success or error instead of human-readable output'
+complete -c gji -n '__fish_seen_subcommand_from pr' -a 'open' -d 'open a pull request in the default browser'
+complete -c gji -n '__gji_should_complete_pr_select' -l select -d 'choose a pull request from any linked worktree'
+complete -c gji -n '__gji_should_complete_pr_target' -a '(__gji_pr_targets)' -d 'branch or PR number'
 
 complete -c gji -n '__fish_seen_subcommand_from back' -l print -d 'print the resolved worktree path explicitly'
 
@@ -251,15 +446,71 @@ __gji_worktree_branches() {
   command gji ls --compact 2>/dev/null | awk 'NR > 1 { branch = ($1 == "*" ? $2 : $1); if (branch != "(detached)") print branch }'
 }
 
+typeset -g __gji_pr_targets_cache=()
+typeset -g __gji_pr_targets_cache_at=0
+typeset -g __gji_pr_targets_cache_loaded=0
+typeset -g __gji_pr_targets_cache_repo=""
+
+__gji_run_bounded() {
+  local output_file pid status attempt
+  output_file=$(mktemp "\${TMPDIR:-/tmp}/gji-completion.XXXXXX") || return 124
+  "$@" >"$output_file" 2>/dev/null &
+  pid=$!
+  for ((attempt = 0; attempt < 20; attempt++)); do
+    if ! kill -0 "$pid" 2>/dev/null; then
+      wait "$pid"
+      status=$?
+      cat "$output_file"
+      rm -f "$output_file"
+      return "$status"
+    fi
+    sleep 0.1
+  done
+  kill "$pid" 2>/dev/null
+  wait "$pid" 2>/dev/null
+  rm -f "$output_file"
+  return 124
+}
+
+__gji_pr_targets() {
+  local now repo_key
+  local -a branches targets
+  now=$(date +%s)
+  repo_key=$(command git rev-parse --show-toplevel 2>/dev/null)
+  if (( __gji_pr_targets_cache_loaded == 1 && "\${repo_key}" == "\${__gji_pr_targets_cache_repo}" && now - __gji_pr_targets_cache_at < 30 )); then
+    print -rl -- "\${__gji_pr_targets_cache[@]}"
+    return
+  fi
+
+  branches=("\${(@f)$(__gji_worktree_branches)}")
+  targets=()
+  if [[ -n "\${repo_key}" && $+commands[gh] -eq 1 ]]; then
+    targets=("\${(@f)$(__gji_run_bounded env GH_PROMPT_DISABLED=1 gh pr list --state open --json number --limit 100 |
+      tr '{},' '\\n' | sed -n 's/.*"number":[[:space:]]*\\([0-9][0-9]*\\).*/\\1/p')}")
+  elif [[ -n "\${repo_key}" && $+commands[glab] -eq 1 ]]; then
+    targets=("\${(@f)$(__gji_run_bounded env GLAB_NON_INTERACTIVE=1 glab mr list --state opened --output json --per-page 100 |
+      tr '{},' '\\n' | sed -n 's/.*"iid":[[:space:]]*\\([0-9][0-9]*\\).*/\\1/p')}")
+  elif [[ -n "\${repo_key}" && $+commands[bb] -eq 1 ]]; then
+    targets=("\${(@f)$(__gji_run_bounded bb pr list --state OPEN --format json |
+      tr '{},' '\\n' | sed -n 's/.*"id":[[:space:]]*\\([0-9][0-9]*\\).*/\\1/p')}")
+  fi
+
+  __gji_pr_targets_cache=("\${branches[@]}" "\${targets[@]}")
+  __gji_pr_targets_cache_at="$now"
+  __gji_pr_targets_cache_loaded=1
+  __gji_pr_targets_cache_repo="$repo_key"
+  print -rl -- "\${__gji_pr_targets_cache[@]}"
+}
+
 local context state line
-local -a commands worktree_branches
+local -a command_entries worktree_branches
 
-commands=(
+command_entries=(
   ${commandLines}
 )
 
 if (( CURRENT == 2 )); then
-  _describe 'command' commands
+  _describe 'command' command_entries
   return
 fi
 
@@ -268,13 +519,26 @@ case "\${words[2]}" in
     _arguments '--detached[create a detached worktree without a branch]' '--force[remove and recreate the worktree if the target path already exists]' '--open[open the new worktree in an editor after creation]' '--editor[editor CLI to use with --open (code, cursor, zed, …)]:editor:' '--dry-run[show what would be created without executing any git commands or writing files]' '--json[emit JSON on success or error instead of human-readable output]' '2:branch: '
     ;;
   init)
-    _arguments '--write[write the integration to the shell config file]' '2:shell:(${shells})'
+    _arguments '--write[write the integration to the shell config file]' '--json[emit a JSON error in non-interactive mode]' '2:shell:(${shells})'
+    ;;
+  doctor)
+    _arguments '--fix[apply safe automatic fixes after showing the plan]' '--yes[apply --fix without prompting]' '--json[emit diagnostic checks as JSON]'
     ;;
   completion)
     _arguments '2:shell:(${shells})'
     ;;
   pr)
-    _arguments '--dry-run[show what would be created without executing any git commands or writing files]' '--json[emit JSON on success or error instead of human-readable output]' '2:ref: '
+    if [[ "\${words[3]}" == "open" ]]; then
+      if (( \${words[(I)--select]} )); then
+        _arguments
+      elif [[ -n "\${words[4]}" && "\${words[4]}" != -* ]]; then
+        _arguments
+      else
+        _arguments '--select[choose a pull request from any linked worktree]' '4:branch or PR number:->pr_targets'
+      fi
+    else
+      _arguments '--dry-run[show what would be created without executing any git commands or writing files]' '--json[emit JSON on success or error instead of human-readable output]' '2:ref:(open)'
+    fi
     ;;
   back)
     _arguments '--print[print the resolved worktree path explicitly]' '2:steps: '
@@ -337,6 +601,10 @@ case "$state" in
     worktree_branches=(\${(@f)$(__gji_worktree_branches)})
     _describe 'worktree branch' worktree_branches
     ;;
+  pr_targets)
+    worktree_branches=(\${(@f)$(__gji_pr_targets)})
+    _describe 'branch or PR number' worktree_branches
+    ;;
   config_keys)
     _values 'config key' ${configKeys}
     ;;

package/dist/shell-setup.d.ts

@@ -0,0 +1,9 @@
+import type { SupportedShell } from "./shell.js";
+export declare const SHELL_INTEGRATION_START_MARKER = "# >>> gji init >>>";
+export declare const SHELL_INTEGRATION_END_MARKER = "# <<< gji init <<<";
+export declare const ONBOARDING_SHELL_INTEGRATION_START_MARKER = "# >>> gji shell integration >>>";
+export declare const ONBOARDING_SHELL_INTEGRATION_END_MARKER = "# <<< gji shell integration <<<";
+export declare function executableExists(command: string): Promise<boolean>;
+export declare function resolveShellConfigPath(shell: SupportedShell, home: string): string;
+export declare function resolveCompletionPath(shell: SupportedShell, home: string): string;
+export declare function hasShellIntegration(config: string, shell: SupportedShell): boolean;

package/dist/shell-setup.js

@@ -0,0 +1,56 @@
+import { constants } from "node:fs";
+import { access } from "node:fs/promises";
+import { delimiter, join } from "node:path";
+export const SHELL_INTEGRATION_START_MARKER = "# >>> gji init >>>";
+export const SHELL_INTEGRATION_END_MARKER = "# <<< gji init <<<";
+export const ONBOARDING_SHELL_INTEGRATION_START_MARKER = "# >>> gji shell integration >>>";
+export const ONBOARDING_SHELL_INTEGRATION_END_MARKER = "# <<< gji shell integration <<<";
+export async function executableExists(command) {
+    const candidates = command.includes("/")
+        ? [command]
+        : (process.env.PATH ?? "")
+            .split(delimiter)
+            .filter(Boolean)
+            .map((directory) => join(directory, command));
+    for (const path of candidates) {
+        try {
+            await access(path, constants.X_OK);
+            return true;
+        }
+        catch {
+            // Continue until a matching executable is found.
+        }
+    }
+    return false;
+}
+export 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");
+    }
+}
+export function resolveCompletionPath(shell, home) {
+    switch (shell) {
+        case "bash":
+            return join(home, ".local", "share", "bash-completion", "completions", "gji");
+        case "fish":
+            return join(home, ".config", "fish", "completions", "gji.fish");
+        case "zsh":
+            return join(home, ".zsh", "completions", "_gji");
+    }
+}
+export function hasShellIntegration(config, shell) {
+    if ((config.includes(SHELL_INTEGRATION_START_MARKER) &&
+        config.includes(SHELL_INTEGRATION_END_MARKER)) ||
+        (config.includes(ONBOARDING_SHELL_INTEGRATION_START_MARKER) &&
+            config.includes(ONBOARDING_SHELL_INTEGRATION_END_MARKER))) {
+        return true;
+    }
+    if (shell === "fish")
+        return false;
+    return new RegExp(`^[\\t ]*eval\\s+["']?\\$\\(\\s*gji\\s+init\\s+${shell}\\s*\\)["']?\\s*(?:#.*)?$`, "m").test(config);
+}

package/dist/warp.d.ts

@@ -1,8 +1,10 @@
+import { type QueryWorktreePullRequests } from "./worktree-picker.js";
 export interface WarpCommandOptions {
     branch?: string;
     cwd: string;
     json?: boolean;
     newWorktree?: boolean;
+    queryPullRequests?: QueryWorktreePullRequests;
     stderr: (chunk: string) => void;
     stdout: (chunk: string) => void;
 }
@@ -16,5 +18,6 @@ export declare function resolveWarpTarget(options: {
     commandName?: string;
     cwd: string;
     json?: boolean;
+    queryPullRequests?: QueryWorktreePullRequests;
     stderr: (chunk: string) => void;
 }): Promise<WarpTarget | null>;

package/dist/warp.js

@@ -36,6 +36,7 @@ async function runWarpNavigate(options) {
         ...options,
         commandName: "gji warp",
         json: options.json,
+        queryPullRequests: options.queryPullRequests,
     });
     if (!target)
         return 1;
@@ -152,15 +153,16 @@ export async function resolveWarpTarget(options) {
     }
     const results = await Promise.allSettled(registry.map(async (entry) => {
         const worktrees = await listWorktrees(entry.path);
-        return { repoName: entry.name, worktrees };
+        return { repoName: entry.name, repoRoot: entry.path, worktrees };
     }));
     const allItems = [];
     for (const result of results) {
         if (result.status === "rejected")
             continue;
-        const { repoName, worktrees } = result.value;
+        const { repoName, repoRoot, worktrees } = result.value;
         for (const worktree of worktrees) {
             allItems.push({
+                repoRoot,
                 repoName,
                 worktree: {
                     ...worktree,
@@ -174,6 +176,7 @@ export async function resolveWarpTarget(options) {
         return null;
     }
     const promptSources = allItems.map((item) => ({
+        repoRoot: item.repoRoot,
         repoName: item.repoName,
         worktree: item.worktree,
     }));
@@ -185,7 +188,9 @@ export async function resolveWarpTarget(options) {
         }
         return { branch: match.worktree.branch, path: match.worktree.path };
     }
-    const promptEntries = await buildWorktreePromptEntries(promptSources);
+    const promptEntries = await buildWorktreePromptEntries(promptSources, {
+        queryPullRequests: options.queryPullRequests,
+    });
     const path = await promptForWarpTarget(promptEntries);
     if (!path) {
         options.stderr("Aborted\n");

package/dist/worktree-picker.d.ts

@@ -1,6 +1,8 @@
 import type { Readable, Writable } from "node:stream";
+import { type PullRequestInfo } from "./pull-requests.js";
 import type { WorktreeEntry } from "./repo.js";
 export interface WorktreePromptSource {
+    repoRoot?: string;
     repoName: string;
     worktree: WorktreeEntry;
 }
@@ -8,8 +10,16 @@ export interface WorktreePromptEntry extends WorktreeEntry {
     group: "recent" | "other";
     label: string;
     metadata?: string | null;
+    pullRequestNumbers?: number[];
+    pullRequestUrls?: string[];
     repoName: string;
 }
+export type QueryWorktreePullRequests = (repoRoot: string, sourceBranch: string) => Promise<PullRequestInfo[]>;
+export type QueryRepositoryPullRequests = (repoRoot: string) => Promise<PullRequestInfo[]>;
+export interface BuildWorktreePromptEntriesDependencies {
+    queryPullRequests?: QueryWorktreePullRequests;
+    queryRepositoryPullRequests?: QueryRepositoryPullRequests;
+}
 export interface WorktreePickerIO {
     input?: Readable & {
         isTTY?: boolean;
@@ -20,7 +30,8 @@ export interface WorktreePickerIO {
         rows?: number;
     };
 }
-export declare function buildWorktreePromptEntries(sources: WorktreePromptSource[]): Promise<WorktreePromptEntry[]>;
+export declare function buildWorktreePromptEntries(sources: WorktreePromptSource[], dependencies?: BuildWorktreePromptEntriesDependencies): Promise<WorktreePromptEntry[]>;
 export declare function resolveWorktreeQuery(sources: WorktreePromptSource[], query: string): WorktreePromptSource | null;
 export declare function promptForSingleWorktree(message: string, worktrees: WorktreePromptEntry[], io?: WorktreePickerIO): Promise<string | null>;
 export declare function promptForMultipleWorktrees(message: string, worktrees: WorktreePromptEntry[], io?: WorktreePickerIO): Promise<string[] | null>;
+export declare function formatWorktreeBranchLabel(branch: string | null, pullRequestNumbers?: number[]): string;

package/dist/worktree-picker.js

@@ -1,14 +1,27 @@
 import { env, platform, stdin, stdout } from "node:process";
 import { isCancel, Prompt } from "@clack/core";
 import { loadHistory } from "./history.js";
+import { createPullRequestQuery, } from "./pull-requests.js";
 import { readWorktreeInfos, } from "./worktree-info.js";
-export async function buildWorktreePromptEntries(sources) {
-    const [history, infos] = await Promise.all([
+const MAX_PULL_REQUEST_REPOSITORY_QUERY_CONCURRENCY = 4;
+export async function buildWorktreePromptEntries(sources, dependencies = {}) {
+    const pullRequestQuery = createPullRequestQuery();
+    const queryPullRequests = dependencies.queryPullRequests ?? pullRequestQuery.listOpenPullRequests;
+    const queryRepositoryPullRequests = dependencies.queryRepositoryPullRequests ??
+        (dependencies.queryPullRequests === undefined
+            ? pullRequestQuery.listOpenPullRequestsForRepository
+            : undefined);
+    const repositoryPullRequests = queryRepositoryPullRequests === undefined
+        ? Promise.resolve(null)
+        : readRepositoryPullRequests(sources, queryRepositoryPullRequests);
+    const [history, infos, pullRequestsByRepository] = await Promise.all([
         loadHistory(),
         readWorktreeInfos(sources.map((source) => source.worktree)),
+        repositoryPullRequests,
     ]);
+    const pullRequests = await Promise.all(sources.map((source) => readSourcePullRequests(source, queryPullRequests, pullRequestsByRepository)));
     const historyByPath = new Map(history.map((entry) => [entry.path, entry]));
-    const entries = sources.map((source, index) => buildWorktreePromptEntry(source, infos[index], historyByPath.get(source.worktree.path)?.timestamp ?? null, Date.now()));
+    const entries = sources.map((source, index) => buildWorktreePromptEntry(source, infos[index], pullRequests[index], historyByPath.get(source.worktree.path)?.timestamp ?? null, Date.now()));
     return entries
         .sort(comparePromptEntries)
         .map(({ lastActivityTimestamp: _lastActivityTimestamp, ...entry }) => entry);
@@ -110,7 +123,7 @@ function buildSearchableWorktreeEntry(worktree) {
         searchText: buildPromptSearchText(worktree),
         value: worktree.path,
         worktree: {
-            branch,
+            branch: formatWorktreeBranchLabel(worktree.branch, worktree.pullRequestNumbers),
             metadata,
             path: worktree.path,
             repoName: worktree.repoName,
@@ -715,11 +728,13 @@ function buildPromptSearchText(worktree) {
         worktree.path,
         worktree.label,
         `${worktree.repoName}/${worktree.branch ?? "detached"}`,
+        ...(worktree.pullRequestNumbers ?? []).map((number) => `#${number}`),
+        ...(worktree.pullRequestUrls ?? []),
     ]
         .join(" ")
         .toLowerCase();
 }
-function buildWorktreePromptEntry(source, info, lastUsedTimestamp, now) {
+function buildWorktreePromptEntry(source, info, pullRequests, lastUsedTimestamp, now) {
     const lastWorkedTimestamp = info.lastCommitTimestamp === null ? null : info.lastCommitTimestamp * 1000;
     const lastActivityTimestamp = lastUsedTimestamp ?? lastWorkedTimestamp;
     const lastActivityType = lastUsedTimestamp !== null
@@ -727,7 +742,7 @@ function buildWorktreePromptEntry(source, info, lastUsedTimestamp, now) {
         : lastWorkedTimestamp !== null
             ? "worked"
             : null;
-    const branch = source.worktree.branch ?? "(detached)";
+    const branch = formatWorktreeBranchLabel(source.worktree.branch, pullRequests.map((pullRequest) => pullRequest.number));
     const badges = buildStatusBadges(info);
     const recency = formatPromptRecency(lastActivityTimestamp, lastActivityType, now);
     const status = badges.length > 0 ? badges.map((badge) => `[${badge}]`).join(" ") : null;
@@ -748,9 +763,72 @@ function buildWorktreePromptEntry(source, info, lastUsedTimestamp, now) {
         label,
         lastActivityTimestamp,
         metadata,
+        pullRequestNumbers: pullRequests.map((pullRequest) => pullRequest.number),
+        pullRequestUrls: pullRequests.map((pullRequest) => pullRequest.url),
         repoName: source.repoName,
     };
 }
+async function readSourcePullRequests(source, queryPullRequests, pullRequestsByRepository) {
+    if (source.repoRoot === undefined || source.worktree.branch === null) {
+        return [];
+    }
+    if (pullRequestsByRepository !== null) {
+        return sortSourcePullRequests(pullRequestsByRepository
+            .get(source.repoRoot)
+            ?.filter((pullRequest) => pullRequest.sourceBranch === source.worktree.branch));
+    }
+    try {
+        const pullRequests = await queryPullRequests(source.repoRoot, source.worktree.branch);
+        return sortSourcePullRequests(pullRequests);
+    }
+    catch {
+        // PR metadata is optional selector decoration; preserve the worktree entry on lookup failures.
+        return [];
+    }
+}
+async function readRepositoryPullRequests(sources, queryPullRequests) {
+    const repoRoots = [
+        ...new Set(sources.flatMap((source) => source.repoRoot === undefined || source.worktree.branch === null
+            ? []
+            : [source.repoRoot])),
+    ];
+    const results = await mapWithConcurrency(repoRoots, MAX_PULL_REQUEST_REPOSITORY_QUERY_CONCURRENCY, async (repoRoot) => {
+        try {
+            return [
+                repoRoot,
+                sortSourcePullRequests(await queryPullRequests(repoRoot)),
+            ];
+        }
+        catch {
+            return [repoRoot, []];
+        }
+    });
+    return new Map(results);
+}
+async function mapWithConcurrency(items, limit, mapper) {
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    async function readNext() {
+        for (;;) {
+            const index = nextIndex;
+            nextIndex += 1;
+            if (index >= items.length)
+                return;
+            results[index] = await mapper(items[index]);
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => readNext()));
+    return results;
+}
+function sortSourcePullRequests(pullRequests) {
+    return [...(pullRequests ?? [])].sort((a, b) => a.number - b.number);
+}
+export function formatWorktreeBranchLabel(branch, pullRequestNumbers = []) {
+    const branchLabel = branch ?? "(detached)";
+    if (pullRequestNumbers.length === 0)
+        return branchLabel;
+    return `${branchLabel} (${pullRequestNumbers.map((number) => `#${number}`).join(", ")})`;
+}
 function buildStatusBadges(info) {
     const badges = [];
     if (info.isCurrent) {

package/man/man1/gji-back.1

@@ -1,4 +1,4 @@
-.TH GJI\-BACK 1 "July 2026" "gji 0.8.1" "User Commands"
+.TH GJI\-BACK 1 "July 2026" "gji 0.9.0" "User Commands"
 .SH NAME
 gji\-back \- navigate to the previously visited worktree, optionally N steps back
 .SH SYNOPSIS