@saadjs/pi-git-status 0.1.0 → 0.2.0

package/README.md

@@ -3,7 +3,7 @@
 Git status in Pi's footer, alongside other extensions' statuses.
 
 ```text
-main • 3 changed • 2 untracked • +42 −17
+feat • #3 • 3 changed • 2 untracked • +42 −17
 ```
 
 Clean trees show `main • clean`. The status is hidden outside Git repositories or when Git is unavailable.
@@ -31,6 +31,12 @@ Use an absolute path to `index.ts` when running Pi in another repository.
 
 Counts cover the whole repository, even from a subdirectory. Refreshes on session start, after successful `edit`/`write` tools, and after agent completion.
 
+## Pull request
+
+`#3` is the GitHub PR for the current branch, found with `gh pr view`. It's a clickable link (OSC 8) in terminals that support them. Colors: green for open, muted for draft, accent for merged, red for closed. It's hidden on `main`/`master`, when there is no PR, and when `gh` is missing or signed out.
+
+The PR is looked up when the session starts, when the branch changes, and after `git push`, `git checkout`, `git switch`, or `gh pr` commands. Between those, it's polled every 90s while you're active. Polling slows when you go idle, backs off when no PR is found, and stops after an hour without activity.
+
 Custom footers must display extension statuses via `footerData.getExtensionStatuses()`.
 
 ## Test

package/core.ts

@@ -118,18 +118,89 @@ export async function readGitStatus(cwd: string, signal?: AbortSignal): Promise<
   }
 }
 
+export type PullRequestState = "open" | "draft" | "merged" | "closed";
+
+export interface PullRequest {
+  number: number;
+  url: string;
+  state: PullRequestState;
+}
+
+/** `null` means the branch has no PR; `"unavailable"` means gh is missing or signed out. */
+export type PullRequestLookup = PullRequest | null | "unavailable";
+
+export function parsePullRequest(output: string): PullRequest | null {
+  try {
+    const data: unknown = JSON.parse(output);
+    if (typeof data !== "object" || data === null) return null;
+    const { number, url, state, isDraft } = data as Record<string, unknown>;
+    if (typeof number !== "number" || typeof url !== "string" || !url.startsWith("https://")) {
+      return null;
+    }
+    if (state === "OPEN") return { number, url, state: isDraft === true ? "draft" : "open" };
+    if (state === "MERGED") return { number, url, state: "merged" };
+    if (state === "CLOSED") return { number, url, state: "closed" };
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/** Looks up the PR for the checked-out branch, including merged and closed ones. */
+export function readPullRequest(cwd: string, signal?: AbortSignal): Promise<PullRequestLookup> {
+  return new Promise((resolve, reject) => {
+    execFile(
+      "gh",
+      ["pr", "view", "--json", "number,url,state,isDraft"],
+      {
+        cwd,
+        signal,
+        env: { ...process.env, GH_PROMPT_DISABLED: "1", NO_COLOR: "1" },
+        encoding: "utf8",
+        timeout: 10_000,
+        windowsHide: true,
+      },
+      (error, stdout, stderr) => {
+        if (!error) return resolve(parsePullRequest(stdout));
+        if ((error as NodeJS.ErrnoException).code === "ENOENT") return resolve("unavailable");
+        if (/no (pull requests|open pull requests) found/i.test(stderr)) return resolve(null);
+        if (/gh auth login|authentication|bad credentials/i.test(stderr)) {
+          return resolve("unavailable");
+        }
+        // Network errors, rate limits, non-GitHub remotes: let the caller keep the last result.
+        reject(error);
+      },
+    );
+  });
+}
+
+/** OSC 8 terminal hyperlink. */
+export function hyperlink(url: string, text: string): string {
+  return `\x1b]8;;${url}\x07${text}\x1b]8;;\x07`;
+}
+
+const PR_COLORS: Record<PullRequestState, StatusColor> = {
+  open: "success",
+  draft: "muted",
+  merged: "accent",
+  closed: "error",
+};
+
 type StatusColor = "text" | "accent" | "muted" | "success" | "error";
 
 export function formatGitStatus(
   status: GitStatus,
   color: (name: StatusColor, text: string) => string = (_name, text) => text,
+  pr?: PullRequest | null,
 ): string {
   const separator = color("muted", " • ");
+  const head = [color("text", status.branch)];
+  if (pr) head.push(hyperlink(pr.url, color(PR_COLORS[pr.state], `#${pr.number}`)));
   if (status.changed === 0 && status.untracked === 0) {
-    return color("text", status.branch) + separator + color("success", "clean");
+    return [...head, color("success", "clean")].join(separator);
   }
   return [
-    color("text", status.branch),
+    ...head,
     color(status.changed ? "accent" : "muted", `${status.changed} changed`),
     color("muted", `${status.untracked} untracked`),
     `${color(status.added ? "success" : "muted", `+${status.added}`)} ${color(status.removed ? "error" : "muted", `−${status.removed}`)}`,

package/index.ts

@@ -1,17 +1,43 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { formatGitStatus, readGitStatus } from "./core.ts";
+import {
+  formatGitStatus,
+  readGitStatus,
+  readPullRequest,
+  type GitStatus,
+  type PullRequest,
+} from "./core.ts";
 
 const STATUS_KEY = "git-status";
 const DEBOUNCE_MS = 150;
+const SECOND = 1_000;
+const MINUTE = 60 * SECOND;
+// Same cadence as Claude Code's PR footer: slow down as the user goes idle, stop after an hour.
+const PR_IDLE_STOP_MS = 60 * MINUTE;
+const PR_SKIP_BRANCHES = new Set(["detached", "main", "master"]);
+const PR_COMMAND = /\b(?:git\s+(?:push|checkout|switch)|gh\s+pr)\b/;
+
+function idleInterval(idle: number) {
+  if (idle < 30 * SECOND) return 90 * SECOND;
+  if (idle < 5 * MINUTE) return 3 * MINUTE;
+  if (idle < 30 * MINUTE) return 10 * MINUTE;
+  return 30 * MINUTE;
+}
+
+/** Backoff after lookups that found no PR or failed. */
+function missInterval(misses: number) {
+  return [90 * SECOND, 5 * MINUTE, 15 * MINUTE][misses] ?? 30 * MINUTE;
+}
 
 export default function (pi: ExtensionAPI) {
   let stop: (() => void) | undefined;
-  let requestRefresh: ((ctx: ExtensionContext) => void) | undefined;
+  let requestRefresh: ((ctx: ExtensionContext, options?: { pr?: boolean }) => void) | undefined;
+  let markActive: (() => void) | undefined;
 
   pi.on("session_start", (_event, ctx) => {
     stop?.();
     stop = undefined;
     requestRefresh = undefined;
+    markActive = undefined;
     if (ctx.mode !== "tui" || !ctx.hasUI) return;
 
     let context = ctx;
@@ -22,6 +48,91 @@ export default function (pi: ExtensionAPI) {
     let debounce: ReturnType<typeof setTimeout> | undefined;
     const controller = new AbortController();
 
+    let git: GitStatus | null = null;
+    let pr: PullRequest | null = null;
+    let prBranch: string | undefined;
+    let prUnavailable = false;
+    let prBusy = false;
+    let prPending = false;
+    let prForced = false;
+    let prTimer: ReturnType<typeof setTimeout> | undefined;
+    let lastPrFetch = 0;
+    let prMisses = 0;
+    let lastActivity = Date.now();
+
+    function render() {
+      const current = context;
+      const text = git
+        ? formatGitStatus(
+            git,
+            (name, value) => current.ui.theme.fg(name, value),
+            prBranch === git.branch ? pr : null,
+          )
+        : undefined;
+      if (text !== lastText) {
+        current.ui.setStatus(STATUS_KEY, text);
+        lastText = text;
+      }
+    }
+
+    function prEligible() {
+      return !disposed && !prUnavailable && git !== null && !PR_SKIP_BRANCHES.has(git.branch);
+    }
+
+    function schedulePr() {
+      if (prTimer) clearTimeout(prTimer);
+      prTimer = undefined;
+      if (!prEligible()) return;
+      const now = Date.now();
+      if (now - lastActivity >= PR_IDLE_STOP_MS) return;
+      const interval = Math.max(idleInterval(now - lastActivity), missInterval(prMisses));
+      prTimer = setTimeout(
+        () => {
+          prTimer = undefined;
+          if (Date.now() - lastActivity < PR_IDLE_STOP_MS) void fetchPr();
+        },
+        Math.max(0, lastPrFetch + interval - now),
+      );
+      prTimer.unref();
+    }
+
+    async function fetchPr() {
+      if (!prEligible()) return;
+      if (prBusy) {
+        prPending = true;
+        return;
+      }
+      if (prTimer) clearTimeout(prTimer);
+      prTimer = undefined;
+      prBusy = true;
+      const branch = git!.branch;
+      try {
+        const result = await readPullRequest(context.cwd, controller.signal).catch(
+          () => "error" as const,
+        );
+        if (disposed || git?.branch !== branch) return;
+        lastPrFetch = Date.now();
+        if (result === "unavailable") {
+          prUnavailable = true;
+          pr = null;
+        } else if (result === "error") {
+          prMisses++;
+        } else {
+          pr = result;
+          prMisses = result ? 0 : prMisses + 1;
+        }
+        render();
+      } finally {
+        prBusy = false;
+        if (prPending && !disposed) {
+          prPending = false;
+          void fetchPr();
+        } else {
+          schedulePr();
+        }
+      }
+    }
+
     async function refresh() {
       if (disposed) return;
       if (busy) {
@@ -29,16 +140,23 @@ export default function (pi: ExtensionAPI) {
         return;
       }
       busy = true;
-      const current = context;
       try {
-        const status = await readGitStatus(current.cwd, controller.signal);
+        const status = await readGitStatus(context.cwd, controller.signal);
         if (disposed) return;
-        const text = status
-          ? formatGitStatus(status, (name, value) => current.ui.theme.fg(name, value))
-          : undefined;
-        if (text !== lastText) {
-          current.ui.setStatus(STATUS_KEY, text);
-          lastText = text;
+        git = status;
+        let fetch = prForced;
+        prForced = false;
+        if (status && status.branch !== prBranch) {
+          prBranch = status.branch;
+          pr = null;
+          prMisses = 0;
+          fetch = true;
+        }
+        render();
+        if (fetch) void fetchPr();
+        else if (!status && prTimer) {
+          clearTimeout(prTimer);
+          prTimer = undefined;
         }
       } finally {
         busy = false;
@@ -49,8 +167,12 @@ export default function (pi: ExtensionAPI) {
       }
     }
 
-    requestRefresh = (nextContext) => {
+    requestRefresh = (nextContext, options) => {
       context = nextContext;
+      if (options?.pr) {
+        prForced = true;
+        prMisses = 0;
+      }
       if (debounce) clearTimeout(debounce);
       debounce = setTimeout(() => {
         debounce = undefined;
@@ -59,28 +181,49 @@ export default function (pi: ExtensionAPI) {
       debounce.unref();
     };
 
+    markActive = () => {
+      const wasIdle = Date.now() - lastActivity >= PR_IDLE_STOP_MS;
+      lastActivity = Date.now();
+      // Polling stops after an hour idle; resume it, fetching right away if overdue.
+      if (wasIdle || (!prTimer && !prBusy)) schedulePr();
+    };
+
     stop = () => {
       if (disposed) return;
       disposed = true;
       if (debounce) clearTimeout(debounce);
+      if (prTimer) clearTimeout(prTimer);
       controller.abort();
       context.ui.setStatus(STATUS_KEY, undefined);
     };
     void refresh();
   });
 
-  // Refresh after successful file mutations, not read-only tools or every shell call.
+  pi.on("input", () => {
+    markActive?.();
+  });
+
   pi.on("tool_result", (event, ctx) => {
-    if (!event.isError && (event.toolName === "edit" || event.toolName === "write")) {
-      requestRefresh?.(ctx);
+    markActive?.();
+    if (event.isError) return;
+    // Refresh after successful file mutations, not read-only tools or every shell call.
+    if (event.toolName === "edit" || event.toolName === "write") requestRefresh?.(ctx);
+    // Pushes, checkouts, and gh pr commands can create a PR or change its state.
+    const command = (event.input as { command?: unknown }).command;
+    if (event.toolName === "bash" && typeof command === "string" && PR_COMMAND.test(command)) {
+      requestRefresh?.(ctx, { pr: true });
     }
   });
   // Catch shell-made changes once the agent finishes.
-  pi.on("agent_end", (_event, ctx) => requestRefresh?.(ctx));
+  pi.on("agent_end", (_event, ctx) => {
+    markActive?.();
+    requestRefresh?.(ctx);
+  });
 
   pi.on("session_shutdown", () => {
     stop?.();
     stop = undefined;
     requestRefresh = undefined;
+    markActive = undefined;
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadjs/pi-git-status",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Live Git branch, changed files, and line counts in the Pi footer",
   "keywords": [
     "extension",