@solaqua/gji 0.7.1 → 0.8.0

package/dist/worktree-picker.js

@@ -0,0 +1,924 @@
+import { env, platform, stdin, stdout } from "node:process";
+import { isCancel, Prompt } from "@clack/core";
+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, io = {}) {
+    const choice = await runSearchablePrompt({
+        entries: worktrees.map(buildSearchableWorktreeEntry),
+        input: io.input,
+        message,
+        multiple: false,
+        output: io.output,
+    });
+    return typeof choice === "string" ? choice : null;
+}
+export async function promptForMultipleWorktrees(message, worktrees, io = {}) {
+    const choice = await runSearchablePrompt({
+        entries: buildGroupedSearchableEntries(worktrees),
+        input: io.input,
+        message,
+        multiple: true,
+        output: io.output,
+    });
+    return Array.isArray(choice) ? choice : null;
+}
+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 = new Map();
+    for (const worktree of worktrees) {
+        const group = worktree.group === "recent" ? "Recent worktrees" : "Other worktrees";
+        const groupWorktrees = groups.get(group);
+        if (groupWorktrees === undefined) {
+            groups.set(group, [worktree]);
+        }
+        else {
+            groupWorktrees.push(worktree);
+        }
+    }
+    return [...groups.entries()];
+}
+function buildGroupedSearchableEntries(worktrees) {
+    const entries = [];
+    for (const [group, groupWorktrees] of groupPromptEntries(worktrees)) {
+        entries.push({
+            label: group,
+            searchText: group.toLowerCase(),
+            selectable: false,
+        });
+        for (const worktree of groupWorktrees) {
+            entries.push(buildSearchableWorktreeEntry(worktree));
+        }
+    }
+    return entries;
+}
+function buildSearchableWorktreeEntry(worktree) {
+    const metadata = worktree.metadata ?? null;
+    const branch = worktree.branch ?? "(detached)";
+    return {
+        detail: [worktree.repoName, branch, metadata, worktree.path]
+            .filter((part) => part !== null && part.length > 0)
+            .join(" · "),
+        label: worktree.label,
+        searchText: buildPromptSearchText(worktree),
+        value: worktree.path,
+        worktree: {
+            branch,
+            metadata,
+            path: worktree.path,
+            repoName: worktree.repoName,
+        },
+    };
+}
+async function runSearchablePrompt(options) {
+    const input = options.input ?? stdin;
+    const output = options.output ?? stdout;
+    if (!input.isTTY) {
+        return null;
+    }
+    const prompt = new SearchablePrompt(options, input, output);
+    const value = await prompt.run();
+    return isCancel(value) ? null : value;
+}
+class SearchablePrompt {
+    options;
+    output;
+    cursor = 0;
+    query = "";
+    searchActive = false;
+    selected = new Set();
+    prompt;
+    constructor(options, input, output) {
+        this.options = options;
+        this.output = output;
+        this.cursor = this.firstSelectableIndex();
+        const owner = this;
+        this.prompt = new WorktreeCorePrompt(this, {
+            input,
+            output,
+            render: function renderWorktreePrompt() {
+                return owner.render(this.state, this.error);
+            },
+        });
+        this.syncValue();
+    }
+    run() {
+        return this.prompt.prompt();
+    }
+    handleKeypress(prompt, character, key) {
+        if (prompt.state === "error") {
+            prompt.state = "active";
+            prompt.error = "";
+        }
+        const action = resolvePromptAction(character, key);
+        if (action === "cancel") {
+            this.cancel(prompt);
+            return;
+        }
+        if (action === "escape") {
+            this.handleEscapeKey(prompt);
+            return;
+        }
+        if (action === "enter") {
+            this.submit(prompt);
+            return;
+        }
+        if (this.searchActive && this.handleSearchKey(character, key?.name)) {
+            this.syncValue();
+            renderPrompt(prompt);
+            return;
+        }
+        if (character === "/" && !this.searchActive) {
+            this.searchActive = true;
+            this.query = "";
+            this.cursor = this.firstSelectableIndex();
+            this.syncValue();
+            renderPrompt(prompt);
+            return;
+        }
+        this.handleNavigationKey(character, action);
+        this.syncValue();
+        renderPrompt(prompt);
+    }
+    handleEscapeKey(prompt) {
+        if (this.searchActive) {
+            this.searchActive = false;
+            this.query = "";
+            this.cursor = this.firstSelectableIndex();
+            this.syncValue();
+            renderPrompt(prompt);
+            return;
+        }
+        this.cancel(prompt);
+    }
+    cancel(prompt) {
+        prompt.state = "cancel";
+        renderPrompt(prompt);
+        closePrompt(prompt);
+    }
+    handleSearchKey(character, keyName) {
+        if (keyName === "space" || character === " ") {
+            return false;
+        }
+        if (keyName === "backspace" || keyName === "delete") {
+            this.query = this.query.slice(0, -1);
+            this.cursor = this.firstSelectableIndex();
+            return true;
+        }
+        if (isPrintableSearchCharacter(character)) {
+            this.query += character;
+            this.cursor = this.firstSelectableIndex();
+            return true;
+        }
+        return false;
+    }
+    handleNavigationKey(character, action) {
+        switch (action) {
+            case "up":
+                this.moveCursor(-1);
+                return;
+            case "down":
+                this.moveCursor(1);
+                return;
+            case "space":
+                this.toggleSelection();
+                return;
+        }
+        switch (character) {
+            case "k":
+                this.moveCursor(-1);
+                return;
+            case "j":
+                this.moveCursor(1);
+                return;
+            case " ":
+                this.toggleSelection();
+                return;
+        }
+    }
+    moveCursor(direction) {
+        const entries = this.visibleEntries();
+        if (entries.length === 0)
+            return;
+        let nextCursor = this.cursor;
+        for (let index = 0; index < entries.length; index += 1) {
+            nextCursor = wrapIndex(nextCursor + direction, entries.length);
+            if (isSelectableEntry(entries[nextCursor])) {
+                this.cursor = nextCursor;
+                return;
+            }
+        }
+    }
+    submit(prompt) {
+        const entry = this.visibleEntries()[this.cursor];
+        if (!this.options.multiple) {
+            prompt.value = isSelectableEntry(entry) ? entry.value : null;
+            prompt.state = "submit";
+            renderPrompt(prompt);
+            closePrompt(prompt);
+            return;
+        }
+        if (this.selected.size === 0) {
+            prompt.error = "Please select at least one option.";
+            prompt.state = "error";
+            renderPrompt(prompt);
+            return;
+        }
+        prompt.value = [...this.selected];
+        prompt.state = "submit";
+        renderPrompt(prompt);
+        closePrompt(prompt);
+    }
+    toggleSelection() {
+        if (!this.options.multiple)
+            return;
+        const entry = this.visibleEntries()[this.cursor];
+        if (!isSelectableEntry(entry))
+            return;
+        if (this.selected.has(entry.value)) {
+            this.selected.delete(entry.value);
+            return;
+        }
+        this.selected.add(entry.value);
+    }
+    render(state, error) {
+        const entries = this.visibleEntries();
+        const visibleEntries = windowPromptEntries(entries, this.cursor, this.maxItems());
+        const glyphs = promptGlyphs();
+        const colors = promptColors();
+        const frame = promptFrameColor(state, colors);
+        const lines = [
+            colors.bar(glyphs.bar),
+            this.renderTitle(state, glyphs, colors),
+            `${frame(glyphs.bar)}  ${this.renderSearchHint(colors)}`,
+            frame(glyphs.bar),
+        ];
+        if (state === "error" && error.length > 0) {
+            lines.push(`${colors.errorBar(glyphs.bar)}  ${colors.error(error)}`);
+            lines.push(frame(glyphs.bar));
+        }
+        lines.push(...this.renderEntries(entries, visibleEntries, glyphs, colors, frame));
+        lines.push(frame(glyphs.bar));
+        const preview = this.activePreview(entries, colors);
+        if (preview !== null) {
+            lines.push(`${frame(glyphs.bar)}  ${preview}`);
+            lines.push(frame(glyphs.bar));
+        }
+        const visibleWorktreeCount = entries.filter(isSelectableEntry).length;
+        const footer = this.footerText(visibleWorktreeCount, colors);
+        if (footer.length > 0) {
+            lines.push(`${frame(glyphs.corner)}  ${footer}`);
+        }
+        return `${lines.join("\n")}\n`;
+    }
+    renderTitle(state, glyphs, colors) {
+        const symbol = colors.symbol(promptSymbol(state, glyphs), state);
+        const maxTitleLength = Math.max(8, this.columns() - 3);
+        if (!this.searchActive) {
+            return `${symbol}  ${middleEllipsize(this.options.message, maxTitleLength)}`;
+        }
+        const search = ` /${this.query}`;
+        const maxSearchLength = Math.min(terminalWidth(search), Math.floor(maxTitleLength / 2));
+        const message = middleEllipsize(this.options.message, Math.max(1, maxTitleLength - maxSearchLength));
+        const visibleSearch = middleEllipsize(search, Math.max(1, maxTitleLength - terminalWidth(message)));
+        return `${symbol}  ${message}${colors.search(visibleSearch)}`;
+    }
+    renderSearchHint(colors) {
+        if (this.searchActive) {
+            return `${colors.hint("type to filter")} ${colors.hint("·")} ${colors.key("esc")} ${colors.hint("clears")}`;
+        }
+        return `${colors.hint("press ")}${colors.key("/")}${colors.hint(" to search")}`;
+    }
+    renderEntries(entries, visibleEntries, glyphs, colors, frame) {
+        if (entries.length === 0) {
+            return [`${frame(glyphs.bar)}  ${colors.hint("No matching worktrees")}`];
+        }
+        return visibleEntries.map((entry) => entry === "ellipsis"
+            ? `${frame(glyphs.bar)}  ${colors.hint("...")}`
+            : this.renderEntry(entries, entry, glyphs, colors, frame));
+    }
+    renderEntry(entries, entry, glyphs, colors, frame) {
+        const active = entries[this.cursor] === entry;
+        const selected = isSelectableEntry(entry) && this.selected.has(entry.value);
+        const prefix = this.entryPrefix(entry, active, selected, glyphs);
+        const label = this.entryLabel(entry, prefix);
+        const line = isSelectableEntry(entry)
+            ? active
+                ? label
+                : colors.hint(label)
+            : colors.hint(label);
+        const marker = selected
+            ? colors.selected(prefix)
+            : active
+                ? this.options.multiple
+                    ? colors.option(prefix)
+                    : colors.selected(prefix)
+                : colors.hint(prefix);
+        return `${frame(glyphs.bar)}  ${marker} ${line}`;
+    }
+    activePreview(entries, colors) {
+        const entry = entries[this.cursor];
+        if (!isSelectableEntry(entry) || entry.detail === undefined)
+            return null;
+        const label = "current";
+        const separator = " ";
+        const width = this.previewWidth();
+        const prefixWidth = terminalWidth(label) + terminalWidth(separator);
+        if (width <= prefixWidth)
+            return colors.key(middleEllipsize(label, width));
+        const detail = middleEllipsize(entry.detail, width - prefixWidth);
+        return `${colors.key(label)}${colors.hint(separator)}${colors.hint(detail)}`;
+    }
+    entryLabel(entry, prefix) {
+        const width = this.labelWidth(prefix);
+        if (entry.worktree === undefined) {
+            return middleEllipsize(entry.label, width);
+        }
+        return fitPromptPieces([
+            {
+                ellipsize: middleEllipsize,
+                max: 18,
+                min: 6,
+                value: entry.worktree.repoName,
+            },
+            {
+                ellipsize: middleEllipsize,
+                max: 32,
+                min: 8,
+                value: entry.worktree.branch,
+            },
+            ...(entry.worktree.metadata === null
+                ? []
+                : [
+                    {
+                        ellipsize: middleEllipsize,
+                        max: 30,
+                        min: 10,
+                        value: entry.worktree.metadata,
+                    },
+                ]),
+            {
+                ellipsize: startEllipsize,
+                max: 36,
+                min: 12,
+                value: entry.worktree.path,
+            },
+        ], width);
+    }
+    labelWidth(prefix) {
+        return Math.max(8, this.columns() - terminalWidth(prefix) - 4);
+    }
+    previewWidth() {
+        return Math.max(8, this.columns() - 3);
+    }
+    entryPrefix(entry, active, selected, glyphs) {
+        if (!isSelectableEntry(entry)) {
+            return active ? glyphs.active : " ";
+        }
+        if (!this.options.multiple) {
+            return active ? glyphs.active : glyphs.inactive;
+        }
+        if (active && selected)
+            return glyphs.checked;
+        if (active)
+            return glyphs.uncheckedActive;
+        return selected ? glyphs.checked : glyphs.unchecked;
+    }
+    footerText(visibleCount, colors) {
+        if (!this.options.multiple)
+            return "";
+        return [
+            `${colors.key("space")} ${colors.hint("select")}`,
+            `${colors.selected(String(this.selected.size))} ${colors.hint("selected")}`,
+            colors.hint(`${visibleCount} shown`),
+        ].join(colors.hint(" · "));
+    }
+    firstSelectableIndex() {
+        const index = this.visibleEntries().findIndex(isSelectableEntry);
+        return index === -1 ? 0 : index;
+    }
+    visibleEntries() {
+        const query = normalizeQuery(this.query);
+        if (query === null) {
+            return this.options.entries;
+        }
+        return filterSearchablePromptEntries(this.options.entries, query);
+    }
+    maxItems() {
+        const rows = this.output.rows ?? 16;
+        return Math.max(5, Math.min(12, rows - 8));
+    }
+    columns() {
+        return Math.max(20, this.output.columns ?? 80);
+    }
+    syncValue() {
+        if (this.options.multiple) {
+            this.prompt.value = [...this.selected];
+            return;
+        }
+        const entry = this.visibleEntries()[this.cursor];
+        this.prompt.value = isSelectableEntry(entry) ? entry.value : null;
+    }
+}
+class WorktreeCorePrompt extends Prompt {
+    worktreePrompt;
+    constructor(worktreePrompt, options) {
+        super(options, false);
+        this.worktreePrompt = worktreePrompt;
+    }
+}
+/*
+ * @clack/core owns raw mode, frame clearing, and cursor restoration, but it
+ * does not expose a public pre-cancel keypress hook. Keep this private adapter
+ * small so slash-search can clear on Esc before Clack maps Esc to cancel.
+ */
+Object.defineProperty(WorktreeCorePrompt.prototype, "onKeypress", {
+    value: onWorktreeKeypress,
+    writable: true,
+});
+function renderPrompt(prompt) {
+    prompt.render();
+}
+function closePrompt(prompt) {
+    prompt.close();
+}
+function onWorktreeKeypress(character, key) {
+    this.worktreePrompt.handleKeypress(this, character, key);
+}
+function resolvePromptAction(character, key) {
+    if ((key?.ctrl && key.name === "c") || character === "\u0003") {
+        return "cancel";
+    }
+    switch (key?.name) {
+        case "escape":
+            return "escape";
+        case "return":
+            return "enter";
+        case "space":
+            return "space";
+        case "up":
+        case "left":
+            return "up";
+        case "down":
+        case "right":
+            return "down";
+    }
+    switch (character) {
+        case " ":
+            return "space";
+        case "k":
+        case "h":
+            return "up";
+        case "j":
+        case "l":
+            return "down";
+    }
+    return undefined;
+}
+function promptGlyphs() {
+    return supportsUnicode()
+        ? {
+            active: "●",
+            bar: "│",
+            checked: "◼",
+            corner: "└",
+            inactive: "○",
+            pending: "◆",
+            submitted: "◇",
+            unchecked: "◻",
+            uncheckedActive: "◻",
+        }
+        : {
+            active: ">",
+            bar: "|",
+            checked: "[x]",
+            corner: "-",
+            inactive: " ",
+            pending: "*",
+            submitted: "o",
+            unchecked: "[ ]",
+            uncheckedActive: "[ ]",
+        };
+}
+function promptColors() {
+    return {
+        activeBar: cyan,
+        bar: gray,
+        error: yellow,
+        errorBar: yellow,
+        hint: dim,
+        key: cyan,
+        option: cyan,
+        search: cyan,
+        selected: green,
+        symbol: (value, state) => {
+            if (state === "submit")
+                return green(value);
+            if (state === "error")
+                return yellow(value);
+            if (state === "cancel")
+                return red(value);
+            return cyan(value);
+        },
+    };
+}
+function promptFrameColor(state, colors) {
+    if (state === "error")
+        return colors.errorBar;
+    if (state === "active" || state === "initial")
+        return colors.activeBar;
+    return colors.bar;
+}
+function promptSymbol(state, glyphs) {
+    return state === "submit" ? glyphs.submitted : glyphs.pending;
+}
+function cyan(value) {
+    return color("\u001b[36m", "\u001b[39m", value);
+}
+function dim(value) {
+    return color("\u001b[2m", "\u001b[22m", value);
+}
+function gray(value) {
+    return color("\u001b[90m", "\u001b[39m", value);
+}
+function green(value) {
+    return color("\u001b[32m", "\u001b[39m", value);
+}
+function red(value) {
+    return color("\u001b[31m", "\u001b[39m", value);
+}
+function yellow(value) {
+    return color("\u001b[33m", "\u001b[39m", value);
+}
+function color(open, close, value) {
+    if (env.NO_COLOR !== undefined)
+        return value;
+    return `${open}${value}${close}`;
+}
+function supportsUnicode() {
+    if (platform !== "win32") {
+        return env.TERM !== "linux";
+    }
+    return Boolean(env.CI ||
+        env.WT_SESSION ||
+        env.TERMINUS_SUBLIME ||
+        env.ConEmuTask === "{cmd::Cmder}" ||
+        env.TERM_PROGRAM === "Terminus-Sublime" ||
+        env.TERM_PROGRAM === "vscode" ||
+        env.TERM === "xterm-256color" ||
+        env.TERM === "alacritty" ||
+        env.TERMINAL_EMULATOR === "JetBrains-JediTerm");
+}
+function isPrintableSearchCharacter(character) {
+    return (typeof character === "string" &&
+        character.length === 1 &&
+        character >= " " &&
+        character !== "\u007f");
+}
+function wrapIndex(index, length) {
+    return (index + length) % length;
+}
+function windowPromptEntries(entries, cursor, maxItems) {
+    if (entries.length <= maxItems) {
+        return entries;
+    }
+    const activeIndex = Math.min(Math.max(cursor, 0), entries.length - 1);
+    const start = Math.max(0, Math.min(activeIndex - 2, entries.length - maxItems));
+    const window = entries.slice(start, start + maxItems);
+    if (start > 0) {
+        window[0] = "ellipsis";
+    }
+    if (start + maxItems < entries.length) {
+        window[window.length - 1] = "ellipsis";
+    }
+    return window;
+}
+function fitPromptPieces(pieces, width) {
+    const separator = " · ";
+    let visiblePieces = pieces.filter((piece) => piece.value.length > 0);
+    let available = width - terminalWidth(separator) * Math.max(0, visiblePieces.length - 1);
+    while (visiblePieces.length > 1 &&
+        available < minimumPieceLength(visiblePieces)) {
+        const removableIndex = visiblePieces.length === 4 ? 2 : visiblePieces.length - 2;
+        visiblePieces = visiblePieces.filter((_, index) => index !== removableIndex);
+        available =
+            width - terminalWidth(separator) * Math.max(0, visiblePieces.length - 1);
+    }
+    if (available <= 0 || available < minimumPieceLength(visiblePieces)) {
+        return middleEllipsize(visiblePieces.map((piece) => piece.value).join(separator), width);
+    }
+    const lengths = visiblePieces.map((piece) => Math.min(terminalWidth(piece.value), piece.max));
+    while (sum(lengths) > available) {
+        const index = largestShrinkablePieceIndex(visiblePieces, lengths);
+        if (index === -1)
+            break;
+        lengths[index] -= 1;
+    }
+    return visiblePieces
+        .map((piece, index) => piece.ellipsize(piece.value, lengths[index]))
+        .join(separator);
+}
+function minimumPieceLength(pieces) {
+    return sum(pieces.map((piece) => Math.min(terminalWidth(piece.value), piece.min)));
+}
+function largestShrinkablePieceIndex(pieces, lengths) {
+    let candidate = -1;
+    for (let index = 0; index < pieces.length; index += 1) {
+        if (lengths[index] <=
+            Math.min(terminalWidth(pieces[index].value), pieces[index].min)) {
+            continue;
+        }
+        if (candidate === -1 || lengths[index] > lengths[candidate]) {
+            candidate = index;
+        }
+    }
+    return candidate;
+}
+function sum(values) {
+    return values.reduce((total, value) => total + value, 0);
+}
+function filterSearchablePromptEntries(entries, query) {
+    const filtered = [];
+    let pendingGroup = null;
+    for (const entry of entries) {
+        if (!isSelectableEntry(entry)) {
+            pendingGroup = entry;
+            continue;
+        }
+        if (!entry.searchText.includes(query)) {
+            continue;
+        }
+        if (pendingGroup !== null) {
+            filtered.push(pendingGroup);
+            pendingGroup = null;
+        }
+        filtered.push(entry);
+    }
+    return filtered;
+}
+function isSelectableEntry(entry) {
+    return (entry !== undefined &&
+        entry.selectable !== false &&
+        typeof entry.value === "string");
+}
+function buildPromptSearchText(worktree) {
+    return [
+        worktree.repoName,
+        worktree.branch ?? "detached",
+        worktree.path,
+        worktree.label,
+        `${worktree.repoName}/${worktree.branch ?? "detached"}`,
+    ]
+        .join(" ")
+        .toLowerCase();
+}
+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 metadataParts = [status, recency].filter((part) => part !== null && part.length > 0);
+    const metadata = metadataParts.length === 0 ? null : metadataParts.join(" · ");
+    const path = middleEllipsize(source.worktree.path, 76);
+    const label = [
+        middleEllipsize(source.repoName, 22),
+        middleEllipsize(branch, 34),
+        metadata,
+        path,
+    ]
+        .filter((part) => part !== null && part.length > 0)
+        .join(" · ");
+    return {
+        ...source.worktree,
+        group: lastUsedTimestamp !== null ? "recent" : "other",
+        label,
+        lastActivityTimestamp,
+        metadata,
+        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 (terminalWidth(value) <= maxLength) {
+        return value;
+    }
+    if (maxLength <= 1) {
+        return "…";
+    }
+    const keep = maxLength - 1;
+    const start = takeTerminalColumns(value, Math.ceil(keep / 2), "start");
+    const end = takeTerminalColumns(value, Math.floor(keep / 2), "end");
+    return `${start}…${end}`;
+}
+function startEllipsize(value, maxLength) {
+    if (terminalWidth(value) <= maxLength) {
+        return value;
+    }
+    if (maxLength <= 1) {
+        return "…";
+    }
+    return `…${takeTerminalColumns(value, maxLength - 1, "end")}`;
+}
+function takeTerminalColumns(value, maxWidth, direction) {
+    const characters = direction === "start" ? Array.from(value) : Array.from(value).reverse();
+    const kept = [];
+    let width = 0;
+    for (const character of characters) {
+        const characterWidth = terminalWidth(character);
+        if (width + characterWidth > maxWidth)
+            break;
+        kept.push(character);
+        width += characterWidth;
+    }
+    return direction === "start" ? kept.join("") : kept.reverse().join("");
+}
+function terminalWidth(value) {
+    let width = 0;
+    for (const character of Array.from(value)) {
+        width += characterTerminalWidth(character);
+    }
+    return width;
+}
+function characterTerminalWidth(character) {
+    const codePoint = character.codePointAt(0);
+    if (codePoint === undefined)
+        return 0;
+    if (isZeroWidthCodePoint(codePoint) || /\p{Mark}/u.test(character)) {
+        return 0;
+    }
+    return isWideCodePoint(codePoint) ? 2 : 1;
+}
+function isZeroWidthCodePoint(codePoint) {
+    return (codePoint === 0 ||
+        codePoint === 0x200d ||
+        (codePoint >= 0xfe00 && codePoint <= 0xfe0f));
+}
+function isWideCodePoint(codePoint) {
+    return ((codePoint >= 0x1100 && codePoint <= 0x115f) ||
+        codePoint === 0x2329 ||
+        codePoint === 0x232a ||
+        (codePoint >= 0x2e80 && codePoint <= 0xa4cf) ||
+        (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+        (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+        (codePoint >= 0xfe10 && codePoint <= 0xfe19) ||
+        (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
+        (codePoint >= 0xff00 && codePoint <= 0xff60) ||
+        (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
+        (codePoint >= 0x1f300 && codePoint <= 0x1faff) ||
+        (codePoint >= 0x20000 && codePoint <= 0x3fffd));
+}