@solaqua/gji 0.7.1 → 0.7.2

package/dist/go.d.ts

@@ -1,5 +1,4 @@
-import { type WorktreeHealth } from "./git.js";
-import { type WorktreeEntry } from "./repo.js";
+import { type WorktreePromptEntry } from "./worktree-picker.js";
 export interface GoCommandOptions {
     branch?: string;
     cwd: string;
@@ -8,8 +7,7 @@ export interface GoCommandOptions {
     stdout: (chunk: string) => void;
 }
 export interface GoCommandDependencies {
-    promptForWorktree: (worktrees: WorktreeEntry[]) => Promise<string | null>;
+    promptForWorktree: (worktrees: WorktreePromptEntry[]) => Promise<string | null>;
 }
 export declare function createGoCommand(dependencies?: Partial<GoCommandDependencies>): (options: GoCommandOptions) => Promise<number>;
 export declare const runGoCommand: (options: GoCommandOptions) => Promise<number>;
-export declare function formatUpstreamHint(branch: string | null, health: WorktreeHealth): string | null;

package/dist/go.js

@@ -1,13 +1,12 @@
 import { basename } from "node:path";
-import { isCancel, select } from "@clack/prompts";
 import { loadEffectiveConfig } from "./config.js";
-import { readWorktreeHealth } from "./git.js";
 import { isHeadless } from "./headless.js";
-import { appendHistory } from "./history.js";
+import { recordWorktreeUsage } from "./history.js";
 import { extractHooks, runHook } from "./hooks.js";
-import { detectRepository, listWorktrees, sortByCurrentFirst, } from "./repo.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";
 const GO_OUTPUT_FILE_ENV = "GJI_GO_OUTPUT_FILE";
 export function createGoCommand(dependencies = {}) {
     const prompt = dependencies.promptForWorktree ?? promptForWorktree;
@@ -32,7 +31,7 @@ export function createGoCommand(dependencies = {}) {
             });
             if (!target)
                 return 1;
-            appendHistory(target.path, target.branch).catch(() => undefined);
+            await recordWorktreeUsage(target.path, target.branch);
             await writeShellOutput(GO_OUTPUT_FILE_ENV, target.path, options.stdout);
             return 0;
         }
@@ -40,11 +39,19 @@ export function createGoCommand(dependencies = {}) {
             options.stderr("gji go: branch argument is required in non-interactive mode (GJI_NO_TUI=1)\n");
             return 1;
         }
-        const prompted = options.branch
-            ? null
-            : await prompt(sortByCurrentFirst(worktrees));
+        const promptSources = worktrees.map((worktree) => ({
+            repoName: repository.repoName,
+            worktree,
+        }));
+        const promptEntries = options.branch
+            ? []
+            : await buildWorktreePromptEntries(promptSources);
+        const queried = options.branch
+            ? resolveWorktreeQuery(promptSources, options.branch)
+            : null;
+        const prompted = options.branch ? null : await prompt(promptEntries);
         const resolvedPath = options.branch
-            ? worktrees.find((entry) => entry.branch === options.branch)?.path
+            ? queried?.worktree.path
             : (prompted ?? undefined);
         if (!resolvedPath) {
             if (options.branch) {
@@ -64,48 +71,12 @@ export function createGoCommand(dependencies = {}) {
             path: resolvedPath,
             repo: basename(repository.repoRoot),
         }, options.stderr);
-        appendHistory(resolvedPath, chosenWorktree?.branch ?? null).catch(() => undefined);
+        await recordWorktreeUsage(resolvedPath, chosenWorktree?.branch ?? null);
         await writeShellOutput(GO_OUTPUT_FILE_ENV, resolvedPath, options.stdout);
         return 0;
     };
 }
 export const runGoCommand = createGoCommand();
 async function promptForWorktree(worktrees) {
-    const healthResults = await Promise.allSettled(worktrees.map((w) => readWorktreeHealth(w.path)));
-    const choice = await select({
-        message: "Choose a worktree",
-        options: worktrees.map((worktree, i) => {
-            const health = healthResults[i].status === "fulfilled" ? healthResults[i].value : null;
-            const pathHint = worktree.isCurrent
-                ? `${worktree.path} (current)`
-                : worktree.path;
-            const upstream = health
-                ? formatUpstreamHint(worktree.branch, health)
-                : null;
-            return {
-                value: worktree.path,
-                label: worktree.branch ?? "(detached)",
-                hint: upstream ? `${upstream} · ${pathHint}` : pathHint,
-            };
-        }),
-    });
-    if (isCancel(choice)) {
-        return null;
-    }
-    return choice;
-}
-export function formatUpstreamHint(branch, health) {
-    if (branch === null)
-        return null;
-    if (!health.hasUpstream)
-        return "no upstream";
-    if (health.upstreamGone)
-        return "upstream gone";
-    if (health.ahead === 0 && health.behind === 0)
-        return "up to date";
-    if (health.ahead === 0)
-        return `behind ${health.behind}`;
-    if (health.behind === 0)
-        return `ahead ${health.ahead}`;
-    return `ahead ${health.ahead}, behind ${health.behind}`;
+    return promptForSingleWorktree("Choose a worktree", worktrees);
 }

package/dist/history.d.ts

@@ -7,3 +7,4 @@ export interface HistoryEntry {
 export declare function HISTORY_FILE_PATH(home?: string): string;
 export declare function loadHistory(home?: string): Promise<HistoryEntry[]>;
 export declare function appendHistory(path: string, branch: string | null, home?: string): Promise<void>;
+export declare function recordWorktreeUsage(path: string, branch: string | null, home?: string): Promise<void>;

package/dist/history.js

@@ -27,15 +27,22 @@ export async function loadHistory(home = homedir()) {
 export async function appendHistory(path, branch, home = homedir()) {
     const historyPath = HISTORY_FILE_PATH(home);
     const existing = await loadHistory(home);
-    // Skip if the most recent entry is the same path (no-op navigation)
-    if (existing.length > 0 && existing[0].path === path) {
-        return;
-    }
     const entry = { branch, path, timestamp: Date.now() };
-    const next = [entry, ...existing].slice(0, MAX_HISTORY_ENTRIES);
+    const next = [
+        entry,
+        ...existing.filter((existingEntry) => existingEntry.path !== path),
+    ].slice(0, MAX_HISTORY_ENTRIES);
     await mkdir(dirname(historyPath), { recursive: true });
     await writeFile(historyPath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
 }
+export async function recordWorktreeUsage(path, branch, home = homedir()) {
+    try {
+        await appendHistory(path, branch, home);
+    }
+    catch {
+        // Usage history is advisory metadata; primary command success should stand.
+    }
+}
 function isHistoryEntry(value) {
     return (typeof value === "object" &&
         value !== null &&

package/dist/new.js

@@ -8,7 +8,7 @@ import { pathExists, promptForPathConflict, } from "./conflict.js";
 import { defaultSpawnEditor, EDITORS } from "./editor.js";
 import { syncFiles } from "./file-sync.js";
 import { isHeadless } from "./headless.js";
-import { appendHistory } from "./history.js";
+import { recordWorktreeUsage } from "./history.js";
 import { extractHooks, runHook } from "./hooks.js";
 import { maybeRunInstallPrompt, } from "./install-prompt.js";
 import { detectRepository, resolveWorktreePath, validateBranchName, } from "./repo.js";
@@ -117,7 +117,7 @@ export function createNewCommand(dependencies = {}) {
             else {
                 const choice = await prompt(worktreePath);
                 if (choice === "reuse") {
-                    appendHistory(worktreePath, worktreeName).catch(() => undefined);
+                    await recordWorktreeUsage(worktreePath, worktreeName);
                     await writeOutput(worktreePath, options.stdout);
                     return 0;
                 }
@@ -170,7 +170,7 @@ export function createNewCommand(dependencies = {}) {
             options.stdout(`${JSON.stringify({ branch: worktreeName, path: worktreePath }, null, 2)}\n`);
         }
         else {
-            await appendHistory(worktreePath, worktreeName);
+            await recordWorktreeUsage(worktreePath, worktreeName);
             await writeOutput(worktreePath, options.stdout);
         }
         if (options.open) {
@@ -203,6 +203,31 @@ export function generateBranchPlaceholder(random = Math.random) {
         "lovelace",
         "nietzsche",
         "kafka",
+        "sappho",
+        "aristotle",
+        "pythagoras",
+        "artemis",
+        "apollo",
+        "minerva",
+        "persephone",
+        "icarus",
+        "odysseus",
+        "murasaki",
+        "shakespeare",
+        "frida",
+        "davinci",
+        "kepler",
+        "copernicus",
+        "faraday",
+        "noether",
+        "hopper",
+        "boole",
+        "shannon",
+        "gauss",
+        "ramanujan",
+        "austen",
+        "borges",
+        "zeno",
     ];
     const antics = [
         "borrowed-a-bike",
@@ -220,8 +245,49 @@ export function generateBranchPlaceholder(random = Math.random) {
         "washed-the-dishes",
         "folded-the-laundry",
         "took-a-nap",
+        "lost-a-sock",
+        "patched-the-boat",
+        "alphabetized-the-spoons",
+        "argued-with-the-calendar",
+        "misplaced-the-moon",
+        "painted-the-fence",
+        "overcooked-the-rice",
+        "packed-the-snacks",
+        "dropped-the-spoon",
+        "hid-the-remote",
+        "untangled-the-cables",
+        "rebooted-the-kettle",
+        "indexed-the-attic",
+        "forgot-the-password",
+        "sorted-the-buttons",
+        "mopped-the-ceiling",
+        "polished-the-doorknob",
+        "misread-the-map",
+        "reheated-the-tea",
+        "fixed-the-squeak",
+        "labeled-the-drawer",
+        "stacked-the-chairs",
+        "overslept-the-standup",
+        "claimed-the-last-bagel",
+        "debugged-the-toaster",
     ];
-    return `${pickRandom(roots, random)}-${pickRandom(antics, random)}`;
+    const root = pickRandom(roots, random);
+    const antic = pickRandom(antics, random);
+    const suffix = generateBranchPlaceholderSuffix(random);
+    return `${root}-${antic}-${suffix}`;
+}
+function pickRandom(values, random) {
+    const index = Math.floor(random() * values.length);
+    return values[Math.min(index, values.length - 1)];
+}
+function generateBranchPlaceholderSuffix(random) {
+    const characters = "abcdefghijklmnopqrstuvwxyz0123456789";
+    let suffix = "";
+    for (let index = 0; index < 3; index += 1) {
+        const characterIndex = Math.floor(random() * characters.length);
+        suffix += characters[Math.min(characterIndex, characters.length - 1)];
+    }
+    return suffix;
 }
 function applyConfiguredBranchPrefix(branch, branchPrefix) {
     if (typeof branchPrefix !== "string" || branchPrefix.length === 0) {
@@ -258,10 +324,6 @@ async function defaultPromptForBranch(placeholder) {
     }
     return choice.trim();
 }
-function pickRandom(values, random) {
-    const index = Math.floor(random() * values.length);
-    return values[Math.min(index, values.length - 1)];
-}
 async function localBranchExists(repoRoot, branchName) {
     try {
         await execFileAsync("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`], { cwd: repoRoot });

package/dist/open.d.ts

@@ -1,5 +1,5 @@
 import { type EditorDefinition } from "./editor.js";
-import { type WorktreeEntry } from "./repo.js";
+import { type WorktreePromptEntry } from "./worktree-picker.js";
 export type { EditorDefinition };
 export interface OpenCommandOptions {
     branch?: string;
@@ -13,7 +13,7 @@ export interface OpenCommandOptions {
 export interface OpenCommandDependencies {
     detectEditors: () => Promise<EditorDefinition[]>;
     promptForEditor: (editors: EditorDefinition[]) => Promise<string | null>;
-    promptForWorktree: (worktrees: WorktreeEntry[]) => Promise<string | null>;
+    promptForWorktree: (worktrees: WorktreePromptEntry[]) => Promise<string | null>;
     spawnEditor: (cli: string, args: string[]) => Promise<void>;
 }
 export declare function createOpenCommand(dependencies?: Partial<OpenCommandDependencies>): (options: OpenCommandOptions) => Promise<number>;

package/dist/open.js

@@ -6,7 +6,9 @@ import { isCancel, select } from "@clack/prompts";
 import { loadEffectiveConfig, resolveConfigString, updateGlobalConfigKey, } from "./config.js";
 import { defaultSpawnEditor, EDITORS, } from "./editor.js";
 import { isHeadless } from "./headless.js";
-import { detectRepository, listWorktrees, sortByCurrentFirst, } from "./repo.js";
+import { recordWorktreeUsage } from "./history.js";
+import { detectRepository, listWorktrees } from "./repo.js";
+import { buildWorktreePromptEntries, promptForSingleWorktree, resolveWorktreeQuery, } from "./worktree-picker.js";
 const execFileAsync = promisify(execFile);
 export function createOpenCommand(dependencies = {}) {
     const detectEditors = dependencies.detectEditors ?? detectInstalledEditors;
@@ -20,25 +22,36 @@ export function createOpenCommand(dependencies = {}) {
         ]);
         // Resolve target worktree path.
         let targetPath;
+        let targetWorktree;
         if (options.branch) {
-            const entry = worktrees.find((w) => w.branch === options.branch);
-            if (!entry) {
-                options.stderr(`gji open: no worktree found for branch: ${options.branch}\n`);
+            const match = resolveWorktreeQuery(worktrees.map((worktree) => ({
+                repoName: repository.repoName,
+                worktree,
+            })), options.branch);
+            if (!match) {
+                options.stderr(`gji open: no worktree found matching: ${options.branch}\n`);
                 options.stderr(`Hint: Use 'gji ls' to see available worktrees\n`);
                 return 1;
             }
-            targetPath = entry.path;
+            targetPath = match.worktree.path;
+            targetWorktree = match.worktree;
         }
         else if (isHeadless()) {
-            targetPath = worktrees.find((w) => w.isCurrent)?.path ?? options.cwd;
+            targetWorktree = worktrees.find((w) => w.isCurrent);
+            targetPath = targetWorktree?.path ?? options.cwd;
         }
         else {
-            const chosen = await promptForWorktree(sortByCurrentFirst(worktrees));
+            const entries = await buildWorktreePromptEntries(worktrees.map((worktree) => ({
+                repoName: repository.repoName,
+                worktree,
+            })));
+            const chosen = await promptForWorktree(entries);
             if (!chosen) {
                 options.stderr("Aborted\n");
                 return 1;
             }
             targetPath = chosen;
+            targetWorktree = worktrees.find((w) => w.path === chosen);
         }
         // Resolve which editor to use.
         const config = await loadEffectiveConfig(repository.repoRoot, undefined, options.stderr);
@@ -100,6 +113,7 @@ export function createOpenCommand(dependencies = {}) {
             return 1;
         }
         const displayName = editorDef?.name ?? editorCli;
+        await recordWorktreeUsage(targetPath, targetWorktree?.branch ?? null);
         options.stdout(`Opened ${targetPath} in ${displayName}\n`);
         return 0;
     };
@@ -122,17 +136,7 @@ async function isCommandAvailable(command) {
     }
 }
 async function defaultPromptForWorktree(worktrees) {
-    const choice = await select({
-        message: "Choose a worktree to open",
-        options: worktrees.map((w) => ({
-            value: w.path,
-            label: w.branch ?? "(detached)",
-            hint: w.isCurrent ? `${w.path} (current)` : w.path,
-        })),
-    });
-    if (isCancel(choice))
-        return null;
-    return choice;
+    return promptForSingleWorktree("Choose a worktree to open", worktrees);
 }
 async function defaultPromptForEditor(editors) {
     const choice = await select({

package/dist/pr.js

@@ -6,7 +6,7 @@ import { loadEffectiveConfig, resolveConfigString } from "./config.js";
 import { pathExists, promptForPathConflict, } from "./conflict.js";
 import { syncFiles } from "./file-sync.js";
 import { isHeadless } from "./headless.js";
-import { appendHistory } from "./history.js";
+import { recordWorktreeUsage } from "./history.js";
 import { extractHooks, runHook } from "./hooks.js";
 import { maybeRunInstallPrompt, } from "./install-prompt.js";
 import { detectRepository, resolveWorktreePath } from "./repo.js";
@@ -61,7 +61,7 @@ export function createPrCommand(dependencies = {}) {
             }
             const choice = await prompt(worktreePath);
             if (choice === "reuse") {
-                appendHistory(worktreePath, branchName).catch(() => undefined);
+                await recordWorktreeUsage(worktreePath, branchName);
                 await writeOutput(worktreePath, options.stdout);
                 return 0;
             }
@@ -120,7 +120,7 @@ export function createPrCommand(dependencies = {}) {
             options.stdout(`${JSON.stringify({ branch: branchName, path: worktreePath }, null, 2)}\n`);
         }
         else {
-            await appendHistory(worktreePath, branchName);
+            await recordWorktreeUsage(worktreePath, branchName);
             await writeOutput(worktreePath, options.stdout);
         }
         return 0;

package/dist/remove.d.ts

@@ -1,4 +1,5 @@
-import { type WorktreeEntry } from "./repo.js";
+import type { WorktreeEntry } from "./repo.js";
+import { type WorktreePromptEntry } from "./worktree-picker.js";
 export interface RemoveCommandOptions {
     branch?: string;
     cwd: string;
@@ -12,7 +13,7 @@ export interface RemoveCommandDependencies {
     confirmForceDeleteBranch: (branch: string) => Promise<boolean>;
     confirmForceRemoveWorktree: (worktreePath: string) => Promise<boolean>;
     confirmRemoval: (worktree: WorktreeEntry) => Promise<boolean>;
-    promptForWorktree: (worktrees: WorktreeEntry[]) => Promise<string | null>;
+    promptForWorktree: (worktrees: WorktreePromptEntry[]) => Promise<string | null>;
 }
 export declare function createRemoveCommand(dependencies?: Partial<RemoveCommandDependencies>): (options: RemoveCommandOptions) => Promise<number>;
 export declare const runRemoveCommand: (options: RemoveCommandOptions) => Promise<number>;

package/dist/remove.js

@@ -1,11 +1,11 @@
 import { basename } from "node:path";
-import { confirm, isCancel, select } from "@clack/prompts";
+import { confirm, isCancel } from "@clack/prompts";
 import { loadEffectiveConfig } from "./config.js";
 import { isHeadless } from "./headless.js";
 import { extractHooks, runHook } from "./hooks.js";
-import { sortByCurrentFirst } from "./repo.js";
 import { writeShellOutput } from "./shell-handoff.js";
 import { deleteBranch, forceDeleteBranch, forceRemoveWorktree, isBranchUnmergedError, isWorktreeDirtyError, loadLinkedWorktrees, removeWorktree, } from "./worktree-management.js";
+import { buildWorktreePromptEntries, promptForSingleWorktree, } from "./worktree-picker.js";
 import { defaultConfirmForceDeleteBranch, defaultConfirmForceRemoveWorktree, } from "./worktree-prompts.js";
 const REMOVE_OUTPUT_FILE_ENV = "GJI_REMOVE_OUTPUT_FILE";
 export function createRemoveCommand(dependencies = {}) {
@@ -31,7 +31,10 @@ export function createRemoveCommand(dependencies = {}) {
             return 1;
         }
         const selection = options.branch ??
-            (await promptForWorktree(sortByCurrentFirst(linkedWorktrees)));
+            (await promptForWorktree(await buildWorktreePromptEntries(linkedWorktrees.map((worktree) => ({
+                repoName: repository.repoName,
+                worktree,
+            })))));
         if (!selection) {
             options.stderr("Aborted\n");
             return 1;
@@ -129,15 +132,7 @@ export function createRemoveCommand(dependencies = {}) {
 }
 export const runRemoveCommand = createRemoveCommand();
 async function defaultPromptForWorktree(worktrees) {
-    const choice = await select({
-        message: "Choose a worktree to finish",
-        options: worktrees.map((worktree) => ({
-            hint: worktree.isCurrent ? `${worktree.path} (current)` : worktree.path,
-            label: worktree.branch ?? "(detached)",
-            value: worktree.path,
-        })),
-    });
-    return isCancel(choice) ? null : choice;
+    return promptForSingleWorktree("Choose a worktree to finish", worktrees);
 }
 async function defaultConfirmRemoval(worktree) {
     const choice = await confirm({

package/dist/repo.d.ts

@@ -14,4 +14,3 @@ export declare function detectRepository(cwd: string): Promise<RepositoryContext
 export declare function resolveWorktreePath(repoRoot: string, branch: string, basePath?: string): string;
 export declare function validateBranchName(name: string): string | null;
 export declare function listWorktrees(cwd: string): Promise<WorktreeEntry[]>;
-export declare function sortByCurrentFirst(worktrees: WorktreeEntry[]): WorktreeEntry[];

package/dist/repo.js

@@ -88,15 +88,6 @@ export async function listWorktrees(cwd) {
         };
     });
 }
-export function sortByCurrentFirst(worktrees) {
-    return [...worktrees].sort((a, b) => {
-        if (a.isCurrent && !b.isCurrent)
-            return -1;
-        if (!a.isCurrent && b.isCurrent)
-            return 1;
-        return 0;
-    });
-}
 function findPorcelainValue(block, key) {
     const value = findOptionalPorcelainValue(block, key);
     if (!value) {

package/dist/warp.js

@@ -1,13 +1,13 @@
 import { realpath } from "node:fs/promises";
 import { basename, resolve } from "node:path";
 import { isCancel, select } from "@clack/prompts";
-import { readWorktreeHealth } from "./git.js";
 import { isHeadless } from "./headless.js";
-import { appendHistory } from "./history.js";
+import { recordWorktreeUsage } from "./history.js";
 import { runNewCommand } from "./new.js";
-import { listWorktrees } from "./repo.js";
+import { detectRepository, listWorktrees } from "./repo.js";
 import { loadRegistry } from "./repo-registry.js";
 import { writeShellOutput } from "./shell-handoff.js";
+import { buildWorktreePromptEntries, promptForSingleWorktree, resolveWorktreeQuery, } from "./worktree-picker.js";
 const WARP_OUTPUT_FILE_ENV = "GJI_WARP_OUTPUT_FILE";
 export async function runWarpCommand(options) {
     if (options.newWorktree) {
@@ -44,7 +44,7 @@ async function runWarpNavigate(options) {
         options.stdout(`${JSON.stringify({ branch: target.branch, path: target.path }, null, 2)}\n`);
         return 0;
     }
-    appendHistory(target.path, target.branch).catch(() => undefined);
+    await recordWorktreeUsage(target.path, target.branch);
     await writeShellOutput(WARP_OUTPUT_FILE_ENV, target.path, options.stdout);
     return 0;
 }
@@ -130,17 +130,6 @@ async function canonicalizeRepoPath(repoPath) {
         return resolve(repoPath);
     }
 }
-function findByQuery(items, query) {
-    const slashIdx = query.indexOf("/");
-    if (slashIdx !== -1) {
-        const repoQuery = query.slice(0, slashIdx);
-        const branchQuery = query.slice(slashIdx + 1);
-        const match = items.find((item) => item.repoName === repoQuery && item.worktree.branch === branchQuery);
-        if (match)
-            return match;
-    }
-    return items.find((item) => item.worktree.branch === query) ?? null;
-}
 export async function resolveWarpTarget(options) {
     const cmd = options.commandName ?? "gji";
     const emitError = (message, hint) => {
@@ -154,6 +143,9 @@ export async function resolveWarpTarget(options) {
         }
     };
     const registry = await loadRegistry();
+    const currentRoot = await detectRepository(options.cwd)
+        .then((repository) => repository.currentRoot)
+        .catch(() => null);
     if (registry.length === 0) {
         emitError("not in a git repository and no repos registered yet.", "Use any gji command inside a repository to register it.\n");
         return null;
@@ -168,61 +160,40 @@ export async function resolveWarpTarget(options) {
             continue;
         const { repoName, worktrees } = result.value;
         for (const worktree of worktrees) {
-            allItems.push({ repoName, worktree });
+            allItems.push({
+                repoName,
+                worktree: {
+                    ...worktree,
+                    isCurrent: currentRoot !== null && worktree.path === currentRoot,
+                },
+            });
         }
     }
     if (allItems.length === 0) {
         emitError("no accessible worktrees found in any registered repo.");
         return null;
     }
+    const promptSources = allItems.map((item) => ({
+        repoName: item.repoName,
+        worktree: item.worktree,
+    }));
     if (options.branch) {
-        const match = findByQuery(allItems, options.branch);
+        const match = resolveWorktreeQuery(promptSources, options.branch);
         if (!match) {
             emitError(`no worktree found matching: ${options.branch}`);
             return null;
         }
         return { branch: match.worktree.branch, path: match.worktree.path };
     }
-    const path = await promptForWarpTarget(allItems);
+    const promptEntries = await buildWorktreePromptEntries(promptSources);
+    const path = await promptForWarpTarget(promptEntries);
     if (!path) {
         options.stderr("Aborted\n");
         return null;
     }
-    const chosen = allItems.find((item) => item.worktree.path === path);
-    return { branch: chosen?.worktree.branch ?? null, path };
+    const chosen = promptEntries.find((item) => item.path === path);
+    return { branch: chosen?.branch ?? null, path };
 }
 async function promptForWarpTarget(items) {
-    const healthResults = await Promise.allSettled(items.map((item) => readWorktreeHealth(item.worktree.path)));
-    const choice = await select({
-        message: "Warp to a worktree",
-        options: items.map((item, i) => {
-            const health = healthResults[i].status === "fulfilled" ? healthResults[i].value : null;
-            const upstream = health ? formatHint(item.worktree.branch, health) : null;
-            const label = `${item.repoName} › ${item.worktree.branch ?? "(detached)"}`;
-            const pathHint = item.worktree.isCurrent
-                ? `${item.worktree.path} (current)`
-                : item.worktree.path;
-            const hint = upstream ? `${upstream} · ${pathHint}` : pathHint;
-            return { hint, label, value: item.worktree.path };
-        }),
-    });
-    if (isCancel(choice)) {
-        return null;
-    }
-    return choice;
-}
-function formatHint(branch, health) {
-    if (branch === null)
-        return null;
-    if (!health.hasUpstream)
-        return "no upstream";
-    if (health.upstreamGone)
-        return "upstream gone";
-    if (health.ahead === 0 && health.behind === 0)
-        return "up to date";
-    if (health.ahead === 0)
-        return `behind ${health.behind}`;
-    if (health.behind === 0)
-        return `ahead ${health.ahead}`;
-    return `ahead ${health.ahead}, behind ${health.behind}`;
+    return promptForSingleWorktree("Warp to a worktree", items);
 }

package/dist/worktree-info.d.ts

@@ -27,7 +27,6 @@ export type UpstreamState = {
 };
 export declare function readWorktreeInfos(worktrees: WorktreeEntry[]): Promise<WorktreeInfo[]>;
 export declare function serializeWorktreeInfo(info: WorktreeInfo): SerializedWorktreeInfo;
-export declare function formatWorktreeHint(info: WorktreeInfo): string;
 export declare function formatUpstreamState(upstream: UpstreamState): string;
 export declare function formatLastCommit(timestampSeconds: number | null): string;
 export declare function formatRelativeAge(timestampSeconds: number): string;

package/dist/worktree-info.js

@@ -1,6 +1,22 @@
 import { readBranchLastCommitTimestamp, readWorktreeHealth, } from "./git.js";
+const MAX_WORKTREE_INFO_READ_CONCURRENCY = 8;
 export async function readWorktreeInfos(worktrees) {
-    return Promise.all(worktrees.map((worktree) => readWorktreeInfo(worktree)));
+    return mapWithConcurrency(worktrees, MAX_WORKTREE_INFO_READ_CONCURRENCY, readWorktreeInfo);
+}
+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;
 }
 async function readWorktreeInfo(worktree) {
     const [healthResult, lastCommitResult] = await Promise.allSettled([
@@ -46,16 +62,6 @@ export function serializeWorktreeInfo(info) {
         upstream: info.upstream,
     };
 }
-export function formatWorktreeHint(info) {
-    const details = [
-        `status: ${info.status}`,
-        `upstream: ${formatUpstreamState(info.upstream)}`,
-    ];
-    if (info.lastCommitTimestamp !== null) {
-        details.push(`last: ${formatRelativeAge(info.lastCommitTimestamp)}`);
-    }
-    return `${info.path} (${details.join(", ")})`;
-}
 export function formatUpstreamState(upstream) {
     if (upstream.kind === "detached") {
         return "n/a";