dsh-code 1.0.7 → 1.3.0

package/src/rainbow.ts

@@ -0,0 +1,218 @@
+/**
+ * The rainbow theme's per-launch roll: a seeded shuffle over a twelve-color
+ * bright-tier spectrum that fills every palette role, the status-bar tone map
+ * (adjacent tones in canonical on-screen order never share a color, the
+ * row1/row2 boundary included), the panel accent ring, and full-spectrum
+ * flow anchors with a random phase. The roll happens once per launch and
+ * stays stable for the whole run; setting RAINBOW_SEED=<uint32> pins it for
+ * reproduction (the /theme notification prints the seed of the current roll).
+ *
+ * All pool colors clear AA body text (≥4.5:1) on a black terminal by a wide
+ * margin (11-17:1); diff rows pair a bright hue with its own 22% dark tint
+ * so the foreground stays 7.7-10.2:1 on its background.
+ *
+ * @module @deepseek-ai/dsh-tui/rainbow
+ */
+
+import type { StatusTone } from './render/status.ts'
+import type { RgbTriple, ThemePalette } from './theme.ts'
+
+/**
+ * The bright-tier spectrum: twelve Tailwind *-300 hues covering red through
+ * fuchsia, every one ≥11:1 on black. The roll samples this pool by shuffle;
+ * nothing outside it is ever painted.
+ */
+export const RAINBOW_POOL: readonly RgbTriple[] = [
+  [252, 165, 165],
+  [253, 186, 116],
+  [253, 230, 138],
+  [253, 224, 71],
+  [190, 242, 100],
+  [134, 239, 172],
+  [94, 234, 212],
+  [103, 232, 249],
+  [125, 211, 252],
+  [147, 197, 253],
+  [196, 181, 253],
+  [240, 171, 252],
+]
+
+/**
+ * Status tones in canonical on-screen order (row one left-to-right, then row
+ * two): consecutive entries here are the pairs the "adjacent spans differ"
+ * guarantee covers, including the accent→value step across the row boundary.
+ */
+const TONE_ORDER: readonly StatusTone[] = [
+  'live', 'model', 'path', 'branch', 'accent',
+  'value', 'label', 'meta', 'ctxFill', 'success', 'plan', 'warn', 'error',
+]
+
+/** One per-launch carnival roll: everything the rainbow theme paints from. */
+export interface RainbowRoll {
+  /** The seed this roll came from (print it to reproduce). */
+  readonly seed: number
+  /** The full 15-token palette for this launch. */
+  readonly palette: ThemePalette
+  /** The four-color panel ring (random order and start). */
+  readonly ring: readonly RgbTriple[]
+  /** Status-tone → color: adjacent tones in {@link TONE_ORDER} never match. */
+  readonly toneColors: Readonly<Record<StatusTone, RgbTriple>>
+  /** Full-spectrum flow anchors in hue order (a different subset every launch). */
+  readonly flowAnchors: readonly RgbTriple[]
+  /** Random phase offset into the flow lap, milliseconds. */
+  readonly flowPhaseMs: number
+}
+
+/** Parse a RAINBOW_SEED value: a non-negative decimal uint32, else nothing. */
+export function parseRainbowSeed(value: string | undefined): number | undefined {
+  if (value === undefined || !/^\d{1,10}$/.test(value.trim())) return undefined
+  const parsed = Number(value.trim())
+  return Number.isSafeInteger(parsed) ? parsed >>> 0 : undefined
+}
+
+/**
+ * One parsed `/rainbow` argument: empty means a fresh random roll; a
+ * decimal uint32 pins that seed; anything else is a usage error.
+ * @param argument - the raw text after `/rainbow`.
+ * @returns `{ seed }`, `'random'`, or `'usage'`.
+ */
+export function parseRainbowArgument(argument: string): { seed: number } | 'random' | 'usage' {
+  const trimmed = argument.trim()
+  if (trimmed === '') return 'random'
+  const parsed = parseRainbowSeed(trimmed)
+  return parsed === undefined ? 'usage' : { seed: parsed }
+}
+
+/** Deterministic 32-bit RNG (mulberry32) — one roll, one stream. */
+function mulberry32(seed: number): () => number {
+  let state = seed >>> 0
+  return () => {
+    state = (state + 0x6d2b79f5) | 0
+    let t = Math.imul(state ^ (state >>> 15), 1 | state)
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296
+  }
+}
+
+/** Fisher–Yates shuffle over a copy, driven by the roll's RNG. */
+function shuffle<T>(items: readonly T[], rng: () => number): T[] {
+  const out = [...items]
+  for (let i = out.length - 1; i > 0; i -= 1) {
+    const j = Math.floor(rng() * (i + 1))
+    ;[out[i], out[j]] = [out[j], out[i]]
+  }
+  return out
+}
+
+/** Approximate HSL hue of one RGB triple, degrees in [0, 360). */
+function hueOf([r, g, b]: RgbTriple): number {
+  const max = Math.max(r, g, b)
+  const min = Math.min(r, g, b)
+  if (max === min) return 0
+  const span = max - min
+  if (max === r) return (60 * (g - b) / span + 360) % 360
+  if (max === g) return (60 * (b - r) / span + 120) % 360
+  return (60 * (r - g) / span + 240) % 360
+}
+
+/** Strict RGB equality for the wrap-collision repair. */
+function sameRgb(left: RgbTriple, right: RgbTriple): boolean {
+  return left[0] === right[0] && left[1] === right[1] && left[2] === right[2]
+}
+
+/** A dark row tint for diff backgrounds: the hue at 22% strength over black. */
+function darkTint(hue: RgbTriple): RgbTriple {
+  return [Math.round(hue[0] * 0.22), Math.round(hue[1] * 0.22), Math.round(hue[2] * 0.22)]
+}
+
+/** Readability anchors shared by every roll: captions, text, band stay calm. */
+const DIM: RgbTriple = [166, 163, 184]
+const TEXT: RgbTriple = [240, 238, 249]
+const BAND: RgbTriple = [46, 46, 52]
+
+/**
+ * Build the roll for one seed: pure and deterministic, so tests pin exact
+ * outcomes and RAINBOW_SEED reproduces a lucky launch exactly.
+ * @param seed - the uint32 seed to roll from.
+ * @returns the complete carnival roll.
+ */
+export function rollRainbow(seed: number): RainbowRoll {
+  const rng = mulberry32(seed)
+  const pool = shuffle(RAINBOW_POOL, rng)
+  const [brand, brandBright, brandMid, brandDeep, code, success, error, warn, addHue, delHue] = pool
+  const palette: ThemePalette = {
+    brand: brand,
+    brandBright: brandBright,
+    brandMid: brandMid,
+    brandDeep: brandDeep,
+    dim: DIM,
+    success: success,
+    error: error,
+    warn: warn,
+    text: TEXT,
+    code: code,
+    composerBand: BAND,
+    diffAdd: darkTint(addHue),
+    diffDel: darkTint(delHue),
+    diffAddFg: addHue,
+    diffDelFg: delHue,
+    // Prompt-row bars ride the roll's own colors: the bright brand hue for an
+    // ordinary prompt, the rolled warning hue for a queued one, and the rolled
+    // code hue for a steered one. Each bar is that color over the surface.
+    surface: [0, 0, 0],
+    prompt: brandBright,
+    queued: warn,
+    steered: code,
+  }
+  const ring = shuffle(RAINBOW_POOL, rng).slice(0, 4)
+  // Consecutive tones take consecutive slots of a 12-distinct shuffle, so
+  // on-screen neighbors never match. 13 tones wrap: live (index 0) and error
+  // (index 12) would share a color. Reassign error to a pool hue that is
+  // neither live nor its neighbor warn — error must not look like the busy dot.
+  const offset = Math.floor(rng() * RAINBOW_POOL.length)
+  const toneColors = {} as Record<StatusTone, RgbTriple>
+  TONE_ORDER.forEach((tone, index) => {
+    toneColors[tone] = pool[(offset + index) % pool.length]!
+  })
+  if (sameRgb(toneColors.live, toneColors.error)) {
+    const replacement = pool.find(hue => !sameRgb(hue, toneColors.live) && !sameRgb(hue, toneColors.warn))
+    if (replacement !== undefined) toneColors.error = replacement
+  }
+  const flowAnchors = [...RAINBOW_POOL].sort((a, b) => hueOf(a) - hueOf(b))
+  const flowPhaseMs = Math.floor(rng() * 2400)
+  return { seed, palette, ring, toneColors, flowAnchors, flowPhaseMs }
+}
+
+/** The launch seed: RAINBOW_SEED when parseable, else a fresh random roll. */
+function launchSeed(): number {
+  const pinned = parseRainbowSeed(process.env.RAINBOW_SEED)
+  if (pinned !== undefined) return pinned
+  return (Date.now() ^ Math.floor(Math.random() * 0x100000000)) >>> 0
+}
+
+let rolled: RainbowRoll | undefined
+
+/** The memoized per-launch roll; computed once, stable for the whole run. */
+export function rainbowRoll(): RainbowRoll {
+  if (rolled === undefined) rolled = rollRainbow(launchSeed())
+  return rolled
+}
+
+/**
+ * Replace the memoized roll: omit the seed for a fresh random one, or pass
+ * a uint32 to pin it. `/rainbow` uses this so a mid-session reroll actually
+ * recolors; {@link setTheme}(`'rainbow'`) must run afterwards so the
+ * palette accessor picks the new values up.
+ * @param seed - the seed to pin, or undefined for a new random roll.
+ * @returns the roll now in force.
+ */
+export function rerollRainbow(seed?: number): RainbowRoll {
+  const next = seed ?? ((Date.now() ^ Math.floor(Math.random() * 0x100000000)) >>> 0)
+  rolled = rollRainbow(next)
+  return rolled
+}
+
+/** The current roll's seed as display copy (also the RAINBOW_SEED value). */
+export function rainbowSeedLabel(): string {
+  return String(rainbowRoll().seed)
+}

package/src/render/animations.ts

@@ -91,6 +91,31 @@ export function deepDivingSparkColor(tick: number, base: RgbTriple, highlight: R
   return blendRgb(highlight, base, deepDivingSparkIntensity(tick))
 }
 
+/** One full prismatic flow lap — lively: violet → fuchsia → cyan → violet in 2.4s. */
+export const FLOW_PERIOD_MS = 2_400
+
+/**
+ * The prismatic flow color at one elapsed-time sample: a smoothstep walk
+ * around the anchor triangle, one full lap per {@link FLOW_PERIOD_MS}. Pure —
+ * the Ink layer owns the timer and passes its tick scaled by its own cadence
+ * (tick × tickMs). Callers gate on the animations preference and fall back to
+ * a static palette color when animation is off.
+ * @param elapsedMs - milliseconds since the flow started (any sign or size).
+ * @param anchors - the colors to walk, in order (theme.ts FLOW_ANCHORS).
+ * @returns the interpolated anchor color at this instant.
+ */
+export function flowColor(elapsedMs: number, anchors: readonly RgbTriple[]): RgbTriple {
+  if (anchors.length === 0) throw new Error('flowColor needs at least one anchor')
+  if (anchors.length === 1) return anchors[0]
+  const lap = ((elapsedMs % FLOW_PERIOD_MS) + FLOW_PERIOD_MS) % FLOW_PERIOD_MS
+  const span = FLOW_PERIOD_MS / anchors.length
+  const at = lap / span
+  const index = Math.floor(at)
+  const phase = at - index
+  const eased = phase * phase * (3 - 2 * phase)
+  return blendRgb(anchors[(index + 1) % anchors.length], anchors[index % anchors.length], eased)
+}
+
 /** Caret blink cadence: one blink step (on or off) per tick. */
 export const CARET_BLINK_TICK_MS = 530
 
@@ -332,6 +357,79 @@ export function envelope(elapsed: number, total: number, fadeIn: number, fadeOut
   return Math.min(Math.max(Math.min(rise, fall), 0), 1)
 }
 
+/**
+ * The /rainbow celebration on the three-row composer band: a FIXED
+ * seven-color spectrum (not the rolled palette) that slides across every
+ * row as one ribbon. Triggered when switching to rainbow or rerolling the
+ * seed; independent of RAINBOW_SEED so the burst always reads as a prism.
+ */
+export const RAINBOW_BURST_TICK_MS = 33
+export const RAINBOW_BURST_DURATION_MS = 1_800
+export const RAINBOW_BURST_HUES: readonly RgbTriple[] = [
+  [255, 59, 48],
+  [255, 149, 0],
+  [255, 204, 0],
+  [52, 199, 89],
+  [0, 199, 190],
+  [10, 132, 255],
+  [175, 82, 222],
+]
+
+/**
+ * Smoothstep in 0..1, then wrap-lerp around the seven burst hues.
+ * Position 0 is red, wrapping back toward red at 1. Shared by the
+ * composer burst and the static rainbow whale header.
+ */
+export function rainbowSpectrumHue(position: number): RgbTriple {
+  const hues = RAINBOW_BURST_HUES
+  const x = ((position % 1) + 1) % 1
+  const scaled = x * hues.length
+  const index = Math.floor(scaled)
+  const t = scaled - index
+  const eased = t * t * (3 - 2 * t)
+  const a = hues[index % hues.length]
+  const b = hues[(index + 1) % hues.length]
+  return [
+    Math.round(a[0] + (b[0] - a[0]) * eased),
+    Math.round(a[1] + (b[1] - a[1]) * eased),
+    Math.round(a[2] + (b[2] - a[2]) * eased),
+  ]
+}
+
+/**
+ * Background tint for one composer-band cell during the rainbow burst.
+ * Every row of a column shares the same hue (a solid ribbon); edge rows
+ * are slightly dimmer so the middle editor row reads as the crest. The
+ * spectrum slides ~1.2 widths over the burst, then fades to the band base.
+ * @param tick - frame index at {@link RAINBOW_BURST_TICK_MS}.
+ * @param column - band column (0..width-1).
+ * @param width - band width in columns.
+ * @param base - the theme's composerBand color to blend toward.
+ * @param row - band row (0..rows-1).
+ * @param rows - band height (composer is three rows: pad, editor, pad).
+ * @returns the blended RGB, or null after the burst (or at zero alpha).
+ */
+export function rainbowBurstColumnBg(
+  tick: number,
+  column: number,
+  width: number,
+  base: RgbTriple,
+  row = 0,
+  rows = 1,
+): RgbTriple | null {
+  const elapsed = tick * RAINBOW_BURST_TICK_MS / 1000
+  const total = RAINBOW_BURST_DURATION_MS / 1000
+  const fade = envelope(elapsed, total, 0.18, 0.45)
+  if (fade <= 0) return null
+  const span = Math.max(1, width - 1)
+  const slide = elapsed / total * 1.2
+  const mixed = rainbowSpectrumHue(column / span + slide)
+  const edge = rows > 1 && (row === 0 || row === rows - 1)
+  const alpha = Math.min(0.72 * fade * (edge ? 0.78 : 1), 0.70)
+  if (alpha < 0.02) return null
+  return blendRgb(mixed, base, alpha)
+}
+
 /** Per-band sampling context: everything geometry needs beyond the timeline. */
 interface BandContext {
   /** Aspect-weighted row offset from the band's center row (Pulse 2-D ring). */
@@ -522,19 +620,19 @@ export function deepseekWaveColumnBg(
   let bandIndex = 0
   for (const band of DEEPSEEK_WAVE_BANDS[style][tier]) {
     for (const [hue, strength] of bandSample(style, band, elapsed, column, width, { dy, u, undulating, pulseSpan, bandIndex, total })) {
-      weights[hue] = style === 'aurora' ? weights[hue]! + strength : Math.max(weights[hue]!, strength)
+      weights[hue] = style === 'aurora' ? weights[hue] + strength : Math.max(weights[hue], strength)
     }
     bandIndex += 1
   }
-  const weight = weights[0]! + weights[1]! + weights[2]!
+  const weight = weights[0] + weights[1] + weights[2]
   if (weight <= 0.01) return null
   let red = 0
   let green = 0
   let blue = 0
   for (let index = 0; index < 3; index += 1) {
-    red += weights[index]! * hues[index]![0]
-    green += weights[index]! * hues[index]![1]
-    blue += weights[index]! * hues[index]![2]
+    red += weights[index] * hues[index][0]
+    green += weights[index] * hues[index][1]
+    blue += weights[index] * hues[index][2]
   }
   const mixed: RgbTriple = [
     Math.round(red / weight),
@@ -590,7 +688,7 @@ export function deepseekWaveWordVisible(tick: number, tier: DeepseekWaveTier, st
  * @returns the hue for that character.
  */
 export function deepseekWaveWordHue(index: number, hues: readonly [RgbTriple, RgbTriple, RgbTriple]): RgbTriple {
-  return hues[index % hues.length]!
+  return hues[index % hues.length]
 }
 
 /**

package/src/render/editor.ts

@@ -58,7 +58,7 @@ export function splitGraphemes(text: string): readonly GraphemeSpan[] {
 /** Round one UTF-16 offset down to the grapheme boundary at or before it. */
 function floorBoundary(spans: readonly GraphemeSpan[], offset: number): number {
   for (let index = spans.length - 1; index >= 0; index -= 1) {
-    const span = spans[index]!
+    const span = spans[index]
     if (span.end <= offset) return span.end
     if (span.start < offset) return span.start
   }
@@ -85,7 +85,7 @@ export function clampCursor(value: string, offset: number): number {
 export function deleteLastGrapheme(text: string): string {
   if (text === '') return ''
   const spans = splitGraphemes(text)
-  return text.slice(0, spans[spans.length - 1]!.start)
+  return text.slice(0, spans[spans.length - 1].start)
 }
 
 /**
@@ -100,7 +100,7 @@ export function moveCursorBy(value: string, offset: number, delta: number): numb
   const current = boundaries.indexOf(clampCursor(value, offset))
   if (current === -1) return clampCursor(value, offset)
   const next = Math.max(0, Math.min(boundaries.length - 1, current + delta))
-  return boundaries[next]!
+  return boundaries[next]
 }
 
 /**
@@ -221,9 +221,9 @@ export function editorRowParts(
   if (!caretEnabled || rowIndex !== caretRow) return { before: '', caret: '', after: row.text, hasCaret: false }
   const at = row.offsets.indexOf(cursor)
   if (at < 0) return { before: '', caret: '', after: row.text, hasCaret: false }
-  const before = at > 0 ? row.text.slice(0, row.cuts[at]!) : ''
-  const caret = at < row.cuts.length - 1 ? row.text.slice(row.cuts[at]!, row.cuts[at + 1]!) : ' '
-  const after = at < row.cuts.length - 1 ? row.text.slice(row.cuts[at + 1]!) : ''
+  const before = at > 0 ? row.text.slice(0, row.cuts[at]) : ''
+  const caret = at < row.cuts.length - 1 ? row.text.slice(row.cuts[at], row.cuts[at + 1]) : ' '
+  const after = at < row.cuts.length - 1 ? row.text.slice(row.cuts[at + 1]) : ''
   return { before, caret, after, hasCaret: true }
 }
 
@@ -231,12 +231,12 @@ export function editorRowParts(
 export function caretSite(model: EditorModel, offset: number): CaretSite {
   const target = Math.max(0, Math.min(model.length, offset))
   for (let index = model.rows.length - 1; index >= 0; index -= 1) {
-    const row = model.rows[index]!
+    const row = model.rows[index]
     const at = row.offsets.indexOf(target)
-    if (at >= 0) return { row: index, column: row.columns[at]! }
+    if (at >= 0) return { row: index, column: row.columns[at] }
   }
   const last = model.rows[model.rows.length - 1]
-  return { row: model.rows.length - 1, column: last === undefined ? 0 : last.columns[last.columns.length - 1]! }
+  return { row: model.rows.length - 1, column: last === undefined ? 0 : last.columns[last.columns.length - 1] }
 }
 
 /**
@@ -250,14 +250,14 @@ export function moveCursorVertically(model: EditorModel, offset: number, preferr
   if (delta === 0) return offset
   if (target < 0) return 0
   if (target >= model.rows.length) return model.length
-  const row = model.rows[target]!
-  const wanted = Math.max(0, Math.min(preferredColumn, row.columns[row.columns.length - 1]!))
+  const row = model.rows[target]
+  const wanted = Math.max(0, Math.min(preferredColumn, row.columns[row.columns.length - 1]))
   let best = 0
   for (let index = 1; index < row.columns.length; index += 1) {
-    if (row.columns[index]! <= wanted) best = index
+    if (row.columns[index] <= wanted) best = index
     else break
   }
-  return row.offsets[best]!
+  return row.offsets[best]
 }
 
 /** The start/end offsets of the logical line containing the cursor. */
@@ -309,13 +309,13 @@ export function moveWordLeft(value: string, offset: number): number {
   // left-hand fragment, instead of skipping the whole containing run.
   let index = runs.findLastIndex(run => run.start < cursor)
   if (index < 0) return 0
-  if (runs[index]!.class === 'space') {
+  if (runs[index].class === 'space') {
     index -= 1
     if (index < 0) return 0
   }
   let target = index
-  while (target > 0 && runs[target]!.class === 'punct' && runs[target - 1]!.class === 'punct') target -= 1
-  return runs[target]!.start
+  while (target > 0 && runs[target].class === 'punct' && runs[target - 1].class === 'punct') target -= 1
+  return runs[target].start
 }
 
 /**
@@ -329,13 +329,13 @@ export function moveWordRight(value: string, offset: number): number {
   // right-hand fragment, instead of jumping straight to the following word.
   let index = runs.findIndex(run => run.end > cursor)
   if (index >= runs.length) return value.length
-  if (runs[index]!.class === 'space') {
+  if (runs[index].class === 'space') {
     index += 1
     if (index >= runs.length) return value.length
   }
   let target = index
-  while (target < runs.length - 1 && runs[target]!.class === 'punct' && runs[target + 1]!.class === 'punct') target += 1
-  return runs[target]!.end
+  while (target < runs.length - 1 && runs[target].class === 'punct' && runs[target + 1].class === 'punct') target += 1
+  return runs[target].end
 }
 
 /** One edit outcome: the next draft value, cursor, and killed span (if any). */
@@ -362,7 +362,7 @@ function replaceRange(value: string, cursor: number, start: number, end: number,
 export function deleteBackward(value: string, cursor: number): EditResult {
   if (cursor === 0) return { value, cursor, killed: undefined }
   const spans = splitGraphemes(value.slice(0, cursor))
-  const start = spans.length === 0 ? 0 : spans[spans.length - 1]!.start
+  const start = spans.length === 0 ? 0 : spans[spans.length - 1].start
   return replaceRange(value, cursor, start, cursor, false)
 }