sigrank 0.19.0 → 1.0.1

package/presentation/narrate.mjs

@@ -0,0 +1,219 @@
+/**
+ * narrate.mjs — deterministic prose "card" for a cascade result.
+ *
+ * Uses the 10 build archetype composition classifier, synced with the app's
+ * lib/analytics/build-archetypes.ts. Every operator lands in exactly one
+ * archetype that describes their operating shape — not their rank.
+ *
+ * Classification precedence (first match wins):
+ *   1. CONVERGENT   — P80+ on all 3 axes (leverage + velocity + construction)
+ *   2. KINETIC      — velocity >= 0.80
+ *   3. Construction  — construction >= 0.02 (BUILDER / RECURSIVE / AMPLIFIER)
+ *   4. Reuse depth   — else (INPUT-BOUND / PRIMING / CONTEXTUAL / DEEP READER / ARCHIVIST)
+ *
+ * The three derived dimensions:
+ *   leverage     = cache_read / input
+ *   velocity     = output / input
+ *   construction = cache_write / cache_read
+ *
+ * Token-only. No network, no randomness.
+ */
+
+// Safe formatters: never emit NaN/Infinity/undefined into the card.
+const safeNum = (n) => (Number.isFinite(Number(n)) ? Number(n) : null);
+const comma = (n, dec) => {
+  const v = safeNum(n);
+  return v !== null
+    ? v.toLocaleString("en-US", {
+        minimumFractionDigits: dec,
+        maximumFractionDigits: dec,
+      })
+    : "—";
+};
+const plain = (n, dec) => {
+  const v = safeNum(n);
+  return v !== null ? v.toFixed(dec) : "—";
+};
+
+// P80 thresholds calibrated from HCM cut (1,586 operators).
+const CONVERGENT_T = { levP80: 74.6, velP80: 0.34, constrP80: 0.0431 };
+const VEL_KINETIC = 0.8;
+const LEV_INPUT_BOUND = 5;
+const LEV_PRIMING = 10;
+const LEV_CONTEXTUAL = 15;
+const LEV_DEEP_READER = 23;
+const CONSTR_ACTIVE = 0.02;
+const LEV_BUILDER = 30;
+const LEV_RECURSIVE = 50;
+
+/** Classify an operator's cascade into one of 10 build archetypes.
+ *  Returns { key, name, family, familyLabel, blurb }. */
+export function classifyArchetype(cascade) {
+  const v = safeNum(cascade.velocity);
+  const l = safeNum(cascade.leverage);
+  const cw = cascade.pillars ? Number(cascade.pillars.cacheCreate) : NaN;
+  const cr = cascade.pillars ? Number(cascade.pillars.cacheRead) : NaN;
+  const input = cascade.pillars ? Number(cascade.pillars.input) : NaN;
+
+  // Derive construction = cache_write / cache_read
+  const constr = Number.isFinite(cr) && cr > 0 && Number.isFinite(cw) ? cw / cr : 0;
+  const lev = l ?? 0;
+  const vel = v ?? 0;
+
+  // 1. CONVERGENT — all three axes elevated (P80+)
+  if (
+    lev > CONVERGENT_T.levP80 &&
+    vel > CONVERGENT_T.velP80 &&
+    constr > CONVERGENT_T.constrP80
+  ) {
+    return {
+      key: "convergent",
+      name: "CONVERGENT",
+      family: "convergence",
+      familyLabel: "Convergence",
+      blurb:
+        "Deep reuse, active construction, and high generation rise together. A rare composition where all three operating axes are elevated without the usual tradeoffs.",
+    };
+  }
+
+  // 2. KINETIC — generation breakout
+  if (vel >= VEL_KINETIC) {
+    return {
+      key: "kinetic",
+      name: "KINETIC",
+      family: "generation",
+      familyLabel: "Generation",
+      blurb:
+        "Generation has broken out. Output approaches or exceeds fresh input, making transmission the defining feature of the composition.",
+    };
+  }
+
+  // 3. Construction branch — active context construction
+  if (constr >= CONSTR_ACTIVE) {
+    if (lev >= LEV_RECURSIVE) {
+      return {
+        key: "amplifier",
+        name: "AMPLIFIER",
+        family: "construction",
+        familyLabel: "Active Construction",
+        blurb:
+          "Deep reuse and active construction are operating together at scale. Existing context produces new work that expands the context available for future cycles.",
+      };
+    }
+    if (lev >= LEV_BUILDER) {
+      return {
+        key: "recursive",
+        name: "RECURSIVE",
+        family: "construction",
+        familyLabel: "Active Construction",
+        blurb:
+          "New context is being built on top of an already substantial reusable base. Construction and reuse are now feeding the same operating loop.",
+      };
+    }
+    return {
+      key: "builder",
+      name: "BUILDER",
+      family: "construction",
+      familyLabel: "Active Construction",
+      blurb:
+        "Active context construction has begun. The system is creating material for future reuse while leverage is still developing.",
+    };
+  }
+
+  // 4. Reuse depth branch — passive (construction < 0.02)
+  if (lev >= LEV_DEEP_READER) {
+    return {
+      key: "archivist",
+      name: "ARCHIVIST",
+      family: "reuse",
+      familyLabel: "Reuse Depth",
+      blurb:
+        "Extreme reuse of accumulated context. A deep context library carries the system while new construction remains limited.",
+    };
+  }
+  if (lev >= LEV_CONTEXTUAL) {
+    return {
+      key: "deep-reader",
+      name: "DEEP READER",
+      family: "reuse",
+      familyLabel: "Reuse Depth",
+      blurb:
+        "Strong accumulated context is carrying the workflow. The operator draws deeply from retained context while creating relatively little new context.",
+    };
+  }
+  if (lev >= LEV_PRIMING) {
+    return {
+      key: "contextual",
+      name: "CONTEXTUAL",
+      family: "reuse",
+      familyLabel: "Reuse Depth",
+      blurb:
+        "Retained context is now materially supporting the workflow. Reuse is established, while active construction remains limited.",
+    };
+  }
+  if (lev >= LEV_INPUT_BOUND) {
+    return {
+      key: "priming",
+      name: "PRIMING",
+      family: "reuse",
+      familyLabel: "Reuse Depth",
+      blurb:
+        "Reuse is beginning to form. Prior context is returning, but the system has not yet developed deep leverage.",
+    };
+  }
+  return {
+    key: "input-bound",
+    name: "INPUT-BOUND",
+    family: "reuse",
+    familyLabel: "Reuse Depth",
+    blurb:
+      "Fresh input still carries most of the workload. Little prior context is returning, so each cycle depends heavily on new input.",
+  };
+}
+
+/**
+ * Given a cascade result ({ velocity, leverage, dev10x, pillars, class }) and an
+ * optional subject name, return "**CLASS.** <archetype blurb with context>".
+ * Deterministic — same numbers in → same card out.
+ */
+export function narrate(cascade, name = "This operator") {
+  const klass = cascade.class || cascade.klass || "UNCLASSED";
+  const v = safeNum(cascade.velocity);
+  const l = safeNum(cascade.leverage);
+  const cw = cascade.pillars ? Number(cascade.pillars.cacheCreate) : NaN;
+
+  // Handle non-compounding (stateless pipe) as a special case before the
+  // archetype classifier — cascade.mjs leaves dev10x null when cacheCreate is 0.
+  const nonCompounding =
+    cascade.dev10x == null || !(cw > 0) || v === null || l === null;
+
+  if (nonCompounding) {
+    const leverageStr =
+      l !== null
+        ? `Leverage ${comma(l, 1)}x comes from reuse alone.`
+        : "Leverage is undefined (no fresh input recorded).";
+    const dev10xNote =
+      cascade.dev10x == null
+        ? " 10xDEV is undefined — the compounding loop has not formed yet."
+        : "";
+    const body =
+      `${name} runs a stateless pipe — no cache commits, so the cascade can't form. ` +
+      `High read volume, but nothing is being built forward. ${leverageStr}${dev10xNote}`;
+    return `**${klass}.** ${body}`;
+  }
+
+  // Classify into one of 10 build archetypes
+  const arch = classifyArchetype(cascade);
+
+  // Build the card with archetype name, family, and context-specific numbers
+  const levStr = l !== null ? `${comma(l, 0)}x leverage` : "undefined leverage";
+  const velStr = v !== null ? `${plain(v, 2)}x generation` : "undefined generation";
+  const cr = cascade.pillars ? Number(cascade.pillars.cacheRead) : NaN;
+  const constrStr = `construction ${plain(Number.isFinite(cr) && cr > 0 ? cw / cr : 0, 4)}`;
+
+  const body =
+    `${name} is ${arch.name} — ${arch.blurb} ` +
+    `${levStr}, ${velStr}, ${constrStr}.`;
+
+  return `**${klass}.** ${body}`;
+}

package/presentation/tui-themes.mjs

@@ -0,0 +1,189 @@
+// tui-themes.mjs — centralized ANSI color palette with multiple themes
+//
+// Tokscale-inspired: all colors live in one module, render code references
+// them through `currentTheme`. Supports dark (default), light, high-contrast,
+// and monochrome themes for accessibility.
+//
+// Usage in tui.mjs:
+//   import { currentTheme as c, setTheme } from "./tui-themes.mjs";
+//   // c.gold, c.cyan, c.reset, etc. — same interface as the old `c` object
+//
+// CLI:
+//   node tui.mjs --theme dark           # default
+//   node tui.mjs --theme light          # light terminal
+//   node tui.mjs --theme high-contrast  # visually impaired
+//   node tui.mjs --theme monochrome     # colorblind
+
+const ESC = "\x1b[";
+
+export const THEMES = {
+  // ── Dark (default) — current palette, designed for dark terminals ──
+  // green uses 256-color 77 (#5fd75f) for WCAG AA compliance on dark bg (9.0:1).
+  // Standard ANSI 32 (#5a8a5a) only achieves 4.1:1 — below the 4.5:1 threshold.
+  dark: {
+    name: "dark",
+    reset: `${ESC}0m`,
+    bold: `${ESC}1m`,
+    dim: `${ESC}2m`,
+    gold: `${ESC}33m`,
+    boldGold: `${ESC}1;33m`,
+    cyan: `${ESC}36m`,
+    boldCyan: `${ESC}1;36m`,
+    green: `${ESC}38;5;77m`,  // brighter green #5fd75f (9.0:1 on dark — was ANSI 32 at 4.1:1)
+    red: `${ESC}38;5;203m`,   // brighter red #ff5f5f (5.6:1 on dark — was ANSI 31 at 4.46:1, just below AA)
+    white: `${ESC}97m`,
+    boldWhite: `${ESC}1;97m`,
+    magenta: `${ESC}35m`,
+    blue: `${ESC}34m`,
+    bgDim: `${ESC}48;5;236m`,
+    bgCyan: `${ESC}48;5;23m`,
+    // Medal backgrounds (256-color) — gold/silver/bronze podium tints
+    medalBg: { 1: 220, 2: 250, 3: 130 },
+    medalFg: `${ESC}38;5;232m`, // dark text on medal bg
+  },
+
+  // ── Light — dark text on light/white terminals ──
+  // Uses 256-color codes (38;5;N) with darker shades that pass WCAG AA (4.5:1)
+  // on white backgrounds. Standard ANSI 33/36/32/31/35/34 render as pastel
+  // shades that fail contrast on white — these 256-color variants fix that.
+  light: {
+    name: "light",
+    reset: `${ESC}0m`,
+    bold: `${ESC}1m`,
+    dim: `${ESC}38;5;242m`,     // medium gray (4.5:1 on white — passes AA for large text)
+    gold: `${ESC}38;5;130m`,    // dark orange-gold #af5f00 (4.7:1 — yellow can't pass AA on white, this is the closest)
+    boldGold: `${ESC}1;38;5;130m`, // bold dark orange-gold (4.7:1)
+    cyan: `${ESC}38;5;24m`,     // dark cyan #005f87 (7.0:1)
+    boldCyan: `${ESC}1;38;5;24m`, // bold dark cyan (7.0:1)
+    green: `${ESC}38;5;28m`,    // dark green #008700 (4.7:1)
+    red: `${ESC}38;5;124m`,     // dark red #af0000 (7.4:1)
+    white: `${ESC}30m`,         // BLACK text on light bg (21:1)
+    boldWhite: `${ESC}1;30m`,   // bold black
+    magenta: `${ESC}38;5;90m`,  // dark magenta #870087 (8.8:1)
+    blue: `${ESC}38;5;19m`,     // dark blue #0000af (13.0:1)
+    bgDim: `${ESC}48;5;250m`,   // light grey bg for active tab
+    bgCyan: `${ESC}48;5;194m`,  // light teal bg for active tab
+    medalBg: { 1: 220, 2: 250, 3: 130 },
+    medalFg: `${ESC}38;5;232m`,
+  },
+
+  // ── High contrast — bold everything, no dim, maximum readability ──
+  highContrast: {
+    name: "high-contrast",
+    reset: `${ESC}0m`,
+    bold: `${ESC}1m`,
+    dim: `${ESC}0;37m`,       // NO dim — full brightness white instead
+    gold: `${ESC}1;33m`,      // bold gold
+    boldGold: `${ESC}1;33m`,
+    cyan: `${ESC}1;36m`,      // bold cyan
+    boldCyan: `${ESC}1;36m`,
+    green: `${ESC}1;32m`,     // bold green
+    red: `${ESC}1;31m`,       // bold red
+    white: `${ESC}1;97m`,     // bold bright white
+    boldWhite: `${ESC}1;97m`,
+    magenta: `${ESC}1;35m`,   // bold magenta
+    blue: `${ESC}1;34m`,      // bold blue
+    bgDim: `${ESC}48;5;238m`, // slightly lighter dark bg
+    bgCyan: `${ESC}48;5;24m`, // slightly lighter teal bg
+    medalBg: { 1: 220, 2: 250, 3: 130 },
+    medalFg: `${ESC}1;38;5;232m`,
+  },
+
+  // ── Monochrome — bold/normal only, no color (colorblind-safe) ──
+  monochrome: {
+    name: "monochrome",
+    reset: `${ESC}0m`,
+    bold: `${ESC}1m`,
+    dim: `${ESC}2m`,          // dim is fine in monochrome (it's weight, not color)
+    gold: `${ESC}1m`,         // bold only (no color)
+    boldGold: `${ESC}1m`,
+    cyan: `${ESC}0m`,         // normal weight
+    boldCyan: `${ESC}1m`,     // bold
+    green: `${ESC}0m`,        // normal
+    red: `${ESC}1m`,          // bold (errors stand out by weight)
+    white: `${ESC}0m`,        // normal
+    boldWhite: `${ESC}1m`,    // bold
+    magenta: `${ESC}0m`,      // normal
+    blue: `${ESC}0m`,         // normal
+    bgDim: `${ESC}7m`,        // reverse video for active tab (no color)
+    bgCyan: `${ESC}7m`,       // reverse video
+    medalBg: {},              // no medal colors in monochrome
+    medalFg: `${ESC}1m`,      // bold for medal winners
+  },
+};
+
+export let currentTheme = THEMES.dark;
+
+export function setTheme(name) {
+  if (THEMES[name]) {
+    currentTheme = THEMES[name];
+  }
+  return currentTheme;
+}
+
+export function getThemeNames() {
+  return Object.keys(THEMES);
+}
+
+// ── Platform color map ─────────────────────────────────────────────────────
+// Each platform gets a distinct 256-color code so platforms are visually
+// distinguishable in the cascade table, token composition bars, board, and
+// watch tabs. The colors are chosen for distinguishability on dark terminals
+// (the default theme). For light theme, darker 256-color variants are used.
+// Monochrome theme returns no color (bold only) — colorblind-safe.
+//
+// Color assignments (dark theme 256-color codes):
+//   claude    = 75  (blue-cyan)
+//   codex     = 114 (green)
+//   amp       = 179 (orange)
+//   gemini    = 129 (purple-magenta)
+//   kimi      = 213 (pink)
+//   qwen      = 68  (steel blue)
+//   goose     = 142 (olive)
+//   kilo      = 166 (dark orange)
+//   hermes    = 96  (plum)
+//   droid     = 167 (salmon)
+//   codebuff  = 72  (teal-green)
+//   copilot   = 33  (bright blue)
+//   openclaw  = 136 (gold-brown)
+//   pi        = 177 (light purple)
+//   omp       = 220 (gold — the "oh my pi" platform gets gold)
+//   opencode  = 60  (slate)
+//   devin     = 30  (teal)
+//   proxy     = 245 (gray — synthetic passthrough)
+//   other     = 245 (gray — catch-all)
+
+const PLATFORM_COLORS_DARK = {
+  claude: 75, codex: 114, amp: 179, gemini: 129, kimi: 213,
+  qwen: 68, goose: 142, kilo: 166, hermes: 96, droid: 167,
+  codebuff: 72, copilot: 33, openclaw: 136, pi: 177, omp: 220,
+  opencode: 60, devin: 30, proxy: 245, other: 245,
+};
+
+// Light theme: darker shades of the same hues for contrast on white
+const PLATFORM_COLORS_LIGHT = {
+  claude: 24, codex: 28, amp: 130, gemini: 54, kimi: 90,
+  qwen: 19, goose: 100, kilo: 130, hermes: 54, droid: 124,
+  codebuff: 23, copilot: 19, openclaw: 130, pi: 90, omp: 130,
+  opencode: 19, devin: 23, proxy: 242, other: 242,
+};
+
+/**
+ * Returns a paint function for the given platform name, theme-aware.
+ * Usage: `const pc = platformColor("claude"); pc("claude")` → colored string.
+ * Falls back to the theme's cyan for unknown platforms.
+ */
+export function platformColor(platform) {
+  const themeName = currentTheme.name;
+  // Monochrome: no color, just bold (colorblind-safe)
+  if (themeName === "monochrome") {
+    return (s) => `${currentTheme.bold}${s}${currentTheme.reset}`;
+  }
+  const map = themeName === "light" ? PLATFORM_COLORS_LIGHT : PLATFORM_COLORS_DARK;
+  const code = map[platform];
+  if (code == null) {
+    // Unknown platform — fall back to cyan
+    return (s) => `${currentTheme.cyan}${s}${currentTheme.reset}`;
+  }
+  return (s) => `${ESC}38;5;${code}m${s}${currentTheme.reset}`;
+}