@promptctl/cc-candybar 1.42.1 → 1.43.0

package/src/template-engine/layout.ts

@@ -1,133 +0,0 @@
-// [LAW:single-enforcer] All per-segment width/justify/truncate enforcement
-// runs through applySegmentLayout. RichText owns the slice/pad/truncate
-// primitives; this function chooses which to call from the segment-level
-// options. No second path exists.
-//
-// [LAW:dataflow-not-control-flow] Every step is unconditional in shape;
-// option values (width, justify, truncate) decide what the output is, not
-// whether the step runs. "auto" width is not a branch that skips logic —
-// it is a value that selects "collapse only, no resize" over "collapse then
-// size to width".
-//
-// [LAW:types-are-the-program] With RichText as the cell type, every layout
-// operation is span-preserving by construction. There is no rebuild path,
-// no slice-then-restyle dance: `richText.truncate({width, mode, marker})`
-// and `richText.align(justify, width)` clip and shift spans through every
-// cut. The bzh.9 limitation (truncation drops per-part fg) cannot be
-// expressed in this shape — its preconditions don't exist.
-
-import { RichText } from "@promptctl/rich-js";
-import type { Style } from "@promptctl/rich-js";
-import type { Template } from "@promptctl/go-template-js";
-
-export type JustifyMode = "left" | "center" | "right";
-export type TruncateMode = "right" | "left" | "middle";
-
-export interface SegmentLayoutOptions {
-  /** "auto" → content-sized; a positive integer → fixed terminal-cell width. */
-  width: "auto" | number;
-  /** Alignment within a fixed-width segment. Ignored when width is "auto". */
-  justify: JustifyMode;
-  /** Overflow strategy when content exceeds a fixed width. Ignored when "auto". */
-  truncate: TruncateMode;
-  /**
-   * Spaces synthesized inside the collapsed cell on each side (the resolved
-   * globals.padding). [LAW:types-are-the-program] Required so every layout
-   * site states the value — the walk threads the one render-wide resolution;
-   * there is no per-site re-default. Applied BEFORE width sizing, so padding
-   * sits inside a fixed `width` (the legacy intra-cell semantics: the joiners
-   * sit between cells; padding sits inside the bg fill).
-   */
-  padding: number;
-  /** Glyph inserted at the overflow cut point. Default "…". */
-  truncateMarker?: string;
-  /**
-   * Style for synthesized whitespace — RichText pads using plain spaces.
-   * The padding inherits the cell's wrapping style at render time, so the
-   * segment bg/fg is continuous across padded gaps without a second style
-   * assignment here.
-   */
-  baseStyle?: Style;
-}
-
-/**
- * Evaluate a `when` predicate template against `scope`.
- * Returns false only when the evaluated text equals the string "false".
- * A missing template means the segment is always visible.
- *
- * [LAW:dataflow-not-control-flow] Visibility is a value that flows out of the
- * template engine. The engine always runs; the output value decides visibility.
- */
-export function evaluateWhen(
-  template: Template<RichText> | undefined,
-  scope: object,
-): boolean {
-  if (template === undefined) return true;
-  const fragments = template.evaluate(scope);
-  return fragments.map((f) => f.plain).join("") !== "false";
-}
-
-/**
- * Collapse a visual line's cells into the ONE strip item the unit contributes
- * for that line. [LAW:single-enforcer] A unit (segment, or an inline leaf) is
- * one strip item — the powerline joiner caps BETWEEN units, never inside one,
- * so a unit's interior bg/fg variation is paint, not a structural seam the
- * joiner reads. Each input cell's wrapping style becomes a span over its range
- * and its interior spans (including OSC-8 links) carry through, so every
- * clickable region survives as its own span — serialized as one OSC-8 region
- * each. `baseStyle` is the wrapping default so synthesized padding and gaps
- * inherit the unit's bg.
- */
-function collapseToCell(
-  cells: readonly RichText[],
-  baseStyle?: Style,
-): RichText {
-  const merged = RichText.fromFragments(cells);
-  merged.end = "";
-  merged.noWrap = true;
-  if (baseStyle !== undefined && !baseStyle.isNull) merged.style = baseStyle;
-  return merged;
-}
-
-/**
- * Lay out one segment visual line: collapse its cells into a single strip
- * item, then size that item to the requested width. Returns `[]` for an empty
- * line (a unit that rendered nothing contributes no strip item) or `[cell]`
- * for one — never more, so the caller's branchless spread handles both.
- *
- * [LAW:dataflow-not-control-flow] `width` is the value that selects the sizing
- * op: "auto" keeps the content-sized cell as-is; a fixed width truncates when
- * over and pad-aligns when under. Truncation/align are span-preserving, so the
- * collapsed link structure survives every cut.
- */
-export function applySegmentLayout(
-  cells: readonly RichText[],
-  options: SegmentLayoutOptions,
-): RichText[] {
-  const {
-    width,
-    justify,
-    truncate,
-    truncateMarker = "…",
-    baseStyle,
-    padding,
-  } = options;
-
-  if (cells.length === 0) return [];
-
-  // [LAW:one-source-of-truth] The DSL path's ONE intra-cell padding
-  // application — the same rich-js pad primitive toCell (render/strip.ts)
-  // uses on the legacy shape, threading the same resolved globals.padding.
-  // pad() shifts spans, so OSC-8 link regions survive; the spaces inherit
-  // the cell's wrapping style, so the segment bg is continuous.
-  const cell = collapseToCell(cells, baseStyle).pad(padding);
-  if (width === "auto") return [cell];
-
-  if (cell.cellLength > width) {
-    cell.truncate(width, { mode: truncate, marker: truncateMarker });
-  } else if (cell.cellLength < width) {
-    cell.align(justify, width);
-  }
-
-  return [cell];
-}

package/src/template-engine/scope.ts

@@ -1,62 +0,0 @@
-// [LAW:dataflow-not-control-flow] The scope Proxy converts a flat variable
-// store (keys like "session.id", "git.branch", "cwd") into the nested object
-// shape the template engine expects for ".session.id" field access.
-// No data is materialised — the proxy navigates namespace prefixes lazily and
-// calls store.read() only when a leaf is reached, so MobX dependency tracking
-// fires at the point of actual reads inside a computed body.
-//
-// The engine's getField() uses `name in obj` before `obj[name]`, so the
-// proxy must define a `has` trap as well as `get`.
-
-import type { VariableStore } from "../var-system/store.js";
-
-// Build the scope object the engine receives as `.` (dot).
-// Call once per render; the returned object is a read-only view of the store
-// at evaluation time — do not cache across renders.
-export function buildScope(store: VariableStore): object {
-  const names = new Set(store.names());
-  return makeProxy(store, names, "");
-}
-
-function makeProxy(
-  store: VariableStore,
-  names: Set<string>,
-  prefix: string,
-): object {
-  return new Proxy(Object.create(null) as object, {
-    has(_, key: string | symbol): boolean {
-      if (typeof key !== "string") return false;
-      const fullKey = prefix ? `${prefix}.${key}` : key;
-      // Leaf: exact variable.
-      if (names.has(fullKey)) return true;
-      // Interior: a namespace prefix for at least one stored variable.
-      const nsPrefix = `${fullKey}.`;
-      for (const n of names) {
-        if (n.startsWith(nsPrefix)) return true;
-      }
-      return false;
-    },
-
-    get(_, key: string | symbol): unknown {
-      if (typeof key !== "string") return undefined;
-      const fullKey = prefix ? `${prefix}.${key}` : key;
-
-      // Leaf: exact variable in the store.
-      if (names.has(fullKey)) {
-        return store.read(fullKey);
-      }
-
-      // Interior: a namespace prefix for at least one stored variable.
-      // Return a nested proxy; MobX tracking fires only at the leaf read.
-      const nsPrefix = `${fullKey}.`;
-      for (const n of names) {
-        if (n.startsWith(nsPrefix)) {
-          return makeProxy(store, names, fullKey);
-        }
-      }
-
-      // Unknown: `has` returned false so the engine will throw MissingFieldError.
-      return undefined;
-    },
-  });
-}

package/src/template-engine/sparkline.ts

@@ -1,79 +0,0 @@
-// [LAW:effects-at-boundaries] A sparkline is a PURE projection: a numeric
-// series in, a string of block glyphs out. It reads no clock, touches no
-// store, accumulates nothing — any history it draws is owned by the daemon
-// cache and handed in as data (cf. session-usage-store's burn-rate ring).
-// [LAW:one-source-of-truth] The renderer operates on number[] (the real
-// domain); the var-system can only carry a scalar across the payload→template
-// seam, so `parseSeries` decodes the delimited string form at that one edge —
-// the wire shape and the domain shape have a single, tested conversion.
-
-// The eight-level block ramp, lowest→highest. Index into this is the only
-// place a value's normalized height becomes a glyph.
-export const SPARK_LEVELS = [
-  "▁", // ▁
-  "▂", // ▂
-  "▃", // ▃
-  "▄", // ▄
-  "▅", // ▅
-  "▆", // ▆
-  "▇", // ▇
-  "█", // █
-] as const;
-
-const LEVELS = SPARK_LEVELS.length;
-
-// Render a numeric series as a unicode mini-graph.
-//
-// `width` caps the glyph count to fit a cell: the MOST RECENT `width` samples
-// are shown (tail slice), so a fixed-width cell tracks the live tail of a
-// growing series. Omitted → every sample renders; `width <= 0` → empty.
-//
-// Heights are RELATIVE to the rendered window's own min/max — a sparkline shows
-// shape, never absolute magnitude, so the full ramp is always used when the
-// window varies. [LAW:dataflow-not-control-flow] The mapping is one unconditional
-// fold over the values; the only data-driven value is `range`, and a flat
-// window (range === 0) falls to the lowest tier by the same formula's limit
-// (height-above-min is 0 for every sample), not a special-cased branch.
-export function renderSparkline(values: number[], width?: number): string {
-  const window =
-    width === undefined ? values : width <= 0 ? [] : values.slice(-width);
-  if (window.length === 0) return "";
-
-  let min = window[0]!;
-  let max = window[0]!;
-  for (const v of window) {
-    if (v < min) min = v;
-    if (v > max) max = v;
-  }
-  const range = max - min;
-
-  let out = "";
-  for (const v of window) {
-    // range === 0 ⇒ every sample sits at its own min ⇒ height 0 ⇒ lowest tier.
-    const idx =
-      range === 0 ? 0 : Math.round(((v - min) / range) * (LEVELS - 1));
-    out += SPARK_LEVELS[idx]!;
-  }
-  return out;
-}
-
-// Decode the delimited string a series travels as across the scalar var-system
-// seam into the number[] the renderer consumes. Empty / blank tokens are the
-// genuine "no sample" form (an empty payload field is ""), so they drop; a
-// non-empty, non-numeric token is malformed input and fails LOUDLY rather than
-// being silently skipped into a wrong-shaped graph. [LAW:no-silent-failure]
-export function parseSeries(s: string): number[] {
-  const out: number[] = [];
-  for (const tok of s.split(",")) {
-    const t = tok.trim();
-    if (t === "") continue;
-    const n = Number(t);
-    if (!Number.isFinite(n)) {
-      throw new TypeError(
-        `sparkline: non-numeric series element ${JSON.stringify(tok)}`,
-      );
-    }
-    out.push(n);
-  }
-  return out;
-}

package/src/themes/index.ts

@@ -1,20 +0,0 @@
-// [LAW:single-enforcer] Public barrel for the themes module. Name/string policy
-// lives in policy.ts; memoized resolver construction (name→resolver and
-// transposition) lives in palette-resolvers.ts. rich-js owns palettes,
-// hydration, all color math, and the anchor rule — cc-candybar keeps no color
-// arithmetic of its own.
-export {
-  resolvePaletteName,
-  effectiveThemeName,
-  effectiveLookName,
-  lookKeyByName,
-  effectiveStripStyle,
-  effectiveAutoWrap,
-  effectivePadding,
-  isStripStyle,
-  listResolvablePaletteNames,
-  STRIP_STYLES,
-} from "./policy.js";
-export type { StripStyle } from "./policy.js";
-
-export { paletteForThemeName, transposedPalette } from "./palette-resolvers.js";

package/src/themes/palette-resolvers.ts

@@ -1,84 +0,0 @@
-// Memoized Palette construction over rich-js. cc-candybar moves theme
-// NAMES and ThemeKey axes (data); rich-js owns every color value operation. Two
-// memos live here: a theme name -> base palette, and a (base, ThemeKey) ->
-// transposed palette. They compose — the per-render base palette feeds the
-// per-segment transposition (the session look's axes + the segment's hue shift,
-// folded into one key by the caller).
-//
-// [LAW:no-shared-mutable-globals] Single owner: this module. Both Maps are pure
-// memos of pure rich-js functions, keyed by immutable inputs (resolved theme
-// name; palette name + the four ThemeKey axes). rich-js palettes are immutable
-// registry singletons, so a cached palette never goes stale. Key spaces are
-// bounded by #themes and #themes × #declared looks × #distinct hueShifts
-// (hueShift = look shift + segIndex*hueStep, segIndex bounded by layout; look
-// axes bounded by the loaded configs' looks blocks) — both small. Shared on
-// purpose: a theme's base palette and its gruvbox+42° transposition are each
-// computed once per process, not once per RenderCache entry or per render.
-// Read/written only through the two functions below.
-
-import { transposePalette, getThemePalette } from "@promptctl/rich-js";
-import type { ThemeKey, Palette } from "@promptctl/rich-js";
-import { resolvePaletteName } from "./policy.js";
-
-const baseCache = new Map<string, Palette>();
-const transposeCache = new Map<string, Palette>();
-
-/**
- * The Palette for a theme name (aliases resolved). Memoized.
- *
- * [LAW:single-enforcer] The one place a theme name becomes a Palette —
- * the per-render base palette and per-segment `palette:` overrides both flow
- * through here. A name that does not resolve is registry/resolver drift, never
- * user error: the loader validates `globals.palette` and the set-state verb
- * validates session theme values against the resolvable set, so by the time a
- * name reaches here it must resolve. [LAW:no-defensive-null-guards] the throw is
- * the loud failure for that broken invariant, not a fallback.
- */
-export function paletteForThemeName(name: string): Palette {
-  const resolved = resolvePaletteName(name);
-  const hit = baseCache.get(resolved);
-  if (hit !== undefined) return hit;
-
-  const palette = getThemePalette(resolved);
-  if (palette === null) {
-    throw new Error(
-      `Palette "${name}" (resolved "${resolved}") did not resolve in the ` +
-        `theme registry — allowed names and the registry are inconsistent`,
-    );
-  }
-  baseCache.set(resolved, palette);
-  return palette;
-}
-
-/**
- * `base` transposed by a full ThemeKey — the adapted-palette constructor:
- * (base palette, key) → palette. The caller
- * composes whatever axes it carries (a look's four axes, the per-segment hue
- * shift) into ONE key and this makes ONE transposePalette call — never chain
- * two transpositions: chaining double-pays OKLCH quantization AND collides this
- * memo (a transposed palette keeps the base palette's name, so a re-transposed
- * gruvbox-with-look and plain gruvbox would share cache keys).
- *
- * [LAW:dataflow-not-control-flow] The key is data; the identity key flows
- * through transposePalette's isIdentityKey fast-path (byte-exact, no
- * round-trip) — no branch here. rich-js hue-locks ANCHORED_ROOTS
- * (error/success/warning), so semantic meaning is preserved by construction —
- * no local exemption list to drift.
- *
- * [LAW:single-enforcer] The sole place a transposed palette is built — a
- * future look `roles` remap is additive at this one seam. The memo miss
- * (undefined) is genuine optionality — not-yet-computed — not a defended
- * invariant. [LAW:one-source-of-truth] The cache key carries every axis of the
- * ThemeKey: two keys differing on any axis are distinct palettes.
- */
-export function transposedPalette(base: Palette, key: ThemeKey): Palette {
-  const cacheKey =
-    `${base.name} ${key.hueShift} ${key.chromaScale} ` +
-    `${key.lightnessScale} ${key.lightnessShift}`;
-  const hit = transposeCache.get(cacheKey);
-  if (hit !== undefined) return hit;
-
-  const transposed = transposePalette(base, key);
-  transposeCache.set(cacheKey, transposed);
-  return transposed;
-}