@pi-archimedes/footer 0.3.2 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-archimedes/footer",
-  "version": "0.3.2",
+  "version": "0.5.0",
   "type": "module",
   "keywords": [
     "pi-package"
@@ -15,7 +15,7 @@
     "./config": "./src/config.ts"
   },
   "dependencies": {
-    "@pi-archimedes/core": "0.3.2"
+    "@pi-archimedes/core": "0.5.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": ">=0.1.0",

package/src/index.ts

@@ -16,13 +16,24 @@ import { formatContextBar, formatGitStatusIndicators, formatThinkingIndicator, f
 import { footerIcons } from "./utils/icons.js";
 
 export function registerFooter(pi: ExtensionAPI): void {
+  // Module-level state for session lifecycle (shared between session_start and session_shutdown)
+  let footerAccumulator: CostAccumulator | undefined;
+
+  // session_shutdown handler (top-level to prevent accumulation on /reload)
+  pi.on("session_shutdown", (_event, _ctx) => {
+    if (footerAccumulator) {
+      footerAccumulator.dispose();
+      footerAccumulator.reset();
+      footerAccumulator = undefined;
+    }
+  });
 
   pi.on("session_start", (_event, ctx: ExtensionContext) => {
     const splitThreshold = loadFooterConfig().splitThreshold;
 
     // Create cost accumulator for subagent costs
-    const accumulator = new CostAccumulator();
-    accumulator.subscribe();
+    footerAccumulator = new CostAccumulator();
+    footerAccumulator.subscribe();
 
     ctx.ui.setFooter((tui, theme, footerData) => {
       const unsubscribe = footerData.onBranchChange(() => tui.requestRender());
@@ -42,12 +53,13 @@ export function registerFooter(pi: ExtensionAPI): void {
 
             // Merge main agent stats with subagent stats from accumulator
             const mainStats = getTokenUsageStats(ctx);
+            const acc = footerAccumulator;
             const mergedStats: TokenUsageStats = {
-              totalInput: mainStats.totalInput + accumulator.inputTokens,
-              totalOutput: mainStats.totalOutput + accumulator.outputTokens,
-              totalCacheRead: mainStats.totalCacheRead + accumulator.cacheReadTokens,
-              totalCacheWrite: mainStats.totalCacheWrite + accumulator.cacheWriteTokens,
-              totalCost: mainStats.totalCost + accumulator.cost,
+              totalInput: mainStats.totalInput + (acc?.inputTokens ?? 0),
+              totalOutput: mainStats.totalOutput + (acc?.outputTokens ?? 0),
+              totalCacheRead: mainStats.totalCacheRead + (acc?.cacheReadTokens ?? 0),
+              totalCacheWrite: mainStats.totalCacheWrite + (acc?.cacheWriteTokens ?? 0),
+              totalCost: mainStats.totalCost + (acc?.cost ?? 0),
             };
 
             const { totalInput, totalOutput, totalCacheRead, totalCacheWrite, totalCost } = mergedStats;
@@ -152,11 +164,6 @@ export function registerFooter(pi: ExtensionAPI): void {
         },
       };
     });
-
-    pi.on("session_shutdown", (_event, _ctx) => {
-      accumulator.dispose();
-      accumulator.reset();
-    });
   });
 }
 

package/src/utils/format.ts

@@ -1,14 +1,15 @@
 import { footerIcons, gitDisplayIcons, gitStatusColors, thinkingLevelColors, type ColorFn } from "./icons.js";
 
+// Token counts use SI units (1K = 1000), not binary (1024)
+const TOKEN_K = 1_000;
+const TOKEN_M = 1_000_000;
+
 export function formatTokenCount(count: number): string {
-  const K = 1024;
-  const M = 1048576; // 1024 * 1024
-
-  if (count < K) return count.toString();
-  if (count < K * 10) return (count / K).toFixed(1) + "k";
-  if (count < M) return Math.round(count / K) + "k";
-  if (count < M * 10) return (count / M).toFixed(1) + "M";
-  return Math.round(count / M) + "M";
+  if (count < TOKEN_K) return count.toString();
+  if (count < TOKEN_K * 10) return (count / TOKEN_K).toFixed(1) + "k";
+  if (count < TOKEN_M) return Math.round(count / TOKEN_K) + "k";
+  if (count < TOKEN_M * 10) return (count / TOKEN_M).toFixed(1) + "M";
+  return Math.round(count / TOKEN_M) + "M";
 }
 
 export function formatContextBar(colorize: ColorFn, percentValue: number, availableSpace: number): string {

package/src/utils/git.ts

@@ -12,6 +12,22 @@ 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;
 
+// Cache TTL: 1 second — git status doesn't change on every render
+const GIT_CACHE_TTL_MS = 1_000;
+
+interface GitCacheEntry {
+  value: GitStatus;
+  timestamp: number;
+}
+
+interface WorktreeCacheEntry {
+  value: string | null;
+  timestamp: number;
+}
+
+let gitStatusCache: GitCacheEntry | undefined;
+let worktreeCache: WorktreeCacheEntry | undefined;
+
 interface FileStates {
   indexField: string;
   workTreeField: string;
@@ -20,19 +36,24 @@ interface FileStates {
 function parseGitStatusLine(line: string): FileStates | null {
   // Scored format: "<score> XY..."
   const scoredMatch = line.match(/^\d+ (..) /);
-  if (scoredMatch) return { indexField: scoredMatch[1][0], workTreeField: scoredMatch[1][1] };
+  if (scoredMatch) return { indexField: scoredMatch[1]![0]!, workTreeField: scoredMatch[1]![1]! };
 
   // Unscored format: "XY..."
   const noScoreMatch = line.match(/^(..) /);
-  if (noScoreMatch) return { indexField: noScoreMatch[1][0], workTreeField: noScoreMatch[1][1] };
+  if (noScoreMatch) return { indexField: noScoreMatch[1]![0]!, workTreeField: noScoreMatch[1]![1]! };
 
   // Untracked format: "? ..."
   const untrackedMatch = line.match(/^(.) (.)/);
   if (!untrackedMatch) return null;
-  return { indexField: untrackedMatch[1], workTreeField: untrackedMatch[2] };
+  return { indexField: untrackedMatch[1]!, workTreeField: untrackedMatch[2]! };
 }
 
 export function getGitStatus(): GitStatus {
+  // Return cached result if still fresh
+  if (gitStatusCache && Date.now() - gitStatusCache.timestamp < GIT_CACHE_TTL_MS) {
+    return gitStatusCache.value;
+  }
+
   const status: GitStatus = { staged: 0, unstaged: 0, untracked: 0, ahead: 0, behind: 0 };
 
   try {
@@ -40,6 +61,7 @@ export function getGitStatus(): GitStatus {
       cwd: process.cwd(),
       encoding: "utf8",
       stdio: ["pipe", "pipe", "pipe"],
+      timeout: 2_000, // Kill hung git processes after 2s
     });
 
     for (const line of gitOutput.trim().split("\n")) {
@@ -73,21 +95,32 @@ export function getGitStatus(): GitStatus {
     /* not a git repo or command failed */
   }
 
+  gitStatusCache = { value: status, timestamp: Date.now() };
   return status;
 }
 
 export function getWorktreeBranch(): string | null {
+  // Return cached result if still fresh
+  if (worktreeCache && Date.now() - worktreeCache.timestamp < GIT_CACHE_TTL_MS) {
+    return worktreeCache.value;
+  }
+
   try {
     const worktreeOutput = execSync("git worktree list --porcelain", {
       cwd: process.cwd(),
       encoding: "utf8",
       stdio: ["pipe", "pipe", "pipe"],
+      timeout: 2_000,
     });
 
     const worktreeEntries = worktreeOutput.trim().split("\n\n").filter(Boolean);
-    if (worktreeEntries.length <= 1) return null;
+    if (worktreeEntries.length <= 1) {
+      worktreeCache = { value: null, timestamp: Date.now() };
+      return null;
+    }
 
     const currentDirectoryPath = realpathSync(process.cwd());
+    let result: string | null = null;
     for (const entry of worktreeEntries) {
       const entryLines = entry.split("\n");
       const pathLine = entryLines.find((l) => l.startsWith("worktree "));
@@ -95,12 +128,15 @@ export function getWorktreeBranch(): string | null {
       const worktreePath = pathLine?.replace("worktree ", "");
 
       if (worktreePath && (currentDirectoryPath === worktreePath || currentDirectoryPath.startsWith(worktreePath + "/"))) {
-        return branchLine?.replace("branch refs/heads/", "") ?? null;
+        result = branchLine?.replace("branch refs/heads/", "") ?? null;
+        break;
       }
     }
+    worktreeCache = { value: result, timestamp: Date.now() };
+    return result;
   } catch {
     /* not a git repo */
+    worktreeCache = { value: null, timestamp: Date.now() };
+    return null;
   }
-
-  return null;
 }

package/src/utils/stats.ts

@@ -20,14 +20,36 @@ export interface TokenUsageStats {
   totalCost: number;
 }
 
+// Cache TTL: 500ms — stats don't change more frequently than message_end events
+const STATS_CACHE_TTL_MS = 500;
+
+interface StatsCacheEntry {
+  value: TokenUsageStats;
+  timestamp: number;
+  entryCount: number;
+}
+
+let statsCache: StatsCacheEntry | undefined;
+
 export function getTokenUsageStats(ctx: ExtensionContext): TokenUsageStats {
+  const entries = ctx.sessionManager.getEntries();
+
+  // Return cached result if entry count hasn't changed and cache is fresh
+  if (
+    statsCache &&
+    statsCache.entryCount === entries.length &&
+    Date.now() - statsCache.timestamp < STATS_CACHE_TTL_MS
+  ) {
+    return statsCache.value;
+  }
+
   let totalInput = 0,
     totalOutput = 0,
     totalCacheRead = 0,
     totalCacheWrite = 0,
     totalCost = 0;
 
-  for (const sessionEntry of ctx.sessionManager.getEntries()) {
+  for (const sessionEntry of entries) {
     if (sessionEntry.type === "message" && sessionEntry.message.role === "assistant") {
       const assistantMessage = sessionEntry.message as AssistantMessage;
       totalInput += assistantMessage.usage.input;
@@ -38,7 +60,14 @@ export function getTokenUsageStats(ctx: ExtensionContext): TokenUsageStats {
     }
   }
 
-  return { totalInput, totalOutput, totalCacheRead, totalCacheWrite, totalCost };
+  const result: TokenUsageStats = { totalInput, totalOutput, totalCacheRead, totalCacheWrite, totalCost };
+  statsCache = { value: result, timestamp: Date.now(), entryCount: entries.length };
+  return result;
+}
+
+/** Clear the stats cache — call when a new message arrives. */
+export function invalidateStatsCache(): void {
+  statsCache = undefined;
 }
 
 export interface ContextWindowInfo {