@pi-unipi/core 2.16.0 → 2.17.0

package/fusion-status.ts

@@ -0,0 +1,39 @@
+/**
+ * @pi-unipi/core — shared Fusion display status
+ *
+ * The fusion package owns the active lead/sidekick selection; the footer
+ * package owns the input-box frame that should display it. Same pattern as
+ * background-tasks' shared registry: a Symbol.for global published at
+ * extension init / session start and cleared on shutdown.
+ */
+
+export interface SharedFusionStatus {
+  /** Display name of the lead (the session model). */
+  leadName: string;
+  /** Lead thinking level, e.g. "medium". */
+  leadEffort: string;
+  /** Display name of the sidekick. */
+  sidekickName: string;
+  /** Sidekick thinking level. */
+  sidekickEffort: string;
+  /** Estimated savings compared with pricing all sidekick usage at lead rates. */
+  savedUsd?: number;
+}
+
+const KEY = Symbol.for("unipi.fusion.status");
+
+type Holder = { status?: SharedFusionStatus | undefined };
+
+function holder(): Holder {
+  const g = globalThis as { [KEY]?: Holder };
+  g[KEY] ??= {};
+  return g[KEY] as Holder;
+}
+
+export function setSharedFusionStatus(status: SharedFusionStatus | undefined): void {
+  holder().status = status;
+}
+
+export function getSharedFusionStatus(): SharedFusionStatus | undefined {
+  return holder().status;
+}

package/index.ts

@@ -12,3 +12,5 @@ export * from "./model-cache.js";
 export * from "./tui-width.js";
 export * from "./tui-overlay.js";
 export * from "./bounded-output.js";
+export * from "./spinner-line.js";
+export * from "./fusion-status.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/core",
-  "version": "2.16.0",
+  "version": "2.17.0",
   "description": "Shared utilities, event types, and constants for Unipi extension suite",
   "type": "module",
   "license": "MIT",

package/spinner-line.ts

@@ -0,0 +1,99 @@
+/**
+ * @pi-unipi/core — self-animating spinner line widget
+ *
+ * A one-line `ctx.ui.setWidget()` component that owns its own animation
+ * timer and calls `tui.requestRender()` on every frame — the same pattern
+ * as pi's built-in `Loader`. Use it for "still working" indicators whose
+ * data refreshes slowly (1 s task polls, agent trackers) but whose spinner
+ * must still look alive at ~12 fps.
+ *
+ * The text callback runs on every frame so elapsed times stay fresh; return
+ * `undefined` to render nothing (the line collapses) without disposing.
+ */
+
+export const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"] as const;
+export const SPINNER_INTERVAL_MS = 80;
+
+export interface SpinnerLineOptions {
+  /** Produce the line body (without the spinner glyph). `undefined` hides the line. */
+  text: () => string | undefined;
+  /** Colour the spinner glyph. Defaults to identity. */
+  colorSpinner?: ((glyph: string) => string) | undefined;
+  /** Animation frames. Defaults to braille dots. */
+  frames?: readonly string[] | undefined;
+  intervalMs?: number | undefined;
+  /** Left padding columns. Defaults to 1. */
+  padLeft?: number | undefined;
+}
+
+export interface SpinnerLineComponent {
+  render(width: number): string[];
+  invalidate(): void;
+  dispose(): void;
+}
+
+type RenderRequester = { requestRender(): void };
+
+/**
+ * Create the widget factory to pass to `ctx.ui.setWidget(key, factory, opts)`.
+ * The returned component starts animating when constructed and stops on
+ * `dispose()` (pi calls `dispose` when the widget is replaced or cleared).
+ */
+export function createSpinnerLine(
+  options: SpinnerLineOptions,
+): (tui: RenderRequester, theme: unknown) => SpinnerLineComponent {
+  const frames = options.frames ?? SPINNER_FRAMES;
+  const intervalMs = options.intervalMs ?? SPINNER_INTERVAL_MS;
+  const pad = " ".repeat(Math.max(0, options.padLeft ?? 1));
+  const color = options.colorSpinner ?? ((g: string) => g);
+
+  return (tui) => {
+    let frame = 0;
+    let timer: ReturnType<typeof setInterval> | undefined =
+      frames.length > 1
+        ? setInterval(() => {
+            frame = (frame + 1) % frames.length;
+            tui.requestRender();
+          }, intervalMs)
+        : undefined;
+
+    return {
+      render(width: number): string[] {
+        const body = options.text();
+        if (body === undefined) return [];
+        const glyph = frames[frame] ?? "";
+        const line = `${pad}${glyph.length > 0 ? `${color(glyph)} ` : ""}${body}`;
+        return [width > 0 ? truncateVisible(line, Math.max(1, width - 1)) : line];
+      },
+      invalidate() {
+        /* stateless between renders; frame lives in closure */
+      },
+      dispose() {
+        if (timer !== undefined) {
+          clearInterval(timer);
+          timer = undefined;
+        }
+      },
+    };
+  };
+}
+
+/** Cheap width-safe truncation that ignores ANSI escapes when counting. */
+function truncateVisible(line: string, max: number): string {
+  let visible = 0;
+  let out = "";
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i] ?? "";
+    if (ch === "\x1b") {
+      const end = line.indexOf("m", i);
+      if (end === -1) break;
+      out += line.slice(i, end + 1);
+      i = end;
+      continue;
+    }
+    if (visible >= max) break;
+    out += ch;
+    visible++;
+  }
+  return out;
+}

package/tui-overlay.ts

@@ -87,3 +87,35 @@ export class OverlayTheme {
     return this.fg("borderMuted", `${left}${safeRepeat("─", innerWidth)}${right}`);
   }
 }
+
+/**
+ * Wrap already-rendered body lines in a solid, opaque frame so an overlay
+ * never lets the transcript bleed through. Every row is padded to the full
+ * inner width and tinted with `bgFn` (defaults to a dark neutral), which is
+ * what makes it opaque — pi's overlay compositor only paints the cells a
+ * component returns.
+ */
+export function frameOverlay(
+  body: readonly string[],
+  width: number,
+  options: {
+    title?: string | undefined;
+    borderFg?: ((text: string) => string) | undefined;
+    bgFn?: ((text: string) => string) | undefined;
+  } = {},
+): string[] {
+  const inner = Math.max(1, width - 2);
+  const border = options.borderFg ?? ((t: string) => `\x1b[38;2;83;160;215m${t}\x1b[0m`);
+  const bg = options.bgFn ?? ((t: string) => `\x1b[48;2;24;26;32m${t}\x1b[49m`);
+  const row = (content: string): string => {
+    const cut = truncateToWidth(content, inner, "");
+    const padded = cut + safeRepeat(" ", Math.max(0, inner - visibleWidth(cut)));
+    return `${border("│")}${bg(padded)}${border("│")}`;
+  };
+  const titleText = options.title ? ` ${options.title} ` : "";
+  const topFill = Math.max(0, inner - visibleWidth(titleText));
+  const lines = [border(`╭${titleText}${safeRepeat("─", topFill)}╮`)];
+  for (const line of body) lines.push(row(line));
+  lines.push(border(`╰${safeRepeat("─", inner)}╯`));
+  return lines;
+}