@pi-vault/pi-status 0.1.0

package/src/index.ts

@@ -0,0 +1,293 @@
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import {
+  USAGE_CORE_READY_EVENT,
+  USAGE_CORE_REQUEST_EVENT,
+  USAGE_CORE_UPDATE_CURRENT_EVENT,
+} from "@pi-vault/pi-usage/events";
+import type { UsageCoreState } from "@pi-vault/pi-usage/types";
+import {
+  loadConfig,
+  saveConfigToSettings,
+  type PiStatusConfig,
+} from "./config.ts";
+import { buildFooterLine } from "./render.ts";
+import { createStatuslineEditor } from "./ui/statusline-editor.ts";
+import { fromPiTheme, noTheme, type StatuslineMenuTheme } from "./ui/statusline-theme.ts";
+
+type FooterComponent = {
+  render: (width: number) => string[];
+  invalidate: () => void;
+  dispose?: () => void;
+};
+
+type FooterDataLike = {
+  getGitBranch: () => string | null;
+  getExtensionStatuses: () => ReadonlyMap<string, string>;
+  onBranchChange?: (listener: () => void) => (() => void) | undefined;
+};
+
+type FooterFactory = (
+  tui: { requestRender?: () => void },
+  theme: { fg: (color: string, text: string) => string },
+  footerData: FooterDataLike,
+) => FooterComponent;
+
+// Used only to suppress the live footer while a custom UI (e.g. /statusline)
+// is open. Renders no lines and is a no-op otherwise.
+const EMPTY_FOOTER_FACTORY: FooterFactory = () => ({
+  render(_width: number): string[] {
+    return [];
+  },
+  invalidate(): void {},
+  dispose(): void {},
+});
+
+// `ctx.ui.custom(...)` is expected to hand us a live Pi theme, but the
+// runtime contract is loose and the theme may be missing in some test or
+// boot contexts. We only adapt it when both `fg` and `bold` are callable so
+// the editor always gets a well-formed `StatuslineMenuTheme` and never has
+// to defend against partial themes at render time.
+function isLiveTheme(value: unknown): boolean {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value as { fg?: unknown; bold?: unknown };
+  return typeof candidate.fg === "function" && typeof candidate.bold === "function";
+}
+
+function aggregateBranchTotals(ctx: ExtensionContext): {
+  input: number;
+  output: number;
+  totalTokens: number;
+} {
+  const totals = { input: 0, output: 0, totalTokens: 0 };
+  const branch = ctx.sessionManager.getBranch() as unknown[];
+
+  for (const entry of branch ?? []) {
+    if (!entry || typeof entry !== "object") continue;
+    const type = (entry as { type?: unknown }).type;
+    if (type !== "message") continue;
+    const message = (
+      entry as {
+        message?: {
+          role?: unknown;
+          usage?: { input?: number; output?: number; totalTokens?: number };
+        };
+      }
+    ).message;
+    if (message?.role !== "assistant") continue;
+    const usage = message.usage;
+    if (!usage) continue;
+    if (typeof usage.input === "number") totals.input += usage.input;
+    if (typeof usage.output === "number") totals.output += usage.output;
+    if (typeof usage.totalTokens === "number")
+      totals.totalTokens += usage.totalTokens;
+  }
+
+  return totals;
+}
+
+export default function createExtension(pi: ExtensionAPI): void {
+  let runtimeConfig: PiStatusConfig = loadConfig().config;
+  let currentCtx: ExtensionContext | undefined;
+  let requestRender: (() => void) | undefined;
+  let usageState: UsageCoreState | undefined;
+  let lastGitBranch: string | null = null;
+  let lastExtensionStatuses = new Map<string, string>();
+
+  function refreshRuntimeConfig(cwd?: string): void {
+    runtimeConfig = loadConfig(cwd ? { cwd } : undefined).config;
+  }
+
+  function acceptUsageState(payload: unknown): void {
+    if (!payload || typeof payload !== "object") return;
+    const maybe = payload as { state?: unknown };
+    const next =
+      maybe.state && typeof maybe.state === "object" ? maybe.state : payload;
+    usageState = next as UsageCoreState;
+    requestRender?.();
+  }
+
+  function installFooter(ctx: ExtensionContext): void {
+    if (!ctx.hasUI) return;
+
+    const factory: FooterFactory = (tui, theme, footerData) => {
+      requestRender = () => tui.requestRender?.();
+      const unsubscribe = footerData.onBranchChange?.(() =>
+        tui.requestRender?.(),
+      );
+
+      return {
+        dispose() {
+          unsubscribe?.();
+          if (requestRender === tui.requestRender) {
+            requestRender = undefined;
+          }
+        },
+        invalidate() {
+          requestRender?.();
+        },
+        render(width: number) {
+          const activeCtx = currentCtx ?? ctx;
+          lastGitBranch = footerData.getGitBranch();
+          lastExtensionStatuses = new Map(
+            footerData.getExtensionStatuses().entries(),
+          );
+          const line = buildFooterLine(
+            {
+              model: activeCtx.model,
+              cwd: activeCtx.cwd,
+              thinkingLevel: String(pi.getThinkingLevel()),
+              gitBranch: lastGitBranch,
+              runState: !activeCtx.isIdle()
+                ? "busy"
+                : activeCtx.hasPendingMessages()
+                  ? "queued"
+                  : "idle",
+              contextUsage: activeCtx.getContextUsage(),
+              branchTotals: aggregateBranchTotals(activeCtx),
+              sessionId: activeCtx.sessionManager.getSessionId(),
+              usageState,
+              extensionStatuses: lastExtensionStatuses,
+              filter: runtimeConfig.filter,
+              segments: runtimeConfig.segments,
+            },
+            theme,
+            width,
+          );
+
+          return [line];
+        },
+      };
+    };
+
+    ctx.ui.setFooter(factory as never);
+  }
+
+  function installEmptyFooter(ctx: ExtensionContext): void {
+    if (!ctx.hasUI) return;
+    ctx.ui.setFooter(EMPTY_FOOTER_FACTORY as never);
+  }
+
+  function refresh(ctx: ExtensionContext): void {
+    currentCtx = ctx;
+    refreshRuntimeConfig(ctx.cwd);
+    requestRender?.();
+  }
+
+  const unsubscribeUsageReady = pi.events.on(
+    USAGE_CORE_READY_EVENT,
+    (payload: unknown) => {
+      acceptUsageState(payload);
+    },
+  );
+
+  const unsubscribeUsageUpdate = pi.events.on(
+    USAGE_CORE_UPDATE_CURRENT_EVENT,
+    (payload: unknown) => {
+      acceptUsageState(payload);
+    },
+  );
+
+  pi.events.emit(USAGE_CORE_REQUEST_EVENT, {
+    type: "current",
+    reply(payload: unknown) {
+      acceptUsageState(payload);
+    },
+  });
+
+  pi.registerCommand("statusline", {
+    description: "Configure statusline segments and extension-status filters",
+    handler: async (_args, ctx) => {
+      if (!ctx.hasUI) {
+        ctx.ui.notify("/statusline requires interactive UI", "warning");
+        return;
+      }
+
+      const discovered = [...lastExtensionStatuses.keys()].sort((a, b) =>
+        a.localeCompare(b),
+      );
+
+      let result: PiStatusConfig | null = null;
+      try {
+        installEmptyFooter(ctx);
+        result = await ctx.ui.custom<PiStatusConfig | null>(
+          (tui, theme, _keys, done) => {
+            const activeCtx = currentCtx ?? ctx;
+            const menuTheme: StatuslineMenuTheme = isLiveTheme(theme)
+              ? fromPiTheme(theme)
+              : noTheme;
+            return createStatuslineEditor({
+              config: runtimeConfig,
+              discoveredStatuses: discovered,
+              previewInput: {
+                model: activeCtx.model,
+                cwd: activeCtx.cwd,
+                thinkingLevel: String(pi.getThinkingLevel()),
+                gitBranch: lastGitBranch,
+                runState: !activeCtx.isIdle()
+                  ? "busy"
+                  : activeCtx.hasPendingMessages()
+                    ? "queued"
+                    : "idle",
+                contextUsage: activeCtx.getContextUsage(),
+                branchTotals: aggregateBranchTotals(activeCtx),
+                sessionId: activeCtx.sessionManager.getSessionId(),
+                usageState,
+                extensionStatuses: lastExtensionStatuses,
+              },
+              theme: menuTheme,
+              done,
+              requestRender: () => tui.requestRender?.(),
+            });
+          },
+        );
+      } finally {
+        installFooter(ctx);
+      }
+
+      if (!result) return;
+
+      try {
+        saveConfigToSettings(result, { cwd: ctx.cwd });
+        runtimeConfig = result;
+        requestRender?.();
+      } catch (error) {
+        const message =
+          error instanceof Error
+            ? error.message
+            : "Failed to save statusline settings";
+        ctx.ui.notify(message, "warning");
+      }
+    },
+  });
+
+  pi.on("session_start", (_event, ctx) => {
+    refreshRuntimeConfig(ctx.cwd);
+    currentCtx = ctx;
+    installFooter(ctx);
+  });
+
+  pi.on("session_tree", (_event, ctx) => {
+    refreshRuntimeConfig(ctx.cwd);
+    currentCtx = ctx;
+    installFooter(ctx);
+  });
+
+  pi.on("model_select", (_event, ctx) => {
+    refresh(ctx);
+  });
+
+  pi.on("thinking_level_select", (_event, ctx) => {
+    refresh(ctx);
+  });
+
+  pi.on("session_shutdown", (_event, ctx) => {
+    currentCtx = undefined;
+    requestRender = undefined;
+    unsubscribeUsageReady();
+    unsubscribeUsageUpdate();
+    if (ctx.hasUI) ctx.ui.setFooter(undefined);
+  });
+}

package/src/render.ts

@@ -0,0 +1,343 @@
+import { existsSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { homedir } from "node:os";
+import { truncateToWidth } from "@earendil-works/pi-tui";
+
+// Color roles the live `buildFooterLine` rendering actually depends on. Kept
+// narrow on purpose: it only covers the segment colors and the "dim"
+// separator, not the full Pi `ThemeColor` union. `StatuslineMenuTheme` is
+// built as a superset of this so the same adapted theme can also feed the
+// bottom preview line.
+export type FooterRenderColor =
+  | "accent"
+  | "dim"
+  | "success"
+  | "warning"
+  | "error";
+
+export type ThemeLike = {
+  fg: (color: FooterRenderColor, text: string) => string;
+};
+
+export type ModelLike = {
+  id?: string;
+  name?: string;
+  reasoning?: boolean;
+};
+
+export type StatusLineSegmentId =
+  | "model"
+  | "model-with-reasoning"
+  | "project-name"
+  | "current-dir"
+  | "git-branch"
+  | "run-state"
+  | "context-remaining"
+  | "context-used"
+  | "context-window-size"
+  | "used-tokens"
+  | "total-input-tokens"
+  | "total-output-tokens"
+  | "session-id"
+  | "five-hour-limit"
+  | "weekly-limit"
+  | "extension-statuses";
+
+export type RunState = "busy" | "queued" | "idle";
+
+export type StatusFilter =
+  | { mode: "all"; hidden: string[] }
+  | { mode: "only"; shown: string[] };
+
+export type FooterRenderInput = {
+  model?: ModelLike;
+  cwd: string;
+  thinkingLevel: string;
+  gitBranch?: string | null;
+  runState: RunState;
+  contextUsage?: {
+    tokens?: number | null;
+    contextWindow?: number;
+    percent?: number | null;
+  };
+  branchTotals?: { input: number; output: number; totalTokens: number };
+  sessionId?: string;
+  usageState?: {
+    compatibility?: {
+      currentLiveProviderSnapshot?: {
+        providerId?: string;
+        windows: Array<{
+          key?: string;
+          label?: string;
+          usedPercent?: number;
+          unavailableReason?: string | null;
+        }>;
+      } | null;
+    };
+  };
+  extensionStatuses?: ReadonlyMap<string, string>;
+  filter: StatusFilter;
+  segments: StatusLineSegmentId[];
+};
+
+export const DEFAULT_SEGMENTS: StatusLineSegmentId[] = [
+  "model-with-reasoning",
+  "current-dir",
+];
+
+export function normalizeThinkingLevel(level: string): string {
+  switch (level) {
+    case "minimal":
+      return "min";
+    case "medium":
+      return "med";
+    default:
+      return level;
+  }
+}
+
+export function formatCompactNumber(value: number): string {
+  if (value < 1000) return String(Math.trunc(value));
+  const unit = value >= 1_000_000 ? "M" : "k";
+  const divisor = unit === "M" ? 1_000_000 : 1_000;
+  const short = (value / divisor).toFixed(1).replace(/\.0$/, "");
+  return `${short}${unit}`;
+}
+
+export function formatModelWithReasoning(
+  model: ModelLike | undefined,
+  thinkingLevel: string,
+): string | null {
+  const base = model?.name ?? model?.id;
+  if (!base) return null;
+  if (!model?.reasoning) return base;
+  return `${base} [${normalizeThinkingLevel(thinkingLevel)}]`;
+}
+
+export function abbreviateHomeDir(cwd: string, home = homedir()): string {
+  if (!home) return cwd;
+  if (cwd === home) return "~";
+  if (cwd.startsWith(`${home}/`)) return `~${cwd.slice(home.length)}`;
+  return cwd;
+}
+
+export function findProjectRootLabel(cwd: string): string | null {
+  let current = cwd;
+  while (true) {
+    if (
+      existsSync(join(current, ".git")) ||
+      existsSync(join(current, ".pi/settings.json"))
+    ) {
+      const base = basename(current);
+      return base || current;
+    }
+    const parent = dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+
+function contextColor(
+  percent: number | null | undefined,
+): "success" | "warning" | "error" | "dim" {
+  if (percent === undefined || percent === null) return "dim";
+  if (percent < 70) return "success";
+  if (percent < 90) return "warning";
+  return "error";
+}
+
+function getRateWindow(
+  input: FooterRenderInput,
+  key: "fiveHour" | "weekly",
+): { usedPercent: number } | null {
+  const snapshot = input.usageState?.compatibility?.currentLiveProviderSnapshot;
+  if (snapshot?.providerId !== "openai-codex") return null;
+  const window = snapshot.windows.find((item) => item.key === key);
+  if (
+    !window ||
+    typeof window.usedPercent !== "number" ||
+    window.unavailableReason
+  )
+    return null;
+  return { usedPercent: window.usedPercent };
+}
+
+function rateColor(usedPercent: number): "success" | "warning" | "error" {
+  if (usedPercent < 70) return "success";
+  if (usedPercent < 90) return "warning";
+  return "error";
+}
+
+const ANSI_PREFIX = `${String.fromCharCode(27)}[`;
+
+function hasAnsi(value: string): boolean {
+  return value.includes(ANSI_PREFIX);
+}
+
+function normalizeFilterList(input: string[]): string[] {
+  const out: string[] = [];
+  const seen = new Set<string>();
+  for (const item of input) {
+    if (seen.has(item)) continue;
+    seen.add(item);
+    out.push(item);
+  }
+  return out;
+}
+
+function formatExtensionStatuses(
+  input: FooterRenderInput,
+  theme: ThemeLike,
+): string | null {
+  const entries = [...(input.extensionStatuses?.entries() ?? [])].sort(
+    ([a], [b]) => a.localeCompare(b),
+  );
+  if (entries.length === 0) return null;
+
+  const filter = input.filter;
+  const blocked =
+    filter.mode === "all"
+      ? new Set(normalizeFilterList(filter.hidden))
+      : undefined;
+  const allowed =
+    filter.mode === "only"
+      ? new Set(normalizeFilterList(filter.shown))
+      : undefined;
+  const visible =
+    filter.mode === "all"
+      ? entries.filter(([key]) => !blocked?.has(key))
+      : entries.filter(([key]) => allowed?.has(key));
+
+  const parts = visible.slice(0, 5).map(([key, value]) => {
+    const trimmed = hasAnsi(value)
+      ? value
+      : value.replace(
+          new RegExp(
+            `^${key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?:\\s*[:=-]\\s*|\\s+)`,
+            "i",
+          ),
+          "",
+        );
+    return truncateToWidth(trimmed, 18, "...");
+  });
+
+  if (parts.length === 0) return null;
+  return parts.join(theme.fg("dim", " | "));
+}
+
+function formatSegment(
+  id: StatusLineSegmentId,
+  input: FooterRenderInput,
+  theme: ThemeLike,
+): [text: string, color: FooterRenderColor | null] | null {
+  switch (id) {
+    case "model": {
+      const value = input.model?.name ?? input.model?.id;
+      return value ? [value, "accent"] : null;
+    }
+    case "model-with-reasoning": {
+      const value = formatModelWithReasoning(input.model, input.thinkingLevel);
+      return value ? [value, "accent"] : null;
+    }
+    case "current-dir": {
+      const value = abbreviateHomeDir(input.cwd);
+      return value ? [value, "success"] : null;
+    }
+    case "project-name": {
+      const value = findProjectRootLabel(input.cwd);
+      return value ? [value, "success"] : null;
+    }
+    case "git-branch":
+      return input.gitBranch ? [input.gitBranch, "warning"] : null;
+    case "run-state":
+      return [input.runState, input.runState === "idle" ? "dim" : "accent"];
+    case "context-used": {
+      const percent = input.contextUsage?.percent;
+      return percent === undefined || percent === null
+        ? null
+        : [`${Math.round(percent)}% ctx`, contextColor(percent)];
+    }
+    case "context-remaining": {
+      const total = input.contextUsage?.tokens;
+      const window = input.contextUsage?.contextWindow;
+      const percent = input.contextUsage?.percent;
+      if (
+        total === undefined ||
+        total === null ||
+        window === undefined ||
+        percent === undefined ||
+        percent === null
+      ) {
+        return null;
+      }
+      const remaining = Math.max(0, window - total);
+      return [`${formatCompactNumber(remaining)} left`, contextColor(percent)];
+    }
+    case "context-window-size": {
+      const value = input.contextUsage?.contextWindow;
+      return value === undefined
+        ? null
+        : [`${formatCompactNumber(value)} ctx`, "dim"];
+    }
+    case "used-tokens": {
+      const value = input.branchTotals?.totalTokens;
+      return value === undefined
+        ? null
+        : [`${formatCompactNumber(value)} tok`, "dim"];
+    }
+    case "total-input-tokens": {
+      const value = input.branchTotals?.input;
+      return value === undefined
+        ? null
+        : [`↑${formatCompactNumber(value)}`, "dim"];
+    }
+    case "total-output-tokens": {
+      const value = input.branchTotals?.output;
+      return value === undefined
+        ? null
+        : [`↓${formatCompactNumber(value)}`, "dim"];
+    }
+    case "session-id":
+      return input.sessionId
+        ? [`sid ${input.sessionId.slice(0, 8)}`, "dim"]
+        : null;
+    case "five-hour-limit": {
+      const window = getRateWindow(input, "fiveHour");
+      if (!window) return null;
+      const remaining = Math.min(
+        100,
+        Math.max(0, 100 - Math.round(window.usedPercent)),
+      );
+      return [`5h ${remaining}% left`, rateColor(window.usedPercent)];
+    }
+    case "weekly-limit": {
+      const window = getRateWindow(input, "weekly");
+      if (!window) return null;
+      const remaining = Math.min(
+        100,
+        Math.max(0, 100 - Math.round(window.usedPercent)),
+      );
+      return [`wk ${remaining}% left`, rateColor(window.usedPercent)];
+    }
+    case "extension-statuses": {
+      const value = formatExtensionStatuses(input, theme);
+      return value ? [value, null] : null;
+    }
+    default:
+      return null;
+  }
+}
+
+export function buildFooterLine(
+  input: FooterRenderInput,
+  theme: ThemeLike,
+  width: number,
+): string {
+  const parts = input.segments
+    .map((id) => formatSegment(id, input, theme))
+    .filter((x): x is [string, FooterRenderColor | null] => x !== null)
+    .map(([text, color]) => (color ? theme.fg(color, text) : text));
+
+  const line = parts.join(theme.fg("dim", " · "));
+  return truncateToWidth(line, width);
+}