@pi-archimedes/footer 0.2.0

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@pi-archimedes/footer",
+  "version": "0.2.0",
+  "type": "module",
+  "keywords": [
+    "pi-package"
+  ],
+  "description": "Rich footer status bar for pi-archimedes",
+  "files": [
+    "src"
+  ],
+  "main": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./config": "./src/config.ts"
+  },
+  "dependencies": {
+    "@pi-archimedes/core": "0.2.0"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": ">=0.1.0",
+    "@earendil-works/pi-tui": ">=0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^6.0.0"
+  },
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ]
+  }
+}

package/src/config.ts

@@ -0,0 +1,50 @@
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+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,
+};
+
+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;
+}
+
+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");
+}
+
+export function getFooterSettingsItems(): SettingItem[] {
+  return [
+    {
+      id: "splitThreshold",
+      label: "Split Threshold",
+      description: "Terminal width threshold for two-line footer split",
+      currentValue: String(loadFooterConfig().splitThreshold),
+    },
+  ];
+}

package/src/cost-accumulator.ts

@@ -0,0 +1,35 @@
+import { getBus, Events, type CostUpdatePayload } from "@pi-archimedes/core/bus";
+
+export class CostAccumulator {
+  inputTokens = 0;
+  outputTokens = 0;
+  cacheReadTokens = 0;
+  cacheWriteTokens = 0;
+  cost = 0;
+  private unsubscribes: Array<() => void> = [];
+
+  subscribe(): void {
+    const unsub = getBus().on(Events.COST_UPDATE, (payload: unknown) => {
+      const data = payload as CostUpdatePayload;
+      this.inputTokens += data.inputTokens ?? 0;
+      this.outputTokens += data.outputTokens ?? 0;
+      this.cacheReadTokens += data.cacheReadTokens ?? 0;
+      this.cacheWriteTokens += data.cacheWriteTokens ?? 0;
+      this.cost += data.cost ?? 0;
+    });
+    this.unsubscribes.push(unsub);
+  }
+
+  reset(): void {
+    this.inputTokens = 0;
+    this.outputTokens = 0;
+    this.cacheReadTokens = 0;
+    this.cacheWriteTokens = 0;
+    this.cost = 0;
+  }
+
+  dispose(): void {
+    this.unsubscribes.forEach(unsub => unsub());
+    this.unsubscribes = [];
+  }
+}

package/src/index.ts

@@ -0,0 +1,163 @@
+/**
+ * dir | model | ◐thinking | branch [+status] | worktree | ↑↓R W $cost | ━━━━━ context%
+ * Splits into two lines when terminal width < splitThreshold (default 150):
+ *   Line 1: system info (dir, branch, model, thinking, worktree)
+ *   Line 2: usage stats (↑↓R W $cost + context progress bar)
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { clampLine } from "@pi-archimedes/core/text";
+import { loadFooterConfig } from "./config.js";
+import { CostAccumulator } from "./cost-accumulator.js";
+import { getGitStatus, getWorktreeBranch } from "./utils/git.js";
+import { getContextWindowInfo, getTokenUsageStats, type TokenUsageStats } from "./utils/stats.js";
+import { formatContextBar, formatGitStatusIndicators, formatThinkingIndicator, formatTokenCount } from "./utils/format.js";
+import { footerIcons } from "./utils/icons.js";
+
+export function registerFooter(pi: ExtensionAPI): void {
+
+  pi.on("session_start", (_event, ctx: ExtensionContext) => {
+    const splitThreshold = loadFooterConfig().splitThreshold;
+
+    // Create cost accumulator for subagent costs
+    const accumulator = new CostAccumulator();
+    accumulator.subscribe();
+
+    ctx.ui.setFooter((tui, theme, footerData) => {
+      const unsubscribe = footerData.onBranchChange(() => tui.requestRender());
+
+      return {
+        dispose: unsubscribe,
+        invalidate() { },
+        render(width: number): string[] {
+          try {
+            const colorize = (token: string, s: string) => theme.fg(token as any, s);
+            const activeModel = ctx.model?.id || "no-model";
+            const currentBranch = footerData.getGitBranch();
+            const currentDirectory = process.cwd().split("/").pop() || process.cwd();
+            const gitStatus = getGitStatus();
+            const worktreeBranch = getWorktreeBranch();
+            const thinkingLevel = pi.getThinkingLevel();
+
+            // Merge main agent stats with subagent stats from accumulator
+            const mainStats = getTokenUsageStats(ctx);
+            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,
+            };
+
+            const { totalInput, totalOutput, totalCacheRead, totalCacheWrite, totalCost } = mergedStats;
+            const { percent: contextPercent, percentValue: contextPercentValue, windowSize: contextWindowSize } = getContextWindowInfo(ctx);
+
+            // ── Two-line split for narrow terminals ────────────────────────────
+
+            const shouldSplit = width < splitThreshold;
+
+            // Thinking display
+            const thinkingIndicatorStr = formatThinkingIndicator(thinkingLevel, colorize);
+
+            // Git status indicators
+            const gitStatusStr = formatGitStatusIndicators(gitStatus, colorize);
+
+            // Left section: dir | branch [+status] | model | thinking | worktree
+            const leftSections = [
+              colorize("syntaxFunction", " " + footerIcons.directory + currentDirectory),
+              currentBranch ? colorize("success", footerIcons.branch + " " + currentBranch + (gitStatusStr ? " " + gitStatusStr : "")) : "",
+              colorize("syntaxType", footerIcons.model + " " + activeModel),
+              thinkingIndicatorStr,
+              worktreeBranch ? colorize("syntaxNumber", footerIcons.worktree + " " + worktreeBranch) : "",
+            ].filter(Boolean);
+
+            const separator = theme.fg("dim", " | ");
+            const leftSectionStr = leftSections.join(separator);
+
+            // Token stats with context percentage
+            const statsParts: string[] = [];
+            if (totalInput) statsParts.push("↑" + formatTokenCount(totalInput));
+            if (totalOutput) statsParts.push("↓" + formatTokenCount(totalOutput));
+            if (totalCacheRead) statsParts.push("R" + formatTokenCount(totalCacheRead));
+            if (totalCacheWrite) statsParts.push("W" + formatTokenCount(totalCacheWrite));
+            if (totalCost) statsParts.push("$" + totalCost.toFixed(2));
+
+            const contextUsed = contextWindowSize * (contextPercentValue / 100);
+            const contextDisplay =
+              contextPercent === "?"
+                ? "?"
+                : formatTokenCount(contextUsed) + "/" + formatTokenCount(contextWindowSize);
+            const contextColored =
+              contextPercentValue > 95
+                ? theme.fg("error", contextDisplay)
+                : contextPercentValue > 80
+                  ? theme.fg("warning", contextDisplay)
+                  : contextDisplay;
+            statsParts.push(contextColored);
+
+            const rawStatsSectionStr = statsParts.join(" ");
+            const statsSectionStr = theme.fg("dim", rawStatsSectionStr);
+
+            if (shouldSplit) {
+              // ── Two-line mode ──────────────────────────────────────────────
+
+              // Calculate available space for the context progress bar on line 2
+              const availableBarSpace = Math.max(2, width - visibleWidth(statsSectionStr) - 13);
+
+              // Context progress bar (expands to fill remaining space)
+              const contextBarStr = formatContextBar(colorize as (token: string, s: string) => string, contextPercentValue, availableBarSpace);
+
+              // Assemble line 2: stats | bar
+              const rightSections: string[] = [];
+              if (statsSectionStr) rightSections.push(statsSectionStr);
+              if (contextBarStr) rightSections.push(contextBarStr);
+              const rightSectionStr = rightSections.join(theme.fg("dim", " | "));
+
+              // Edge case: if both stats and bar are empty, return only line 1
+              if (!rightSectionStr) {
+                return [clampLine(leftSectionStr, width)];
+              }
+
+              return [
+                clampLine(leftSectionStr, width),
+                clampLine(rightSectionStr, width),
+              ];
+            }
+
+            // ── Single-line mode ───────────────────────────────────────────────
+
+            // Separator between left and right sections
+            const sectionSeparator = theme.fg("dim", " | ");
+
+            // Calculate available space for the context progress bar (after stats)
+            const availableBarSpace = Math.max(
+              2,
+              width - visibleWidth(leftSectionStr) - 1 - visibleWidth(sectionSeparator) - visibleWidth(statsSectionStr) - 10,
+            );
+
+            // Context progress bar (expands to fill remaining space)
+            const contextBarStr = formatContextBar(colorize as (token: string, s: string) => string, contextPercentValue, availableBarSpace);
+
+            // Assemble: left | stats | bar
+            const rightSections: string[] = [];
+            if (statsSectionStr) rightSections.push(statsSectionStr);
+            if (contextBarStr) rightSections.push(contextBarStr);
+            const rightSectionStr = rightSections.join(theme.fg("dim", " | "));
+
+            return [clampLine(leftSectionStr + sectionSeparator + rightSectionStr, width)];
+          } catch (e) {
+            return [];
+          }
+        },
+      };
+    });
+
+    pi.on("session_shutdown", (_event, _ctx) => {
+      accumulator.dispose();
+      accumulator.reset();
+    });
+  });
+}
+
+export default registerFooter;

package/src/utils/format.ts

@@ -0,0 +1,45 @@
+import { footerIcons, gitDisplayIcons, gitStatusColors, thinkingLevelColors, type ColorFn } from "./icons.js";
+
+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";
+}
+
+export function formatContextBar(colorize: ColorFn, percentValue: number, availableSpace: number): string {
+  if (availableSpace <= 2) return "";
+
+  const pct = Math.min(1, percentValue / 100);
+  const filledLength = percentValue > 0 ? Math.max(1, Math.round(pct * availableSpace)) : 0;
+  const emptyLength = availableSpace - filledLength;
+
+  const barToken = pct >= 0.9 ? "error" : pct >= 0.7 ? "warning" : "syntaxString";
+
+  const filledBar = filledLength > 0 ? colorize(barToken, "━".repeat(filledLength)) : "";
+  const emptyBar = emptyLength > 0 ? colorize("dim", "━".repeat(emptyLength)) : "";
+  const bar = filledBar + emptyBar;
+
+  return colorize(barToken, footerIcons.contextWindow) + "  " + bar + " " + colorize(barToken, Math.round(percentValue) + "%");
+}
+
+export function formatGitStatusIndicators(
+  gitStatus: { staged: number; unstaged: number; untracked: number; ahead: number; behind: number },
+  colorize: ColorFn,
+): string {
+  const statusParts: string[] = [];
+  if (gitStatus.staged > 0) statusParts.push(colorize(gitStatusColors.staged, gitDisplayIcons.staged + gitStatus.staged));
+  if (gitStatus.unstaged > 0) statusParts.push(colorize(gitStatusColors.unstaged, gitDisplayIcons.unstaged + gitStatus.unstaged));
+  if (gitStatus.untracked > 0) statusParts.push(colorize(gitStatusColors.untracked, gitDisplayIcons.untracked + gitStatus.untracked));
+  if (gitStatus.ahead > 0) statusParts.push(colorize(gitStatusColors.ahead, gitDisplayIcons.ahead + gitStatus.ahead));
+  if (gitStatus.behind > 0) statusParts.push(colorize(gitStatusColors.behind, gitDisplayIcons.behind + gitStatus.behind));
+  return statusParts.join("");
+}
+
+export function formatThinkingIndicator(thinkingLevel: string, colorize: ColorFn): string {
+  return thinkingLevel !== "off" ? colorize(thinkingLevelColors[thinkingLevel] || "dim", "◐ " + thinkingLevel) : "";
+}

package/src/utils/git.ts

@@ -0,0 +1,106 @@
+import { execSync } from "child_process";
+import { realpathSync } from "fs";
+
+export interface GitStatus {
+  staged: number;
+  unstaged: number;
+  untracked: number;
+  ahead: number;
+  behind: number;
+}
+
+const STAGED_INDEX_STATES = ["A", "M", "D", "R", "C", "U", "T"] as const;
+const UNSTAGED_WORKTREE_STATES = ["M", "D", "U"] as const;
+
+interface FileStates {
+  indexField: string;
+  workTreeField: string;
+}
+
+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] };
+
+  // Unscored format: "XY..."
+  const noScoreMatch = line.match(/^(..) /);
+  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] };
+}
+
+export function getGitStatus(): GitStatus {
+  const status: GitStatus = { staged: 0, unstaged: 0, untracked: 0, ahead: 0, behind: 0 };
+
+  try {
+    const gitOutput = execSync("git status --porcelain=v2 -uall", {
+      cwd: process.cwd(),
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    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++;
+      }
+    }
+  } catch {
+    /* not a git repo or command failed */
+  }
+
+  return status;
+}
+
+export function getWorktreeBranch(): string | null {
+  try {
+    const worktreeOutput = execSync("git worktree list --porcelain", {
+      cwd: process.cwd(),
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    const worktreeEntries = worktreeOutput.trim().split("\n\n").filter(Boolean);
+    if (worktreeEntries.length <= 1) return null;
+
+    const currentDirectoryPath = realpathSync(process.cwd());
+    for (const entry of worktreeEntries) {
+      const entryLines = entry.split("\n");
+      const pathLine = entryLines.find((l) => l.startsWith("worktree "));
+      const branchLine = entryLines.find((l) => l.startsWith("branch "));
+      const worktreePath = pathLine?.replace("worktree ", "");
+
+      if (worktreePath && (currentDirectoryPath === worktreePath || currentDirectoryPath.startsWith(worktreePath + "/"))) {
+        return branchLine?.replace("branch refs/heads/", "") ?? null;
+      }
+    }
+  } catch {
+    /* not a git repo */
+  }
+
+  return null;
+}

package/src/utils/icons.ts

@@ -0,0 +1,37 @@
+// Nerd Font icons
+export const footerIcons = {
+  model: "\udb81\udea9 ",
+  directory: "\uf4d3 ",
+  branch: "\uf126",
+  worktree: "\u{f0405}",
+  contextWindow: "\uee9c",
+} as const;
+
+// Git status display icons
+export const gitDisplayIcons = {
+  staged: "●",
+  unstaged: "~",
+  untracked: "U",
+  ahead: "↑",
+  behind: "↓",
+} as const;
+
+export const gitStatusColors: Record<keyof typeof gitDisplayIcons, "success" | "warning" | "dim" | "info"> = {
+  staged: "success",
+  unstaged: "warning",
+  untracked: "dim",
+  ahead: "info",
+  behind: "warning",
+};
+
+export const thinkingLevelColors: Record<string, string> = {
+  off: "dim",
+  minimal: "thinkingMinimal",
+  low: "thinkingLow",
+  medium: "thinkingMedium",
+  high: "thinkingHigh",
+  xhigh: "thinkingXhigh",
+};
+
+// Color function type used by formatting functions
+export type ColorFn = (token: string, s: string) => string;

package/src/utils/stats.ts

@@ -0,0 +1,64 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+interface MessageUsage {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  cost: { total: number };
+}
+
+interface AssistantMessage {
+  usage: MessageUsage;
+}
+
+export interface TokenUsageStats {
+  totalInput: number;
+  totalOutput: number;
+  totalCacheRead: number;
+  totalCacheWrite: number;
+  totalCost: number;
+}
+
+export function getTokenUsageStats(ctx: ExtensionContext): TokenUsageStats {
+  let totalInput = 0,
+    totalOutput = 0,
+    totalCacheRead = 0,
+    totalCacheWrite = 0,
+    totalCost = 0;
+
+  for (const sessionEntry of ctx.sessionManager.getEntries()) {
+    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;
+    }
+  }
+
+  return { totalInput, totalOutput, totalCacheRead, totalCacheWrite, totalCost };
+}
+
+export interface ContextWindowInfo {
+  percent: string;
+  percentValue: number;
+  windowSize: number;
+}
+
+export function getContextWindowInfo(ctx: ExtensionContext): ContextWindowInfo {
+  const contextUsage = ctx.getContextUsage();
+  const modelContextWindow = contextUsage?.contextWindow ?? ctx.model?.contextWindow ?? 0;
+  const tokenStats = getTokenUsageStats(ctx);
+
+  const percentValue =
+    contextUsage?.percent ??
+    (modelContextWindow > 0 ? ((tokenStats.totalInput + tokenStats.totalOutput) / modelContextWindow) * 100 : 0);
+
+  return {
+    percent: contextUsage?.percent != null ? percentValue.toFixed(1) : "?",
+    percentValue,
+    windowSize: modelContextWindow,
+  };
+}