aegiscode 6.0.0 → 6.1.0

package/src/screen.js

@@ -1,30 +1,50 @@
 'use strict';
 
 /**
- * Terminal plumbing: cell-accurate width maths, wrapping, and the ephemeral
- * "live" region the CLI redraws while a call is in flight.
+ * Terminal plumbing: cell-accurate width maths, the span/line render model,
+ * wrapping, and the ephemeral "live" region the CLI redraws while a call is in
+ * flight.
+ *
+ * The render model is aegiscodex-dev's: a line is an array of spans
+ * `{ t: text, s: style-prefix, w: cell-width }`, built with `span()`, measured
+ * with `lineWidth()`, padded/truncated with `padLine()`, and painted with
+ * `paint()`. Two width functions exist because they have different callers:
+ * `w()` returns the display width of a *plain string* (the linear transcript
+ * and the string renderers in render.js use it), while `padLine()` does the
+ * per-codepoint maths for a span line (the overlays use it).
  *
  * Design note — this CLI is a LINEAR transcript, not a full-screen alt-buffer
  * TUI (which is what Claude Code and aegiscodex-dev are). Finished turns are
  * written once to scrollback, so output stays selectable, pipeable and
- * scrollback-searchable; only the one live status/spinner line is redrawn. That
- * is a deliberate product difference, and it is also why there is no alt-screen
- * or mouse handling here.
+ * scrollback-searchable; only the one live status/spinner line is redrawn. The
+ * main session loop deliberately does NOT enter the alternate screen — `--print`
+ * and piped runs must keep working. The alt-screen / mouse / bracketed-paste
+ * helpers below exist only so the overlay renderers (overlays.js) and any future
+ * modal can paint and restore cleanly; they are never called on the transcript
+ * path. Keeping the two concerns in one module (rather than two) is the same
+ * split the reference uses.
  */
 
 const ANSI_RE = /\x1b\[[0-9;]*[A-Za-z]/g;
 
-/** Combining marks and variation selectors occupy no cell. */
-const RE_ZERO = /[\u0300-\u036f\ufe00-\ufe0f\u200b-\u200f]/;
-/** Wide (CJK/fullwidth/emoji) ranges occupy two cells. */
-const RE_WIDE =
-  /[\u1100-\u115f\u2e80-\u303e\u3041-\u33ff\u3400-\u4dbf\u4e00-\u9fff\ua000-\ua4cf\uac00-\ud7a3\uf900-\ufaff\ufe30-\ufe6f\uff00-\uff60\uffe0-\uffe6]|[\u{1f300}-\u{1faff}]|[\u{1f000}-\u{1f2ff}]/u;
+// Real terminal cell width (wcwidth-style). Combining marks and variation
+// selectors occupy no cell; CJK fullwidth forms and emoji-presentation glyphs
+// occupy two; everything else one. A plain code-point count misaligns every
+// width decision — padding, wrapping, cursor placement — the moment a line
+// contains CJK or emoji, because the terminal draws those two cells wide.
+// (Regexes copied verbatim from aegiscodex-dev/src/screen.js.)
+const RE_ZERO = /[\u0300-\u036F\u1AB0-\u1AFF\u1DC0-\u1DFF\u20D0-\u20FF\uFE00-\uFE0F\uFE20-\uFE2F]/u;
+const RE_WIDE = /[\u1100-\u115F\u2E80-\u303E\u3041-\u33FF\u3400-\u4DBF\u4E00-\u9FFF\uA000-\uA4CF\uA960-\uA97F\uAC00-\uD7A3\uF900-\uFAFF\uFE10-\uFE19\uFE30-\uFE4F\uFF00-\uFF60\uFFE0-\uFFE6\u{1F1E6}-\u{1F1FF}\u{1F300}-\u{1F64F}\u{1F680}-\u{1F6FF}\u{1F900}-\u{1F9FF}\u{1FA70}-\u{1FAFF}\u{20000}-\u{3FFFD}]/u;
+/** Cell width of one code point. */
+const cwidth = (ch) => (RE_ZERO.test(ch) ? 0 : RE_WIDE.test(ch) ? 2 : 1);
 
 function stripAnsi(s) {
   return String(s).replace(ANSI_RE, '');
 }
 
-/** Display width of a string in terminal cells. */
+/** Display width of a string in terminal cells. ANSI escapes are transparent
+ *  (so a styled line measures the same as its visible text) — kept from the
+ *  previous revision so callers measuring render output stay correct. */
 function w(s) {
   let n = 0;
   for (const ch of stripAnsi(s)) {
@@ -34,13 +54,14 @@ function w(s) {
   return n;
 }
 
-/** Truncate to `width` cells without cutting a wide/combining codepoint. */
+/** Truncate a plain string to `width` cells without cutting a wide/combining
+ *  codepoint. */
 function clip(s, width) {
   if (w(s) <= width) return s;
   let out = '';
   let used = 0;
-  for (const ch of s) {
-    const cw = RE_ZERO.test(ch) ? 0 : RE_WIDE.test(ch) ? 2 : 1;
+  for (const ch of String(s)) {
+    const cw = cwidth(ch);
     if (used + cw > width) break;
     out += ch;
     used += cw;
@@ -48,20 +69,74 @@ function clip(s, width) {
   return out;
 }
 
-/** Pad (or clip) to exactly `width` cells. */
+/** Pad (or clip) a plain string to exactly `width` cells. */
 function pad(s, width) {
   const t = clip(s, width);
   return t + ' '.repeat(Math.max(0, width - w(t)));
 }
 
-/** Right-align inside `width`. */
+/** Right-align a plain string inside `width`. */
 function padStart(s, width) {
   const t = clip(s, width);
   return ' '.repeat(Math.max(0, width - w(t))) + t;
 }
 
+// ── the span/line render model ──────────────────────────────────────────────
+
+/** A styled text run. Shape { t, s, w } is the contract with overlays.js and
+ *  markdown.js. */
+function span(style, t) {
+  return { t, s: style, w: w(t) };
+}
+
+/** Total display width of a span line. */
+const lineWidth = (line) => line.reduce((a, sp) => a + sp.w, 0);
+
+/**
+ * Pad / truncate a span line to an exact cell width. Truncation is visual only
+ * (a trailing style reset may be dropped) — the terminal clips whole glyphs, and
+ * a 2-cell glyph is never split mid-width.
+ */
+function padLine(line, width) {
+  let cur = 0;
+  const out = [];
+  for (const sp of line) {
+    if (cur >= width) break;
+    let t = sp.t;
+    let tw = sp.w;
+    if (cur + tw > width) {
+      // Truncate by whole code points that fit in the remaining cells — a
+      // codepoint slice (keep chars) would split a 2-cell glyph mid-width.
+      const room = width - cur;
+      let piece = '';
+      let used = 0;
+      for (const ch of [...t]) {
+        const cw = w(ch);
+        if (used + cw > room) break;
+        piece += ch;
+        used += cw;
+      }
+      t = piece;
+      tw = used;
+    }
+    out.push({ t, s: sp.s, w: tw });
+    cur += tw;
+  }
+  if (cur < width) out.push(span('', ' '.repeat(width - cur)));
+  return out;
+}
+
+/** Term size, clamped so a zero-column report (CI, redirected stdout) still
+ *  yields a paintable frame. */
+const getSize = () => ({
+  cols: Math.max(20, (process.stdout && process.stdout.columns) || 80),
+  rows: Math.max(5, (process.stdout && process.stdout.rows) || 24),
+});
+
+// ── wrapping (plain strings; the string renderers use these) ─────────────────
+
 /**
- * Word-wrap one logical line to `width` cells, preserving words and never
+ * Word-wrap one logical plain line to `width` cells, preserving words and never
  * breaking mid-word unless the word alone exceeds the width.
  */
 function wrapLine(line, width, indent = '') {
@@ -94,8 +169,7 @@ function wrapLine(line, width, indent = '') {
   return out;
 }
 
-/** Wrap a block of text (honours existing newlines), applying `indent` to
- *  continuation lines only when `hang` is true. */
+/** Wrap a block of plain text (honours existing newlines), applying `indent`. */
 function wrapBlock(text, width, indent = '', hang = false) {
   const lines = [];
   for (const raw of String(text).split('\n')) {
@@ -104,12 +178,12 @@ function wrapBlock(text, width, indent = '', hang = false) {
       continue;
     }
     const parts = wrapLine(raw, width - w(indent));
-    parts.forEach((p, i) => lines.push(i === 0 || !hang ? indent + p : indent + p));
+    parts.forEach((p) => lines.push(indent + p));
   }
   return lines;
 }
 
-// --- cursor / screen control ------------------------------------------------
+// ── cursor / screen control ─────────────────────────────────────────────────
 
 const ESC = {
   hideCursor: '\x1b[?25l',
@@ -122,6 +196,86 @@ const ESC = {
   col: (n) => `\x1b[${n}G`,
 };
 
+const hideCursor = () => process.stdout.write('\x1b[?25l');
+const showCursor = () => process.stdout.write('\x1b[?25h');
+const moveTo = (row, col) => process.stdout.write(`\x1b[${row};${col}H`);
+
+function clearScreen() {
+  process.stdout.write('\x1b[2J\x1b[H');
+}
+
+// Alternate screen buffer. Not used by the transcript (see the module note);
+// available to overlays that need to paint and then restore the pre-launch
+// terminal exactly. Guarded so paired enter/leave stay balanced.
+let inAlt = false;
+function enterAltScreen() {
+  if (inAlt) return;
+  inAlt = true;
+  process.stdout.write('\x1b[?1049h');
+}
+function leaveAltScreen() {
+  if (!inAlt) return;
+  inAlt = false;
+  process.stdout.write('\x1b[?1049l');
+}
+const isAltScreen = () => inAlt;
+
+// Bracketed paste (DEC 2004): a paste arrives as one \x1b[200~ … \x1b[201~
+// chunk instead of a burst of keystrokes.
+const enableBracketedPaste = () => process.stdout.write('\x1b[?2004h');
+const disableBracketedPaste = () => process.stdout.write('\x1b[?2004l');
+
+// Mouse button-event tracking (DECSET 1000) + SGR coordinates (1006). Only the
+// alt-screen/overlay path turns these on; disabled on exit so the shell we
+// return to isn't left forwarding raw wheel bytes as input.
+const enableMouseTracking = () => process.stdout.write('\x1b[?1000h\x1b[?1006h');
+const disableMouseTracking = () => process.stdout.write('\x1b[?1000l\x1b[?1006l');
+
+/**
+ * Paint span lines top-aligned and clear the rest of the frame. Used by the
+ * overlay renderers; the transcript path never calls it (it stays linear).
+ */
+function paint(lines) {
+  const { rows, cols } = getSize();
+  let out = '\x1b[H';
+  for (let i = 0; i < rows; i++) {
+    // Reset at the top of every row: span styles are colour codes, and a colour
+    // code does NOT clear bold/italic/dim. Without this a row that ends inside a
+    // BOLD segment whose "off" span got dropped by padding would leak the
+    // attribute into every later row of the frame.
+    out += '\x1b[0m';
+    const line = lines[i];
+    if (line) {
+      const pl = padLine(line, cols);
+      for (const sp of pl) out += sp.s + sp.t;
+      out += '\x1b[0K';
+    } else {
+      out += '\x1b[0K';
+    }
+    if (i < rows - 1) out += '\n';
+  }
+  out += '\x1b[0m';
+  process.stdout.write(out);
+}
+
+/** Repaint from `startRow` down, leaving rows above it untouched. */
+function paintFrom(lines, startRow) {
+  const { rows, cols } = getSize();
+  let out = '';
+  for (let i = 0; i < rows - startRow; i++) {
+    const line = lines[startRow + i];
+    if (i > 0) out += '\n';
+    out += '\x1b[0K';
+    out += '\x1b[0m';
+    if (line) {
+      const pl = padLine(line, cols);
+      for (const sp of pl) out += sp.s + sp.t;
+    }
+  }
+  out += '\x1b[0m';
+  process.stdout.write(out);
+}
+
 function termWidth(fallback = 80) {
   return Math.max(20, (process.stdout && process.stdout.columns) || fallback);
 }
@@ -164,6 +318,7 @@ class LiveRegion {
 }
 
 module.exports = {
+  // plain-string width helpers (kept for the string renderers + app/bin)
   w,
   clip,
   pad,
@@ -171,7 +326,27 @@ module.exports = {
   stripAnsi,
   wrapLine,
   wrapBlock,
+  // span/line render model (from aegiscodex-dev)
+  span,
+  lineWidth,
+  padLine,
+  paint,
+  paintFrom,
+  getSize,
+  // cursor / screen / input helpers (overlay path)
   EC: ESC,
+  hideCursor,
+  showCursor,
+  moveTo,
+  clearScreen,
+  enterAltScreen,
+  leaveAltScreen,
+  isAltScreen,
+  enableBracketedPaste,
+  disableBracketedPaste,
+  enableMouseTracking,
+  disableMouseTracking,
+  // the live region + sizing (app/bin)
   LiveRegion,
   termWidth,
 };

package/src/theme.js

@@ -1,13 +1,17 @@
 'use strict';
 
 /**
- * AEGIS terminal theme — "Signal".
+ * Design tokens — the aegiscodex-dev design system, adopted wholesale.
  *
- * This CLI is deliberately NOT a Claude Code look-alike. The palette below is
- * the whole point of the file: violet/cyan on ink, not the warm gold/coral
- * scheme every Claude Code derivative ships. `test/cli-identity.test.mjs` pins
- * that divergence — it fails if any of Claude Code's exact RGB triples, or its
- * prompt/spinner glyphs, reappear here.
+ * Every value below is copied verbatim from `aegiscodex-dev/src/theme.js`, which
+ * extracted them from the live ANSI stream of Claude Code: gold 255,193,7 ·
+ * coral 215,119,87 · lavender 177,185,249 · blue 120,160,250 · green 78,186,101
+ * · red 220,90,90 · gray 153,153,153 · dim 80,80,80.
+ *
+ * `test/cli-conformance.test.mjs` pins these to aegiscodex-dev's source, so the
+ * CLI cannot drift away from the design it is meant to match. (The previous
+ * revision of this file was the inverse: a violet/cyan "Signal" palette with a
+ * test asserting divergence. That theme is gone.)
  *
  * Zero dependencies: SGR escapes are hand-built, like the rest of this repo.
  */
@@ -26,76 +30,107 @@ const RESET_BG = '\x1b[49m';
 const RGB = (r, g, b) => `\x1b[38;2;${r};${g};${b}m`;
 const BG = (r, g, b) => `\x1b[48;2;${r};${g};${b}m`;
 
-/**
- * Dark theme (default). Every value is a truecolor triple; the palette leans
- * cool, and `ink`/`panel` are blue-black rather than neutral grey so the
- * transcript reads as a different product at a glance.
- */
-const SIGNAL = {
-  plasma: [124, 92, 255], // brand accent — sigil, prompts, active states
-  beam: [34, 211, 238], // secondary — structure, model ids, code
-  pulse: [52, 211, 153], // success
-  alert: [251, 113, 133], // warning
-  fault: [255, 99, 99], // error
-  muted: [148, 163, 184], // secondary text
-  dim: [71, 85, 105], // rails, rules, disabled
-  text: [226, 232, 240], // body
-  ink: [10, 12, 18], // deepest background (status bar, inverse)
-  panel: [22, 25, 34], // raised surface (banner box)
+/** The dark palette. Role names match aegiscodex-dev exactly. */
+const C = {
+  gold: RGB(255, 193, 7), // header line, accents, welcome frame
+  coral: RGB(215, 119, 87), // "Welcome to ..." title
+  lavender: RGB(177, 185, 249), // selection cursor ❯, links, focused option
+  blue: RGB(120, 160, 250), // selected palette row
+  green: RGB(78, 186, 101), // checkmarks, success, diff additions
+  red: RGB(220, 90, 90), // diff removals, errors
+  gray: RGB(153, 153, 153), // secondary text, menu numbers, hints
+  dim: RGB(80, 80, 80), // ╌ divider lines
+  white: RGB(255, 255, 255), // primary text, spinner glyphs
+  black: RGB(30, 30, 30), // code-block background
+  darkBg: RGB(20, 20, 20), // theme card background
 };
 
-/** Light theme — same roles, daylight values. Never a Claude Code palette. */
-const SIGNAL_LIGHT = {
-  plasma: [79, 55, 200],
-  beam: [8, 122, 145],
-  pulse: [5, 122, 85],
-  alert: [190, 55, 90],
-  fault: [185, 28, 28],
-  muted: [71, 85, 105],
-  dim: [148, 163, 184],
-  text: [15, 23, 42],
-  ink: [248, 250, 252],
-  panel: [241, 245, 249],
+/** Light-theme approximations, true to the dark palette's hue mapping. */
+const LIGHT = {
+  gold: RGB(180, 130, 0),
+  coral: RGB(190, 100, 70),
+  lavender: RGB(120, 130, 220),
+  blue: RGB(70, 110, 220),
+  green: RGB(60, 150, 80),
+  red: RGB(200, 60, 60),
+  gray: RGB(110, 110, 110),
+  dim: RGB(170, 170, 170),
+  white: RGB(40, 40, 40),
+  black: RGB(245, 245, 245),
+  darkBg: RGB(255, 255, 255),
 };
 
 /**
- * Glyphs. Chosen to share no character with Claude Code's prompt (`❯`),
- * spinner (`✢ · ✻ * ✽ ✶`), block cursor (`●`), hook (`⎿`) or quote bar (`▎`).
+ * Glyphs, copied from aegiscodex-dev's `GLYPH` including its platform passes.
+ * A few of these are missing from non-Linux terminal fonts (⎿ U+23BF, ⏸ U+23F8)
+ * or render as double-width emoji (✦ U+2726, ✻/✢/✽/✶), which breaks row
+ * alignment exactly like the welcome art — those platforms get single-width
+ * stand-ins instead.
  */
-const GLYPH = {
-  prompt: '»', // input prompt
-  sigil: '⬢', // AEGIS mark / assistant turns
-  rail: '┃', // heavy vertical gutter, both transcript roles
-  railEnd: '┣', // gutter corner where a turn's meta line attaches
-  spend: '∅', // money readout
-  ok: '✓',
-  err: '✗',
-  warn: '!',
-  bullet: '∙', // U+2219, not Claude's U+00B7
-  pointer: '▶', // selected row
-  divider: '─',
-  rule: '━',
-  spin: ['▁', '▂', '▃', '▄', '▅', '▆', '▇', '█', '▇', '▆', '▅', '▄', '▃', '▂'],
-  box: { tl: '┏', tr: '┓', bl: '┗', br: '┛', h: '━', v: '┃' }, // heavy, not rounded
-};
+const GLYPH = (() => {
+  const base = {
+    cursor: '❯', // menu selection marker, prompt prefix
+    check: '✔', // selected / completed
+    divider: '╌', // menu separators
+    bullet: '·', // inline separators
+    hint: '❯', // "Try ..." suggestion marker
+    pause: '⏸', // bottom status line (manual mode)
+    star: '✦', // own-session marker, decorations
+    leftarrow: '←', // hints on the status line
+    pointer: '▸', // tips list bullets
+    hook: '⎿', // inline command / tip rows (tool commands, usage hints)
+    block: '●', // streaming cursor / assistant answer marker
+    bloom: '✻', // "done" spinner glyph (✻ Brewed for 2s)
+    spin: ['✢', '·', '✻', '*', '✽', '✶'], // working spinner
+    ellipse: '…',
+  };
+  if (process.platform === 'win32') {
+    return {
+      ...base,
+      pause: '❚❚', // ⏸ U+23F8 missing from many Windows fonts
+      hook: '_|', // ⎿ U+23BF almost never present in Windows fonts
+      star: '*', // ✦ U+2726 renders wide/emoji
+      bloom: '*', // ✻ U+273B
+      spin: ['|', '/', '-', '\\', '*', '-'],
+    };
+  }
+  if (process.platform === 'darwin') {
+    return {
+      ...base,
+      pause: '❚❚', // ⏸ has an emoji presentation on Apple fonts
+      star: '*', // ✦ renders as a double-width emoji in Terminal.app
+      hook: '_|', // ⎿ U+23BF not in Apple monospace fonts
+    };
+  }
+  return base;
+})();
 
-/** Verbs for the working line — plain, no Claude Code whimsy. */
+/** Working-line verbs, verbatim from the capture-backed table. */
 const VERBS = [
-  'Consulting',
-  'Routing',
-  'Pooling',
-  'Reasoning',
-  'Drafting',
-  'Checking',
-  'Settling',
+  'Incubating',
+  'Tempering',
+  'Determining',
+  'Beboppin\'',
+  'Julienning',
+  'Inferring',
+  'Simmering',
+  'Twisting',
+  'Fermenting',
+  'Fiddle-faddling',
+  'Orbiting',
+  'Prestidigitating',
 ];
 
-const THEMES = { dark: SIGNAL, light: SIGNAL_LIGHT };
+/** Completion verbs: "✻ Churned for 3s" after a chat turn, "✻ Worked for 3s"
+ *  after one that used tools. */
+const DONE_VERBS = ['Churned', 'Worked'];
+
+const THEMES = { dark: C, light: LIGHT };
 
-/** The palette object for a context, per the rule that colours are always
- *  derived from one of the two theme objects — never typed inline. */
+/** The palette object for a context. Colours are always derived from one of the
+ *  two theme objects — never typed inline. */
 function themeOf(ctx) {
-  return ctx && ctx.light ? SIGNAL_LIGHT : SIGNAL;
+  return ctx && ctx.light ? LIGHT : C;
 }
 
 module.exports = {
@@ -111,10 +146,11 @@ module.exports = {
   UNDER_OFF,
   RESET_FG,
   RESET_BG,
-  SIGNAL,
-  SIGNAL_LIGHT,
+  C,
+  LIGHT,
   THEMES,
   GLYPH,
   VERBS,
+  DONE_VERBS,
   themeOf,
 };