@pi-archimedes/footer 2.9.1 → 2.9.2

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.2",
   "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.2"
   },
   "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/jj.test.ts

@@ -0,0 +1,98 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { resolve } from "path";
+
+describe("getJjBookmark", () => {
+  let getJjBookmark: () => string | null;
+  let execFileSync: ReturnType<typeof vi.fn>;
+  let execFile: ReturnType<typeof vi.fn>;
+  let existing: Set<string>;
+
+  // `paths` = repo markers that exist, relative to cwd. Default is a colocated jj repo.
+  async function load(opts: { paths?: string[]; output?: string; throws?: boolean } = {}) {
+    vi.resetModules();
+    execFileSync = vi.fn(() => {
+      if (opts.throws) throw new Error("ENOENT");
+      return opts.output ?? "";
+    });
+    execFile = vi.fn();
+    vi.doMock("child_process", () => ({ execFileSync, execFile }));
+    existing = new Set((opts.paths ?? [".jj", ".git"]).map((p) => resolve(process.cwd(), p)));
+    vi.doMock("fs", () => ({ existsSync: vi.fn((p: string) => existing.has(p)) }));
+    getJjBookmark = (await import("./jj.js")).getJjBookmark;
+  }
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("returns null without spawning jj outside a jj repo", async () => {
+    await load({ paths: [".git"] });
+    expect(getJjBookmark()).toBeNull();
+    expect(execFileSync).not.toHaveBeenCalled();
+  });
+
+  it("detects a jj repo initialised after a cached negative result", async () => {
+    await load({ paths: [".git"], output: "main\n" });
+    const now = vi.spyOn(Date, "now").mockReturnValue(1_000);
+    expect(getJjBookmark()).toBeNull();
+
+    existing.add(resolve(process.cwd(), ".jj")); // `jj git init --colocate`
+    now.mockReturnValue(5_000);
+    expect(getJjBookmark()).toBe("main");
+  });
+
+  it("leaves a git repo nested inside a jj tree to git", async () => {
+    await load({ paths: [".git", "../.jj"] });
+    expect(getJjBookmark()).toBeNull();
+    expect(execFileSync).not.toHaveBeenCalled();
+  });
+
+  it("finds a jj repo from a subdirectory", async () => {
+    await load({ paths: ["../.jj"], output: "main\n" });
+    expect(getJjBookmark()).toBe("main");
+  });
+
+  it("prefers the first bookmark line over the @ change-id line", async () => {
+    await load({ output: "@mooqvmmx\nmain\nother\n" });
+    expect(getJjBookmark()).toBe("main");
+  });
+
+  it("returns the bookmark when @ itself is bookmarked", async () => {
+    await load({ output: "feature-x\n" });
+    expect(getJjBookmark()).toBe("feature-x");
+  });
+
+  it("falls back to the change id when no ancestor is bookmarked", async () => {
+    await load({ output: "@mooqvmmx\n" });
+    expect(getJjBookmark()).toBe("mooqvmmx");
+  });
+
+  it("returns null when jj fails", async () => {
+    await load({ throws: true });
+    expect(getJjBookmark()).toBeNull();
+  });
+
+  it("serves the cache within the TTL and refreshes in the background after", async () => {
+    await load({ output: "main\n" });
+    const now = vi.spyOn(Date, "now").mockReturnValue(1_000);
+    expect(getJjBookmark()).toBe("main");
+    expect(getJjBookmark()).toBe("main");
+    expect(execFileSync).toHaveBeenCalledTimes(1);
+    // Never snapshot the working copy from a render (op-log writes, repo lock)
+    expect(execFileSync.mock.calls[0]![1]).toContain("--ignore-working-copy");
+    expect(execFile).not.toHaveBeenCalled();
+
+    now.mockReturnValue(5_000);
+    expect(getJjBookmark()).toBe("main"); // stale value while refreshing
+    expect(execFile).toHaveBeenCalledTimes(1);
+
+    const done = execFile.mock.calls[0]![3] as (e: Error | null, out: string) => void;
+    done(new Error("lock timeout"), "");
+    expect(getJjBookmark()).toBe("main"); // failed refresh keeps stale value
+
+    now.mockReturnValue(10_000);
+    getJjBookmark();
+    (execFile.mock.calls[1]![3] as typeof done)(null, "feature-x\n");
+    expect(getJjBookmark()).toBe("feature-x");
+  });
+});

package/src/utils/jj.ts

@@ -0,0 +1,85 @@
+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. */
+function parseJjOutput(output: string): string | null {
+  const lines = output.split("\n").filter(Boolean);
+  return lines.find((l) => !l.startsWith("@")) ?? (lines[0]?.slice(1) || null);
+}
+
+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;
+}