@pi-archimedes/ui 2.10.3 → 2.11.0

package/src/startup/index.ts

@@ -1,27 +1,28 @@
-import { VERSION, type Theme } from "@earendil-works/pi-coding-agent";
-import { getShinedLogo, TRUECOLOR, LOGO_PAD, LOGO_SETTLE_FRAME } from "./logo.js";
+import { VERSION, type ScopedModel, type Theme } from "@earendil-works/pi-coding-agent";
+import { getShinedLogo, LOGO_SETTLE_FRAME } from "./logo.js";
 import { loadUIConfig } from "../config.js";
-import { detectSection, parseSectionText, parseModelScope, formatColumns, buildItemWrapper, type ParsedSection, SECTION_KEYS } from "./sections.js";
-import { fetchLatestVersion, compareVersions } from "./version.js";
-import { stripAnsi } from "@pi-archimedes/core/text";
-import { Text, Spacer, Container, type TUI, truncateToWidth, visibleWidth, type Component } from "@earendil-works/pi-tui";
-
-// Symbol keys (survive hot-reload)
-const LISTING_REF = Symbol.for("splashscreen:listingRef");
-const ANIM_INTERVAL = Symbol.for("splashscreen:animInterval");
-const DEBOUNCE_TIMER = Symbol.for("splashscreen:debounceTimer");
-const PATCHED_CLEAR = Symbol.for("splashscreen:clearPatched");
-const PATCHED_LISTING = Symbol.for("splashscreen:listingPatched");
-const ORIG_ADD_CHILD = Symbol.for("splashscreen:origAddChild");
-
-// Animation constants
-const MAX_RENDER_WIDTH = 9999;
-const MIN_HEADER_LINES = 11;
-const REVEAL_DEBOUNCE_MS = 150;
-const RAMP_FRAMES = 22;
-const STAGGER_FRAMES = 0;
-const BASE_FADE_DELAY = 3;
-const MAX_STAGGER = BASE_FADE_DELAY + 5 * STAGGER_FRAMES;
+import {
+  formatColumns,
+  RAMP_FRAMES,
+  MAX_STAGGER,
+  type ParsedSection,
+} from "./sections.js";
+import { visibleWidth, type TUI } from "@earendil-works/pi-tui";
+
+// ── What this module owns ───────────────────────────────────────────────────
+//
+// The splash: the logo animation, the version row, and the text reveal that
+// carries them in. That is all.
+//
+// It used to own pi's startup listing too — finding pi's resource container by
+// child-order heuristics, intercepting `addChild`, swallowing pi's section
+// components and re-rendering them here, plus a `console.log` patch that ate
+// pi's `Model scope:` line. All of that is gone (pi 1.x alignment, Task 8): pi
+// renders its own listing, `quietStartup` decides whether it shows, and
+// `ctx.scopedModels` hands us the model scope directly, so there is nothing
+// left to scrape and no reason to touch the console or pi's component tree.
+// `ui/src/index.ts` decides *whether* to install this splash (quietStartup) and
+// what sections to reveal (the model scope); this module animates them.
 
 export interface ListingRef {
   sections: ParsedSection[];
@@ -29,48 +30,65 @@ export interface ListingRef {
   revealed: boolean;
   revealedAt: number;
   scaffoldAt: number;
-  latestVersion?: string;
   settled: boolean;
   cachedLines?: string[];
   cachedWidth?: number;
-  cachedHeight?: number;
-  maxHeaderHeight?: number;
 }
 
-// ── renderHeader() — composes logo + sections + padding ────────────────
+// ── renderHeader() — composes logo + listing ───────────────────────────
 
-export function renderHeader(theme: Theme, ref: ListingRef, width: number, height: number): string[] {
-  const dim = (t: string) => theme.fg("dim", t);
-  const accent = (t: string) => theme.fg("accent", t);
+/**
+ * The splash's own text rows, drawn in pi's shape (`formatColumns`), under the
+ * animated logo. Everything the header is, and nothing else.
+ *
+ * The block is exactly its content on both screens, and that is deliberate
+ * twice over:
+ *
+ * - a frame-bounded (fullscreen) screen allocates the height itself (ADR 0027),
+ *   so a header padded to the terminal would be the whole viewport and the
+ *   editor would get nothing — the reason #97/#102 sized it to content;
+ * - on regular screen the padding was the defect the maintainer pointed at.
+ *   pi's header container puts a `Spacer(1)` above and below whatever header is
+ *   installed (`interactive-mode.js:764-766`) and its resource listing opens
+ *   with one more, so a header padded to `rows - 3` pushed pi's own listing a
+ *   screen down and left the two halves of the intro reading as two documents.
+ *
+ * Nothing here is sized by the screen any more, which is also why the header
+ * factory no longer asks the renderer which screen it is on: there is no
+ * per-screen measurement left to take and nothing per-screen left to go stale.
+ */
+export function renderHeader(theme: Theme, ref: ListingRef, width: number): string[] {
   const cfg = loadUIConfig();
   const logoLines = getShinedLogo(ref.frame, cfg.animationStyle, cfg.colorfulLogo);
 
   // Use cached text lines if settled (no more animations)
   let listingLines: string[];
 
-  if (ref.settled && ref.cachedLines && ref.cachedWidth === width && ref.cachedHeight === height) {
+  if (ref.settled && ref.cachedLines && ref.cachedWidth === width) {
     listingLines = ref.cachedLines;
   } else {
-    const sectionsToRender: { name: "Version" | ParsedSection["name"]; items: string[] }[] = [];
+    const sectionsToRender: ParsedSection[] = [];
 
     if (!ref.revealed) {
       // Logo only — sections appear together on reveal
     } else {
-      const latest = ref.latestVersion ?? VERSION;
-      const hasUpdate = compareVersions(latest, VERSION) > 0;
-      const latestStr = hasUpdate ? `Latest: ${accent("v" + latest)}` : `Latest: v${latest}`;
-      sectionsToRender.push({ name: "Version", items: [`Local: v${VERSION}`, latestStr] });
-
-      // Display sections in SECTION_KEYS order, skip empty
-      const byName = new Map(ref.sections.map(s => [s.name, s]));
-      for (const key of SECTION_KEYS) {
-        const sec = byName.get(key);
-        if (sec && sec.items.length > 0) sectionsToRender.push(sec);
+      // The version row is ours to state; pi owns its own update check
+      // (`--update`, `/changelog`, `PI_SKIP_VERSION_CHECK`), so there is no
+      // second `Latest:` here — that used to arrive from a registry fetch on
+      // every start.
+      sectionsToRender.push({ name: "Version", items: [`v${VERSION}`] });
+
+      // Then whatever the caller revealed in. pi decides which of *its*
+      // sections exist; we only ever carry the model scope. Empty sections are
+      // "nothing loaded", skip them.
+      for (const sec of ref.sections) {
+        if (sec.items.length > 0) sectionsToRender.push(sec);
       }
     }
 
-    const listingMaxW = Math.floor(width * 0.7);
-    listingLines = formatColumns(sectionsToRender, theme, listingMaxW, ref);
+    // pi writes its listing rows across the frame, so the rows break at the
+    // frame edge rather than at some narrower column of ours.
+    listingLines = formatColumns(sectionsToRender, theme, width, ref);
 
     // Cache once text animations are done
     const textAge = ref.revealed ? ref.frame - ref.revealedAt : 0;
@@ -81,141 +99,121 @@ export function renderHeader(theme: Theme, ref: ListingRef, width: number, heigh
       ref.settled = true;
       ref.cachedLines = listingLines;
       ref.cachedWidth = width;
-      ref.cachedHeight = height;
     }
   }
 
   // Build content: logo + separator + listing
   const contentLines: string[] = [];
 
-  // Logo centered above listing (same center as listing text)
-  const listingMaxW = Math.floor(width * 0.7);
-  const listingLeftPad = Math.floor((width - listingMaxW) / 2);
+  // Logo centred across the frame — the top half of the intro, unchanged.
   for (const logoRow of logoLines) {
-    const pad = Math.floor((listingMaxW - visibleWidth(logoRow)) / 2);
-    contentLines.push(" ".repeat(LOGO_PAD) + " ".repeat(listingLeftPad + pad) + logoRow);
+    const pad = Math.max(0, Math.floor((width - visibleWidth(logoRow)) / 2));
+    contentLines.push(" ".repeat(pad) + logoRow);
   }
 
   // Separator
   contentLines.push("");
 
-  // Listing
-  for (const listRow of listingLines) {
-    contentLines.push(" ".repeat(LOGO_PAD) + " ".repeat(listingLeftPad) + listRow);
-  }
-
-  // Pad top and bottom to fill height (+5 top bias for visual centering)
-  const VERTICAL_CENTER_BIAS = 5; // Shift content slightly upward for visual balance
-  const contentHeight = contentLines.length;
-  const remaining = Math.max(0, height - contentHeight);
-  const topPad = Math.floor(remaining / 2) + VERTICAL_CENTER_BIAS;
-  const bottomPad = remaining - topPad;
-
-  const result: string[] = [];
-  for (let i = 0; i < topPad; i++) result.push("");
-  for (const line of contentLines) result.push(line);
-  for (let i = 0; i < bottomPad; i++) result.push("");
+  // Listing, at column 1: pi's rows start there, and anything indenting ours
+  // past it is what made the two halves look unrelated.
+  for (const listRow of listingLines) contentLines.push(listRow);
 
-  return result;
+  return contentLines;
 }
 
-// ── Section text extraction ───────────────────────────────────────────────
+// ── The section the splash is allowed to know about ───────────────────────
 
 /**
- * Read the full text of a section component.
+ * The session's model scope, in the shape the splash renders — the same set
+ * `ctx.scopedModels` reports and `/scoped-models` lists, formatted the way pi's
+ * own `Model scope:` line does (`id`, plus `:thinkingLevel` when the pattern
+ * carried one).
  *
- * pi ≥0.99 builds ExpandableText with constructor closures (no instance
- * getExpandedText() anymore) and starts collapsed — a plain render() would
- * return the lossy comma-joined body. setExpanded(true) (pi's own public
- * expansion API) makes render() return the full per-item body.
+ * The alternative it replaces was a `console.log` patch watching for pi to
+ * print that line, which both hid the line (the patch consumed it) and had no
+ * answer for a session where pi prints nothing.
+ *
+ * Returns `undefined` for no scope, so the section is simply absent: an empty
+ * `[Models]` header is pi's "nothing scoped" case, and there pi offers every
+ * model. A host without the property answers the same way.
  */
-function expandedText(component: Text): string {
-  const setExpanded = (component as any).setExpanded;
-  if (typeof setExpanded === "function") setExpanded.call(component, true);
-  return stripAnsi(component.render(MAX_RENDER_WIDTH).join("\n"));
+export function modelScopeSection(
+  scopedModels: readonly ScopedModel[] | undefined,
+): ParsedSection | undefined {
+  if (!Array.isArray(scopedModels)) return undefined;
+
+  const items: string[] = [];
+  for (const scoped of scopedModels) {
+    const id = scoped?.model?.id;
+    if (typeof id !== "string" || id === "") continue;
+    items.push(scoped.thinkingLevel ? `${id}:${scoped.thinkingLevel}` : id);
+  }
+  return items.length > 0 ? { name: "Models", items } : undefined;
 }
 
-// ── Chat container discovery ────────────────────────────────────────────
+// ── The animation ───────────────────────────────────────────────────────────
 
-// Fragile: relies on TUI child ordering (header, chat, footer) which is an
-// internal layout detail of pi's InteractiveMode. If upstream changes the
-// child structure, this will need updating.
-//
-// Strategy (most specific → least specific):
-// 1. Container with "Scrollable" in constructor name
-// 2. Middle child — TUI layout is [headerContainer, chatContainer, footer]
-//    This is position-stable even when chatContainer is empty (e.g. after clear)
-// 3. Container with most children (chat usually has the most)
-// 4. First Container found
-function findChatContainer(tui: TUI): Container | undefined {
-  // Strategy 1: Look for Scrollable container
-  for (const child of tui.children) {
-    if (child instanceof Container && child.constructor.name.includes("Scrollable")) {
-      return child;
-    }
+/**
+ * Sections wait this long after the header is built before they appear, so the
+ * logo gets its reveal frames first. The old value, kept: it is the interval
+ * pi's own section components used to arrive inside, and the splash looks the
+ * same either way.
+ */
+const REVEAL_DEBOUNCE_MS = 150;
+const FRAME_INTERVAL_MS = 16;
+
+// One splash is on screen at a time. pi disposes the previous header before it
+// builds the next one (`setExtensionHeader()` — a new session, `/reload`, or any
+// `setHeader()` call), so a module pair of timers cannot leak a second
+// animation — and holds no renderer: each timer closes over the `tui` it was
+// started with, and the one running is the one the current header factory was
+// handed (ADR 0027).
+let frameTimer: ReturnType<typeof setInterval> | undefined;
+let revealTimer: ReturnType<typeof setTimeout> | undefined;
+
+/** Stop both halves of the animation (header disposed, session ended). */
+export function stopStartupListing(): void {
+  if (frameTimer) {
+    clearInterval(frameTimer);
+    frameTimer = undefined;
   }
-
-  // Strategy 2: Middle child — TUI layout is [headerContainer, chatContainer, footer]
-  if (tui.children.length >= 3) {
-    const middle = tui.children[1];
-    if (middle instanceof Container) return middle;
+  if (revealTimer) {
+    clearTimeout(revealTimer);
+    revealTimer = undefined;
   }
-
-  // Strategy 3: Find the Container with the most children (chat area)
-  const containers = tui.children.filter((c): c is Container => c instanceof Container);
-  if (containers.length > 1) {
-    const largest = containers.reduce((best, c) =>
-      c.children.length > best.children.length ? c : best,
-    );
-    if (largest.children.length > 0) return largest;
-  }
-
-  // Strategy 4: First Container
-  if (containers.length > 0) return containers[0];
-
-  return undefined;
 }
 
-// Pi 0.84+ moved resource sections from chatContainer to loadedResourcesContainer
-// (child of documentContainer). Find it by locating documentContainer (the first TUI
-// child that contains Container sub-children), then taking its second Container child.
-//
-// Pi 0.84+ TUI layout (regular mode, 7 top-level children):
-//   documentContainer → [headerContainer(0), loadedResourcesContainer(1), chatContainer(2)]
-function findLoadedResourcesContainer(tui: TUI): Container | undefined {
-  // Only run this heuristic on Pi >= 0.84.0 where loadedResourcesContainer exists.
-  // On older Pi versions, return undefined so the caller falls back to findChatContainer().
-  if (compareVersions(VERSION, "0.84.0") < 0) return undefined;
-
-  // Find documentContainer: first tui child that has Container sub-children
-  const docContainer = tui.children.find(
-    (c) => c instanceof Container && c.children.some((child) => child instanceof Container)
-  ) as Container | undefined;
-  if (!docContainer) return undefined;
-
-  const containerChildren = docContainer.children.filter(
-    (c): c is Container => c instanceof Container
-  );
-  // Pi 0.84+: [headerContainer(0), loadedResourcesContainer(1), chatContainer(2)]
-  // The index [1] assumption is load-bearing — tied to Pi 0.84+ initialization order.
-  if (containerChildren.length < 2) return undefined;
-  return containerChildren[1]; // loadedResourcesContainer
+function startFrameTimer(tui: TUI, ref: ListingRef): void {
+  if (frameTimer) clearInterval(frameTimer);
+  frameTimer = setInterval(() => {
+    ref.frame++;
+    // Logo done and either the listing settled, or nothing is revealed and
+    // none is on its way — the state a quiet start leaves behind. Idle frames
+    // cost a full viewport redraw on fullscreen screen, so stop here rather
+    // than repaint forever (#92).
+    const nothingToAnimate = ref.settled || (!ref.revealed && !revealTimer);
+    if (nothingToAnimate && ref.frame >= LOGO_SETTLE_FRAME) {
+      clearInterval(frameTimer);
+      frameTimer = undefined;
+      return;
+    }
+    tui.requestRender();
+  }, FRAME_INTERVAL_MS);
 }
 
-export function patchStartupListing(
-  tui: TUI,
-  _theme: Theme,
-  ref: ListingRef,
-): void {
-  const resourcesContainer = findLoadedResourcesContainer(tui) ?? findChatContainer(tui);
-  if (!resourcesContainer) {
-    console.warn("[archimedes] Could not find resources container — startup listing disabled. This may indicate a pi TUI structure change.");
-    return;
-  }
-  const rc = resourcesContainer as any;
-
-  // Always update ref + restart animation (critical for /reload)
-  rc[LISTING_REF] = ref;
+/**
+ * Install the splash for the header we were just handed: reset the animation
+ * ref and start the frame timer. Re-installing (a new session, `/reload`, or
+ * any other `setHeader()` replacement, each of which pi disposes the old header
+ * before it calls the factory) restarts the animation on the renderer now in
+ * hand and stops the previous one — a stale renderer must not keep being asked
+ * for frames.
+ *
+ * Sections are not passed here: call {@link revealStartupListing} with them
+ * (or not at all, which leaves the splash as logo + version).
+ */
+export function patchStartupListing(tui: TUI, ref: ListingRef): void {
+  stopStartupListing();
   ref.frame = 0;
   ref.revealed = false;
   ref.revealedAt = 0;
@@ -223,127 +221,36 @@ export function patchStartupListing(
   ref.settled = false;
   delete ref.cachedLines;
   delete ref.cachedWidth;
-  delete ref.maxHeaderHeight;
-
-  if (rc[ANIM_INTERVAL]) clearInterval(rc[ANIM_INTERVAL]);
-  if (rc[DEBOUNCE_TIMER]) clearTimeout(rc[DEBOUNCE_TIMER]);
-
-  const interval = setInterval(() => {
-    try {
-      const current: ListingRef = rc[LISTING_REF];
-      if (!current) {
-        clearInterval(interval);
-        return;
-      }
-      current.frame++;
-      if (current.settled && current.frame >= LOGO_SETTLE_FRAME) {
-        clearInterval(interval);
-        rc[ANIM_INTERVAL] = null;
-        return;
-      }
-      tui.requestRender();
-    } catch {
-      clearInterval(interval);
-    }
-  }, 16);
-
-  rc[ANIM_INTERVAL] = interval;
-
-  // Fetch latest version from npm
-  fetchLatestVersion().then(v => {
-    if (v) {
-      const current: ListingRef = rc[LISTING_REF];
-      current.latestVersion = v;
-      // Invalidate cache so version updates on next render
-      delete current.cachedLines;
-      current.settled = false;
-    }
-  });
-
-  // Patch clear() to intercept container rebuild
-  if (!rc[PATCHED_CLEAR]) {
-    rc[PATCHED_CLEAR] = true;
-    const origClear = resourcesContainer.clear.bind(resourcesContainer);
-    resourcesContainer.clear = () => {
-      return origClear();
-    };
-  }
-
-  // Only patch addChild once — the closure reads rc[LISTING_REF] dynamically
-  if (rc[PATCHED_LISTING]) {
-    resourcesContainer.clear();
-    return;
-  }
-  rc[PATCHED_LISTING] = true;
-
-  const origAddChild = resourcesContainer.addChild.bind(resourcesContainer);
-  rc[ORIG_ADD_CHILD] = origAddChild; // Store for cleanup on shutdown
-  resourcesContainer.clear();
-
-  resourcesContainer.addChild = (component: Component) => {
-    try {
-      const currentRef: ListingRef = rc[LISTING_REF];
 
-      if (component instanceof Text) {
-      // pi ≥0.67.6 wraps startup sections in ExpandableText; collapsed body
-      // is a lossy comma-joined base-name list. Parse the expanded text so
-      // Extensions keep real names instead of "index.ts/index.js/index".
-      // pi ≥0.99 moved the text builders into the constructor (no instance
-      // getExpandedText()) — expandedText() forces expansion via setExpanded().
-      const getExpanded = (component as any).getExpandedText;
-      const plain = typeof getExpanded === "function"
-        ? stripAnsi(getExpanded.call(component))
-        : expandedText(component);
-
-      const section = parseSectionText(plain) ?? parseModelScope(plain);
-      if (section) {
-        const existing = currentRef.sections.find(s => s.name === section.name);
-        if (existing) {
-          existing.items = [...new Set([...existing.items, ...section.items])];
-        } else {
-          currentRef.sections.push(section);
-        }
-
-        // Invalidate cache so late-arriving sections show up
-        currentRef.settled = false;
-        delete currentRef.cachedLines;
-
-        if (currentRef.revealed) {
-          // Already revealed — show new section immediately
-          tui.requestRender();
-        } else {
-          // Batch initial sections — reset debounce on each arrival
-          if (rc[DEBOUNCE_TIMER]) clearTimeout(rc[DEBOUNCE_TIMER]);
-          rc[DEBOUNCE_TIMER] = setTimeout(() => {
-            const ref: ListingRef = rc[LISTING_REF];
-            ref.revealed = true;
-            ref.revealedAt = ref.frame;
-            ref.scaffoldAt = ref.frame;
-            tui.requestRender();
-            rc[DEBOUNCE_TIMER] = null;
-          }, REVEAL_DEBOUNCE_MS);
-        }
-
-        return;
-      }
-
-      if (
-        plain.includes("Listing all available commands") ||
-        plain.includes("(Source: extension)") ||
-        plain.trim().startsWith("/skill:")
-      ) {
-        return;
-      }
-    }
+  startFrameTimer(tui, ref);
+}
 
-    if (component instanceof Spacer && !currentRef.revealed) return;
-    try {
-      origAddChild(component);
-    } catch (err) {
-      console.error("[archimedes] Error in resourcesContainer.addChild:", err);
-    }
-  } catch (err) {
-    console.error("[archimedes] Error in startup listing addChild handler:", err);
-  }
-  };
+/**
+ * Reveal the splash's text half — the version row always comes with the
+ * header, `sections` is whatever the caller decided to show next (see
+ * {@link modelScopeSection}).
+ *
+ * Debounced so the logo keeps its frames, and it restarts the frame timer when
+ * the logo already settled before anything arrived: without the restart the
+ * text would be revealed into a stopped animation and fade in over frames
+ * nobody draws.
+ */
+export function revealStartupListing(
+  tui: TUI,
+  ref: ListingRef,
+  sections: ParsedSection[],
+): void {
+  if (revealTimer) clearTimeout(revealTimer);
+  revealTimer = setTimeout(() => {
+    revealTimer = undefined;
+    ref.sections = sections;
+    ref.revealed = true;
+    ref.revealedAt = ref.frame;
+    ref.scaffoldAt = ref.frame;
+    ref.settled = false;
+    delete ref.cachedLines;
+    delete ref.cachedWidth;
+    tui.requestRender();
+    if (!frameTimer) startFrameTimer(tui, ref);
+  }, REVEAL_DEBOUNCE_MS);
 }