@narumitw/pi-statusline 0.50.3 → 0.51.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@narumitw/pi-statusline",
-  "version": "0.50.3",
+  "version": "0.51.0",
   "description": "Pi extension that replaces the footer with an information-rich statusline.",
   "type": "module",
   "license": "MIT",
@@ -17,6 +17,7 @@
     "dist",
     "docs",
     "README.md",
+    "CHANGELOG.md",
     "LICENSE"
   ],
   "pi": {
@@ -36,9 +37,9 @@
     "@earendil-works/pi-tui": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "1.4.0",
-    "@earendil-works/pi-tui": "1.4.0",
-    "@types/node": "26.6.5",
+    "@earendil-works/pi-coding-agent": "1.5.0",
+    "@earendil-works/pi-tui": "1.5.0",
+    "@types/node": "26.6.6",
     "esbuild": "0.28.2",
     "typescript": "7.0.2"
   },
@@ -48,6 +49,6 @@
     "directory": "packages/pi-statusline"
   },
   "dependencies": {
-    "@narumitw/pi-tui-kit": "^0.68.1"
+    "@narumitw/pi-tui-kit": "^0.69.0"
   }
 }

package/src/commands.ts

@@ -30,6 +30,7 @@ import {
   SEGMENT_NAMES,
   type SegmentName,
 } from "./types.js";
+import { summarizeFooterUsage } from "./usage.js";
 
 const EDIT_SETTINGS_LABEL = "Edit settings JSON";
 const SEGMENT_VIEWPORT_SIZE = 6;
@@ -477,6 +478,7 @@ async function chooseSegments(ctx: ExtensionCommandContext, options: StatuslineC
     updateThemedText();
 
     return {
+      capturesViewportInput: true,
       render: (width: number) => container.render(width),
       invalidate() {
         container.invalidate();
@@ -816,6 +818,8 @@ function editableSettings(
 function showStatus(ctx: ExtensionCommandContext, options: StatuslineCommandOptions) {
   if (!canNotify(ctx)) return;
   const loaded = options.getLoaded();
+  const usage = summarizeFooterUsage(ctx.sessionManager.getEntries());
+  const costSource = usage.costTotalFromProvider ? "provider-reported" : "unconfirmed";
   const diagnostics = loaded.diagnostics
     .slice(0, 5)
     .map((item) => `${item.path || "root"}: ${item.message}`)
@@ -830,6 +834,7 @@ function showStatus(ctx: ExtensionCommandContext, options: StatuslineCommandOpti
       `separator: ${loaded.config.separator}`,
       `information: ${inferInformationProfile(loaded.config.segments)}`,
       `segments: ${loaded.config.segments.join(", ") || "none"}`,
+      `session cost: $${usage.cost.toFixed(usage.cost >= 1 ? 2 : 3)} (${costSource})`,
       diagnostics ? `warnings: ${diagnostics}` : "warnings: none",
     ].join("\n"),
     loaded.diagnostics.length > 0 ? "warning" : "info",
@@ -842,7 +847,7 @@ function showHelp(ctx: ExtensionCommandContext, settingsPath: string) {
     [
       "/statusline — open Appearance, Information, Advanced, Status, and Help",
       "/statusline settings — edit and apply JSON",
-      "/statusline status — show source, path, information level, and warnings",
+      "/statusline status — show settings, session cost source, and warnings",
       "/statusline help — show this help",
       "Menu actions: Appearance, Information, Advanced, Status, Help.",
       "Information levels: minimal, balanced, detailed; any other segment array is custom.",

package/src/extension-status-metadata.ts

@@ -0,0 +1,208 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+const UPDATE_CHANNEL = "extension-status:v1:update";
+const REQUEST_CHANNEL = "extension-status:v1:request";
+const ACTIVITIES = new Set([
+  "idle",
+  "checking",
+  "working",
+  "pushing",
+  "pulling",
+  "resolving",
+  "retry",
+  "blocked",
+  "local-change",
+  "remote-change",
+  "review",
+] as const);
+
+export type ExtensionStatusActivity =
+  | "idle"
+  | "checking"
+  | "working"
+  | "pushing"
+  | "pulling"
+  | "resolving"
+  | "retry"
+  | "blocked"
+  | "local-change"
+  | "remote-change"
+  | "review";
+
+export interface ExtensionStatusPresentation {
+  readonly value: string;
+  readonly activity: ExtensionStatusActivity;
+  readonly reason?: string;
+}
+
+export interface ExtensionStatusMetadata {
+  get(key: string, value: string): ExtensionStatusPresentation | undefined;
+  reconcile(statuses: ReadonlyMap<string, string>): void;
+  dispose(): void;
+}
+
+function parseMetadata(data: Record<string, unknown>): {
+  presentation?: ExtensionStatusPresentation;
+  withdrawal: boolean;
+} {
+  if (Array.isArray(data)) return { withdrawal: false };
+  // Capture fields once: accessors and proxy traps can synchronously replace the current state.
+  const { version, value, activity, reason } = data;
+  const hasValue = Object.hasOwn(data, "value");
+  const hasActivity = "activity" in data;
+  const hasReason = "reason" in data;
+  const withdrawal = version === 1 && hasValue && value === undefined && !hasActivity && !hasReason;
+  if (
+    version !== 1 ||
+    !hasValue ||
+    typeof value !== "string" ||
+    value.length === 0 ||
+    !ACTIVITIES.has(activity as ExtensionStatusActivity)
+  )
+    return { withdrawal };
+  if (activity === "retry" || activity === "blocked") {
+    // JavaScript's $ also matches before a final newline; require the complete safe label.
+    if (typeof reason !== "string" || /^[a-z][a-z0-9-]{0,31}$/.exec(reason)?.[0] !== reason) return { withdrawal };
+    return { presentation: Object.freeze({ value, activity, reason }), withdrawal };
+  }
+  if (hasReason) return { withdrawal };
+  return { presentation: Object.freeze({ value, activity: activity as ExtensionStatusActivity }), withdrawal };
+}
+
+/** Optional display metadata; the raw Pi status map remains authoritative. */
+export function subscribeExtensionStatusMetadata(
+  events: ExtensionAPI["events"],
+  sessionManager: object,
+  getStatuses: () => ReadonlyMap<string, string>,
+  requestRender: () => void,
+): ExtensionStatusMetadata {
+  const records = new Map<string, ExtensionStatusPresentation>();
+  const liveKeys = new Set<string>();
+  const requestId = {};
+  let observedStatuses = new Map<string, string>();
+  try {
+    observedStatuses = new Map(getStatuses());
+  } catch {
+    // A raw-map read failure must leave the ordinary footer available.
+  }
+  let disposed = false;
+  let revision = 0;
+  const keyRevisions = new Map<string, number>();
+  const isCurrent = (key: string, owner: number) => !disposed && keyRevisions.get(key) === owner;
+  let unsubscribe: (() => void) | undefined;
+
+  const reconcile = (statuses: ReadonlyMap<string, string>, ownerKey?: string) => {
+    if (disposed) return;
+    const before = revision;
+    const snapshot = new Map(statuses);
+    if (disposed || revision !== before) return;
+    for (const [key, value] of observedStatuses) {
+      if (snapshot.get(key) === value) continue;
+      records.delete(key);
+      // An observed raw replacement must also fence off a delayed same-value snapshot.
+      liveKeys.add(key);
+      if (key !== ownerKey) keyRevisions.set(key, ++revision);
+    }
+    for (const key of snapshot.keys()) {
+      if (observedStatuses.has(key)) continue;
+      liveKeys.add(key);
+      if (key !== ownerKey) keyRevisions.set(key, ++revision);
+    }
+    observedStatuses = snapshot;
+  };
+
+  const metadata: ExtensionStatusMetadata = {
+    get(key, value) {
+      const presentation = records.get(key);
+      return presentation?.value === value ? presentation : undefined;
+    },
+    reconcile(statuses) {
+      reconcile(statuses);
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      revision++;
+      keyRevisions.clear();
+      records.clear();
+      liveKeys.clear();
+      observedStatuses.clear();
+      try {
+        unsubscribe?.();
+      } catch {
+        // Optional metadata cleanup must not prevent footer disposal.
+      }
+      unsubscribe = undefined;
+    },
+  };
+
+  const receive = (payload: unknown) => {
+    if (disposed || !payload || typeof payload !== "object") return;
+    const entered = revision;
+    let key: string;
+    let snapshot: boolean;
+    const data = payload as Record<string, unknown>;
+    try {
+      const rawKey = data.key;
+      const manager = data.sessionManager;
+      snapshot = "requestId" in data;
+      const replyId = snapshot ? data.requestId : undefined;
+      if (disposed || manager !== sessionManager || typeof rawKey !== "string" || !rawKey) return;
+      key = rawKey;
+      if ((keyRevisions.get(key) ?? 0) > entered) return;
+      if (snapshot && (replyId !== requestId || liveKeys.has(key))) return;
+    } catch {
+      return;
+    }
+
+    // Only an accepted envelope for this key can supersede its in-flight update.
+    const owner = ++revision;
+    keyRevisions.set(key, owner);
+    if (!snapshot) liveKeys.add(key);
+    const previous = records.get(key);
+    try {
+      const { presentation, withdrawal } = parseMetadata(data);
+      if (!isCurrent(key, owner)) return;
+      // Read after payload accessors, and copy before touching the cache: either operation can reenter.
+      const reading = revision;
+      const statuses = new Map(getStatuses());
+      if (!isCurrent(key, owner)) return;
+      if (revision !== reading) {
+        // An unstable read must not retain old hidden state or erase a newer sibling record.
+        records.delete(key);
+      } else {
+        reconcile(statuses, key);
+        if (!isCurrent(key, owner) || (snapshot && liveKeys.has(key))) return;
+        if (presentation && statuses.get(key) === presentation.value) {
+          records.set(key, presentation);
+        } else if (!snapshot || withdrawal) {
+          // Invalid live data and explicit withdrawals restore the existing raw-text path.
+          records.delete(key);
+        }
+      }
+    } catch {
+      if (!isCurrent(key, owner)) return;
+      if (!snapshot) records.delete(key);
+    }
+    if (isCurrent(key, owner) && previous !== records.get(key)) {
+      try {
+        requestRender();
+      } catch {
+        // A closed UI must not turn optional metadata delivery into an event-bus error.
+      }
+    }
+  };
+
+  try {
+    unsubscribe = events.on(UPDATE_CHANNEL, receive);
+  } catch {
+    // Metadata support must not prevent the footer from loading.
+    return metadata;
+  }
+  try {
+    events.emit(REQUEST_CHANNEL, { version: 1, sessionManager, requestId });
+  } catch {
+    // Keep the live subscription usable when a snapshot request fails.
+  }
+  return metadata;
+}

package/src/extension-status.ts

@@ -1,7 +1,9 @@
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { getAgentDir, type Theme, type ThemeColor } from "@earendil-works/pi-coding-agent";
-import { wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { sanitizeTerminalText } from "@narumitw/pi-tui-kit/terminal-text";
+import type { ExtensionStatusMetadata, ExtensionStatusPresentation } from "./extension-status-metadata.js";
 import { powerlineExtensionSeparator } from "./powerline.js";
 import { DEFAULT_EXTENSION_STATUS_ICONS } from "./settings.js";
 import type { StatuslineConfig } from "./types.js";
@@ -10,6 +12,7 @@ export type ExtensionStatusIconAliasMap = ReadonlyMap<string, readonly string[]>
 export interface ExtensionStatusRuntime {
   duplicateExtensions: string[];
   extensionStatusIconAliases: ExtensionStatusIconAliasMap;
+  extensionStatusMetadata?: ExtensionStatusMetadata;
 }
 
 const STATUSLINE_KEY = "statusline";
@@ -32,12 +35,19 @@ export function formatExtensionStatuses(
   hiddenKeys: ReadonlySet<string> = new Set(),
   trueColor = true,
 ): string {
+  runtime.extensionStatusMetadata?.reconcile(statuses);
   const separator = extensionStatusSeparator(config, theme, trueColor);
   const visibleStatuses = [
     ...formatDuplicateExtensionStatus(runtime, theme),
     ...[...statuses.entries()]
       .filter(([key, value]) => key !== STATUSLINE_KEY && !hiddenKeys.has(key) && value.trim().length > 0)
-      .map(([key, value]) => formatExtensionStatus(key, value, theme, config, runtime.extensionStatusIconAliases)),
+      .map(([key, value]) => {
+        const presentation = runtime.extensionStatusMetadata?.get(key, value);
+        return presentation
+          ? formatCompactExtensionStatus(key, value, presentation, theme, config, runtime.extensionStatusIconAliases)
+          : formatExtensionStatus(key, value, theme, config, runtime.extensionStatusIconAliases);
+      })
+      .filter((status) => status.length > 0),
   ].slice(0, 5);
 
   return visibleStatuses.join(separator);
@@ -59,6 +69,38 @@ export function formatExtensionStatus(
   return icon ? `${theme.fg(color, icon)} ${renderedText}` : renderedText;
 }
 
+function formatCompactExtensionStatus(
+  key: string,
+  value: string,
+  presentation: ExtensionStatusPresentation,
+  theme: Theme,
+  config: Pick<StatuslineConfig, "extensionStatusIcons">,
+  aliases: ExtensionStatusIconAliasMap,
+): string {
+  if (presentation.activity === "idle") return "";
+  // Only the compact path strips terminal controls; raw statuses retain their existing PR links.
+  const status = splitExtensionStatusIcon(
+    stripExtensionStatusPrefix(sanitizeTerminalText(key), sanitizeTerminalText(value)),
+  );
+  const icon = sanitizeTerminalText(extensionStatusIcon(key, status.icon, config.extensionStatusIcons, aliases));
+  const bodies = {
+    checking: "…",
+    working: "↻",
+    pushing: "↑",
+    pulling: "↓",
+    resolving: "AI",
+    retry: `retry: ${presentation.reason}`,
+    blocked: `! ${presentation.reason}`,
+    "local-change": "⇡",
+    "remote-change": "⇣",
+    review: "⇕",
+  };
+  const warning = presentation.activity === "blocked" || presentation.activity === "retry";
+  const color = warning ? "warning" : extensionColor(key, value);
+  const body = theme.fg(warning ? "warning" : "muted", bodies[presentation.activity]);
+  return icon ? `${theme.fg(color, icon)} ${body}` : body;
+}
+
 function extensionStatusIcon(
   key: string,
   leadingIcon: string | undefined,
@@ -68,14 +110,16 @@ function extensionStatusIcon(
   if (Object.hasOwn(configuredIcons, key)) return configuredIcons[key];
   const namespaceIcon = configuredNamespaceIcon(key, configuredIcons);
   if (namespaceIcon !== undefined) return namespaceIcon;
-  const compatibleKey = COMPATIBLE_STATUS_ICON_KEYS[key];
+  const compatibleKey = Object.hasOwn(COMPATIBLE_STATUS_ICON_KEYS, key) ? COMPATIBLE_STATUS_ICON_KEYS[key] : undefined;
   if (compatibleKey && Object.hasOwn(configuredIcons, compatibleKey)) {
     return configuredIcons[compatibleKey];
   }
   for (const alias of extensionStatusAliasesForKey(key, extensionStatusIconAliases)) {
     if (Object.hasOwn(configuredIcons, alias)) return configuredIcons[alias];
   }
-  return leadingIcon ?? DEFAULT_EXTENSION_STATUS_ICONS[key] ?? "🔌";
+  return (
+    leadingIcon ?? (Object.hasOwn(DEFAULT_EXTENSION_STATUS_ICONS, key) ? DEFAULT_EXTENSION_STATUS_ICONS[key] : "🔌")
+  );
 }
 
 function configuredNamespaceIcon(key: string, configuredIcons: Readonly<Record<string, string>>): string | undefined {
@@ -105,7 +149,9 @@ function statusKeyMatchesStatusBase(key: string, statusBase: string): boolean {
 
 export function wrapExtensionStatusline(status: string, width: number): string[] {
   if (!status || width <= 0) return [];
-  return wrapTextWithAnsi(status, width);
+  return wrapTextWithAnsi(status, width).map((line) =>
+    visibleWidth(line) > width ? truncateToWidth(line, width, "") : line,
+  );
 }
 
 function formatDuplicateExtensionStatus(runtime: ExtensionStatusRuntime, theme: Theme): string[] {

package/src/git-status.ts

@@ -2,6 +2,9 @@ import { isAbsolute } from "node:path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 const GIT_STATUS_TIMEOUT_MS = 3_000;
+// Bound combined stdout/stderr while allowing large worktree listings and one absolute root path.
+const GIT_STATUS_MAX_BUFFER = 1024 * 1024;
+const GIT_ROOT_MAX_BUFFER = 16 * 1024;
 
 export interface GitStatusSummary {
   root?: string;
@@ -22,19 +25,21 @@ export async function readGitStatus(
     pi.exec("git", ["--no-optional-locks", "status", "--porcelain=v1", "--branch", "--untracked-files=normal"], {
       cwd,
       timeout: GIT_STATUS_TIMEOUT_MS,
+      maxBuffer: GIT_STATUS_MAX_BUFFER,
       signal,
     }),
     pi
       .exec("git", ["rev-parse", "--path-format=absolute", "--show-toplevel"], {
         cwd,
         timeout: GIT_STATUS_TIMEOUT_MS,
+        maxBuffer: GIT_ROOT_MAX_BUFFER,
         signal,
       })
       .catch(() => undefined),
   ]);
-  if (statusResult.code !== 0 || statusResult.killed) return undefined;
+  if (statusResult.truncated || statusResult.code !== 0 || statusResult.killed) return undefined;
   const summary = parseGitStatusPorcelain(statusResult.stdout);
-  if (rootResult && rootResult.code === 0 && !rootResult.killed) {
+  if (rootResult && !rootResult.truncated && rootResult.code === 0 && !rootResult.killed) {
     const root = parseGitRoot(rootResult.stdout);
     if (root) summary.root = root;
   }

package/src/render.ts

@@ -47,6 +47,7 @@ export function renderStatusline(
 ): string {
   if (width <= 0) return "";
 
+  const inlineStatuses = legacyInlineStatuses(footerData.getExtensionStatuses(), runtime);
   const usageSummary = summarizeFooterUsage(ctx.sessionManager.getEntries());
   const rows: Array<{ configuredSegments: number; segments: RenderSegment[] }> = [
     { configuredSegments: 0, segments: [] },
@@ -60,7 +61,7 @@ export function renderStatusline(
     const row = rows.at(-1);
     if (!row) continue;
     row.configuredSegments += 1;
-    const rendered = buildSegment(name, ctx, footerData, config, runtime, usageSummary);
+    const rendered = buildSegment(name, ctx, footerData, config, runtime, usageSummary, inlineStatuses);
     if (rendered && rendered.text.length > 0) row.segments.push(rendered);
   }
 
@@ -84,7 +85,7 @@ export function renderExtensionStatusline(
   trueColor = true,
 ): string[] {
   const statuses = footerData.getExtensionStatuses();
-  const prContext = prContextFromStatuses(statuses);
+  const prContext = prContextFromStatuses(legacyInlineStatuses(statuses, runtime));
   const rendersPrInline = prContext !== undefined && mainLine.includes(prContext);
   const status = formatExtensionStatuses(
     statuses,
@@ -97,6 +98,16 @@ export function renderExtensionStatusline(
   return wrapExtensionStatusline(status, width);
 }
 
+function legacyInlineStatuses(
+  statuses: ReadonlyMap<string, string>,
+  runtime: ExtensionStatusRuntime,
+): ReadonlyMap<string, string> {
+  const metadata = runtime.extensionStatusMetadata;
+  if (!metadata) return statuses;
+  metadata.reconcile(statuses);
+  return new Map([...statuses].filter(([key, value]) => !metadata.get(key, value)));
+}
+
 function buildSegment(
   name: SegmentName,
   ctx: ExtensionContext,
@@ -104,6 +115,7 @@ function buildSegment(
   config: StatuslineConfig,
   runtime: RuntimeState,
   usageSummary: FooterUsageSummary,
+  inlineStatuses: ReadonlyMap<string, string>,
 ): RenderSegment | undefined {
   switch (name) {
     case "brand":
@@ -124,7 +136,7 @@ function buildSegment(
       return segment(name, runtime.thinkingLevel, config, thinkingColor(runtime.thinkingLevel), "header");
     case "branch": {
       const branch = footerData.getGitBranch();
-      const pr = branch ? prContextFromStatuses(footerData.getExtensionStatuses()) : undefined;
+      const pr = branch ? prContextFromStatuses(inlineStatuses) : undefined;
       return segment(name, formatGitBranchValue(branch, runtime.gitStatus, pr), config, "accent", "git");
     }
     case "cwd":