@pi-archimedes/footer 2.7.2 → 2.8.0

package/package.json

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

package/src/index.ts

@@ -1,11 +1,13 @@
 /**
- * dir | branch [+status] | worktree | model | ◕thinking | ↑↓R W $cost ━ context%
+ * dir | branch [+status] | worktree | model | ◕thinking · ⚠ext-status | ↑↓R W $cost ━ context%
  *
  * Adaptive layout — wraps to additional lines instead of truncating:
  * - fits width → single line (system info · stats · context bar)
  * - doesn't fit → two lines (system info above, stats + bar below)
  * - left sections alone overflow → three or more lines
  * - below splitThreshold (default 150) → at least two lines, as configured
+ * - oversized extension statuses are word-wrapped into multiple chunks so no
+ *   content is ever truncated by clampLine
  */
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
@@ -15,7 +17,7 @@ import { loadFooterConfig } from "./config.js";
 import { CostAccumulator } from "./cost-accumulator.js";
 import { getGitStatus, isInsideLinkedWorktree } from "./utils/git.js";
 import { getContextWindowInfo, getTokenUsageStats, type TokenUsageStats } from "./utils/stats.js";
-import { formatContextBar, formatGitStatusIndicators, formatThinkingIndicator, formatTokenCount } from "./utils/format.js";
+import { formatContextBar, formatGitStatusIndicators, formatThinkingIndicator, formatTokenCount, wrapStatusToChunks } from "./utils/format.js";
 import { footerIcons } from "./utils/icons.js";
 import { packFooterLines, SEP_W, SEPARATOR } from "./utils/layout.js";
 
@@ -76,12 +78,18 @@ export function registerFooter(pi: ExtensionAPI): void {
 
             const branchIcon = inWorktree ? footerIcons.worktree : footerIcons.branch;
 
-            // System info sections: dir | branch [+status] | model | thinking
+            // Extension status texts (pi setStatus) — may contain ANSI; oversized statuses wrap
+            const extensionStatusChunks = [...footerData.getExtensionStatuses().values()]
+              .filter(Boolean)
+              .flatMap((s) => wrapStatusToChunks(s, width));
+
+            // System info sections: dir | branch [+status] | model | thinking | ext-statuses
             const leftSections = [
               colorize("syntaxFunction", " " + footerIcons.directory + currentDirectory),
               currentBranch ? colorize("success", branchIcon + " " + currentBranch + (gitStatusStr ? " " + gitStatusStr : "")) : "",
               colorize("syntaxType", footerIcons.model + " " + activeModel),
               thinkingIndicatorStr,
+              ...extensionStatusChunks,
             ].filter(Boolean);
 
             // Usage stats: ↑in ↓out RcacheRead WcacheWrite $cost contextWindow

package/src/utils/format.test.ts

@@ -1,10 +1,12 @@
 import { describe, it, expect } from "vitest";
 import { visibleWidth } from "@earendil-works/pi-tui";
+import { stripAnsi } from "@pi-archimedes/core/text";
 import {
   formatTokenCount,
   formatContextBar,
   formatGitStatusIndicators,
   formatThinkingIndicator,
+  wrapStatusToChunks,
 } from "./format.js";
 import { thinkingLevelColors, thinkingLevelIcons, type ColorFn } from "./icons.js";
 
@@ -161,3 +163,55 @@ describe("formatThinkingIndicator", () => {
     expect(formatThinkingIndicator("unknown", mockColor)).toBe("◑ unknown");
   });
 });
+
+// ── wrapStatusToChunks ──────────────────────────────────────────────────────
+
+describe("wrapStatusToChunks", () => {
+  it("short status fits → returned unchanged (including ANSI)", () => {
+    const status = "\u001b[33m⚠ token invalid\u001b[0m";
+    const chunks = wrapStatusToChunks(status, 80);
+    expect(chunks).toEqual([status]);
+  });
+
+  it("empty status → [status]", () => {
+    expect(wrapStatusToChunks("", 80)).toEqual([""]);
+    expect(wrapStatusToChunks("   ", 80)).toEqual(["   "]);
+  });
+
+  it("oversized status wraps: no content loss, every chunk ≤ width", () => {
+    const colored = "\u001b[33m⚠\u001b[0m";
+    // Build a ~40-word status with an ANSI-colored prefix
+    const words = Array.from({ length: 40 }, (_, i) => `word${i}`);
+    const status = colored + " " + words.join(" ");
+    const width = 40;
+    const chunks = wrapStatusToChunks(status, width);
+    // Every chunk must fit in width
+    expect(chunks.every((c) => visibleWidth(c) <= width)).toBe(true);
+    // No content loss — normalise whitespace in stripped versions
+    const joined = chunks.map(stripAnsi).join(" ").replace(/\s+/g, " ").trim();
+    const original = stripAnsi(status).replace(/\s+/g, " ").trim();
+    expect(joined).toBe(original);
+  });
+
+  it("oversized single word (URL) splits without loss", () => {
+    const url = "https://" + "a".repeat(192);
+    const width = 30;
+    const chunks = wrapStatusToChunks(url, width);
+    // Concat of stripped chunks equals stripped original
+    expect(chunks.map(stripAnsi).join("")).toBe(stripAnsi(url));
+    // Every chunk fits
+    expect(chunks.every((c) => visibleWidth(c) <= width)).toBe(true);
+  });
+
+  it("word-wider-than-width preserves ANSI — concatenated raw string equals input", () => {
+    const longWord = "\u001b[31m" + "Z".repeat(60) + "\u001b[0m";
+    const width = 20;
+    const chunks = wrapStatusToChunks(longWord, width);
+    // Some chunk must contain the opening escape
+    expect(chunks.some((c) => c.includes("\u001b[31m"))).toBe(true);
+    // Concatenation of raw chunks (no spaces) equals the input
+    expect(chunks.join("")).toBe(longWord);
+    // No chunk exceeds width
+    expect(chunks.every((c) => visibleWidth(c) <= width)).toBe(true);
+  });
+});

package/src/utils/format.ts

@@ -1,3 +1,4 @@
+import { visibleWidth } from "@earendil-works/pi-tui";
 import { footerIcons, gitDisplayIcons, gitStatusColors, thinkingLevelColors, thinkingLevelIcons, type ColorFn } from "./icons.js";
 
 // Token counts use binary units (1K = 1024)
@@ -52,3 +53,126 @@ export function formatGitStatusIndicators(
 export function formatThinkingIndicator(thinkingLevel: string, colorize: ColorFn): string {
   return colorize(thinkingLevelColors[thinkingLevel] || "dim", `${thinkingLevelIcons[thinkingLevel] || "◑"} ${thinkingLevel}`);
 }
+
+/**
+ * Wrap an extension status into chunks that fit the terminal.
+ * - fits (visibleWidth ≤ width) → [status] (unchanged, including ANSI)
+ * - oversized → greedy word-wrap: whole words packed per chunk; a single word
+ *   wider than `width` is split at character level on the raw string (ANSI
+ *   sequences stay attached to the chars they prefix because we split on plain
+ *   whitespace only — never mid-escape).
+ * No content is ever dropped; every returned chunk has visibleWidth ≤ width.
+ */
+export function wrapStatusToChunks(status: string, width: number): string[] {
+  // Edge cases: empty/whitespace or non-positive width → return as-is
+  if (width <= 0 || !status.trim()) return [status];
+  // Already fits → return unchanged (preserves ANSI)
+  if (visibleWidth(status) <= width) return [status];
+
+  // Split on whitespace boundaries only — never inside ANSI escapes
+  // (ANSI escapes contain no plain whitespace, so splitting on /\s+/ is safe)
+  const words = status.split(/(\s+)/);
+  // words alternates: [word, sep, word, sep, ...]
+  // We reassemble non-sep tokens and carry sep tokens to preserve spacing context
+  // Simpler: collect [token, isSep] pairs
+  const tokens: Array<{ text: string; isSep: boolean }> = [];
+  for (const w of words) {
+    if (w === "") continue;
+    tokens.push({ text: w, isSep: /^\s+$/.test(w) });
+  }
+
+  const chunks: string[] = [];
+  let current = "";
+  let currentW = 0;
+
+  /**
+   * Split a single word (no whitespace) that is wider than `width` into
+   * sub-chunks of at most `width` visible columns, character by character.
+   * ANSI escapes are kept intact (we only split printable characters;
+   * the regex /\x1b\[[^m]*m/ never contains whitespace, so they were
+   * never split by the outer word-split, and here we advance char by char
+   * through the raw string, which keeps escape bytes together with their
+   * surrounding characters as long as we don't split inside an escape).
+   *
+   * Implementation: iterate character-by-character through the raw string,
+   * accumulating into a sub-chunk until adding the next char would exceed width.
+   */
+  function splitWideWord(word: string): string[] {
+    const result: string[] = [];
+    let sub = "";
+    let subW = 0;
+    let i = 0;
+    while (i < word.length) {
+      // Detect ANSI escape sequence starting at i (\x1b[...m)
+      // An escape contributes 0 visible width, so we append it whole.
+      if (word[i] === "\x1b") {
+        const end = word.indexOf("m", i + 1);
+        if (end !== -1) {
+          sub += word.slice(i, end + 1);
+          i = end + 1;
+          continue;
+        }
+      }
+      // Regular character (may be multi-byte Unicode)
+      const char = word[i]!;
+      const charW = visibleWidth(char);
+      if (subW + charW > width && sub !== "") {
+        result.push(sub);
+        sub = char;
+        subW = charW;
+      } else {
+        sub += char;
+        subW += charW;
+      }
+      i++;
+    }
+    if (sub !== "") result.push(sub);
+    return result.length > 0 ? result : [word];
+  }
+
+  function flushCurrent() {
+    if (current !== "") {
+      chunks.push(current);
+      current = "";
+      currentW = 0;
+    }
+  }
+
+  for (const token of tokens) {
+    if (token.isSep) {
+      // Separator — skip (we rebuild spacing implicitly via chunks)
+      continue;
+    }
+    const word = token.text;
+    const wordW = visibleWidth(word);
+
+    if (wordW > width) {
+      // Word is wider than the entire terminal — flush then char-split it
+      flushCurrent();
+      const subChunks = splitWideWord(word);
+      for (let j = 0; j < subChunks.length - 1; j++) {
+        chunks.push(subChunks[j]!);
+      }
+      // Last sub-chunk becomes the start of the next current
+      const last = subChunks[subChunks.length - 1]!;
+      current = last;
+      currentW = visibleWidth(last);
+    } else if (currentW === 0) {
+      // Starting a new chunk
+      current = word;
+      currentW = wordW;
+    } else if (currentW + 1 + wordW <= width) {
+      // Append with a single space
+      current += " " + word;
+      currentW += 1 + wordW;
+    } else {
+      // Doesn't fit — flush and start new chunk
+      flushCurrent();
+      current = word;
+      currentW = wordW;
+    }
+  }
+  flushCurrent();
+
+  return chunks.length > 0 ? chunks : [status];
+}

package/src/utils/render-smoke.test.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect } from "vitest";
 import { stripAnsi } from "@pi-archimedes/core/text";
 import { packFooterLines, SEP_W, SEPARATOR } from "./layout.js";
-import { formatContextBar } from "./format.js";
+import { formatContextBar, wrapStatusToChunks } from "./format.js";
 import { visibleWidth } from "@earendil-works/pi-tui";
 
 // Minimal stand-ins: same visible chars as the real footer, no ANSI
@@ -14,13 +14,14 @@ const MODEL = "🧠 claude-sonnet-4-6";
 const THINKING = "◕ high"; // current format for the 'high' level
 const STATS = "↑141 ↓42k R8.7M W220k $4.25 116k/977k";
 
-function buildLines(width: number, pct: number, splitThreshold = 150) {
+function buildLines(width: number, pct: number, splitThreshold = 150, extraSections: string[] = []) {
   const leftSections = [
     DIR,
     BRANCH,
     WORKTREE,
     MODEL,
     THINKING,
+    ...extraSections,
   ].filter(Boolean);
   let groups = packFooterLines([...leftSections, STATS], width, SEP_W);
   if (groups.length < 2 && width < splitThreshold && leftSections.length > 0) {
@@ -84,4 +85,35 @@ describe("render glue simulation", () => {
     // No line exceeds 40 visible columns
     expect(lines.every((l) => visibleWidth(stripAnsi(l)) <= 40)).toBe(true);
   });
+
+  it("extension status chunk wraps without truncation on the user's terminal", () => {
+    const STATUS = "⚠ litellm token invalid — re-auth required";
+    const lines = buildLines(158, 12, 150, [STATUS]);
+    const stripped = lines.map((l) => stripAnsi(l));
+    const all = stripped.join(" ");
+    // (a) status text is fully present across joined lines (no clipping)
+    expect(all).toContain(STATUS);
+    // (b) no line exceeds 158 visible columns
+    expect(lines.every((l) => visibleWidth(stripAnsi(l)) <= 158)).toBe(true);
+  });
+
+  it("oversized extension status wraps through the production path without truncation", () => {
+    const LONG =
+      "⚠ litellm token invalid — re-auth required: " +
+      "gcloud auth application-default login (see https://support.google.com/a/answer/9368756 for details) — check Settings → Auth for more context " +
+      "and verify your credentials are up-to-date before retrying the long operation that failed";
+    // Verify it is >158 visible chars
+    expect(visibleWidth(LONG)).toBeGreaterThan(158);
+    const chunks = wrapStatusToChunks(LONG, 158);
+    const lines = buildLines(158, 12, 150, chunks);
+    const stripped = lines.map((l) => stripAnsi(l));
+    // (a) every word of the original status appears in the joined lines
+    const allText = stripped.join(" ");
+    const words = stripAnsi(LONG).split(/\s+/).filter(Boolean);
+    for (const word of words) {
+      expect(allText).toContain(word);
+    }
+    // (b) every line ≤ 158 visible cols
+    expect(lines.every((l) => visibleWidth(stripAnsi(l)) <= 158)).toBe(true);
+  });
 });