pi-minimal 0.5.0 → 0.6.0

package/dist/index.js

@@ -1,4 +1,8 @@
+import { Type } from "@earendil-works/pi-ai";
+import { showBackgroundOverlay } from "./background-overlay.js";
 import { installCodeBox } from "./code-box.js";
+import { isPrCreateCommand } from "./prs.js";
+import { parsePrFilter, prsToolResult, runPrsCommand } from "./prs-command.js";
 import { createSession } from "./session.js";
 import { installToolRenderers, stopLiveWatch } from "./tools.js";
 import { installTranscript } from "./transcript.js";
@@ -17,9 +21,61 @@ export default function piMinimalExtension(pi) {
     installCodeBox();
     let active;
     let busy = false;
+    // Background processes: `/bg` and a shortcut (default ctrl+b, see `backgroundShortcut`). The
+    // shortcut is registered once per key at load, since pi has no unregister; it reads the active
+    // session's config when pressed.
+    const openBackground = async (ctx) => {
+        if (!active?.background)
+            return;
+        await showBackgroundOverlay(ctx, active.background, active.backgroundShortcut ?? undefined);
+    };
+    pi.registerCommand("bg", { description: "Show processes left running by bash tool calls", handler: (_args, ctx) => openBackground(ctx) });
+    // Open PRs for the repo in cwd: `/prs [mine|review|all]` and the `list_open_prs` tool.
+    pi.registerCommand("prs", {
+        description: "Open PRs in this repo that I authored or that need my review",
+        handler: (args, ctx) => runPrsCommand(args, ctx, pi, active?.prs),
+    });
+    pi.registerTool({
+        name: "list_open_prs",
+        label: "List Open PRs",
+        description: "List open pull requests in the current repository that the user authored or has been asked to review (via the gh CLI).",
+        parameters: Type.Object({
+            filter: Type.Optional(Type.Union([Type.Literal("all"), Type.Literal("mine"), Type.Literal("review")], { description: "all (default), mine, or review (waiting on my review)" })),
+        }),
+        async execute(_toolCallId, params) {
+            await active?.prs?.refresh();
+            const result = prsToolResult(active?.prs, params.filter ?? parsePrFilter(""));
+            const text = result.prs.length === 0
+                ? `No open PRs${result.repo ? ` in ${result.repo}` : ""}${result.error ? ` (${result.error})` : ""}.`
+                : result.prs.map((pr) => `#${pr.number} [${pr.kind}${pr.isDraft ? ", draft" : ""}${pr.ciFailing ? ", CI failing" : ""}] ${pr.title} — ${pr.url}`).join("\n");
+            return { content: [{ type: "text", text }], details: result };
+        },
+    });
+    const registeredShortcuts = new Set();
+    const ensureShortcut = () => {
+        const key = active?.backgroundShortcut;
+        if (!key || registeredShortcuts.has(key) || typeof pi.registerShortcut !== "function")
+            return;
+        registeredShortcuts.add(key);
+        pi.registerShortcut(key, {
+            description: "Show background processes",
+            handler: (ctx) => (active?.backgroundShortcut === key ? openBackground(ctx) : undefined),
+        });
+    };
     pi.on("session_start", (_event, ctx) => {
         active?.dispose();
         active = createSession(pi, ctx, { busy: () => busy });
+        ensureShortcut();
+    });
+    // Commands that create a PR: remember the URL they print so the chips follow the session
+    // even when cwd is another repo (worktrees) or no repo at all.
+    const prCreateCalls = new Map();
+    pi.on("tool_execution_start", (event) => {
+        active?.background?.toolStart(event.toolCallId, event.toolName);
+        const command = event.args?.command;
+        if ((event.toolName === "bash" || event.toolName === "powershell") && typeof command === "string" && isPrCreateCommand(command)) {
+            prCreateCalls.set(event.toolCallId, true);
+        }
     });
     pi.on("agent_start", () => {
         busy = true;
@@ -32,7 +88,12 @@ export default function piMinimalExtension(pi) {
         active?.pin("turn_end");
         active?.refreshGit();
     });
-    pi.on("tool_execution_end", () => {
+    pi.on("tool_execution_end", (event) => {
+        active?.background?.toolEnd(event.toolCallId, event.toolName);
+        if (prCreateCalls.delete(event.toolCallId) && !event.isError) {
+            const content = event.result?.content ?? [];
+            active?.notePrUrls(content.map((part) => (part.type === "text" && typeof part.text === "string" ? part.text : "")).join("\n"));
+        }
         active?.pin("tool_execution_end");
         active?.refreshGit();
     });

package/dist/listeners.js

@@ -0,0 +1,23 @@
+/** A tiny change-notification set shared by the git and sibling sources. */
+export function createListeners() {
+    const listeners = new Set();
+    return {
+        notify() {
+            for (const listener of listeners) {
+                try {
+                    listener();
+                }
+                catch {
+                    // One listener's failure must not starve the others.
+                }
+            }
+        },
+        add(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+        clear() {
+            listeners.clear();
+        },
+    };
+}

package/dist/prs-command.js

@@ -0,0 +1,76 @@
+import { describePr, PR_LEGEND } from "./prs.js";
+export function parsePrFilter(args) {
+    const word = args.trim().split(/\s+/)[0]?.toLowerCase() ?? "";
+    if (["mine", "author", "authored", "my"].includes(word))
+        return "mine";
+    if (["review", "reviews", "review-requested", "requested"].includes(word))
+        return "review";
+    return "all";
+}
+export function filterPrs(prs, filter) {
+    if (filter === "all")
+        return prs;
+    return prs.filter((pr) => pr.kind === filter);
+}
+const ACTIONS = ["Open in browser", "Paste URL into editor", "Checkout branch", "Cancel"];
+export async function runPrsCommand(args, ctx, pi, source) {
+    if (!source) {
+        ctx.ui.notify("PRs are only tracked in interactive sessions.", "info");
+        return;
+    }
+    await source.refresh(true);
+    const snap = source.get();
+    if (!snap.repo && snap.prs.length === 0) {
+        ctx.ui.notify(snap.error ? `No GitHub repo here: ${snap.error}` : "No GitHub repo here.", "warning");
+        return;
+    }
+    const filter = parsePrFilter(args);
+    const prs = filterPrs(snap.prs, filter);
+    const title = `${snap.repo?.nameWithOwner ?? "this session"}: ${prs.length} open PR${prs.length === 1 ? "" : "s"}${filter === "all" ? "" : ` (${filter})`}${snap.error ? ` · stale: ${snap.error}` : ""}`;
+    if (prs.length === 0) {
+        ctx.ui.notify(title, "info");
+        return;
+    }
+    if (ctx.mode !== "tui") {
+        ctx.ui.notify(`${title}\n${prs.map((pr) => `${describePr(pr, snap.repo ? `${snap.repo.host}/${snap.repo.nameWithOwner}` : undefined)}\n  ${pr.url}`).join("\n")}`, "info");
+        return;
+    }
+    const cwdRepo = snap.repo ? `${snap.repo.host}/${snap.repo.nameWithOwner}` : undefined;
+    const labels = prs.map((pr) => describePr(pr, cwdRepo));
+    const chosen = await ctx.ui.select(`${title}\n${PR_LEGEND}`, labels);
+    if (chosen === undefined)
+        return;
+    const pr = prs[labels.indexOf(chosen)];
+    if (!pr)
+        return;
+    const action = await ctx.ui.select(`#${pr.number} ${pr.title}`, [...ACTIONS]);
+    if (action === "Open in browser") {
+        const open = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+        const run = await pi.exec(open, [pr.url]);
+        if (run.code !== 0)
+            ctx.ui.notify(`Could not open browser: ${run.stderr.trim()}`, "error");
+    }
+    else if (action === "Paste URL into editor") {
+        ctx.ui.pasteToEditor(pr.url);
+    }
+    else if (action === "Checkout branch") {
+        const run = await pi.exec("gh", ["pr", "checkout", String(pr.number), "-R", pr.repo], { cwd: ctx.cwd, timeout: 60_000 });
+        ctx.ui.notify(run.code === 0 ? `Checked out #${pr.number}` : `Checkout failed: ${run.stderr.trim()}`, run.code === 0 ? "info" : "error");
+    }
+}
+export function prsToolResult(source, filter) {
+    const snap = source?.get();
+    const prs = filterPrs(snap?.prs ?? [], filter).map((pr) => ({
+        number: pr.number,
+        title: pr.title,
+        url: pr.url,
+        repo: pr.repo,
+        author: pr.author,
+        isDraft: pr.isDraft,
+        kind: pr.kind,
+        reviewDecision: pr.reviewDecision,
+        ciFailing: pr.ciFailing,
+        updatedAt: pr.updatedAt,
+    }));
+    return { repo: snap?.repo?.nameWithOwner, host: snap?.repo?.host, fetchedAt: snap?.fetchedAt, error: snap?.error, prs };
+}

package/dist/prs.js

@@ -0,0 +1,270 @@
+import { hyperlink } from "@earendil-works/pi-tui";
+import { createListeners } from "./listeners.js";
+export const PR_LIST_FIELDS = "number,title,url,isDraft,author,reviewRequests,reviewDecision,statusCheckRollup,updatedAt";
+/** A GitHub PR URL on any host: `https://host/owner/repo/pull/123`. */
+export const PR_URL_RE = /https?:\/\/([a-z0-9.-]+)\/([^\s/]+)\/([^\s/]+)\/pull\/(\d+)\b/gi;
+/** Finds PR URLs in text, e.g. the output of `gh pr create`. */
+export function findPrUrls(text) {
+    const urls = new Set();
+    for (const match of text.matchAll(PR_URL_RE))
+        urls.add(`https://${match[1]}/${match[2]}/${match[3]}/pull/${match[4]}`);
+    return [...urls];
+}
+/** Repo (`host/owner/repo`) a PR URL belongs to. */
+export function prUrlRepo(url) {
+    const match = new RegExp(PR_URL_RE.source, "i").exec(url);
+    return match ? `${match[1]}/${match[2]}/${match[3]}` : undefined;
+}
+/** Commands whose output announces a PR this session created. */
+export function isPrCreateCommand(command) {
+    return /\bgh\s+pr\s+create\b|\bgt\s+submit\b/.test(command);
+}
+/** Parses `gh repo view --json nameWithOwner,url`. */
+export function parseRepoView(stdout) {
+    const data = JSON.parse(stdout);
+    if (typeof data.nameWithOwner !== "string" || typeof data.url !== "string")
+        throw new Error("invalid gh repo view");
+    return { nameWithOwner: data.nameWithOwner, host: new URL(data.url).host, url: data.url };
+}
+const FAILED_STATES = new Set(["FAILURE", "ERROR"]);
+const FAILED_CONCLUSIONS = new Set(["FAILURE", "TIMED_OUT", "CANCELLED", "ACTION_REQUIRED", "STARTUP_FAILURE"]);
+export function ciFailing(checks) {
+    return (checks ?? []).some((check) => FAILED_STATES.has(check.state ?? "") || FAILED_CONCLUSIONS.has(check.conclusion ?? ""));
+}
+function toPullRequest(raw, repo, kind) {
+    if (typeof raw.number !== "number" || typeof raw.url !== "string")
+        return undefined;
+    return {
+        number: raw.number,
+        title: typeof raw.title === "string" ? raw.title : "",
+        url: raw.url,
+        repo,
+        author: typeof raw.author?.login === "string" ? raw.author.login : "",
+        isDraft: raw.isDraft === true,
+        kind,
+        reviewDecision: typeof raw.reviewDecision === "string" ? raw.reviewDecision : "",
+        ciFailing: ciFailing(raw.statusCheckRollup),
+        updatedAt: typeof raw.updatedAt === "string" ? raw.updatedAt : "",
+    };
+}
+/** Parses `gh pr view URL --json …` for a PR this session created (always `mine`). */
+export function parsePrView(stdout, url) {
+    const raw = JSON.parse(stdout);
+    if (raw.state !== undefined && raw.state !== "OPEN")
+        return undefined;
+    const repo = prUrlRepo(url);
+    return repo ? toPullRequest(raw, repo, "mine") : undefined;
+}
+/**
+ * Parses `gh pr list --json …` for `involves:@me` into my PRs: authored by `login`, or requesting
+ * my review (directly; team requests are included when `teams` lists my team slugs). Others I'm
+ * merely mentioned on are dropped.
+ */
+export function parsePrList(stdout, repo, login, teams = []) {
+    const data = JSON.parse(stdout);
+    if (!Array.isArray(data))
+        throw new Error("invalid gh pr list");
+    const teamSet = new Set(teams.map((team) => team.toLowerCase()));
+    const prs = [];
+    for (const raw of data) {
+        const author = typeof raw.author?.login === "string" ? raw.author.login : "";
+        const requested = (raw.reviewRequests ?? []).some((request) => {
+            if (typeof request.login === "string")
+                return request.login.toLowerCase() === login.toLowerCase();
+            const slug = typeof request.slug === "string" ? request.slug : typeof request.name === "string" ? request.name : "";
+            return teamSet.has(slug.toLowerCase());
+        });
+        const mine = author.toLowerCase() === login.toLowerCase();
+        if (!mine && !requested)
+            continue;
+        const pr = toPullRequest(raw, `${repo.host}/${repo.nameWithOwner}`, mine ? "mine" : "review");
+        if (pr)
+            prs.push(pr);
+    }
+    // Review requests first (they need me), then mine; newest first within each.
+    prs.sort((a, b) => (a.kind === b.kind ? (a.updatedAt < b.updatedAt ? 1 : -1) : a.kind === "review" ? -1 : 1));
+    return prs;
+}
+/** Chip colour: trouble (failing CI, changes requested) wins, then review requests, then drafts. */
+export function prColor(pr) {
+    if (pr.ciFailing || pr.reviewDecision === "CHANGES_REQUESTED")
+        return "error";
+    if (pr.kind === "review")
+        return "warning";
+    if (pr.isDraft)
+        return "dim";
+    return "accent";
+}
+export const PR_LEGEND = "#n mine · dim draft · amber needs my review · red failing CI / changes requested";
+/** `#1675` inside the cwd repo; `repo#1675` for a PR elsewhere (created in this session) or when cwd is no repo. */
+export function prChipLabel(pr, cwdRepo) {
+    if (cwdRepo && pr.repo === cwdRepo)
+        return `#${pr.number}`;
+    return `${pr.repo.split("/").pop()}#${pr.number}`;
+}
+/** Footer segment: `#1675 #1670 +3` with each number an OSC 8 link; undefined when empty. */
+export function prSegment(prs, theme, max = 4, cwdRepo) {
+    if (prs.length === 0)
+        return undefined;
+    const shown = prs.slice(0, max);
+    const chips = shown.map((pr) => theme.fg(prColor(pr), hyperlink(prChipLabel(pr, cwdRepo), pr.url)));
+    const rest = prs.length - shown.length;
+    if (rest > 0)
+        chips.push(theme.fg("dim", `+${rest}`));
+    return chips.join(" ");
+}
+export function describePr(pr, cwdRepo) {
+    const flags = [
+        pr.kind === "review" ? "review requested" : pr.isDraft ? "draft" : "mine",
+        pr.ciFailing ? "CI failing" : undefined,
+        pr.reviewDecision === "CHANGES_REQUESTED" ? "changes requested" : pr.reviewDecision === "APPROVED" ? "approved" : undefined,
+    ].filter(Boolean);
+    return `${prChipLabel(pr, cwdRepo)}  ${pr.title}  · ${flags.join(" · ")}${pr.kind === "review" ? ` · @${pr.author}` : ""}`;
+}
+const GH_TIMEOUT_MS = 15_000;
+const DEFAULT_POLL_MS = 3 * 60_000;
+const DEFAULT_MIN_INTERVAL_MS = 60_000;
+export function createPrSource(deps) {
+    const now = deps.now ?? Date.now;
+    const pollMs = deps.pollMs ?? DEFAULT_POLL_MS;
+    const minIntervalMs = deps.minIntervalMs ?? DEFAULT_MIN_INTERVAL_MS;
+    const listeners = createListeners();
+    let alive = true;
+    let state = { prs: [] };
+    let inFlight;
+    let timer;
+    let lastRun = 0;
+    const logins = new Map();
+    const session = new Set(deps.sessionPrs ?? []);
+    // Only what is displayed counts as a change; a refresh that confirms the same list is silent.
+    const visible = (snap) => JSON.stringify([snap.repo, snap.prs, snap.error]);
+    const set = (next) => {
+        const changed = visible(next) !== visible(state);
+        state = next;
+        if (changed)
+            listeners.notify();
+    };
+    const gh = (args) => deps.pi.exec("gh", args, { cwd: deps.cwd(), timeout: GH_TIMEOUT_MS });
+    const viewerLogin = async (host) => {
+        const cached = logins.get(host);
+        if (cached)
+            return cached;
+        const run = await gh(["api", "--hostname", host, "user", "--jq", ".login"]);
+        if (run.code !== 0)
+            return undefined;
+        const login = run.stdout.trim();
+        if (login)
+            logins.set(host, login);
+        return login || undefined;
+    };
+    /** PRs this session created, wherever they live; a merged or closed one is forgotten. */
+    const fetchSessionPrs = async (exclude) => {
+        const extra = await Promise.all([...session].filter((url) => !exclude.has(url)).map(async (url) => {
+            const view = await gh(["pr", "view", url, "--json", `${PR_LIST_FIELDS},state`]);
+            if (view.code !== 0)
+                return undefined;
+            try {
+                const pr = parsePrView(view.stdout, url);
+                if (!pr)
+                    session.delete(url);
+                return pr;
+            }
+            catch {
+                return undefined;
+            }
+        }));
+        return extra.filter((pr) => pr !== undefined);
+    };
+    const fetchOnce = async () => {
+        let repo = state.repo;
+        let repoError;
+        try {
+            if (!repo) {
+                const view = await gh(["repo", "view", "--json", "nameWithOwner,url"]);
+                if (!alive)
+                    return;
+                if (view.code === 0)
+                    repo = parseRepoView(view.stdout);
+                else
+                    repoError = view.stderr.trim() || "gh repo view failed";
+            }
+            let prs = [];
+            let error = repoError;
+            if (repo) {
+                const login = await viewerLogin(repo.host);
+                if (!alive)
+                    return;
+                if (!login) {
+                    error = `gh is not authenticated for ${repo.host}`;
+                }
+                else {
+                    const list = await gh([
+                        "pr", "list", "-R", `${repo.host}/${repo.nameWithOwner}`, "--state", "open", "--limit", "100",
+                        "--search", "involves:@me", "--json", PR_LIST_FIELDS,
+                    ]);
+                    if (!alive)
+                        return;
+                    if (list.code !== 0)
+                        error = list.stderr.trim() || "gh pr list failed";
+                    else
+                        prs = parsePrList(list.stdout, repo, login);
+                }
+            }
+            // Outside a GitHub repo, or when the list failed, the session's own PRs still show.
+            prs.push(...(await fetchSessionPrs(new Set(prs.map((pr) => pr.url)))));
+            if (!alive)
+                return;
+            set({ repo, prs: error && prs.length === 0 && state.prs.length > 0 ? state.prs : prs, error, fetchedAt: now() });
+        }
+        catch (error) {
+            if (!alive)
+                return;
+            set({ repo, prs: state.prs, error: error instanceof Error ? error.message : String(error), fetchedAt: state.fetchedAt });
+        }
+    };
+    const schedule = () => {
+        if (!alive)
+            return;
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(() => { void refresh(true); }, pollMs);
+        timer.unref?.();
+    };
+    const refresh = (force = false) => {
+        if (!alive)
+            return Promise.resolve();
+        if (inFlight)
+            return inFlight;
+        if (!force && now() - lastRun < minIntervalMs)
+            return Promise.resolve();
+        lastRun = now();
+        inFlight = fetchOnce().finally(() => {
+            inFlight = undefined;
+            schedule();
+        });
+        return inFlight;
+    };
+    void refresh(true);
+    return {
+        get: () => state,
+        onChange: listeners.add,
+        refresh,
+        addSessionPr(url) {
+            const found = findPrUrls(url)[0];
+            if (!found || session.has(found))
+                return;
+            session.add(found);
+            void refresh(true);
+        },
+        sessionPrs: () => [...session],
+        dispose() {
+            if (!alive)
+                return;
+            alive = false;
+            if (timer)
+                clearTimeout(timer);
+            timer = undefined;
+            listeners.clear();
+        },
+    };
+}