@gonrocca/zero-pi 0.1.27 → 0.1.29

package/README.md

@@ -64,7 +64,7 @@ into `/forge` for you.
 | **`/zero-sync`** | Folds each run's spec delta into a canonical, project-wide spec store. |
 | **Run memory** | Every run recalls and saves traces to Cortex, so runs learn from each other. |
 | **Provider guard** | Warns when the `anthropic` provider runs on a metered API key instead of your subscription. |
-| **Startup banner** | The animated `ZERO` wordmark — Tetris-cell assembly + a sparkle pass. |
+| **Startup banner** | The violet ANSI-Shadow `ZERO` wordmark, drawn once at pi startup — `ZERO_HEADER=off` to disable. |
 | **Working-phrase ticker** | Swaps pi's `Working...` for a context-aware Spanish phrase + spinner. |
 | **Conversation resume** | Writes `.pi/zero-resume.md` on exit — the restore command + a conversation tail. |
 | **Windows tree-kill** | Aborting a turn kills the whole process tree — no orphaned `claude`. |
@@ -84,8 +84,7 @@ into `/forge` for you.
 
 zero-pi keeps its state in `~/.pi/zero.json` (per-phase models + autotune mode)
 and `~/.pi/zero-runs.jsonl` (the run-metrics log); per-project artifacts live
-under `.sdd/`. Environment variables: `ZERO_BANNER` (`shimmer` / `static` /
-`off`) and `ZERO_RESUME` (`off` disables the resume note).
+under `.sdd/`. Set `ZERO_RESUME=off` to disable the conversation-resume note.
 
 ## 🔗 Relationship to `zero`
 

package/extensions/autotune-extension.ts

@@ -15,8 +15,8 @@
 //
 // All decisions live in `autotune.ts`; this file only reads files, calls those
 // functions, and applies/notifies. The whole handler is wrapped in a swallowing
-// `try/catch` — exactly like `startup-banner.ts`, a failure must never break a
-// pi session. The package stays dependency-free: `node:fs`/`node:os`/`node:path`
+// `try/catch` — a failure must never break a pi session. The package stays
+// dependency-free: `node:fs`/`node:os`/`node:path`
 // only, plus minimal local interfaces for the pi API.
 
 import { readFileSync, writeFileSync } from "node:fs";

package/extensions/zero-banner.ts

@@ -0,0 +1,151 @@
+// zero-pi — static ZERO SDD startup banner.
+//
+// Renders the ZERO wordmark ONCE, at extension load, as an "ANSI Shadow" 3D
+// block in ceroclawd.com violet — deep-violet faces, a lit top edge, dark
+// shadow strokes and a cast shadow for depth.
+//
+// It writes a single block to stdout before pi's UI takes over. There is
+// deliberately NO setHeader and NO animation timer: an animated header that
+// re-renders on a timer spammed the terminal on pi 0.75.x and could crash the
+// session. A one-time stdout write cannot re-render, so it cannot spam.
+//
+// Disable with the ZERO_HEADER=off environment variable.
+
+type RGB = [number, number, number];
+
+const WORD = "ZERO";
+const ROWS = 6;
+
+// Cast-shadow offset — light from the top-left, shadow falls bottom-right.
+const SHADOW_DX = 2;
+const SHADOW_DY = 1;
+
+// ANSI Shadow glyphs — six rows each, glued edge to edge like figlet output.
+const FONT: Record<string, string[]> = {
+  Z: ["███████╗", "╚══███╔╝", "  ███╔╝ ", " ███╔╝  ", "███████╗", "╚══════╝"],
+  E: ["███████╗", "██╔════╝", "█████╗  ", "██╔══╝  ", "███████╗", "╚══════╝"],
+  R: ["██████╗ ", "██╔══██╗", "██████╔╝", "██╔══██╗", "██║  ██║", "╚═╝  ╚═╝"],
+  O: [" ██████╗ ", "██╔═══██╗", "██║   ██║", "██║   ██║", "╚██████╔╝", " ╚═════╝ "],
+  " ": ["    ", "    ", "    ", "    ", "    ", "    "],
+};
+
+// ceroclawd.com palette — violet, glow and darkness.
+const VIOLET_DEEP: RGB = [124, 58, 237];
+const LAVENDER: RGB = [205, 188, 255];
+const PEAK: RGB = [248, 244, 255];
+const SHADOW: RGB = [38, 24, 66];
+const INK: RGB = [20, 13, 34];
+const VIOLET: RGB = [167, 139, 250];
+const MUTED: RGB = [120, 110, 150];
+
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+
+function fg([r, g, b]: RGB, text: string): string {
+  return `\x1b[38;2;${r};${g};${b}m${text}\x1b[0m`;
+}
+
+function lerp(a: number, b: number, t: number): number {
+  return a + (b - a) * t;
+}
+
+function mix(a: RGB, b: RGB, t: number): RGB {
+  const k = Math.max(0, Math.min(1, t));
+  return [
+    Math.round(lerp(a[0], b[0], k)),
+    Math.round(lerp(a[1], b[1], k)),
+    Math.round(lerp(a[2], b[2], k)),
+  ];
+}
+
+/** Printable width of a string, ignoring ANSI colour escapes. */
+export function visibleWidth(text: string): number {
+  return text.replace(ANSI_RE, "").length;
+}
+
+function center(text: string, width: number): string {
+  const pad = Math.max(0, Math.floor((width - visibleWidth(text)) / 2));
+  return " ".repeat(pad) + text;
+}
+
+function matrixFor(text: string): { rows: string[]; width: number } {
+  const rows = Array.from({ length: ROWS }, () => "");
+  for (const raw of Array.from(text)) {
+    const glyph = FONT[raw.toUpperCase()] ?? FONT[" "];
+    for (let row = 0; row < ROWS; row++) rows[row] += glyph[row];
+  }
+  return { rows, width: rows[0]?.length ?? 0 };
+}
+
+/** Front-face colour: violet vertical gradient with a lit top edge. */
+function faceColor(row: number, topEdge: boolean): RGB {
+  const vt = Math.pow(row / (ROWS - 1), 0.85);
+  const base = mix(LAVENDER, VIOLET_DEEP, vt);
+  return topEdge ? mix(base, PEAK, 0.5) : base;
+}
+
+/** Extrusion side: a darker, shaded version of the face it belongs to. */
+function sideColor(row: number): RGB {
+  const vt = Math.pow(row / (ROWS - 1), 0.85);
+  return mix(mix(LAVENDER, VIOLET_DEEP, vt), SHADOW, 0.66);
+}
+
+function renderLogo(width: number): string[] {
+  const matrix = matrixFor(WORD);
+  const W = matrix.width;
+  const cellAt = (r: number, c: number): string =>
+    r >= 0 && r < ROWS && c >= 0 && c < W ? matrix.rows[r][c] ?? " " : " ";
+  const isFill = (r: number, c: number): boolean => cellAt(r, c) !== " ";
+
+  const lines: string[] = [];
+  for (let gr = 0; gr < ROWS + SHADOW_DY; gr++) {
+    let out = "";
+    for (let gc = 0; gc < W + SHADOW_DX; gc++) {
+      const ch = cellAt(gr, gc);
+      if (ch !== " ") {
+        out += ch === "█" ? fg(faceColor(gr, !isFill(gr - 1, gc)), ch) : fg(sideColor(gr), ch);
+      } else if ((gr >= ROWS || gc >= W) && isFill(gr - SHADOW_DY, gc - SHADOW_DX)) {
+        out += fg(INK, "█");
+      } else {
+        out += " ";
+      }
+    }
+    lines.push(center(out, width));
+  }
+  return lines;
+}
+
+/** A thin violet rule, brightest in the middle. */
+function ornament(width: number): string {
+  const length = Math.min(46, Math.max(22, Math.floor(width * 0.5)));
+  let line = "";
+  for (let i = 0; i < length; i++) {
+    const t = i / Math.max(1, length - 1);
+    line += fg(mix(VIOLET_DEEP, VIOLET, Math.sin(t * Math.PI)), "─");
+  }
+  return center(line, width);
+}
+
+/** The full banner block, centered to the given width. */
+export function bannerBlock(width: number): string[] {
+  if (width < 64) {
+    return [center(fg(VIOLET, "ZERO SDD"), width), center(fg(MUTED, "pi.dev · spec-driven work"), width)];
+  }
+  const tag = fg(VIOLET, "ZERO SDD") + fg(MUTED, "   explore → plan → build → veredicto");
+  return [ornament(width), "", ...renderLogo(width), "", center(tag, width), ornament(width)];
+}
+
+/**
+ * The pi extension entry point. Renders the banner exactly once, synchronously,
+ * at load time. Any failure is swallowed — a banner must never break a session.
+ */
+export default function register(_pi?: unknown): void {
+  try {
+    if ((process.env.ZERO_HEADER ?? "").trim().toLowerCase() === "off") return;
+    const stream = process.stdout;
+    if (!stream || !stream.isTTY || process.env.NO_COLOR) return;
+    const width = stream.columns && stream.columns > 0 ? stream.columns : 80;
+    stream.write("\n" + bannerBlock(width).join("\n") + "\n\n");
+  } catch {
+    // A banner failure must never break a pi session.
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gonrocca/zero-pi",
-  "version": "0.1.27",
-  "description": "zero-pi — an installable layer for pi (pi.dev): the zero spec-driven development workflow, skill auto-learning, and an animated ZERO startup banner. Adds capability to pi without modifying pi.",
+  "version": "0.1.29",
+  "description": "zero-pi — an installable layer for pi (pi.dev): the zero spec-driven development workflow, per-phase model autotune, and skill auto-learning. Adds capability to pi without modifying pi.",
   "type": "module",
   "keywords": [
     "pi",
@@ -23,7 +23,7 @@
       "./themes"
     ],
     "extensions": [
-      "./extensions/startup-banner.ts",
+      "./extensions/zero-banner.ts",
       "./extensions/working-phrases.ts",
       "./extensions/win-tree-kill.ts",
       "./extensions/sdd-agents.ts",
@@ -38,7 +38,7 @@
     "prompts",
     "skills",
     "themes",
-    "extensions/startup-banner.ts",
+    "extensions/zero-banner.ts",
     "extensions/working-phrases.ts",
     "extensions/win-tree-kill.ts",
     "extensions/sdd-agents.ts",

package/extensions/startup-banner.ts

@@ -1,280 +0,0 @@
-// zero-pi - animated startup banner.
-//
-// A pi extension that renders the ZERO wordmark as ASCII-safe Tetris cells.
-// The animated mode progressively assembles the wordmark from the bottom up,
-// then settles into the complete banner. The extension stays dependency-free
-// and keeps the historical ZERO_BANNER controls.
-
-type RGB = [number, number, number];
-
-const COLORS: Record<string, RGB> = {
-  cyan: [80, 210, 255],
-  blue: [116, 151, 255],
-  mint: [79, 221, 171],
-  amber: [238, 190, 92],
-  rose: [255, 106, 122],
-  violet: [175, 138, 255],
-  peak: [255, 245, 218],
-};
-
-/** Number of rows in every glyph. */
-const ROWS = 6;
-
-// Five-cell-wide glyphs. Non-space characters become visible Tetris cells.
-const FONT: Record<string, string[]> = {
-  Z: ["ZZZZZ", "   ZZ", "  ZZ ", " ZZ  ", "ZZ   ", "ZZZZZ"],
-  E: ["EEEEE", "EE   ", "EEEE ", "EE   ", "EE   ", "EEEEE"],
-  R: ["RRRR ", "RR RR", "RRRR ", "RR RR", "RR  R", "RR  R"],
-  O: [" OOO ", "OO OO", "OO OO", "OO OO", "OO OO", " OOO "],
-  P: ["PPPP ", "PP PP", "PP PP", "PPPP ", "PP   ", "PP   "],
-  I: ["IIIII", "  II ", "  II ", "  II ", "  II ", "IIIII"],
-  "-": ["     ", "     ", "-----", "     ", "     ", "     "],
-  " ": ["     ", "     ", "     ", "     ", "     ", "     "],
-};
-
-const PIECE_COLORS: Record<string, RGB> = {
-  Z: COLORS.cyan,
-  E: COLORS.amber,
-  R: COLORS.mint,
-  O: COLORS.rose,
-  P: COLORS.violet,
-  I: COLORS.blue,
-  "-": COLORS.amber,
-};
-
-interface Matrix {
-  rows: string[];
-  width: number;
-  totalCells: number;
-  ranks: Map<string, number>;
-}
-
-function glyphFor(ch: string): string[] {
-  return FONT[ch.toUpperCase()] ?? FONT[" "];
-}
-
-function matrixForText(text: string): Matrix {
-  const rows = Array.from({ length: ROWS }, () => "");
-  for (const [index, raw] of Array.from(text).entries()) {
-    const glyph = glyphFor(raw);
-    for (let r = 0; r < ROWS; r++) {
-      rows[r] += (index === 0 ? "" : " ") + glyph[r];
-    }
-  }
-
-  const cells: Array<{ row: number; col: number }> = [];
-  for (let row = 0; row < ROWS; row++) {
-    for (let col = 0; col < rows[row].length; col++) {
-      if (rows[row][col] !== " ") cells.push({ row, col });
-    }
-  }
-
-  // Tetris reads as a pile building upward: bottom rows settle first.
-  cells.sort((a, b) => b.row - a.row || a.col - b.col);
-
-  const ranks = new Map<string, number>();
-  for (const [rank, cell] of cells.entries()) {
-    ranks.set(`${cell.row}:${cell.col}`, rank);
-  }
-
-  return {
-    rows,
-    width: rows[0]?.length ?? 0,
-    totalCells: cells.length,
-    ranks,
-  };
-}
-
-/** Lay a word out as six rows of ASCII-safe Tetris cells. */
-export function bannerLines(text = "ZERO"): string[] {
-  return matrixForText(text).rows.map((row) =>
-    Array.from(row)
-      .map((cell) => (cell === " " ? "  " : "[]"))
-      .join(""),
-  );
-}
-
-function lerp(a: number, b: number, t: number): number {
-  return a + (b - a) * t;
-}
-
-function lerpColor(c1: RGB, c2: RGB, t: number): RGB {
-  const k = Math.max(0, Math.min(1, t));
-  return [
-    Math.round(lerp(c1[0], c2[0], k)),
-    Math.round(lerp(c1[1], c2[1], k)),
-    Math.round(lerp(c1[2], c2[2], k)),
-  ];
-}
-
-function ansiFg([r, g, b]: RGB, text: string): string {
-  return `\x1b[38;2;${r};${g};${b}m${text}\x1b[0m`;
-}
-
-function colorForPiece(piece: string, row: number, rank: number, active: boolean): RGB {
-  if (active) return COLORS.peak;
-  const base = PIECE_COLORS[piece] ?? COLORS.blue;
-  const heightWarmth = (ROWS - 1 - row) / Math.max(1, ROWS - 1);
-  const rankPulse = (rank % 7) / 18;
-  return lerpColor(base, COLORS.peak, heightWarmth * 0.18 + rankPulse);
-}
-
-function paintMatrixLine(
-  matrix: Matrix,
-  row: number,
-  visibleCells: number,
-  sparkles?: ReadonlySet<string>,
-): string {
-  let out = "";
-  const line = matrix.rows[row] ?? "";
-  for (let col = 0; col < matrix.width; col++) {
-    const piece = line[col] ?? " ";
-    if (piece === " ") {
-      out += "  ";
-      continue;
-    }
-    const key = `${row}:${col}`;
-    const rank = matrix.ranks.get(key) ?? Number.POSITIVE_INFINITY;
-    if (rank >= visibleCells) {
-      out += "  ";
-      continue;
-    }
-    // A cell glints when it is the assembly's leading cell or when this
-    // sparkle frame picked it.
-    const glint = rank === visibleCells - 1 || (sparkles?.has(key) ?? false);
-    out += ansiFg(colorForPiece(piece, row, rank, glint), "[]");
-  }
-  return out;
-}
-
-/** Pick a handful of distinct settled cells to glint for one sparkle frame. */
-function pickSparkles(matrix: Matrix, count: number, rand: () => number): Set<string> {
-  const keys = Array.from(matrix.ranks.keys());
-  const chosen = new Set<string>();
-  const target = Math.min(Math.max(0, count), keys.length);
-  for (let guard = 0; chosen.size < target && guard < target * 8; guard++) {
-    chosen.add(keys[Math.floor(rand() * keys.length)]);
-  }
-  return chosen;
-}
-
-interface OutStream {
-  write(chunk: string): unknown;
-  isTTY?: boolean;
-}
-
-/** Whether colour output is appropriate for the given stream. */
-function shouldColor(stream: OutStream): boolean {
-  if (process.env.NO_COLOR) return false;
-  if (process.env.FORCE_COLOR) return true;
-  return Boolean(stream && stream.isTTY);
-}
-
-/** The three banner modes, resolved from the ZERO_BANNER environment variable. */
-export type BannerMode = "off" | "static" | "shimmer";
-
-/** Resolve the banner mode from an environment-variable value. */
-export function resolveBannerMode(raw: string | undefined): BannerMode {
-  const value = (raw ?? "").trim().toLowerCase();
-  if (value === "off" || value === "0" || value === "false" || value === "none") return "off";
-  if (value === "static" || value === "plain" || value === "no-animate") return "static";
-  return "shimmer";
-}
-
-// Atomics.wait gives us a synchronous sleep without adding a dependency. The
-// banner renders before Pi's TUI takes over, so blocking briefly is intentional.
-const SLEEP_SLOT = new Int32Array(new SharedArrayBuffer(4));
-function sleepSync(ms: number): void {
-  if (ms > 0) Atomics.wait(SLEEP_SLOT, 0, 0, ms);
-}
-
-function easeOutCubic(t: number): number {
-  return 1 - Math.pow(1 - t, 3);
-}
-
-/** Options for {@link renderBanner}. */
-export interface RenderOptions {
-  mode?: BannerMode;
-  text?: string;
-  frames?: number;
-  frameMs?: number;
-  /** Number of post-settle sparkle frames (shimmer mode). `0` disables it. */
-  sparkleFrames?: number;
-  /** Delay between sparkle frames, in milliseconds. */
-  sparkleMs?: number;
-  stream?: OutStream;
-}
-
-/**
- * Render the ZERO banner synchronously.
- *
- * On a non-colour stream the banner is printed plain. Otherwise the animated
- * mode assembles cells frame by frame, then settles on the completed wordmark.
- */
-export function renderBanner(options: RenderOptions = {}): void {
-  const mode = options.mode ?? resolveBannerMode(process.env.ZERO_BANNER);
-  if (mode === "off") return;
-
-  const stream: OutStream = options.stream ?? process.stdout;
-  const matrix = matrixForText(options.text ?? "ZERO");
-
-  if (!shouldColor(stream)) {
-    stream.write("\n" + bannerLines(options.text ?? "ZERO").join("\n") + "\n\n");
-    return;
-  }
-
-  stream.write("\n" + Array.from({ length: ROWS }, () => "").join("\n") + "\n");
-
-  // Repaint the six rows in place; optionally with this frame's sparkle set.
-  const paintRows = (sparkles?: ReadonlySet<string>): void => {
-    stream.write(`\x1b[${ROWS}A\r`);
-    for (let r = 0; r < ROWS; r++) {
-      stream.write("\x1b[2K" + paintMatrixLine(matrix, r, matrix.totalCells, sparkles) + "\n");
-    }
-  };
-
-  if (mode === "shimmer") {
-    const frames = Math.max(2, options.frames ?? 42);
-    const frameMs = Math.max(1, options.frameMs ?? 18);
-    for (let f = 0; f < frames; f++) {
-      const t = easeOutCubic(f / (frames - 1));
-      const visibleCells = Math.max(1, Math.ceil(matrix.totalCells * t));
-      stream.write(`\x1b[${ROWS}A\r`);
-      for (let r = 0; r < ROWS; r++) {
-        stream.write("\x1b[2K" + paintMatrixLine(matrix, r, visibleCells) + "\n");
-      }
-      sleepSync(frameMs);
-    }
-  }
-
-  // Settle on the completed wordmark.
-  paintRows();
-
-  // Sparkle pass — a few settled cells glint bright each frame, then a clean
-  // final settle. Shimmer only; `sparkleFrames: 0` disables it.
-  if (mode === "shimmer") {
-    const sparkleFrames = Math.max(0, options.sparkleFrames ?? 22);
-    const sparkleMs = Math.max(1, options.sparkleMs ?? 36);
-    for (let f = 0; f < sparkleFrames; f++) {
-      paintRows(pickSparkles(matrix, 3 + (f % 4), Math.random));
-      sleepSync(sparkleMs);
-    }
-    if (sparkleFrames > 0) paintRows();
-  }
-
-  stream.write("\n");
-}
-
-/**
- * The pi extension entry point.
- *
- * The pi argument is accepted for API compatibility. The banner is rendered
- * defensively: visual sugar should never break an interactive session.
- */
-export default function register(_pi?: unknown): void {
-  try {
-    renderBanner();
-  } catch {
-    // A banner failure must never break a pi session.
-  }
-}