@solaqua/gji 0.8.1 → 0.10.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=()
@@ -69,16 +137,40 @@ _gji_completion() {
 
   case "$command_name" in
     new)
-      COMPREPLY=( $(compgen -W "--detached --force --open --editor --dry-run --json --help" -- "$cur") )
+      COMPREPLY=( $(compgen -W "--detached --from-current --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") )
@@ -87,7 +179,7 @@ _gji_completion() {
       COMPREPLY=( $(compgen -W "--json --help" -- "$cur") )
       ;;
     open)
-      COMPREPLY=( $(compgen -W "$(__gji_worktree_branches) --editor --save --workspace --help" -- "$cur") )
+      COMPREPLY=( $(compgen -W "$(__gji_worktree_branches) --editor --select --save --workspace --help" -- "$cur") )
       ;;
     go|jump)
       COMPREPLY=( $(compgen -W "$(__gji_worktree_branches) --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
@@ -177,6 +364,7 @@ complete -c gji -f
 ${commandLines}
 
 complete -c gji -n '__fish_seen_subcommand_from new' -l detached -d 'create a detached worktree without a branch'
+complete -c gji -n '__fish_seen_subcommand_from new' -l from-current -d 'base the new branch on the current worktree instead of the main worktree'
 complete -c gji -n '__fish_seen_subcommand_from new' -l force -d 'remove and recreate the worktree if the target path already exists'
 complete -c gji -n '__fish_seen_subcommand_from new' -l open -d 'open the new worktree in an editor after creation'
 complete -c gji -n '__fish_seen_subcommand_from new' -l editor -r -d 'editor CLI to use with --open (code, cursor, zed, …)'
@@ -184,20 +372,29 @@ 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'
 
 complete -c gji -n '__fish_seen_subcommand_from history' -l json -d 'print history as JSON'
 
 complete -c gji -n '__fish_seen_subcommand_from open' -l editor -r -d 'editor CLI to use (code, cursor, zed, windsurf, subl, …)'
+complete -c gji -n '__fish_seen_subcommand_from open' -l select -d 'choose a worktree with the interactive selector'
 complete -c gji -n '__fish_seen_subcommand_from open' -l save -d 'save the chosen editor to global config'
 complete -c gji -n '__fish_seen_subcommand_from open' -l workspace -d 'generate a .code-workspace file before opening (VS Code / Cursor / Windsurf)'
 complete -c gji -n '__fish_seen_subcommand_from open' -a '(__gji_worktree_branches)' -d 'worktree branch'
@@ -251,30 +448,99 @@ __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
 
 case "\${words[2]}" in
   new)
-    _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: '
+    _arguments '--detached[create a detached worktree without a branch]' '--from-current[base the new branch on the current worktree instead of the main worktree]' '--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: '
@@ -283,7 +549,7 @@ case "\${words[2]}" in
     _arguments '--json[print history as JSON]'
     ;;
   open)
-    _arguments '--editor[editor CLI to use (code, cursor, zed, windsurf, subl, …)]:editor:' '--save[save the chosen editor to global config]' '--workspace[generate a .code-workspace file before opening (VS Code / Cursor / Windsurf)]' '2:branch:->worktrees'
+    _arguments '--editor[editor CLI to use (code, cursor, zed, windsurf, subl, …)]:editor:' '--select[choose a worktree with the interactive selector]' '--save[save the chosen editor to global config]' '--workspace[generate a .code-workspace file before opening (VS Code / Cursor / Windsurf)]' '2:branch:->worktrees'
     ;;
   go|jump)
     _arguments '--print[print the resolved worktree path explicitly]' '2:branch:->worktrees'
@@ -337,6 +603,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;