@pi-archimedes/footer 2.9.2 → 2.9.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-archimedes/footer",
-  "version": "2.9.2",
+  "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.2"
+    "@pi-archimedes/core": "2.9.3"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": ">=0.1.0",

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

@@ -1,98 +1,70 @@
-import { describe, it, expect, vi, afterEach } from "vitest";
+import { describe, it, expect, vi } 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();
+// `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 };
+}
 
-  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");
+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("falls back to the change id when no ancestor is bookmarked", async () => {
-    await load({ output: "@mooqvmmx\n" });
-    expect(getJjBookmark()).toBe("mooqvmmx");
+  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 () => {
-    await load({ throws: true });
+    const { getJjBookmark } = 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" });
+  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()).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();
+    expect(getJjBookmark()).toBeNull();
 
+    existing.add(resolve(process.cwd(), ".jj")); // negative detection expires
     now.mockReturnValue(5_000);
-    expect(getJjBookmark()).toBe("main"); // stale value while refreshing
-    expect(execFile).toHaveBeenCalledTimes(1);
+    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
 
-    const done = execFile.mock.calls[0]![3] as (e: Error | null, out: string) => void;
-    done(new Error("lock timeout"), "");
+    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(10_000);
+    now.mockReturnValue(15_000);
     getJjBookmark();
-    (execFile.mock.calls[1]![3] as typeof done)(null, "feature-x\n");
+    (execFile.mock.calls[1]![3] as Done)(null, "feature-x\n");
     expect(getJjBookmark()).toBe("feature-x");
+    now.mockRestore();
   });
 });

package/src/utils/jj.ts

@@ -13,7 +13,7 @@ const JJ_ARGS = [
   "--no-graph",
   "--ignore-working-copy",
   "--color", "never",
-  "-T", 'if(local_bookmarks, local_bookmarks.map(|b| b.name()).join(","), "@" ++ change_id.shortest(8)) ++ "\\n"',
+  "-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;
@@ -38,10 +38,18 @@ function isJjRepo(cwd: string): boolean {
   return isJj;
 }
 
-/** First bookmark line wins; otherwise the `@<change-id>` line without its marker. */
+/**
+ * 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);
-  return lines.find((l) => !l.startsWith("@")) ?? (lines[0]?.slice(1) || null);
+  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 {