rl-workspaces 0.0.0-stage → 0.5.0

package/dist/picker.js

@@ -0,0 +1,182 @@
+import { discoverPrs } from "./pr-discovery.js";
+import { accessLabel, lastAccessed } from "./access.js";
+import path from "node:path";
+import { args, arity, canonical, execute, git, inside, required, timestamp, } from "./common.js";
+import { Store } from "./store.js";
+import { worktrees } from "./repos.js";
+import { repositoryBase, resolveBase, pullRequestBase } from "./base.js";
+const plain = (value) => value.replace(/\x1b\[[0-9;]*m/g, "");
+const color = (value, code) => process.env.NO_COLOR !== undefined ? value : `\x1b[${code}m${value}\x1b[0m`;
+const stateColors = {
+    merged: 35,
+    open: 32,
+    draft: 33,
+    closed: 31,
+    none: 90,
+    unknown: 90,
+};
+export function candidates(repo, base) {
+    return worktrees(repo)
+        .slice(1)
+        .flatMap((record) => {
+        const root = canonical(record.worktree);
+        if (root === repo || !inside(root, base))
+            return [];
+        return [
+            {
+                name: path.relative(base, root),
+                path: root,
+                branch: (record.branch ?? "").replace(/^refs\/heads\//, ""),
+                locked: "locked" in record,
+            },
+        ];
+    });
+}
+export function prState(data) {
+    if (!data?.pr)
+        return "none";
+    const state = String(data.pr.state ?? "").toUpperCase();
+    if (state === "MERGED")
+        return "merged";
+    if (state === "CLOSED")
+        return "closed";
+    if (state === "OPEN")
+        return data.pr.isDraft ? "draft" : "open";
+    return "unknown";
+}
+const visible = (value) => value
+    .replaceAll("\t", "\\t")
+    .replaceAll("\n", "\\n")
+    .replaceAll("\r", "\\r")
+    .replaceAll("\x1b", "");
+export function pickerRows(store, items, defaultBase, prs = new Map()) {
+    const records = new Map(store
+        .records()
+        .filter(([, data]) => data.status === "active")
+        .map(([, data]) => [data.worktree, data]));
+    const fallback = repositoryBase(store.repo, defaultBase);
+    const details = items.map((item) => {
+        const data = records.get(item.path);
+        const lookup = prs.get(item.branch);
+        const pr = lookup ? lookup.pr : data?.pr;
+        const prBase = pullRequestBase(store.repo, pr);
+        const savedBase = typeof data?.baseBranch === "string" ? data.baseBranch : undefined;
+        const explicit = savedBase && savedBase !== defaultBase ? savedBase : undefined;
+        // An unresolved PR target never falls back to an unrelated repository base.
+        const resolved = prBase
+            ? prBase.resolved
+            : explicit
+                ? resolveBase(store.repo, explicit)
+                : fallback;
+        let diff = "—";
+        if (resolved) {
+            try {
+                const [behind, ahead] = git(item.path, "rev-list", "--left-right", "--count", `${resolved.oid}...HEAD`, "--").split(/\s+/);
+                diff = `+${ahead} / -${behind}`;
+            }
+            catch {
+                /* Unavailable worktrees are not clean worktrees. */
+            }
+        }
+        return {
+            item,
+            accessed: lastAccessed(data),
+            state: pr
+                ? prState({ pr }) + (lookup?.stale ? "*" : "")
+                : lookup && !lookup.stale && lookup.checkedAt
+                    ? "none"
+                    : "unknown",
+            diff,
+            base: resolved?.ref ?? prBase?.target ?? explicit ?? "unknown",
+        };
+    });
+    details.sort((a, b) => {
+        const left = a.accessed ? timestamp(a.accessed) : -1n;
+        const right = b.accessed ? timestamp(b.accessed) : -1n;
+        return left === right
+            ? a.item.name.localeCompare(b.item.name)
+            : left > right
+                ? -1
+                : 1;
+    });
+    const columns = process.stderr.columns || 110;
+    const baseWidth = Math.min(24, Math.max(8, ...details.map((row) => visible(row.base).length)));
+    const nameWidth = Math.min(Math.max(12, ...items.map((item) => visible(item.name).length)), Math.max(16, Math.min(48, columns - baseWidth - 47)));
+    const diffWidth = Math.max(13, ...details.map((row) => row.diff.length));
+    const cell = (value, width) => {
+        const text = visible(value);
+        return (text.length > width ? text.slice(0, width - 1) + "…" : text).padEnd(width);
+    };
+    const format = (name, state, diff, base) => `${cell(name, nameWidth)}  ${cell(state, 7)}  ${cell(diff, diffWidth)}  ${cell(base, baseWidth)}  LAST ACCESSED`;
+    const header = format("WORKSPACE", "PR", "COMMITS + / −", "BASE");
+    return details.map(({ item, state, diff, base, accessed }) => ({
+        item,
+        header,
+        // fzf hides the identity field; selection always uses the untruncated name.
+        line: `${visible(item.name)}\t${cell((item.locked ? "[locked] " : "") + item.name, nameWidth)}  ${color(cell(state, 7), stateColors[state.replace(/\*$/, "")])}  ${cell(diff, diffWidth)
+            .replace(/\+\d+/g, (value) => color(value, 32))
+            .replace(/-\d+/g, (value) => color(value, 31))}  ${color(cell(base, baseWidth), 90)}  ${color(accessLabel(accessed), 90)}`,
+    }));
+}
+export async function select(store, items, defaultBase, multiple) {
+    if (!items.length) {
+        console.error("No managed worktrees to " + (multiple ? "delete." : "open."));
+        return [];
+    }
+    const prs = await discoverPrs(store, items.map((item) => item.branch));
+    const rows = pickerRows(store, items, defaultBase, prs);
+    const header = (multiple
+        ? "Tab select · Ctrl-A all · Enter delete · Esc cancel\nDeletes uncommitted work and local branches."
+        : "Enter open · Esc cancel") +
+        "\nPR auto · * stale · commits ahead / behind base\n\n" +
+        rows[0].header;
+    const options = [
+        "fzf",
+        "--ansi",
+        "--delimiter=\t",
+        "--with-nth=2..",
+        "--prompt=" + (multiple ? "Delete › " : "Workspace › "),
+        "--height=70%",
+        "--border=rounded",
+        "--info=inline",
+        "--reverse",
+        "--no-sort",
+        "--header=" + header,
+    ];
+    if (multiple)
+        options.push("--multi", "--bind=ctrl-a:select-all,ctrl-d:deselect-all");
+    const result = await execute(options, store.repo, {
+        input: rows.map((row) => row.line).join("\n") + "\n",
+        terminalError: true,
+    });
+    if ([1, 130].includes(result.code))
+        return [];
+    if (result.code)
+        throw new Error(`fzf failed (exit ${result.code})`);
+    const selections = result.stdout
+        .split(/\r?\n/)
+        .filter(Boolean)
+        .map((line) => {
+        const row = rows.find((row) => plain(row.line) === plain(line) || row.item.name === line);
+        if (!row)
+            throw new Error("Picker returned an unknown workspace");
+        return row.item;
+    });
+    if (!multiple && selections.length > 1)
+        throw new Error("Picker returned multiple workspaces");
+    return [...new Map(selections.map((item) => [item.path, item])).values()];
+}
+export async function main(argv) {
+    const { values, positionals } = args(argv, [
+        "repo",
+        "state-dir",
+        "base-dir",
+        "default-base",
+    ]);
+    arity(positionals, 0);
+    const store = new Store(required(values, "repo"), required(values, "state-dir"));
+    const selected = await select(store, candidates(store.repo, canonical(required(values, "base-dir"))), required(values, "default-base"), false);
+    if (selected.length)
+        process.stdout.write(selected[0].path + "\n");
+    return 0;
+}

package/dist/pr-discovery.js

@@ -0,0 +1,223 @@
+import fs from "node:fs";
+import path from "node:path";
+import { execute, message, now, object, pooled, readJson, writeJson, } from "./common.js";
+const TTL = 60_000;
+const fields = "number url title state headRefName baseRefName isDraft updatedAt headRepository { nameWithOwner }";
+export async function discoverPrs(store, branches) {
+    const file = path.join(store.root, "pr-cache.json"), cached = new Map();
+    try {
+        if (fs.existsSync(file)) {
+            const data = readJson(file);
+            if (data.schemaVersion === 1 && object(data.branches))
+                for (const [branch, entry] of Object.entries(data.branches)) {
+                    if (object(entry) &&
+                        typeof entry.checkedAt === "string" &&
+                        Number.isFinite(Date.parse(entry.checkedAt)) &&
+                        (entry.pr === null ||
+                            (object(entry.pr) &&
+                                typeof entry.pr.url === "string" &&
+                                entry.pr.headRefName === branch)))
+                        cached.set(branch, entry);
+                }
+        }
+    }
+    catch {
+        /* A disposable lookup cache must not prevent opening a worktree. */
+    }
+    const results = new Map();
+    for (const [, data] of store.records()) {
+        if (data.status !== "active" || !data.pr)
+            continue;
+        const previous = cached.get(data.branch), stamp = data.pr.syncedAt;
+        if (!previous ||
+            (typeof stamp === "string" &&
+                Date.parse(stamp) > Date.parse(previous.checkedAt)))
+            results.set(data.branch, {
+                pr: data.pr,
+                checkedAt: typeof stamp === "string" ? stamp : undefined,
+                stale: false,
+            });
+    }
+    for (const [branch, entry] of cached)
+        if (!results.has(branch))
+            results.set(branch, { ...entry, stale: false });
+    const pending = [...new Set(branches.filter(Boolean))].filter((branch) => {
+        const value = results.get(branch), age = value?.checkedAt
+            ? Date.now() - Date.parse(value.checkedAt)
+            : Infinity;
+        return !(age >= 0 && age < TTL);
+    });
+    if (!pending.length)
+        return results;
+    const fail = (branch) => results.set(branch, {
+        pr: results.get(branch)?.pr ?? null,
+        checkedAt: results.get(branch)?.checkedAt,
+        stale: true,
+    });
+    if (process.env.RL_PR_OFFLINE === "1") {
+        pending.forEach(fail);
+        return results;
+    }
+    const started = now(), deadline = Date.now() + 8000;
+    const ghEnv = { ...process.env, GH_PROMPT_DISABLED: "1" };
+    delete ghEnv.GH_REPO;
+    async function gh(args) {
+        const remaining = deadline - Date.now();
+        if (remaining <= 0)
+            throw new Error("GitHub lookup timed out");
+        const result = await execute(["gh", ...args], store.repo, {
+            timeoutMs: remaining,
+            env: ghEnv,
+        });
+        if (result.code)
+            throw new Error(result.stderr.trim() || "GitHub lookup failed or timed out");
+        return JSON.parse(result.stdout);
+    }
+    const refreshed = new Map(), failures = [];
+    console.error("Checking GitHub PRs…");
+    try {
+        const identity = await gh(["repo", "view", "--json", "nameWithOwner,url"]);
+        if (!object(identity) ||
+            typeof identity.nameWithOwner !== "string" ||
+            typeof identity.url !== "string")
+            throw new Error("Invalid GitHub repository identity");
+        const repositoryName = identity.nameWithOwner;
+        const [owner, name, extra] = repositoryName.split("/"), url = new URL(identity.url);
+        if (!owner ||
+            !name ||
+            extra ||
+            url.protocol !== "https:" ||
+            url.pathname.replace(/\/$/, "") !== `/${owner}/${name}`)
+            throw new Error("Invalid GitHub repository URL");
+        const prefix = identity.url.replace(/\/$/, "") + "/pull/";
+        const batches = [];
+        for (let i = 0; i < pending.length; i += 20)
+            batches.push(pending.slice(i, i + 20));
+        await pooled(batches, 2, async (batch) => {
+            try {
+                const selections = batch
+                    .map((branch, i) => [
+                    `o${i}: pullRequests(headRefName: ${JSON.stringify(branch)}, states: [OPEN], first: 100, orderBy: {field: CREATED_AT, direction: DESC}) { nodes { ${fields} } pageInfo { hasNextPage } }`,
+                    `h${i}: pullRequests(headRefName: ${JSON.stringify(branch)}, states: [CLOSED, MERGED], first: 100, orderBy: {field: CREATED_AT, direction: DESC}) { nodes { ${fields} } pageInfo { hasNextPage } }`,
+                ].join("\n"))
+                    .join("\n");
+                const query = `query($owner: String!, $name: String!) { repository(owner: $owner, name: $name) { ${selections} } }`;
+                const response = await gh([
+                    "api",
+                    "graphql",
+                    "--hostname",
+                    url.host,
+                    "-f",
+                    `query=${query}`,
+                    "-f",
+                    `owner=${owner}`,
+                    "-f",
+                    `name=${name}`,
+                ]);
+                if (!object(response) ||
+                    response.errors ||
+                    !object(response.data) ||
+                    !object(response.data.repository))
+                    throw new Error("Incomplete GitHub PR response");
+                const repository = response.data.repository;
+                for (const [i, branch] of batch.entries()) {
+                    try {
+                        let selected = null;
+                        for (const alias of [`o${i}`, `h${i}`]) {
+                            const connection = repository[alias];
+                            if (!object(connection) ||
+                                !Array.isArray(connection.nodes) ||
+                                !object(connection.pageInfo) ||
+                                typeof connection.pageInfo.hasNextPage !== "boolean")
+                                throw new Error("Incomplete branch lookup");
+                            for (const pr of connection.nodes) {
+                                if (!object(pr) ||
+                                    pr.headRefName !== branch ||
+                                    typeof pr.url !== "string" ||
+                                    !pr.url.startsWith(prefix) ||
+                                    !object(pr.headRepository) ||
+                                    typeof pr.headRepository.nameWithOwner !== "string")
+                                    throw new Error("Invalid branch PR identity");
+                                // A fork can reuse the branch name; it is not this repository's workspace.
+                                if (pr.headRepository.nameWithOwner.toLowerCase() !==
+                                    repositoryName.toLowerCase())
+                                    continue;
+                                if (!Number.isInteger(pr.number) ||
+                                    typeof pr.baseRefName !== "string" ||
+                                    !pr.baseRefName ||
+                                    !["OPEN", "CLOSED", "MERGED"].includes(String(pr.state)) ||
+                                    typeof pr.isDraft !== "boolean" ||
+                                    typeof pr.updatedAt !== "string")
+                                    throw new Error("Incomplete PR metadata");
+                                selected = { ...pr, url: pr.url, syncedAt: started };
+                                break;
+                            }
+                            if (selected)
+                                break;
+                            if (connection.pageInfo.hasNextPage)
+                                throw new Error("Branch PR results truncated");
+                        }
+                        const entry = { pr: selected, checkedAt: started };
+                        refreshed.set(branch, entry);
+                        results.set(branch, { ...entry, stale: false });
+                    }
+                    catch (error) {
+                        fail(branch);
+                        failures.push(`${branch}: ${message(error)}`);
+                    }
+                }
+            }
+            catch (error) {
+                batch.forEach(fail);
+                failures.push(message(error));
+            }
+        });
+    }
+    catch (error) {
+        pending.forEach(fail);
+        failures.push(message(error));
+    }
+    if (refreshed.size) {
+        try {
+            await store.locked(() => {
+                let existing = {};
+                try {
+                    const data = readJson(file);
+                    if (object(data.branches))
+                        existing = data.branches;
+                }
+                catch {
+                    /* New/disposable cache. */
+                }
+                const merged = new Map(Object.entries(existing));
+                for (const [branch, entry] of refreshed) {
+                    const previous = merged.get(branch);
+                    if (!object(previous) ||
+                        typeof previous.checkedAt !== "string" ||
+                        Date.parse(previous.checkedAt) <= Date.parse(started))
+                        merged.set(branch, entry);
+                }
+                writeJson(file, {
+                    schemaVersion: 1,
+                    branches: Object.fromEntries(merged),
+                });
+                for (const [record, data] of store.records()) {
+                    const entry = refreshed.get(data.branch);
+                    if (data.status !== "active" || !entry)
+                        continue;
+                    if (typeof data.pr?.syncedAt === "string" &&
+                        Date.parse(data.pr.syncedAt) > Date.parse(started))
+                        continue;
+                    data.pr = entry.pr;
+                    store.save(record, data);
+                }
+            });
+        }
+        catch (error) {
+            failures.push(`Could not save PR cache: ${message(error)}`);
+        }
+    }
+    if (failures.length)
+        console.error(`rl: PR lookup incomplete; * marks a saved snapshot, unknown means not verified. ${failures[0]}`);
+    return results;
+}