@solaqua/gji 0.7.0 → 0.7.2

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;
@@ -71,7 +74,7 @@ export function createRemoveCommand(dependencies = {}) {
         }
         const config = await loadEffectiveConfig(repository.repoRoot, undefined, options.stderr);
         const hooks = extractHooks(config);
-        await runHook(hooks.beforeRemove, worktree.path, {
+        await runHook(hooks["before-remove"], worktree.path, {
             branch: worktree.branch ?? undefined,
             path: worktree.path,
             repo: basename(repository.repoRoot),
@@ -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/run-hook.d.ts

@@ -0,0 +1,6 @@
+export interface RunHookCommandOptions {
+    cwd: string;
+    hook: string;
+    stderr: (chunk: string) => void;
+}
+export declare function runHookCommand(options: RunHookCommandOptions): Promise<number>;

package/dist/{trigger-hook.js → run-hook.js}

@@ -2,19 +2,25 @@ import { loadEffectiveConfig } from "./config.js";
 import { extractHooks, runHook } from "./hooks.js";
 import { detectRepository, listWorktrees } from "./repo.js";
 const VALID_HOOKS = [
-    "afterCreate",
-    "afterEnter",
-    "beforeRemove",
+    "after-create",
+    "after-enter",
+    "before-remove",
 ];
+const CAMEL_ALIASES = {
+    afterCreate: "after-create",
+    afterEnter: "after-enter",
+    beforeRemove: "before-remove",
+};
 function isValidHook(hook) {
     return VALID_HOOKS.includes(hook);
 }
-export async function runTriggerHookCommand(options) {
-    if (!isValidHook(options.hook)) {
-        options.stderr(`gji trigger-hook: unknown hook '${options.hook}'. Valid hooks: ${VALID_HOOKS.join(", ")}\n`);
+export async function runHookCommand(options) {
+    const normalized = CAMEL_ALIASES[options.hook] ?? options.hook;
+    if (!isValidHook(normalized)) {
+        options.stderr(`gji run-hook: unknown hook '${options.hook}'. Valid hooks: ${VALID_HOOKS.join(", ")}\n`);
         return 1;
     }
-    const hookName = options.hook;
+    const hookName = normalized;
     const repository = await detectRepository(options.cwd);
     const config = await loadEffectiveConfig(repository.repoRoot, undefined, options.stderr);
     const hooks = extractHooks(config);

package/dist/shell-completion.js

@@ -27,14 +27,14 @@ const TOP_LEVEL_COMMANDS = [
     },
     { name: "rm", description: "alias of remove" },
     {
-        name: "trigger-hook",
+        name: "run-hook",
         description: "run a named hook in the current worktree",
     },
     { name: "warp", description: "jump to any worktree across all known repos" },
     { name: "config", description: "manage global config defaults" },
 ];
 const SHELL_NAMES = ["bash", "fish", "zsh"];
-const HOOK_NAMES = ["afterCreate", "afterEnter", "beforeRemove"];
+const HOOK_NAMES = ["after-create", "after-enter", "before-remove"];
 const CONFIG_KEYS = Array.from(KNOWN_GLOBAL_CONFIG_KEYS);
 export function renderShellCompletion(shell) {
     switch (shell) {
@@ -116,7 +116,7 @@ _gji_completion() {
     remove|rm)
       COMPREPLY=( $(compgen -W "$(__gji_worktree_branches) -f --force --dry-run --json --help" -- "$cur") )
       ;;
-    trigger-hook)
+    run-hook)
       COMPREPLY=( $(compgen -W "${hooks} --help" -- "$cur") )
       ;;
     warp)
@@ -149,7 +149,7 @@ complete -F _gji_completion gji`;
 function renderFishCompletion() {
     const commandLines = TOP_LEVEL_COMMANDS.map((command) => `complete -c gji -n '__fish_use_subcommand' -a '${command.name}' -d '${escapeSingleQuotes(command.description)}'`).join("\n");
     const shellLines = SHELL_NAMES.map((shell) => `complete -c gji -n '__fish_seen_subcommand_from init' -a '${shell}' -d 'shell'`).join("\n");
-    const hookLines = HOOK_NAMES.map((hook) => `complete -c gji -n '__fish_seen_subcommand_from trigger-hook' -a '${hook}' -d 'hook'`).join("\n");
+    const hookLines = HOOK_NAMES.map((hook) => `complete -c gji -n '__fish_seen_subcommand_from run-hook' -a '${hook}' -d 'hook'`).join("\n");
     const configKeyLines = CONFIG_KEYS.map((key) => `complete -c gji -n '__gji_should_complete_config_key' -a '${key}' -d 'config key'`).join("\n");
     return `function __gji_worktree_branches
     command gji ls --compact 2>/dev/null | awk 'NR > 1 { branch = ($1 == "*" ? $2 : $1); if (branch != "(detached)") print branch }'
@@ -309,7 +309,7 @@ case "\${words[2]}" in
   remove|rm)
     _arguments '(-f --force)'{-f,--force}'[bypass prompts, force-remove a dirty worktree, and force-delete an unmerged branch]' '--dry-run[show what would be deleted without removing anything]' '--json[emit JSON on success or error instead of human-readable output]' '2:branch:->worktrees'
     ;;
-  trigger-hook)
+  run-hook)
     _arguments "2:hook:(${hooks})"
     ;;
   warp)

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";

package/dist/worktree-picker.d.ts

@@ -0,0 +1,14 @@
+import type { WorktreeEntry } from "./repo.js";
+export interface WorktreePromptSource {
+    repoName: string;
+    worktree: WorktreeEntry;
+}
+export interface WorktreePromptEntry extends WorktreeEntry {
+    group: "recent" | "other";
+    label: string;
+    repoName: string;
+}
+export declare function buildWorktreePromptEntries(sources: WorktreePromptSource[]): Promise<WorktreePromptEntry[]>;
+export declare function resolveWorktreeQuery(sources: WorktreePromptSource[], query: string): WorktreePromptSource | null;
+export declare function promptForSingleWorktree(message: string, worktrees: WorktreePromptEntry[]): Promise<string | null>;
+export declare function promptForMultipleWorktrees(message: string, worktrees: WorktreePromptEntry[]): Promise<string[] | null>;

package/dist/worktree-picker.js

@@ -0,0 +1,228 @@
+import { groupMultiselect, isCancel, select } from "@clack/prompts";
+import { loadHistory } from "./history.js";
+import { readWorktreeInfos, } from "./worktree-info.js";
+export async function buildWorktreePromptEntries(sources) {
+    const [history, infos] = await Promise.all([
+        loadHistory(),
+        readWorktreeInfos(sources.map((source) => source.worktree)),
+    ]);
+    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()));
+    return entries
+        .sort(comparePromptEntries)
+        .map(({ lastActivityTimestamp: _lastActivityTimestamp, ...entry }) => entry);
+}
+export function resolveWorktreeQuery(sources, query) {
+    const normalizedQuery = normalizeQuery(query);
+    if (normalizedQuery === null)
+        return null;
+    const matches = findWorktreePromptSourceMatches(sources, normalizedQuery);
+    if (isAmbiguousRepoOnlyQuery(matches, normalizedQuery))
+        return null;
+    return matches[0]?.source ?? null;
+}
+function findWorktreePromptSourceMatches(sources, normalizedQuery) {
+    return sources
+        .flatMap((source) => {
+        const matchScore = scoreWorktreeMatch({
+            ...source.worktree,
+            repoName: source.repoName,
+        }, normalizedQuery);
+        return matchScore === null ? [] : [{ matchScore, source }];
+    })
+        .sort(compareQueryMatches);
+}
+function isAmbiguousRepoOnlyQuery(matches, query) {
+    if (matches[0]?.matchScore === 1000)
+        return false;
+    return (matches.filter((match) => match.source.repoName.toLowerCase() === query)
+        .length > 1);
+}
+export async function promptForSingleWorktree(message, worktrees) {
+    const choice = await select({
+        message,
+        options: worktrees.map((worktree) => ({
+            label: worktree.label,
+            value: worktree.path,
+        })),
+        maxItems: 12,
+    });
+    return isCancel(choice) ? null : choice;
+}
+export async function promptForMultipleWorktrees(message, worktrees) {
+    const choice = await groupMultiselect({
+        message,
+        options: groupPromptEntries(worktrees),
+        required: true,
+        selectableGroups: false,
+    });
+    return isCancel(choice) ? null : choice;
+}
+function compareQueryMatches(a, b) {
+    if (a.matchScore !== b.matchScore) {
+        return b.matchScore - a.matchScore;
+    }
+    if (a.source.worktree.isCurrent && !b.source.worktree.isCurrent)
+        return -1;
+    if (!a.source.worktree.isCurrent && b.source.worktree.isCurrent)
+        return 1;
+    return (a.source.repoName.localeCompare(b.source.repoName) ||
+        (a.source.worktree.branch ?? "").localeCompare(b.source.worktree.branch ?? "") ||
+        a.source.worktree.path.localeCompare(b.source.worktree.path));
+}
+function groupPromptEntries(worktrees) {
+    const groups = {};
+    for (const worktree of worktrees) {
+        const group = worktree.group === "recent" ? "Recent worktrees" : "Other worktrees";
+        groups[group] ??= [];
+        groups[group].push({
+            label: worktree.label,
+            value: worktree.path,
+        });
+    }
+    return groups;
+}
+function buildWorktreePromptEntry(source, info, lastUsedTimestamp, now) {
+    const lastWorkedTimestamp = info.lastCommitTimestamp === null ? null : info.lastCommitTimestamp * 1000;
+    const lastActivityTimestamp = lastUsedTimestamp ?? lastWorkedTimestamp;
+    const lastActivityType = lastUsedTimestamp !== null
+        ? "used"
+        : lastWorkedTimestamp !== null
+            ? "worked"
+            : null;
+    const branch = source.worktree.branch ?? "(detached)";
+    const badges = buildStatusBadges(info);
+    const recency = formatPromptRecency(lastActivityTimestamp, lastActivityType, now);
+    const status = badges.length > 0 ? badges.map((badge) => `[${badge}]`).join(" ") : null;
+    const path = middleEllipsize(source.worktree.path, 76);
+    const label = [
+        middleEllipsize(source.repoName, 22),
+        middleEllipsize(branch, 34),
+        status,
+        recency,
+        path,
+    ]
+        .filter((part) => part !== null && part.length > 0)
+        .join(" · ");
+    return {
+        ...source.worktree,
+        group: lastUsedTimestamp !== null ? "recent" : "other",
+        label,
+        lastActivityTimestamp,
+        repoName: source.repoName,
+    };
+}
+function buildStatusBadges(info) {
+    const badges = [];
+    if (info.isCurrent) {
+        badges.push("current");
+    }
+    if (info.branch === null) {
+        badges.push("detached");
+    }
+    if (info.status === "dirty") {
+        badges.push("dirty");
+    }
+    if (info.upstream.kind === "stale") {
+        badges.push("stale", "gone");
+    }
+    if (isUpToDate(info.upstream)) {
+        badges.push("up to date");
+    }
+    return badges;
+}
+function isUpToDate(upstream) {
+    return (upstream.kind === "tracked" && upstream.ahead === 0 && upstream.behind === 0);
+}
+function formatPromptRecency(timestamp, type, now) {
+    if (timestamp === null || type === null) {
+        return "last used: never";
+    }
+    const label = type === "used" ? "last used" : "last worked";
+    return `${label}: ${formatPickerAge(timestamp, now)}`;
+}
+function formatPickerAge(timestamp, now) {
+    const ageSeconds = Math.max(0, Math.floor((now - timestamp) / 1000));
+    if (ageSeconds < 60) {
+        return "now";
+    }
+    if (ageSeconds < 60 * 60) {
+        return `${Math.floor(ageSeconds / 60)}m ago`;
+    }
+    if (ageSeconds < 24 * 60 * 60) {
+        return `${Math.floor(ageSeconds / (60 * 60))}h ago`;
+    }
+    if (isYesterday(timestamp, now)) {
+        return "yesterday";
+    }
+    return new Intl.DateTimeFormat("en-US", {
+        day: "numeric",
+        month: "short",
+    }).format(new Date(timestamp));
+}
+function isYesterday(timestamp, now) {
+    const date = new Date(timestamp);
+    const yesterday = new Date(now);
+    yesterday.setDate(yesterday.getDate() - 1);
+    return (date.getFullYear() === yesterday.getFullYear() &&
+        date.getMonth() === yesterday.getMonth() &&
+        date.getDate() === yesterday.getDate());
+}
+function buildSearchText(repoName, worktree) {
+    return [
+        repoName,
+        worktree.branch ?? "detached",
+        worktree.path,
+        `${repoName}/${worktree.branch ?? "detached"}`,
+    ]
+        .join(" ")
+        .toLowerCase();
+}
+function normalizeQuery(query) {
+    const normalized = query?.trim().toLowerCase();
+    return normalized && normalized.length > 0 ? normalized : null;
+}
+function comparePromptEntries(a, b) {
+    if (a.isCurrent && !b.isCurrent)
+        return -1;
+    if (!a.isCurrent && b.isCurrent)
+        return 1;
+    if (a.group !== b.group) {
+        return groupRank(a.group) - groupRank(b.group);
+    }
+    const aRecent = a.lastActivityTimestamp ?? 0;
+    const bRecent = b.lastActivityTimestamp ?? 0;
+    if (aRecent !== bRecent) {
+        return bRecent - aRecent;
+    }
+    return (a.repoName.localeCompare(b.repoName) ||
+        (a.branch ?? "").localeCompare(b.branch ?? "") ||
+        a.path.localeCompare(b.path));
+}
+function groupRank(group) {
+    return group === "recent" ? 0 : 1;
+}
+function scoreWorktreeMatch(entry, query) {
+    const branch = entry.branch ?? "detached";
+    const exactCandidates = [
+        branch,
+        entry.path,
+        `${entry.repoName}/${branch}`,
+    ].map((candidate) => candidate.toLowerCase());
+    if (exactCandidates.includes(query)) {
+        return 1000;
+    }
+    return buildSearchText(entry.repoName, entry).includes(query) ? 1 : null;
+}
+function middleEllipsize(value, maxLength) {
+    if (value.length <= maxLength) {
+        return value;
+    }
+    if (maxLength <= 1) {
+        return "…";
+    }
+    const keep = maxLength - 1;
+    const start = Math.ceil(keep / 2);
+    const end = Math.floor(keep / 2);
+    return `${value.slice(0, start)}…${value.slice(value.length - end)}`;
+}

package/man/man1/gji-back.1

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

package/man/man1/gji-clean.1

@@ -1,4 +1,4 @@
-.TH GJI\-CLEAN 1 "May 2026" "gji 0.7.0" "User Commands"
+.TH GJI\-CLEAN 1 "June 2026" "gji 0.7.2" "User Commands"
 .SH NAME
 gji\-clean \- interactively prune linked worktrees
 .SH SYNOPSIS

package/man/man1/gji-completion.1

@@ -1,4 +1,4 @@
-.TH GJI\-COMPLETION 1 "May 2026" "gji 0.7.0" "User Commands"
+.TH GJI\-COMPLETION 1 "June 2026" "gji 0.7.2" "User Commands"
 .SH NAME
 gji\-completion \- print shell completion definitions
 .SH SYNOPSIS

package/man/man1/gji-config.1

@@ -1,4 +1,4 @@
-.TH GJI\-CONFIG 1 "May 2026" "gji 0.7.0" "User Commands"
+.TH GJI\-CONFIG 1 "June 2026" "gji 0.7.2" "User Commands"
 .SH NAME
 gji\-config \- manage global config defaults
 .SH SYNOPSIS

package/man/man1/gji-go.1

@@ -1,4 +1,4 @@
-.TH GJI\-GO 1 "May 2026" "gji 0.7.0" "User Commands"
+.TH GJI\-GO 1 "June 2026" "gji 0.7.2" "User Commands"
 .SH NAME
 gji\-go \- print or select a worktree path
 .SH SYNOPSIS

package/man/man1/gji-history.1

@@ -1,4 +1,4 @@
-.TH GJI\-HISTORY 1 "May 2026" "gji 0.7.0" "User Commands"
+.TH GJI\-HISTORY 1 "June 2026" "gji 0.7.2" "User Commands"
 .SH NAME
 gji\-history \- show navigation history
 .SH SYNOPSIS

package/man/man1/gji-init.1

@@ -1,4 +1,4 @@
-.TH GJI\-INIT 1 "May 2026" "gji 0.7.0" "User Commands"
+.TH GJI\-INIT 1 "June 2026" "gji 0.7.2" "User Commands"
 .SH NAME
 gji\-init \- print or install shell integration
 .SH SYNOPSIS

package/man/man1/gji-ls.1

@@ -1,4 +1,4 @@
-.TH GJI\-LS 1 "May 2026" "gji 0.7.0" "User Commands"
+.TH GJI\-LS 1 "June 2026" "gji 0.7.2" "User Commands"
 .SH NAME
 gji\-ls \- list active worktrees
 .SH SYNOPSIS

package/man/man1/gji-new.1

@@ -1,4 +1,4 @@
-.TH GJI\-NEW 1 "May 2026" "gji 0.7.0" "User Commands"
+.TH GJI\-NEW 1 "June 2026" "gji 0.7.2" "User Commands"
 .SH NAME
 gji\-new \- create a new branch or detached linked worktree
 .SH SYNOPSIS

package/man/man1/gji-open.1

@@ -1,4 +1,4 @@
-.TH GJI\-OPEN 1 "May 2026" "gji 0.7.0" "User Commands"
+.TH GJI\-OPEN 1 "June 2026" "gji 0.7.2" "User Commands"
 .SH NAME
 gji\-open \- open the worktree in an editor
 .SH SYNOPSIS

package/man/man1/gji-pr.1

@@ -1,4 +1,4 @@
-.TH GJI\-PR 1 "May 2026" "gji 0.7.0" "User Commands"
+.TH GJI\-PR 1 "June 2026" "gji 0.7.2" "User Commands"
 .SH NAME
 gji\-pr \- fetch a pull request by number, #number, or URL into a linked worktree
 .SH SYNOPSIS