@pi-archimedes/footer 0.6.0 → 0.8.0

package/package.json

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

package/src/config.ts

@@ -1,41 +1,22 @@
-import { readFileSync, writeFileSync, existsSync } from "node:fs";
-import { join } from "node:path";
-import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { loadConfig, saveConfig } from "@pi-archimedes/core/settings-io";
 import type { SettingItem } from "@earendil-works/pi-tui";
 
 export interface FooterConfig {
   splitThreshold: number;
 }
 
-const SETTINGS_PATH = join(getAgentDir(), "settings.json");
-
 export const DEFAULT_FOOTER_CONFIG: FooterConfig = {
   splitThreshold: 150,
 };
 
+const NAMESPACE = "archimedes.footer";
+
 export function loadFooterConfig(): FooterConfig {
-  if (existsSync(SETTINGS_PATH)) {
-    try {
-      const full = JSON.parse(readFileSync(SETTINGS_PATH, "utf-8"));
-      return { ...DEFAULT_FOOTER_CONFIG, ...(full["archimedes.footer"] ?? {}) };
-    } catch {
-      /* ignore corrupt file */
-    }
-  }
-  return DEFAULT_FOOTER_CONFIG;
+  return loadConfig(NAMESPACE, DEFAULT_FOOTER_CONFIG);
 }
 
 export function saveFooterConfig(config: FooterConfig): void {
-  let full: Record<string, unknown> = {};
-  if (existsSync(SETTINGS_PATH)) {
-    try {
-      full = JSON.parse(readFileSync(SETTINGS_PATH, "utf-8"));
-    } catch {
-      /* ignore corrupt file */
-    }
-  }
-  full["archimedes.footer"] = config;
-  writeFileSync(SETTINGS_PATH, JSON.stringify(full, null, 2), "utf-8");
+  saveConfig(NAMESPACE, config);
 }
 
 export function getFooterSettingsItems(): SettingItem[] {

package/src/index.ts

@@ -84,7 +84,7 @@ export function registerFooter(pi: ExtensionAPI): void {
               worktreeBranch ? colorize("syntaxNumber", footerIcons.worktree + " " + worktreeBranch) : "",
             ].filter(Boolean);
 
-            const separator = theme.fg("dim", " | ");
+            const separator = theme.fg("dim", " · ");
             const leftSectionStr = leftSections.join(separator);
 
             // Token stats with context percentage
@@ -124,7 +124,7 @@ export function registerFooter(pi: ExtensionAPI): void {
               const rightSections: string[] = [];
               if (statsSectionStr) rightSections.push(statsSectionStr);
               if (contextBarStr) rightSections.push(contextBarStr);
-              const rightSectionStr = rightSections.join(theme.fg("dim", " | "));
+              const rightSectionStr = rightSections.join(theme.fg("dim", " · "));
 
               // Edge case: if both stats and bar are empty, return only line 1
               if (!rightSectionStr) {
@@ -140,7 +140,7 @@ export function registerFooter(pi: ExtensionAPI): void {
             // ── Single-line mode ───────────────────────────────────────────────
 
             // Separator between left and right sections
-            const sectionSeparator = theme.fg("dim", " | ");
+            const sectionSeparator = theme.fg("dim", " · ");
 
             // Calculate available space for the context progress bar (after stats)
             const availableBarSpace = Math.max(
@@ -155,10 +155,11 @@ export function registerFooter(pi: ExtensionAPI): void {
             const rightSections: string[] = [];
             if (statsSectionStr) rightSections.push(statsSectionStr);
             if (contextBarStr) rightSections.push(contextBarStr);
-            const rightSectionStr = rightSections.join(theme.fg("dim", " | "));
+            const rightSectionStr = rightSections.join(theme.fg("dim", " · "));
 
             return [clampLine(leftSectionStr + sectionSeparator + rightSectionStr, width)];
           } catch (e) {
+            console.error("[archimedes:footer] Render error:", e);
             return [];
           }
         },

package/src/utils/git.ts

@@ -12,8 +12,8 @@ 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;
+// Cache TTL: 2 seconds — git status doesn't change on every render
+const GIT_CACHE_TTL_MS = 2_000;
 
 interface GitCacheEntry {
   value: GitStatus;
@@ -27,6 +27,7 @@ interface WorktreeCacheEntry {
 
 let gitStatusCache: GitCacheEntry | undefined;
 let worktreeCache: WorktreeCacheEntry | undefined;
+let gitRefreshTimer: ReturnType<typeof setTimeout> | undefined;
 
 interface FileStates {
   indexField: string;
@@ -48,55 +49,86 @@ function parseGitStatusLine(line: string): FileStates | null {
   return { indexField: untrackedMatch[1]!, workTreeField: untrackedMatch[2]! };
 }
 
+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);
+        }
+      }
+      continue;
+    }
+
+    const fileStates = parseGitStatusLine(line);
+    if (!fileStates) continue;
+
+    if (STAGED_INDEX_STATES.includes(fileStates.indexField as unknown as typeof STAGED_INDEX_STATES[number])) {
+      status.staged++;
+    }
+    if (fileStates.indexField === "?") {
+      status.untracked++;
+    } else if (UNSTAGED_WORKTREE_STATES.includes(fileStates.workTreeField as unknown as typeof UNSTAGED_WORKTREE_STATES[number])) {
+      status.unstaged++;
+    }
+  }
+  return status;
+}
+
+/** Schedule a background git status refresh (debounced). */
+function scheduleGitRefresh(): void {
+  if (gitRefreshTimer) return; // Already scheduled
+  gitRefreshTimer = setTimeout(() => {
+    gitRefreshTimer = undefined;
+    try {
+      const output = execSync("git status --porcelain=v2 -uall", {
+        cwd: process.cwd(),
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 2_000,
+      });
+      gitStatusCache = { value: parseGitOutput(output), timestamp: Date.now() };
+    } catch {
+      /* not a git repo or command failed — keep stale cache */
+    }
+  }, 0);
+}
+
 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 };
+  // Return stale cache while background refresh kicks in
+  if (gitStatusCache) {
+    scheduleGitRefresh();
+    return gitStatusCache.value;
+  }
 
+  // First call — sync fetch + schedule background refresh
+  const emptyStatus: GitStatus = { staged: 0, unstaged: 0, untracked: 0, ahead: 0, behind: 0 };
   try {
-    const gitOutput = execSync("git status --porcelain=v2 -uall", {
+    const output = execSync("git status --porcelain=v2 -uall", {
       cwd: process.cwd(),
       encoding: "utf8",
       stdio: ["pipe", "pipe", "pipe"],
-      timeout: 2_000, // Kill hung git processes after 2s
+      timeout: 2_000,
     });
-
-    for (const line of gitOutput.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);
-          }
-        }
-        continue;
-      }
-
-      const fileStates = parseGitStatusLine(line);
-      if (!fileStates) continue;
-
-      if (STAGED_INDEX_STATES.includes(fileStates.indexField as unknown as typeof STAGED_INDEX_STATES[number])) {
-        status.staged++;
-      }
-      if (fileStates.indexField === "?") {
-        status.untracked++;
-      } else if (UNSTAGED_WORKTREE_STATES.includes(fileStates.workTreeField as unknown as typeof UNSTAGED_WORKTREE_STATES[number])) {
-        status.unstaged++;
-      }
-    }
+    gitStatusCache = { value: parseGitOutput(output), timestamp: Date.now() };
   } catch {
     /* not a git repo or command failed */
+    gitStatusCache = { value: emptyStatus, timestamp: Date.now() };
   }
-
-  gitStatusCache = { value: status, timestamp: Date.now() };
-  return status;
+  scheduleGitRefresh();
+  return gitStatusCache.value;
 }
 
 export function getWorktreeBranch(): string | null {

package/src/utils/stats.ts

@@ -31,6 +31,10 @@ interface StatsCacheEntry {
 
 let statsCache: StatsCacheEntry | undefined;
 
+// Running total from initial scan — avoids re-scanning old entries
+let runningTotal: TokenUsageStats | undefined;
+let runningTotalEntryCount = 0;
+
 export function getTokenUsageStats(ctx: ExtensionContext): TokenUsageStats {
   const entries = ctx.sessionManager.getEntries();
 
@@ -49,18 +53,49 @@ export function getTokenUsageStats(ctx: ExtensionContext): TokenUsageStats {
     totalCacheWrite = 0,
     totalCost = 0;
 
-  for (const sessionEntry of entries) {
-    if (sessionEntry.type === "message" && sessionEntry.message.role === "assistant") {
-      const assistantMessage = sessionEntry.message as AssistantMessage;
-      totalInput += assistantMessage.usage.input;
-      totalOutput += assistantMessage.usage.output;
-      totalCacheRead += assistantMessage.usage.cacheRead;
-      totalCacheWrite += assistantMessage.usage.cacheWrite;
-      totalCost += assistantMessage.usage.cost.total;
+  // If we have a running total, only scan new entries
+  const hasRunningTotal = runningTotal !== undefined && runningTotalEntryCount < entries.length;
+  const startIdx = hasRunningTotal ? runningTotalEntryCount : 0;
+
+  if (startIdx === 0) {
+    // Full scan — no running total yet
+    for (const sessionEntry of entries) {
+      if (sessionEntry?.type === "message" && sessionEntry.message?.role === "assistant") {
+        const assistantMessage = sessionEntry.message as AssistantMessage;
+        totalInput += assistantMessage.usage.input;
+        totalOutput += assistantMessage.usage.output;
+        totalCacheRead += assistantMessage.usage.cacheRead;
+        totalCacheWrite += assistantMessage.usage.cacheWrite;
+        totalCost += assistantMessage.usage.cost.total;
+      }
+    }
+    runningTotal = { totalInput, totalOutput, totalCacheRead, totalCacheWrite, totalCost };
+    runningTotalEntryCount = entries.length;
+  } else {
+    // Incremental: start from running total + scan new entries
+    const rt = runningTotal!; // Safe: hasRunningTotal guard above
+    totalInput = rt.totalInput;
+    totalOutput = rt.totalOutput;
+    totalCacheRead = rt.totalCacheRead;
+    totalCacheWrite = rt.totalCacheWrite;
+    totalCost = rt.totalCost;
+
+    for (let i = startIdx; i < entries.length; i++) {
+      const sessionEntry = entries[i];
+      if (sessionEntry?.type === "message" && sessionEntry.message?.role === "assistant") {
+        const assistantMessage = sessionEntry.message as AssistantMessage;
+        totalInput += assistantMessage.usage.input;
+        totalOutput += assistantMessage.usage.output;
+        totalCacheRead += assistantMessage.usage.cacheRead;
+        totalCacheWrite += assistantMessage.usage.cacheWrite;
+        totalCost += assistantMessage.usage.cost.total;
+      }
     }
+    runningTotalEntryCount = entries.length;
   }
 
   const result: TokenUsageStats = { totalInput, totalOutput, totalCacheRead, totalCacheWrite, totalCost };
+  runningTotal = result;
   statsCache = { value: result, timestamp: Date.now(), entryCount: entries.length };
   return result;
 }