@pi-archimedes/footer 2.9.2 → 2.10.0

package/README.md

@@ -43,6 +43,7 @@ Two honest caveats: the ledger reflects usage and pricing **as reported to the s
 | Setting | Type | Default | Description |
 |---------|------|---------|-------------|
 | `splitThreshold` | number | `150` | Minimum terminal columns for the single-line layout. Below it, the footer uses the structured multi-line layout; above it, it stays single-line and wraps only if content overflows. |
+| `branchMaxLength` | number | `0` | Max columns for the branch or jj bookmark name, truncated with `…`. `0` = unlimited. Git status indicators are never truncated. Applies on next session or `/reload`. |
 
 In the suite the setting also appears in `/archimedes` (when the panel has a control for it); `/reload` applies it. On/off is managed by the suite: toggle via `/plugins` (`archimedes.footer.enabled`, default on).
 

package/package.json

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

package/src/config.ts

@@ -3,10 +3,12 @@ import type { SettingItem } from "@earendil-works/pi-tui";
 
 export interface FooterConfig {
   splitThreshold: number;
+  branchMaxLength: number;
 }
 
 export const DEFAULT_FOOTER_CONFIG: FooterConfig = {
   splitThreshold: 150,
+  branchMaxLength: 0,
 };
 
 const NAMESPACE = "archimedes.footer";
@@ -27,5 +29,11 @@ export function getFooterSettingsItems(): SettingItem[] {
       description: "Terminal width threshold for two-line footer split",
       currentValue: String(loadFooterConfig().splitThreshold),
     },
+    {
+      id: "branchMaxLength",
+      label: "Branch Max Length",
+      description: "Max columns for the branch/bookmark name (0 = unlimited)",
+      currentValue: String(loadFooterConfig().branchMaxLength),
+    },
   ];
 }

package/src/index.ts

@@ -18,7 +18,7 @@ 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 { formatContextBar, formatGitStatusIndicators, formatThinkingIndicator, formatTokenCount, truncateBranch, wrapStatusToChunks } from "./utils/format.js";
 import { footerIcons } from "./utils/icons.js";
 import { packFooterLines, SEP_W, SEPARATOR } from "./utils/layout.js";
 
@@ -36,7 +36,7 @@ export function registerFooter(pi: ExtensionAPI): void {
   });
 
   pi.on("session_start", (_event, ctx: ExtensionContext) => {
-    const splitThreshold = loadFooterConfig().splitThreshold;
+    const { splitThreshold, branchMaxLength } = loadFooterConfig();
 
     // Create cost accumulator for subagent costs
     footerAccumulator = new CostAccumulator();
@@ -87,7 +87,7 @@ export function registerFooter(pi: ExtensionAPI): void {
             // System info sections: dir | branch [+status] | model | thinking | ext-statuses
             const leftSections = [
               colorize("syntaxFunction", " " + footerIcons.directory + currentDirectory),
-              currentBranch ? colorize("success", branchIcon + " " + currentBranch + (gitStatusStr ? " " + gitStatusStr : "")) : "",
+              currentBranch ? colorize("success", branchIcon + " " + truncateBranch(currentBranch, branchMaxLength) + (gitStatusStr ? " " + gitStatusStr : "")) : "",
               colorize("syntaxType", footerIcons.model + " " + activeModel),
               thinkingIndicatorStr,
               ...extensionStatusChunks,

package/src/utils/format.test.ts

@@ -6,6 +6,7 @@ import {
   formatContextBar,
   formatGitStatusIndicators,
   formatThinkingIndicator,
+  truncateBranch,
   wrapStatusToChunks,
 } from "./format.js";
 import { thinkingLevelColors, thinkingLevelIcons, type ColorFn } from "./icons.js";
@@ -14,6 +15,29 @@ import { thinkingLevelColors, thinkingLevelIcons, type ColorFn } from "./icons.j
 // Passthrough — we test structure, not actual coloring.
 const mockColor: ColorFn = (_token, text) => text;
 
+// ── truncateBranch ──────────────────────────────────────────────────────────
+
+describe("truncateBranch", () => {
+  it("returns the name unchanged when max is 0 (unlimited)", () => {
+    const name = "feature/a-very-long-branch-name";
+    expect(truncateBranch(name, 0)).toBe(name);
+  });
+
+  it("returns the name unchanged when it is shorter than max", () => {
+    expect(truncateBranch("main", 10)).toBe("main");
+  });
+
+  it.each([
+    ["feature/a-very-long-branch-name", 10],
+    ["feature/x", 1], // smallest limit: ellipsis only
+    ["機能ブランチ名前", 5], // wide chars: odd limit can't split a 2-column char
+  ])("truncates %s to %i columns ending with an ellipsis", (name, max) => {
+    const result = truncateBranch(name, max);
+    expect(visibleWidth(result)).toBeLessThanOrEqual(max);
+    expect(stripAnsi(result).endsWith("…")).toBe(true);
+  });
+});
+
 // ── formatTokenCount ────────────────────────────────────────────────────────
 
 describe("formatTokenCount", () => {

package/src/utils/format.ts

@@ -1,4 +1,4 @@
-import { visibleWidth } from "@earendil-works/pi-tui";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { footerIcons, gitDisplayIcons, gitStatusColors, thinkingLevelColors, thinkingLevelIcons, type ColorFn } from "./icons.js";
 
 // Token counts use binary units (1K = 1024)
@@ -50,6 +50,10 @@ export function formatGitStatusIndicators(
   return statusParts.join("");
 }
 
+export function truncateBranch(name: string, max: number): string {
+  return max > 0 ? truncateToWidth(name, max, "…") : name;
+}
+
 export function formatThinkingIndicator(thinkingLevel: string, colorize: ColorFn): string {
   return colorize(thinkingLevelColors[thinkingLevel] || "dim", `${thinkingLevelIcons[thinkingLevel] || "◑"} ${thinkingLevel}`);
 }

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 {