@pi-archimedes/ui 2.9.0

package/src/startup/sections.ts

@@ -0,0 +1,306 @@
+import { clampLine, stripAnsi } from "@pi-archimedes/core/text";
+import { gray, rgb, extractRgb, lerp } from "@pi-archimedes/core/color";
+import { TRUECOLOR } from "./logo.js";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { visibleWidth } from "@earendil-works/pi-tui";
+
+// ── Types ──────────────────────────────────────────────────────
+
+export const SECTION_KEYS = ["Models", "Context", "Prompts", "Skills", "Extensions", "Themes"] as const;
+export type SectionKey = (typeof SECTION_KEYS)[number];
+type RenderSectionKey = SectionKey | "Version";
+
+export interface ParsedSection {
+  name: SectionKey;
+  items: string[];
+}
+
+interface RenderSection {
+  name: RenderSectionKey;
+  items: string[];
+}
+
+// ── Animation constants ────────────────────────────────────────
+
+export const RAMP_FRAMES = 22;
+export const STAGGER_FRAMES = 0;
+export const BASE_FADE_DELAY = 3;
+export const MAX_STAGGER = BASE_FADE_DELAY + 5 * STAGGER_FRAMES;
+
+// ── Section detection & parsing ────────────────────────────────
+
+export function detectSection(plain: string): SectionKey | undefined {
+  for (const key of SECTION_KEYS) {
+    if (plain.includes(`[${key}]`)) return key;
+  }
+  return undefined;
+}
+
+export function parseSectionText(plain: string): ParsedSection | undefined {
+  const sectionName = detectSection(plain);
+  if (!sectionName) return undefined;
+
+  const names = extractItemsFromSection(plain, sectionName);
+  const items = deduplicateItems(names);
+  return { name: sectionName, items };
+}
+
+/**
+ * Extract item names from a section's plain text.
+ * Tracks source prefixes (npm:/git:) for Extensions/Skills sections.
+ */
+function extractItemsFromSection(plain: string, sectionName: SectionKey): string[] {
+  const names: string[] = [];
+  const lines = plain.split("\n");
+  let currentSource = "";
+  let sourceIndent = 0;
+  const showSource = sectionName === "Extensions" || sectionName === "Skills";
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (shouldSkipLine(trimmed, currentSource)) continue;
+
+    const indent = line.length - line.trimStart().length;
+
+    // Track package source headers (e.g. "git:github.com/...", "npm:@foo/bar")
+    if (/^(git:|npm:)\S+\//.test(trimmed)) {
+      currentSource = trimmed.startsWith("git:") ? "git:" : "npm:";
+      sourceIndent = indent;
+      const name = extractName(trimmed, sectionName);
+      if (name && showSource) names.push(name);
+      continue;
+    }
+
+    // Reset source prefix when indent returns to source level or shallower
+    if (currentSource && indent <= sourceIndent) {
+      currentSource = "";
+      sourceIndent = 0;
+    }
+
+    const itemNames = extractNames(trimmed, sectionName);
+    for (const n of itemNames) {
+      names.push(showSource && currentSource ? currentSource + n : n);
+    }
+  }
+  return names;
+}
+
+/**
+ * Extract item name(s) from a line.
+ *
+ * Collapsed section bodies are a single comma-joined line ("a, b, c") —
+ * split it so each name is its own item and the listing can wrap, instead
+ * of one clamped line ending in "...". Expanded bodies are per-item path
+ * lines; names never contain ", ", so splitting is safe.
+ */
+function extractNames(line: string, sectionName: SectionKey): string[] {
+  const parts = line.includes(", ")
+    ? line.split(", ").map(p => p.trim()).filter(Boolean)
+    : [line];
+  const out: string[] = [];
+  for (const part of parts) {
+    const name = extractName(part, sectionName);
+    if (name) out.push(name);
+  }
+  return out;
+}
+
+/** Check if a line should be skipped during section parsing. */
+function shouldSkipLine(trimmed: string, currentSource: string): boolean {
+  if (!trimmed) return true;
+  if (trimmed.startsWith("[")) return true;
+  if (/^(user|project|path)$/.test(trimmed)) return true;
+  if (/^(index\.(ts|js)|src|dist|out|build|lib|bin)$/i.test(trimmed)) return true;
+  // Skip resolved file paths only under source headers
+  if (currentSource) {
+    if (/\/(src|dist|out|build|lib|bin)\//.test(trimmed)) return true;
+    if (/\.(ts|js)$/.test(trimmed) && trimmed.includes("/") && !/SKILL\.(ts|js)$/i.test(trimmed)) return true;
+  }
+  return false;
+}
+
+/**
+ * Deduplicate items by bare name (without prefix).
+ * Prefers prefixed versions (npm:/git:) over bare names.
+ */
+function deduplicateItems(names: string[]): string[] {
+  const seen = new Map<string, string>();
+  for (const n of names) {
+    if (/^(index|dist|src|out|lib|bin)$/i.test(n)) continue;
+    const bare = n.replace(/^(npm:|git:)/, "");
+    if (!seen.has(bare) || n.includes(":")) seen.set(bare, n);
+  }
+  return [...seen.values()];
+}
+
+export function parseModelScope(plain: string): ParsedSection | undefined {
+  const m = plain.match(/Model scope:\s*(.+)/i);
+  if (!m) return undefined;
+  const raw = m[1]!.replace(/\s*\(Ctrl\+\w[\w\s]*\)/gi, "");
+  const items = raw.split(",").map(s => s.trim()).filter(Boolean);
+  return items.length > 0 ? { name: "Models", items } : undefined;
+}
+
+// ── Name extraction helpers ────────────────────────────────────
+
+function detectOrigin(path: string): { prefix: string; clean: string } {
+  if (/^npm:/.test(path)) return { prefix: "npm:", clean: path.slice(4) };
+  if (/^git:/.test(path)) return { prefix: "git:", clean: path.slice(4) };
+  if (/^https?:\/\//.test(path)) return { prefix: "git:", clean: path };
+  return { prefix: "", clean: path };
+}
+
+function cleanName(name: string): string {
+  return name.replace(/\.(ts|js|json|md|git)$/i, "");
+}
+
+type Extractor = (clean: string, prefix: string) => string;
+
+const defaultExtract: Extractor = (clean, prefix) =>
+  prefix + cleanName(clean.split("/").pop() ?? clean);
+
+const sectionExtractors: Record<SectionKey, Extractor> = {
+  Models: defaultExtract,
+  Themes: defaultExtract,
+  Prompts: (clean) => {
+    const base = clean.split("/").pop() ?? clean;
+    return cleanName(base) || clean;
+  },
+  Context: (clean) => clean.split("/").pop() ?? clean,
+  Skills: (clean, prefix) => {
+    if (!clean.includes("/")) return defaultExtract(clean, prefix);
+    const parts = clean.split("/");
+    const file = parts.pop() ?? "";
+    if (/^SKILL\.(md|ts|js)$/i.test(file)) {
+      return prefix + cleanName(parts.pop() ?? file);
+    }
+    return prefix + cleanName(file);
+  },
+  Extensions: (clean, prefix) => {
+    const stripped = clean.replace(/^https?:\/\/[^/]+\//, "");
+    const parts = stripped.split("/").filter(p => {
+      const lower = p.toLowerCase();
+      return p && !/^(index\.(ts|js)|src|dist|out|build|lib|bin)$/.test(lower);
+    });
+    if (parts.length > 0) return prefix + cleanName(parts.pop()!);
+    return prefix + cleanName(clean);
+  },
+};
+
+export function extractName(path: string, section: SectionKey): string {
+  const trimmed = path.trim();
+  const { prefix, clean } = detectOrigin(trimmed);
+  return sectionExtractors[section](clean, prefix);
+}
+
+// ── Column formatter ───────────────────────────────────────────
+
+function pad(s: string, w: number): string {
+  const vw = visibleWidth(s);
+  return vw >= w ? s : s + " ".repeat(w - vw);
+}
+
+export function formatColumns(sections: RenderSection[], theme: Theme, maxW: number, ref: { frame: number; revealed: boolean; revealedAt: number; scaffoldAt: number; settled: boolean }): string[] {
+  if (sections.length === 0) return [];
+
+  const dim = (t: string) => theme.fg("dim", t);
+  const muted = (t: string) => theme.fg("muted", t);
+
+  const headerW = Math.max(...sections.map(s => s.name.length + 2)) + 2;
+
+  const itemAge = ref.revealed ? ref.frame - ref.revealedAt : 0;
+  const labelAge = ref.revealed ? ref.frame - ref.scaffoldAt : 0;
+
+  // RGB endpoints for fade ramps (truecolor only)
+  const fadeStartRgb: [number, number, number] = [20, 20, 20];
+  let dimRgb: [number, number, number] | undefined;
+  let mutedRgb: [number, number, number] | undefined;
+  const labelRamping = TRUECOLOR && ref.revealed && labelAge < RAMP_FRAMES + MAX_STAGGER;
+  const itemRamping = TRUECOLOR && ref.revealed && itemAge < RAMP_FRAMES + MAX_STAGGER;
+  if (labelRamping || itemRamping) {
+    dimRgb = extractRgb(theme.fg("dim", " "));
+    mutedRgb = extractRgb(theme.fg("muted", " "));
+  }
+
+  const lines: string[] = [];
+
+  for (let si = 0; si < sections.length; si++) {
+    const sec = sections[si]!;
+    if (sec.items.length === 0) continue;
+
+    const availableW = maxW - headerW - 1;
+
+    // Label fade: near-invisible → dim (static dim when not revealed)
+    const secLabelAge = Math.max(0, labelAge - BASE_FADE_DELAY - si * STAGGER_FRAMES);
+    const wrapLabel = ref.revealed
+      ? buildItemWrapper(secLabelAge, true, fadeStartRgb, dimRgb, dim)
+      : dim;
+    const header = wrapLabel(`[${sec.name}]`);
+    const paddedHeader = header + " ".repeat(Math.max(0, headerW - sec.name.length - 2));
+
+    // Item fade: near-invisible → muted
+    const secItemAge = Math.max(0, itemAge - BASE_FADE_DELAY - si * STAGGER_FRAMES);
+    const wrapItems = buildItemWrapper(secItemAge, ref.revealed, fadeStartRgb, mutedRgb, muted);
+
+    // Style prefix (npm:/git:) dimmer than the name
+    const styleItem = (raw: string): string => {
+      const prefixMatch = raw.match(/^(npm:|git:)/);
+      if (prefixMatch) {
+        const pfx = prefixMatch[1]!;
+        const name = raw.slice(pfx.length);
+        return wrapLabel(pfx) + wrapItems(name);
+      }
+      return wrapItems(raw);
+    };
+
+    let currentLine = "";
+    let currentStyled = "";
+    let firstLine = true;
+
+    for (const item of sec.items) {
+      const itemW = visibleWidth(item);
+      const currentW = visibleWidth(currentLine);
+
+      if (currentLine && currentW + 2 + itemW > availableW) {
+        const rawLine = firstLine ? `${paddedHeader} ${currentStyled}` : " ".repeat(headerW + 1) + currentStyled;
+        lines.push(clampLine(rawLine, maxW));
+        currentLine = item;
+        currentStyled = styleItem(item);
+        firstLine = false;
+      } else {
+        currentLine = currentLine ? currentLine + "  " + item : item;
+        currentStyled = currentStyled ? currentStyled + "  " + styleItem(item) : styleItem(item);
+      }
+    }
+    if (currentLine) {
+      const rawLine = firstLine ? `${paddedHeader} ${currentStyled}` : " ".repeat(headerW + 1) + currentStyled;
+      lines.push(clampLine(rawLine, maxW));
+    }
+
+    if (sec.name === "Version") {
+      lines.push("");
+    }
+  }
+
+  return lines;
+}
+
+export function buildItemWrapper(
+  sectionAge: number,
+  revealed: boolean,
+  startRgb: [number, number, number] | undefined,
+  mutedRgb: [number, number, number] | undefined,
+  muted: (t: string) => string,
+): (text: string) => string {
+  if (!revealed) return (text) => text; // placeholders already styled
+
+  // No truecolor or ramp done → static muted
+  if (!startRgb || !mutedRgb || sectionAge >= RAMP_FRAMES) return muted;
+
+  const t = Math.min(1, sectionAge / RAMP_FRAMES);
+  const eased = 1 - (1 - t) * (1 - t);
+  const r = lerp(startRgb[0], mutedRgb[0], eased);
+  const g = lerp(startRgb[1], mutedRgb[1], eased);
+  const b = lerp(startRgb[2], mutedRgb[2], eased);
+  return (text) => rgb(r, g, b, text);
+}

package/src/startup/version.test.ts

@@ -0,0 +1,98 @@
+import { describe, it, expect } from "vitest";
+import * as fc from "fast-check";
+import { compareVersions } from "./version.js";
+
+// ── Version generator for property tests ─────────────────────────────────────
+
+const versionArb = fc.tuple(fc.nat(100), fc.nat(100), fc.nat(100)).map(
+	([major, minor, patch]) => `${major}.${minor}.${patch}`,
+);
+
+// ── compareVersions ──────────────────────────────────────────────────────────
+
+describe("compareVersions", () => {
+	it('returns 0 for equal versions', () => {
+		expect(compareVersions("1.0.0", "1.0.0")).toBe(0);
+	});
+
+	it('returns 1 when first version is greater', () => {
+		expect(compareVersions("2.0.0", "1.9.9")).toBe(1);
+	});
+
+	it('returns -1 when second version is greater', () => {
+		expect(compareVersions("1.0.0", "2.0.0")).toBe(-1);
+	});
+
+	it("handles v prefix on first argument", () => {
+		expect(compareVersions("v1.2.3", "1.2.3")).toBe(0);
+	});
+
+	it("handles v prefix on second argument", () => {
+		expect(compareVersions("1.2.3", "v1.2.3")).toBe(0);
+	});
+
+	it("handles v prefix on both arguments", () => {
+		expect(compareVersions("v2.0.0", "v1.0.0")).toBe(1);
+	});
+
+	it("handles partial versions (2 parts vs 3 parts)", () => {
+		expect(compareVersions("1.0", "1.0.0")).toBe(0);
+	});
+
+	it("handles partial versions with difference", () => {
+		expect(compareVersions("1.1", "1.0.5")).toBe(1);
+	});
+
+	it("handles zero-padded versions", () => {
+		expect(compareVersions("01.02.03", "1.2.3")).toBe(0);
+	});
+
+	it("compares minor version correctly", () => {
+		expect(compareVersions("1.2.0", "1.1.9")).toBe(1);
+		expect(compareVersions("1.1.0", "1.2.0")).toBe(-1);
+	});
+
+	it("compares patch version correctly", () => {
+		expect(compareVersions("1.0.5", "1.0.3")).toBe(1);
+		expect(compareVersions("1.0.3", "1.0.5")).toBe(-1);
+	});
+
+	it("handles all-zero versions", () => {
+		expect(compareVersions("0.0.0", "0.0.0")).toBe(0);
+	});
+
+	// ── Property tests ───────────────────────────────────────────────────
+
+	it("property: reflexive — compareVersions(a, a) === 0", () => {
+		fc.assert(
+			fc.property(versionArb, a => {
+				return compareVersions(a, a) === 0;
+			}),
+		);
+	});
+
+	it("property: antisymmetric — compareVersions(a, b) === -compareVersions(b, a)", () => {
+		fc.assert(
+			fc.property(versionArb, versionArb, (a, b) => {
+				return compareVersions(a, b) === -compareVersions(b, a);
+			}),
+		);
+	});
+
+	it("property: transitivity — if a<b and b<c then a<c", () => {
+		fc.assert(
+			fc.property(
+				fc.tuple(versionArb, versionArb, versionArb),
+				([a, b, c]) => {
+					const ab = compareVersions(a, b);
+					const bc = compareVersions(b, c);
+					const ac = compareVersions(a, c);
+					if (ab < 0 && bc < 0) {
+						return ac < 0;
+					}
+					return true;
+				},
+			),
+		);
+	});
+});

package/src/startup/version.ts

@@ -0,0 +1,26 @@
+const NPM_REGISTRY_URL = "https://registry.npmjs.org/@earendil-works/pi-coding-agent/latest";
+const FETCH_TIMEOUT_MS = 4000;
+
+export async function fetchLatestVersion(): Promise<string | undefined> {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    const res = await fetch(NPM_REGISTRY_URL, { signal: controller.signal });
+    clearTimeout(timeout);
+    if (!res.ok) return undefined;
+    const data = (await res.json()) as { version?: string };
+    return data.version;
+  } catch {
+    return undefined;
+  }
+}
+
+export function compareVersions(a: string, b: string): number {
+  const pa = a.replace(/^v/, "").split(".").map(Number);
+  const pb = b.replace(/^v/, "").split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] ?? 0) > (pb[i] ?? 0)) return 1;
+    if ((pa[i] ?? 0) < (pb[i] ?? 0)) return -1;
+  }
+  return 0;
+}