@pi-archimedes/footer 2.9.1 → 2.9.3

package/README.md

@@ -28,7 +28,7 @@ After installing Pi, choose one installation command above, then `cd` into your
 
 ## What you get
 
-- **Session line** — working directory, active git branch with clean/dirty indicator, worktree badge, active model, and thinking level.
+- **Session line** — working directory, active git branch (or nearest jj bookmark in a jj repo) with clean/dirty indicator, worktree badge, active model, and thinking level.
 - **Token ledger** — input (↑) and output (↓) tokens, cache read/write, and the live accumulated dollar cost of the session.
 - **Context bar** — colour-coded (green → yellow → red). It shows **consumption**: how much of the context window is used, not how much headroom is left.
 - **Adaptive layout** — one compact line on wide viewports; it wraps to the lines it needs as the terminal narrows instead of truncating essential data.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-archimedes/footer",
-  "version": "2.9.1",
+  "version": "2.9.3",
   "repository": {
     "type": "git",
     "url": "https://github.com/danielcherubini/pi-archimedes.git"
@@ -19,7 +19,7 @@
     "./config": "./src/config.ts"
   },
   "dependencies": {
-    "@pi-archimedes/core": "2.9.1"
+    "@pi-archimedes/core": "2.9.3"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": ">=0.1.0",

package/src/index.ts

@@ -16,6 +16,7 @@ import { clampLine } from "@pi-archimedes/core/text";
 import { loadFooterConfig } from "./config.js";
 import { CostAccumulator } from "./cost-accumulator.js";
 import { getGitStatus, isInsideLinkedWorktree } from "./utils/git.js";
+import { getJjBookmark } from "./utils/jj.js";
 import { getContextWindowInfo, getTokenUsageStats, type TokenUsageStats } from "./utils/stats.js";
 import { formatContextBar, formatGitStatusIndicators, formatThinkingIndicator, formatTokenCount, wrapStatusToChunks } from "./utils/format.js";
 import { footerIcons } from "./utils/icons.js";
@@ -51,7 +52,7 @@ export function registerFooter(pi: ExtensionAPI): void {
           try {
             const colorize = (token: string, s: string) => theme.fg(token as any, s);
             const activeModel = ctx.model?.id || "no-model";
-            const currentBranch = footerData.getGitBranch();
+            const currentBranch = getJjBookmark() ?? footerData.getGitBranch();
             const currentDirectory = process.cwd().split("/").pop() || process.cwd();
             const gitStatus = getGitStatus();
             const inWorktree = isInsideLinkedWorktree();

package/src/utils/git.test.ts

@@ -71,6 +71,12 @@ describe("getGitStatus", () => {
     expect(result.unstaged).toBe(0);
   });
 
+  it("counts intent-to-add files (jj's new files) as unstaged", async () => {
+    const mockExecSync = vi.fn(() => "1 .A N... 000000 000000 100644 0000 0000 new.txt\n");
+    await loadModule(mockExecSync);
+    expect(getGitStatus()).toMatchObject({ staged: 0, unstaged: 1, untracked: 0 });
+  });
+
   it("parse untracked lines", async () => {
     const mockExecSync = vi.fn(() => "?  untracked1.txt\n?  untracked2.txt\n");
     await loadModule(mockExecSync);
@@ -78,12 +84,13 @@ describe("getGitStatus", () => {
     expect(result.untracked).toBe(2);
   });
 
-  it("parse branch summary (ahead/behind)", async () => {
-    const mockExecSync = vi.fn(() => "## main...origin/main 3 2\n");
+  it("parse branch headers (ahead/behind)", async () => {
+    const mockExecSync = vi.fn((_cmd: string) =>
+      "# branch.oid abc123\n# branch.head main\n# branch.upstream origin/main\n# branch.ab +3 -2\n");
     await loadModule(mockExecSync);
     const result = getGitStatus();
-    expect(result.ahead).toBe(3);
-    expect(result.behind).toBe(2);
+    expect(mockExecSync.mock.calls[0]![0]).toContain("--branch"); // headers only print with --branch
+    expect(result).toEqual({ staged: 0, unstaged: 0, untracked: 0, ahead: 3, behind: 2 });
   });
 
   it("malformed lines ignored gracefully", async () => {

package/src/utils/git.ts

@@ -10,7 +10,10 @@ export interface GitStatus {
 }
 
 const STAGED_INDEX_STATES = ["A", "M", "D", "R", "C", "U", "T"] as const;
-const UNSTAGED_WORKTREE_STATES = ["M", "D", "U"] as const;
+// "A" = intent-to-add (`git add -N`); jj marks every new file this way in colocated repos
+const UNSTAGED_WORKTREE_STATES = ["M", "D", "U", "A"] as const;
+
+const GIT_STATUS_CMD = "git status --porcelain=v2 --branch -uall";
 
 // Cache TTL: 2 seconds — git status doesn't change on every render
 const GIT_CACHE_TTL_MS = 2_000;
@@ -53,16 +56,12 @@ function parseGitOutput(output: string): GitStatus {
   const status: GitStatus = { staged: 0, unstaged: 0, untracked: 0, ahead: 0, behind: 0 };
 
   for (const line of output.trim().split("\n")) {
-    // Branch summary: "## branch_name ... upstream ahead behind"
-    if (/^## /.test(line)) {
-      const branchParts = line.slice(3).trim().split(/\s+/);
-      if (branchParts.length >= 3) {
-        const commitsAhead = Number(branchParts[branchParts.length - 2]);
-        const commitsBehind = Number(branchParts[branchParts.length - 1]);
-        if (!isNaN(commitsAhead) && !isNaN(commitsBehind) && branchParts[branchParts.length - 3]) {
-          status.ahead = Math.max(0, commitsAhead);
-          status.behind = Math.max(0, commitsBehind);
-        }
+    // Branch headers: "# branch.ab +<ahead> -<behind>" (only when an upstream is set)
+    if (line.startsWith("# ")) {
+      const ab = line.match(/^# branch\.ab \+(\d+) -(\d+)/);
+      if (ab) {
+        status.ahead = Number(ab[1]);
+        status.behind = Number(ab[2]);
       }
       continue;
     }
@@ -88,7 +87,7 @@ function scheduleGitRefresh(): void {
   gitRefreshTimer = setTimeout(() => {
     gitRefreshTimer = undefined;
     try {
-      const output = execSync("git status --porcelain=v2 -uall", {
+      const output = execSync(GIT_STATUS_CMD, {
         cwd: process.cwd(),
         encoding: "utf8",
         stdio: ["pipe", "pipe", "pipe"],
@@ -116,7 +115,7 @@ export function getGitStatus(): GitStatus {
   // First call — sync fetch + schedule background refresh
   const emptyStatus: GitStatus = { staged: 0, unstaged: 0, untracked: 0, ahead: 0, behind: 0 };
   try {
-    const output = execSync("git status --porcelain=v2 -uall", {
+    const output = execSync(GIT_STATUS_CMD, {
       cwd: process.cwd(),
       encoding: "utf8",
       stdio: ["pipe", "pipe", "pipe"],

package/src/utils/jj.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect, vi } from "vitest";
+import { resolve } from "path";
+
+// `paths` = repo markers that exist, relative to cwd. Default: colocated jj repo.
+async function load({ paths = [".jj", ".git"], output = "main\n", throws = false } = {}) {
+  vi.resetModules();
+  const existing = new Set(paths.map((p) => resolve(process.cwd(), p)));
+  const execFileSync = vi.fn((_cmd: string, _args: string[]) => {
+    if (throws) throw new Error("ENOENT");
+    return output;
+  });
+  const execFile = vi.fn();
+  vi.doMock("child_process", () => ({ execFileSync, execFile }));
+  vi.doMock("fs", () => ({ existsSync: (p: string) => existing.has(p) }));
+  const { getJjBookmark } = await import("./jj.js");
+  return { getJjBookmark, execFileSync, execFile, existing };
+}
+
+describe("getJjBookmark", () => {
+  it.each([
+    { name: "plain git repo", paths: [".git"], expected: null },
+    { name: "git repo nested in a jj tree", paths: [".git", "../.jj"], expected: null },
+    { name: "colocated jj repo", paths: [".jj", ".git"], expected: "main" },
+    { name: "subdirectory of a jj repo", paths: ["../.jj"], expected: "main" },
+  ])("detects $name", async ({ paths, expected }) => {
+    const { getJjBookmark, execFileSync } = await load({ paths });
+    expect(getJjBookmark()).toBe(expected);
+    if (!expected) expect(execFileSync).not.toHaveBeenCalled(); // git-only users never spawn jj
+  });
+
+  it.each([
+    { output: "@mooqvmmx\nmain\nother\n", expected: "main" }, // first bookmark line beats @
+    { output: "feature-x\n", expected: "feature-x" }, // @ itself bookmarked
+    { output: "main release v2\n", expected: "main +2" }, // capped for layout width
+    { output: "@mooqvmmx\n", expected: "mooqvmmx" }, // no bookmark → change id
+  ])("parses $output", async ({ output, expected }) => {
+    const { getJjBookmark } = await load({ output });
+    expect(getJjBookmark()).toBe(expected);
+  });
+
+  it("returns null when jj fails", async () => {
+    const { getJjBookmark } = await load({ throws: true });
+    expect(getJjBookmark()).toBeNull();
+  });
+
+  it("caches, refreshes in the background, and notices a late `jj git init`", async () => {
+    const { getJjBookmark, execFileSync, execFile, existing } = await load({ paths: [".git"] });
+    const now = vi.spyOn(Date, "now").mockReturnValue(1_000);
+    expect(getJjBookmark()).toBeNull();
+
+    existing.add(resolve(process.cwd(), ".jj")); // negative detection expires
+    now.mockReturnValue(5_000);
+    expect(getJjBookmark()).toBe("main");
+    expect(getJjBookmark()).toBe("main"); // within TTL: no second spawn
+    expect(execFileSync).toHaveBeenCalledTimes(1);
+    expect(execFileSync.mock.calls[0]![1]).toContain("--ignore-working-copy"); // never snapshot from a render
+
+    type Done = (e: Error | null, out: string) => void;
+    now.mockReturnValue(10_000);
+    expect(getJjBookmark()).toBe("main"); // stale while refreshing
+    (execFile.mock.calls[0]![3] as Done)(new Error("lock timeout"), "");
+    expect(getJjBookmark()).toBe("main"); // failed refresh keeps stale value
+
+    now.mockReturnValue(15_000);
+    getJjBookmark();
+    (execFile.mock.calls[1]![3] as Done)(null, "feature-x\n");
+    expect(getJjBookmark()).toBe("feature-x");
+    now.mockRestore();
+  });
+});

package/src/utils/jj.ts

@@ -0,0 +1,93 @@
+import { execFile, execFileSync } from "child_process";
+import { existsSync } from "fs";
+import { dirname, join } from "path";
+
+// Same TTL as git status: bookmarks (and repo markers) don't change on every render
+const JJ_CACHE_TTL_MS = 2_000;
+
+// Nearest bookmarked commit at or below @, plus @ itself as a change-id fallback.
+// --ignore-working-copy: never snapshot (no op-log writes, no repo lock) from a render.
+const JJ_ARGS = [
+  "log",
+  "-r", "heads(::@ & bookmarks()) | @",
+  "--no-graph",
+  "--ignore-working-copy",
+  "--color", "never",
+  "-T", 'if(local_bookmarks, local_bookmarks.map(|b| b.name()).join(" "), "@" ++ change_id.shortest(8)) ++ "\\n"',
+];
+
+let jjRepoCache: { cwd: string; isJj: boolean; timestamp: number } | undefined;
+let bookmarkCache: { cwd: string; value: string | null; timestamp: number } | undefined;
+let refreshInFlight = false;
+
+function isJjRepo(cwd: string): boolean {
+  // Expires so a mid-session `jj git init` (or a removed .jj) is picked up
+  if (jjRepoCache?.cwd === cwd && Date.now() - jjRepoCache.timestamp < JJ_CACHE_TTL_MS) return jjRepoCache.isJj;
+  let dir = cwd;
+  let isJj = false;
+  while (true) {
+    // Stop at the nearest repo root of either kind: a git repo nested in a jj
+    // tree must keep showing its own git branch (colocated has both here).
+    isJj = existsSync(join(dir, ".jj"));
+    if (isJj || existsSync(join(dir, ".git"))) break;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  jjRepoCache = { cwd, isJj, timestamp: Date.now() };
+  return isJj;
+}
+
+/**
+ * First bookmark line wins; otherwise the `@<change-id>` line without its marker.
+ * Several bookmarks on one commit collapse to `first +N` — footer chunks are
+ * atomic, so an unbounded list could push other sections onto their own lines.
+ */
+function parseJjOutput(output: string): string | null {
+  const lines = output.split("\n").filter(Boolean);
+  const bookmarks = lines.find((l) => !l.startsWith("@"));
+  if (!bookmarks) return lines[0]?.slice(1) || null;
+  // Space-joined by the template: git ref names can't contain spaces
+  const [first, ...rest] = bookmarks.split(" ");
+  return rest.length ? `${first} +${rest.length}` : first!;
+}
+
+function refreshInBackground(cwd: string): void {
+  if (refreshInFlight) return;
+  refreshInFlight = true;
+  execFile("jj", JJ_ARGS, { cwd, encoding: "utf8", timeout: 2_000 }, (error, stdout) => {
+    refreshInFlight = false;
+    if (bookmarkCache?.cwd !== cwd) return; // cwd moved on; don't clobber the new entry
+    // On failure keep the stale value (transient lock/timeout shouldn't flash "detached")
+    bookmarkCache = { cwd, value: error ? bookmarkCache.value : parseJjOutput(stdout), timestamp: Date.now() };
+  });
+}
+
+/**
+ * Current jj bookmark for the footer branch section, or null when cwd isn't in
+ * a jj repo or jj can't be run (caller falls back to pi's git branch).
+ */
+export function getJjBookmark(): string | null {
+  const cwd = process.cwd();
+  if (!isJjRepo(cwd)) return null;
+
+  if (bookmarkCache?.cwd === cwd) {
+    if (Date.now() - bookmarkCache.timestamp >= JJ_CACHE_TTL_MS) refreshInBackground(cwd);
+    return bookmarkCache.value;
+  }
+
+  let value: string | null = null;
+  try {
+    const output = execFileSync("jj", JJ_ARGS, {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 2_000,
+    });
+    value = parseJjOutput(output);
+  } catch {
+    /* jj missing or failed */
+  }
+  bookmarkCache = { cwd, value, timestamp: Date.now() };
+  return value;
+}