pi-observability 1.0.0 → 1.3.0

package/extensions/lib/footer-engine/index.ts

@@ -0,0 +1,55 @@
+export type {
+  SegmentKey,
+  FooterSettings,
+  FooterInput,
+  SegmentRenderer,
+  LayoutAssembler,
+  FooterEngineOptions,
+} from "./types.js";
+
+export {
+  fmtDuration,
+  fmtTokens,
+  shortenPath,
+  thinkingColor,
+  contextUsageColor,
+  rainbowText,
+} from "./format.js";
+
+export { builtinRenderers } from "./segments.js";
+export { defaultAssembler } from "./layout.js";
+
+import { builtinRenderers } from "./segments.js";
+import { defaultAssembler } from "./layout.js";
+import type { FooterInput, FooterEngineOptions } from "./types.js";
+
+export function renderFooter(input: FooterInput, width: number): string[] {
+  const segments: Record<string, string> = {};
+  for (const [key, renderer] of Object.entries(builtinRenderers)) {
+    if (input.settings.segments[key as keyof FooterInput["settings"]["segments"]]) {
+      segments[key] = renderer(input);
+    } else {
+      segments[key] = "";
+    }
+  }
+  return defaultAssembler(segments, width, input.theme);
+}
+
+export function createFooterEngine(options: FooterEngineOptions) {
+  const segmentRenderers = { ...builtinRenderers, ...options.segments };
+  const assembler = options.layout ?? defaultAssembler;
+
+  return {
+    render(input: FooterInput, width: number): string[] {
+      const segments: Record<string, string> = {};
+      for (const [key, renderer] of Object.entries(segmentRenderers)) {
+        if (input.settings.segments[key as keyof FooterInput["settings"]["segments"]]) {
+          segments[key] = renderer(input);
+        } else {
+          segments[key] = "";
+        }
+      }
+      return assembler(segments, width, input.theme);
+    },
+  };
+}

package/extensions/lib/footer-engine/layout.ts

@@ -0,0 +1,47 @@
+import { visibleWidth, truncateToWidth } from "@mariozechner/pi-tui";
+import type { LayoutAssembler } from "./types.js";
+
+export const defaultAssembler: LayoutAssembler = (segments, width, theme) => {
+  const sep = " " + theme.fg("dim", "▸") + " ";
+
+  const leftParts = [segments["modelThink"]].filter(Boolean);
+  const rightParts = [
+    segments["contextUsage"],
+    segments["tokens"],
+    segments["tps"],
+    segments["cost"],
+  ].filter(Boolean);
+  const middleParts = [segments["runtime"], segments["pwd"], segments["git"]].filter(Boolean);
+
+  const leftStr = leftParts.join(sep);
+  const rightStr = rightParts.join(sep);
+  const middleStr = middleParts.join(sep);
+
+  const singleLine = middleStr
+    ? leftStr + sep + middleStr + sep + rightStr
+    : leftStr + sep + rightStr;
+
+  if (visibleWidth(singleLine) <= width) {
+    const pad = width - visibleWidth(singleLine);
+    return [singleLine + " ".repeat(Math.max(0, pad))];
+  }
+
+  // Fallback: two lines
+  function fitLine(parts: string[]): string {
+    const line = parts.filter(Boolean).join(sep);
+    const w = visibleWidth(line);
+    if (w < width) return line + " ".repeat(width - w);
+    if (w > width) return truncateToWidth(line, width);
+    return line;
+  }
+
+  const line1 = fitLine([segments["modelThink"], segments["pwd"], segments["git"]]);
+  const line2 = fitLine([
+    segments["runtime"],
+    segments["contextUsage"],
+    segments["tokens"],
+    segments["tps"],
+    segments["cost"],
+  ]);
+  return [line1, line2];
+};

package/extensions/lib/footer-engine/segments.ts

@@ -0,0 +1,94 @@
+import { basename } from "node:path";
+import type { SegmentRenderer } from "./types.js";
+import {
+  fmtDuration,
+  fmtTokens,
+  shortenPath,
+  thinkingColor,
+  contextUsageColor,
+  rainbowText,
+} from "./format.js";
+
+export const builtinRenderers: Record<string, SegmentRenderer> = {
+  modelThink(input) {
+    const { model, thinkingLevel, theme } = input;
+    const text = `${model}:${thinkingLevel}`;
+    if (thinkingLevel === "xhigh" || thinkingLevel === "max") {
+      return rainbowText(text);
+    }
+    return theme.fg(thinkingColor(thinkingLevel), text);
+  },
+
+  runtime(input) {
+    return input.theme.fg("dim", `⏱ ${fmtDuration(input.runtimeMs)}`);
+  },
+
+  pwd(input) {
+    const path = input.showFullPath ? shortenPath(input.cwd) : basename(input.cwd);
+    return input.theme.fg("dim", `📁 ${path}`);
+  },
+
+  git(input) {
+    const { gitBranch, gitDiffAdded, gitDiffRemoved, theme } = input;
+    if (!gitBranch) return "";
+    let text = theme.fg("dim", ` ${gitBranch}`);
+    if (gitDiffAdded > 0 || gitDiffRemoved > 0) {
+      text += ` ${theme.fg("success", `+${gitDiffAdded}`)} ${theme.fg("error", `-${gitDiffRemoved}`)}`;
+    }
+    return text;
+  },
+
+  contextUsage(input) {
+    const { contextUsage, theme, settings } = input;
+    if (!contextUsage || !contextUsage.contextWindow) return "";
+
+    const tokens = contextUsage.tokens || 0;
+    const max = contextUsage.contextWindow;
+    const pct = Math.min(100, Math.max(0, Math.round((tokens / max) * 100)));
+
+    let text = "ctx";
+
+    if (settings.segments.contextProgress) {
+      const barWidth = 10;
+      const filled = Math.round((pct / 100) * barWidth);
+      const empty = barWidth - filled;
+      const bar = "█".repeat(filled) + "░".repeat(empty);
+      text += ` [${bar}]`;
+    }
+
+    if (settings.segments.contextPercentage) {
+      text += ` ${pct}%`;
+    }
+
+    if (settings.segments.contextNumbers) {
+      text += ` ${fmtTokens(tokens)}/${fmtTokens(max)}`;
+    }
+
+    return theme.fg(
+      contextUsageColor(pct, settings.contextZones.expert, settings.contextZones.warning),
+      text,
+    );
+  },
+
+  tokens(input) {
+    const { totalInputTokens, totalOutputTokens, theme } = input;
+    return theme.fg("dim", `↑${fmtTokens(totalInputTokens)} ↓${fmtTokens(totalOutputTokens)}`);
+  },
+
+  tps(input) {
+    const { isStreaming, currentTurnStartTime, currentTurnUpdateCount, lastTurnTps, theme } = input;
+    if (isStreaming && currentTurnStartTime) {
+      const elapsed = (Date.now() - currentTurnStartTime) / 1000;
+      const liveTps = elapsed > 0 ? currentTurnUpdateCount / elapsed : 0;
+      return theme.fg("accent", `⚡${liveTps.toFixed(1)}`);
+    } else if (lastTurnTps > 0) {
+      return theme.fg("dim", `⚡${lastTurnTps.toFixed(1)}`);
+    }
+    return "";
+  },
+
+  cost(input) {
+    const { totalCost, theme } = input;
+    return theme.fg("dim", `$${totalCost.toFixed(4)}`);
+  },
+};

package/extensions/lib/footer-engine/types.ts

@@ -0,0 +1,53 @@
+import type { ContextUsage, Theme as PiTheme } from "@mariozechner/pi-coding-agent";
+
+export type SegmentKey =
+  | "modelThink"
+  | "runtime"
+  | "pwd"
+  | "git"
+  | "contextUsage"
+  | "contextProgress"
+  | "contextPercentage"
+  | "contextNumbers"
+  | "tokens"
+  | "tps"
+  | "cost";
+
+export interface FooterSettings {
+  segments: Record<SegmentKey, boolean>;
+  contextZones: { expert: number; warning: number };
+}
+
+export interface FooterInput {
+  model: string;
+  thinkingLevel: string;
+  runtimeMs: number;
+  isStreaming: boolean;
+  currentTurnStartTime: number | null;
+  currentTurnUpdateCount: number;
+  lastTurnTps: number;
+  totalInputTokens: number;
+  totalOutputTokens: number;
+  totalCost: number;
+  contextUsage: ContextUsage | null;
+  cwd: string;
+  showFullPath: boolean;
+  gitBranch: string | null;
+  gitDiffAdded: number;
+  gitDiffRemoved: number;
+  settings: FooterSettings;
+  theme: PiTheme;
+}
+
+export interface SegmentRenderer {
+  (input: FooterInput): string;
+}
+
+export interface LayoutAssembler {
+  (segments: Record<string, string>, width: number, theme: PiTheme): string[];
+}
+
+export interface FooterEngineOptions {
+  segments?: Partial<Record<SegmentKey, SegmentRenderer>>;
+  layout?: LayoutAssembler;
+}

package/extensions/lib/settings/domain.ts

@@ -0,0 +1,161 @@
+import { DEFAULT_SETTINGS, PRESETS } from "./metadata.js";
+import type { PresetName, SegmentKey, SettingsConfig, SettingsUpdateResult } from "./types.js";
+
+export function createDefaultSettings(): SettingsConfig {
+  return structuredClone(DEFAULT_SETTINGS);
+}
+
+export function applyPreset(config: SettingsConfig, preset: PresetName): SettingsConfig {
+  const next = structuredClone(config);
+  next.preset = preset;
+  const p = PRESETS[preset];
+  for (const [key, val] of Object.entries(p) as [SegmentKey, boolean][]) {
+    next.segments[key] = val;
+  }
+  return next;
+}
+
+export function toggleSegment(config: SettingsConfig, key: SegmentKey): SettingsConfig {
+  const next = structuredClone(config);
+  next.segments[key] = !next.segments[key];
+  return next;
+}
+
+export function setSegment(
+  config: SettingsConfig,
+  key: SegmentKey,
+  value: boolean,
+): SettingsConfig {
+  const next = structuredClone(config);
+  next.segments[key] = value;
+  return next;
+}
+
+export function setZone(
+  config: SettingsConfig,
+  key: "expert" | "warning",
+  value: number,
+): SettingsConfig {
+  const next = structuredClone(config);
+  next.contextZones[key] = Math.max(0, Math.min(100, value));
+  // Ensure expert <= warning
+  if (next.contextZones.expert > next.contextZones.warning) {
+    if (key === "expert") {
+      next.contextZones.warning = next.contextZones.expert;
+    } else {
+      next.contextZones.expert = next.contextZones.warning;
+    }
+  }
+  return next;
+}
+
+export function validateSettings(raw: unknown): SettingsConfig {
+  if (!raw || typeof raw !== "object") {
+    return createDefaultSettings();
+  }
+  const r = raw as Record<string, unknown>;
+
+  const preset = isPresetName(r.preset) ? r.preset : DEFAULT_SETTINGS.preset;
+  const segments = validateSegments(r.segments);
+  const contextZones = validateZones(r.contextZones);
+
+  return { version: 1, preset, segments, contextZones };
+}
+
+export function migrateSettings(raw: unknown): SettingsConfig {
+  const validated = validateSettings(raw);
+  // If we ever need version migrations, add them here
+  return validated;
+}
+
+export function updateSetting(
+  config: SettingsConfig,
+  id: string,
+  value: string,
+): SettingsUpdateResult {
+  let next = structuredClone(config);
+  const derivedUpdates: Array<{ id: string; value: string }> = [];
+
+  switch (id) {
+    case "preset": {
+      if (isPresetName(value)) {
+        next = applyPreset(next, value);
+        for (const key of Object.keys(next.segments) as SegmentKey[]) {
+          derivedUpdates.push({ id: key, value: next.segments[key] ? "true" : "false" });
+        }
+      }
+      break;
+    }
+    case "modelThink":
+    case "runtime":
+    case "pwd":
+    case "git":
+    case "contextUsage":
+    case "contextProgress":
+    case "contextPercentage":
+    case "contextNumbers":
+    case "tokens":
+    case "tps":
+    case "cost": {
+      next = setSegment(next, id, value === "true");
+      // Context sub-toggle dependency: if contextUsage is turned off, children are hidden
+      if (id === "contextUsage" && value === "false") {
+        for (const child of [
+          "contextProgress",
+          "contextPercentage",
+          "contextNumbers",
+        ] as SegmentKey[]) {
+          derivedUpdates.push({ id: child, value: "false" });
+        }
+      }
+      break;
+    }
+    case "expertZone": {
+      next = setZone(next, "expert", parseInt(value, 10));
+      break;
+    }
+    case "warningZone": {
+      next = setZone(next, "warning", parseInt(value, 10));
+      break;
+    }
+  }
+
+  return { config: next, derivedUpdates };
+}
+
+function isPresetName(v: unknown): v is PresetName {
+  return v === "minimal" || v === "standard" || v === "verbose" || v === "performance";
+}
+
+function validateSegments(raw: unknown): Record<SegmentKey, boolean> {
+  const segments = { ...DEFAULT_SETTINGS.segments };
+  if (!raw || typeof raw !== "object") return segments;
+  for (const [key, val] of Object.entries(raw)) {
+    if (key in segments && typeof val === "boolean") {
+      segments[key as SegmentKey] = val;
+    }
+  }
+  return segments;
+}
+
+function validateZones(raw: unknown): { expert: number; warning: number } {
+  const zones = { ...DEFAULT_SETTINGS.contextZones };
+  if (!raw || typeof raw !== "object") return zones;
+  const r = raw as Record<string, unknown>;
+
+  if (typeof r.expert === "number") zones.expert = clamp(0, r.expert, 100);
+  if (typeof r.warning === "number") zones.warning = clamp(0, r.warning, 100);
+
+  // Ensure expert <= warning
+  if (zones.expert > zones.warning) {
+    const avg = Math.round((zones.expert + zones.warning) / 2);
+    zones.expert = avg;
+    zones.warning = avg;
+  }
+
+  return zones;
+}
+
+function clamp(min: number, val: number, max: number): number {
+  return Math.max(min, Math.min(max, val));
+}

package/extensions/lib/settings/index.ts

@@ -0,0 +1,32 @@
+export type {
+  SegmentKey,
+  PresetName,
+  SettingsConfig,
+  SettingsListItem,
+  SettingsUpdateResult,
+  SegmentMetadata,
+} from "./types.js";
+
+export { DEFAULT_SETTINGS, PRESETS, SEGMENT_METADATA, ZONE_VALUE_OPTIONS } from "./metadata.js";
+
+export {
+  createDefaultSettings,
+  applyPreset,
+  toggleSegment,
+  setSegment,
+  setZone,
+  validateSettings,
+  migrateSettings,
+  updateSetting,
+} from "./domain.js";
+
+export { toSettingsListItems } from "./tui.js";
+
+export {
+  createSettingsStorage,
+  createMemorySettingsStorage,
+  loadSettings,
+  saveSettings,
+} from "./storage.js";
+
+export { createSettingsManager, type SettingsManager } from "./manager.js";

package/extensions/lib/settings/manager.ts

@@ -0,0 +1,58 @@
+import { loadSettings, saveSettings } from "./storage.js";
+import {
+  applyPreset,
+  toggleSegment,
+  setSegment,
+  setZone,
+  createDefaultSettings,
+} from "./domain.js";
+import type { PresetName, SegmentKey, SettingsConfig } from "./types.js";
+import type { Storage } from "../storage/index.js";
+
+export interface SettingsManager {
+  load(): Promise<void>;
+  save(): Promise<void>;
+  getConfig(): SettingsConfig;
+  applyPreset(preset: PresetName): SettingsConfig;
+  toggleSegment(key: SegmentKey): SettingsConfig;
+  setSegment(key: SegmentKey, value: boolean): SettingsConfig;
+  setZone(key: "expert" | "warning", value: number): SettingsConfig;
+}
+
+export function createSettingsManager(storage: Storage): SettingsManager {
+  let config: SettingsConfig = createDefaultSettings();
+
+  return {
+    async load() {
+      config = await loadSettings(storage);
+    },
+
+    async save() {
+      await saveSettings(config, storage);
+    },
+
+    getConfig() {
+      return structuredClone(config);
+    },
+
+    applyPreset(preset) {
+      config = applyPreset(config, preset);
+      return structuredClone(config);
+    },
+
+    toggleSegment(key) {
+      config = toggleSegment(config, key);
+      return structuredClone(config);
+    },
+
+    setSegment(key, value) {
+      config = setSegment(config, key, value);
+      return structuredClone(config);
+    },
+
+    setZone(key, value) {
+      config = setZone(config, key, value);
+      return structuredClone(config);
+    },
+  };
+}

package/extensions/lib/settings/metadata.ts

@@ -0,0 +1,114 @@
+import type { PresetName, SegmentKey, SegmentMetadata, SettingsConfig } from "./types.js";
+
+export const DEFAULT_SETTINGS: SettingsConfig = {
+  version: 1,
+  preset: "standard",
+  segments: {
+    modelThink: true,
+    runtime: true,
+    pwd: true,
+    git: true,
+    contextUsage: true,
+    contextProgress: true,
+    contextPercentage: true,
+    contextNumbers: true,
+    tokens: true,
+    tps: true,
+    cost: true,
+  },
+  contextZones: { expert: 70, warning: 85 },
+};
+
+export const PRESETS: Record<PresetName, Partial<Record<SegmentKey, boolean>>> = {
+  minimal: {
+    modelThink: true,
+    contextUsage: true,
+    contextProgress: true,
+    contextPercentage: false,
+    contextNumbers: true,
+    runtime: false,
+    pwd: false,
+    git: false,
+    tokens: false,
+    tps: false,
+    cost: false,
+  },
+  standard: {
+    modelThink: true,
+    runtime: true,
+    pwd: true,
+    git: true,
+    contextUsage: true,
+    contextProgress: true,
+    contextPercentage: true,
+    contextNumbers: true,
+    tokens: true,
+    tps: false,
+    cost: true,
+  },
+  verbose: {
+    modelThink: true,
+    runtime: true,
+    pwd: true,
+    git: true,
+    contextUsage: true,
+    contextProgress: true,
+    contextPercentage: true,
+    contextNumbers: true,
+    tokens: true,
+    tps: true,
+    cost: true,
+  },
+  performance: {
+    modelThink: true,
+    runtime: false,
+    pwd: false,
+    git: false,
+    contextUsage: true,
+    contextProgress: false,
+    contextPercentage: true,
+    contextNumbers: true,
+    tokens: false,
+    tps: true,
+    cost: true,
+  },
+};
+
+export const SEGMENT_METADATA: SegmentMetadata[] = [
+  {
+    id: "modelThink",
+    label: "Model & Thinking",
+    description: "Show current model and thinking level",
+  },
+  { id: "runtime", label: "Runtime", description: "Show session runtime timer" },
+  { id: "pwd", label: "Working Directory", description: "Show current working directory" },
+  { id: "git", label: "Git Branch & Diff", description: "Show git branch and diff stats" },
+  {
+    id: "contextUsage",
+    label: "Context Usage",
+    description: "Master toggle for the context usage segment",
+  },
+  {
+    id: "contextProgress",
+    label: "  └ Progress Bar",
+    description: "Show the progress bar in context usage",
+  },
+  {
+    id: "contextPercentage",
+    label: "  └ Percentage",
+    description: "Show the percentage in context usage",
+  },
+  {
+    id: "contextNumbers",
+    label: "  └ Used / Total",
+    description: "Show the token count in context usage",
+  },
+  { id: "tokens", label: "Session Tokens", description: "Show total input/output token counts" },
+  { id: "tps", label: "TPS (Tokens/Sec)", description: "Show live and last-turn TPS" },
+  { id: "cost", label: "Cost", description: "Show estimated session cost" },
+];
+
+export const ZONE_VALUE_OPTIONS = {
+  expert: ["60", "65", "70", "75", "80"],
+  warning: ["75", "80", "85", "90", "95"],
+};

package/extensions/lib/settings/storage.ts

@@ -0,0 +1,38 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import {
+  createFileBackend,
+  createMemoryBackend,
+  createStorage,
+  type Storage,
+} from "../storage/index.js";
+import { migrateSettings } from "./domain.js";
+import type { SettingsConfig } from "./types.js";
+
+const DEFAULT_DIR = join(homedir(), ".pi", "agent", "observability");
+
+export function createSettingsStorage(options?: { dir?: string }): Storage {
+  const dir = options?.dir ?? DEFAULT_DIR;
+  const backend = createFileBackend({ dir });
+  return createStorage(backend);
+}
+
+export function createMemorySettingsStorage(): Storage {
+  const backend = createMemoryBackend();
+  return createStorage(backend);
+}
+
+export async function loadSettings(storage: Storage): Promise<SettingsConfig> {
+  const store = storage.json<SettingsConfig>("settings", { defaults: undefined });
+  try {
+    const raw = await store.load();
+    return migrateSettings(raw);
+  } catch {
+    return migrateSettings(undefined);
+  }
+}
+
+export async function saveSettings(config: SettingsConfig, storage: Storage): Promise<void> {
+  const store = storage.json<SettingsConfig>("settings");
+  await store.save(config);
+}

package/extensions/lib/settings/tui.ts

@@ -0,0 +1,44 @@
+import { SEGMENT_METADATA, ZONE_VALUE_OPTIONS } from "./metadata.js";
+import type { SettingsConfig, SettingsListItem } from "./types.js";
+
+export function toSettingsListItems(config: SettingsConfig): SettingsListItem[] {
+  const items: SettingsListItem[] = [
+    {
+      id: "preset",
+      label: "Layout Preset",
+      description:
+        "Quick layout presets. Individual segments can still be toggled after applying a preset.",
+      currentValue: config.preset,
+      values: ["minimal", "standard", "verbose", "performance"],
+    },
+  ];
+
+  for (const meta of SEGMENT_METADATA) {
+    items.push({
+      id: meta.id,
+      label: meta.label,
+      description: meta.description,
+      currentValue: config.segments[meta.id] ? "true" : "false",
+      values: ["true", "false"],
+    });
+  }
+
+  items.push(
+    {
+      id: "expertZone",
+      label: "Expert Zone Threshold",
+      description: "Context usage percentage where the bar turns green (0-100)",
+      currentValue: `${config.contextZones.expert}`,
+      values: ZONE_VALUE_OPTIONS.expert,
+    },
+    {
+      id: "warningZone",
+      label: "Warning Zone Threshold",
+      description: "Context usage percentage where the bar turns yellow (0-100)",
+      currentValue: `${config.contextZones.warning}`,
+      values: ZONE_VALUE_OPTIONS.warning,
+    },
+  );
+
+  return items;
+}