@promptctl/cc-candybar 1.42.1 → 1.43.0

package/src/demo/statusline.json5

@@ -1,94 +0,0 @@
-// Demo DSL statusline — a runnable example of the segment DSL.
-//
-//   Run it:   pnpm demo:dsl
-//   Hack it:  edit a template / palette / layout entry below and re-run.
-//             No rebuild — the config IS the program.
-//
-// This file is rendered by the SAME two functions the daemon calls
-// (registerDslConfig + renderDsl in src/dsl/render.ts). There is no
-// demo-only render path — what you see here is what production produces.
-{
-  globals: {
-    // Base palette for every segment that doesn't pull its own (see `branch`).
-    palette: 'textual-dark',
-  },
-
-  // ── Variables: where each segment's data comes from ──────────────────────
-  // Every `kind` maps to one runtime source. Templates reference these by name
-  // with a leading dot (`.user`, `.cwd`, …). A referenced-but-undeclared name
-  // is a load-time error, not a silent blank.
-  variables: {
-    // env  — read straight from the process environment.
-    user: { kind: 'env', name: 'USER', default: 'anon' },
-
-    // input — pulled from the JSON payload Claude Code sends each render tick.
-    cwd:     { kind: 'input', path: 'workspace.current_dir', default: '?' },
-    model:   { kind: 'input', path: 'model.display_name',    default: '' },
-    session: { kind: 'input', path: 'session_id',            default: '' },
-
-    // template — derived from other vars; recomputed reactively when they move.
-    sid:  { kind: 'template', template: '{{ trunc 8 .session }}' },
-    here: { kind: 'template', template: '{{ basename .cwd }}' },
-
-    // shell — run a command, cache the result for a TTL window. Populates
-    // asynchronously: until the command returns, `.branch` is the default ''.
-    branch: { kind: 'shell', command: 'git branch --show-current', cache: { ttl: '5s' }, default: '' },
-
-    // time — the system clock, formatted with a Go reference-time layout.
-    clock: { kind: 'time', layout: '15:04:05', cache: { ttl: '1s' } },
-
-    // literal — a fixed value read like any other var. Here it drives the
-    // per-segment hue rotation (HUE_STEP_VAR): adjacent segments rotate 14° so
-    // they stay distinct. Make it a `state` var + a stepper widget to adjust it
-    // live; a literal is the fixed-value form.
-    'hue.step': { kind: 'literal', value: 14 },
-
-    // (file and git kinds exist too — omitted here to stay minimal.)
-  },
-
-  // ── Segments: how each piece of data is drawn ────────────────────────────
-  // `bg`/`fg` are palette spec strings, and either may also be a template
-  // that computes a color — `fg: '{{ contrastOn (bgOf) }}'` below picks
-  // black or white, whichever is readable against this segment's own
-  // background. `when` hides a segment when it evaluates false.
-  segments: {
-    user: {
-      template: ' {{ .user }} ',
-      bg: 'primary',
-      fg: '{{ contrastOn (bgOf) }}',
-    },
-    directory: {
-      template: ' {{ .here }} ',
-      bg: 'surface',
-      fg: 'foreground',
-    },
-    branch: {
-      template: ' {{ .branch }} ',
-      bg: 'accent',
-      fg: '{{ contrastOn (bgOf) }}',
-      when: '{{ ne .branch "" }}',   // hidden entirely outside a git repo
-      palette: 'gruvbox',      // this segment pulls its OWN palette (per-segment switch)
-    },
-    model: {
-      template: ' {{ .model }} ',
-      bg: 'secondary',
-      fg: '{{ contrastOn (bgOf) }}',
-      when: '{{ ne .model "" }}',
-    },
-    session: {
-      template: ' ⌗{{ .sid }} ',
-      bg: 'surface',
-      fg: 'foreground',
-    },
-    clock: {
-      template: ' {{ .clock }} ',
-      bg: 'primary',
-      fg: '{{ contrastOn (bgOf) }}',
-    },
-  },
-
-  // ── Layout: Option A shape grammar — one horizontal row of segment refs.
-  // { v: [...] } for multiple rows; { h: ['a', 'b'], when: '...' } for a gated row;
-  // bare string 'segname' for a single segment ref.
-  root: { h: ['user', 'directory', 'branch', 'model', 'session', 'clock'] },
-}

package/src/dsl/node-registry.ts

@@ -1,374 +0,0 @@
-// [LAW:single-enforcer] THE node-type registry: the one place each layout node
-// kind's render-time behavior (compile + render) is defined, dispatched through a
-// single typed lookup. The walk is ONE uniform dispatch:
-// nodeType(node.kind).render(node, ctx).
-//
-// [LAW:one-type-per-behavior] The layout is exactly two kinds — `container`
-// (arranges children) and `segment` (THE unit of rendering: one ref into the
-// named segments map, rendered to ONE strip item). Interaction, state-driven
-// display, and multi-region clickability all live in a segment's TEMPLATE, not
-// in extra node kinds — so there is no inline/stepper/picker node arm to add.
-// A horizontal run of segments is spelled `{ h: ["seg1", "seg2"] }` in the
-// A-grammar (the `cells` form and `layout` rows were deleted in 2de.19).
-//
-// [LAW:one-way-deps] This module sits BELOW render.ts (the driver): it imports
-// the leaf render/template helpers directly and receives the two recursive
-// capabilities (compileChild, renderChild) + the hue counter as DATA from the
-// driver. It must NOT import render.ts — that would invert the layering. render.ts
-// imports the compiled types + nodeType() from here, one-way.
-//
-// Hue is per-segment DECORATIVE only: each `segment` advances the cursor by one
-// unit (a container advances none), so colors stay positionally stable. It
-// carries NO structural meaning — unit cohesion is structural (one segment = one
-// strip item), not a function of matching backgrounds.
-
-import { RichText, IDENTITY } from "@promptctl/rich-js";
-import type { Palette, Style, ThemeKey } from "@promptctl/rich-js";
-import type { Template } from "@promptctl/go-template-js";
-import type {
-  LayoutNode,
-  Direction,
-  SegmentDecl,
-} from "../config/dsl-types.js";
-import { splitCellsIntoLines } from "../render/split-lines.js";
-import { transposedPalette } from "../themes/index.js";
-import {
-  fragmentsToCells,
-  evaluateWhen,
-  applySegmentLayout,
-} from "../template-engine/index.js";
-
-// ─── Compiled node shapes ──────────────────────────────────────────────────────
-
-// [LAW:dataflow-not-control-flow] The compiled mirror of a LayoutNode: the same
-// recursive shape with every `when` parsed ONCE at registration. renderDsl walks
-// this compiled tree — never the raw config — so the parse-once guarantee covers
-// every node.
-export interface CompiledSegmentNode {
-  readonly kind: "segment";
-  readonly when?: Template<RichText>;
-  readonly name: string;
-}
-export interface CompiledContainerNode {
-  readonly kind: "container";
-  readonly direction: Direction;
-  readonly when?: Template<RichText>;
-  readonly children: readonly CompiledNode[];
-}
-export type CompiledNode = CompiledSegmentNode | CompiledContainerNode;
-
-// Pre-parsed templates and pre-resolved palette for one segment, built once at
-// registration. A `segment` node names one; render looks it up via
-// ctx.lookupSegment.
-export interface CompiledSegment {
-  readonly when?: Template<RichText>;
-  readonly template: Template<RichText>;
-  readonly bg?: Template<RichText>;
-  readonly fg?: Template<RichText>;
-  readonly palette?: Palette;
-}
-export type CompiledSegments = Readonly<Record<string, CompiledSegment>>;
-
-// A rendered node is a LIST OF LINES, each line a list of cells — NOT yet
-// serialized. [LAW:types-are-the-program] Cells (not ANSI bytes) are the
-// composition substrate: the powerline joiner caps between adjacent cells, so
-// serializing a node before composition would freeze its last cell's edge and
-// make a cap across a sibling seam unrecoverable. Serialization (the single
-// joiner pass) runs exactly once, at the root, after the whole tree composes.
-export type RenderedLines = ReadonlyArray<readonly RichText[]>;
-
-// ─── Compile / render contexts (the injected capabilities) ──────────────────────
-
-// [LAW:locality-or-seam] The compile-time context the driver hands each node
-// type. `when` is PRE-COMPILED by the driver (walk-owned, uniform across kinds);
-// the type only assembles it in. compileChild is the recursion, injected so this
-// module needn't import the driver.
-export interface NodeCompileCtx {
-  readonly path: string;
-  // The node's own `when`, already parsed by the driver (one parse-when site).
-  readonly when?: Template<RichText>;
-  // Compile a child node (the recursion, injected so this module needn't import
-  // the driver).
-  compileChild(node: LayoutNode, path: string): CompiledNode;
-}
-
-// [LAW:single-enforcer] The render-time context. The hue COUNTER lives in the
-// driver; ctx exposes only nextHueShift() (advance + return this unit's shift) so
-// there is exactly one mutator. `visible` is THIS node's computed visibility
-// (the driver ANDs node.when with the parent's). renderChild continues the walk.
-export interface NodeRenderCtx {
-  readonly scope: object;
-  readonly basePalette: Palette;
-  // [LAW:one-source-of-truth] The render-wide look (the session's chosen
-  // theme-adaptation, resolved by the caller via effectiveLookName →
-  // lookKeyByName), threaded by the driver — one ThemeKey per render, IDENTITY
-  // when no look is chosen. Composed with the per-segment hue shift into ONE
-  // transposition key at the segment leaf.
-  readonly look: ThemeKey;
-  readonly visible: boolean;
-  // [LAW:one-source-of-truth] The render-wide intra-cell padding (resolved
-  // globals.padding), threaded by the driver from BuildLineOptions into every
-  // segment's layout — one value per render, never re-defaulted per node.
-  readonly padding: number;
-  // Advance the walk-owned hue cursor by one unit and return that unit's shift.
-  nextHueShift(): number;
-  readonly perSegmentSink?: Map<string, readonly RichText[]>;
-  // [LAW:no-silent-failure] Optional observer for the per-segment render catch
-  // below: a caught evaluation error renders as a visible ⚠ error cell (partial
-  // rendering — the daemon's channel), AND is reported here so a headless caller
-  // (`cc-candybar check`, a blind authoring agent's eyes) can turn it into a
-  // text verdict instead of blessing a bar it cannot see. Trusted non-throwing
-  // (the registry-dispose contract) — see RenderObservers.onSegmentError.
-  readonly onSegmentError?: (segName: string, message: string) => void;
-  // [LAW:locality-or-seam] The segment seam, injected as a capability pair so
-  // this module never imports the menu or color features — it only says when a
-  // segment starts and stops.
-  //
-  // `enterSegment` runs BEFORE any of the segment's templates evaluate. It
-  // publishes what the segment's own templates may ask about themselves — the
-  // name a `{{ menu }}` derives its identity from, the palette `{{ color }}`
-  // resolves against, the background `{{ bgOf }}` returns — and resolves the
-  // segment's `bg:`/`fg:` into its base Style along the way. The bg/fg
-  // resolution HAS to happen here rather than after the body: a body asking for
-  // its own background can only be answered once the background exists.
-  //
-  // `exitSegment` runs AFTER eval: it reads the open menu bodies the menus
-  // carried as metadata on the evaluated fragments (template order) for the
-  // boundary to stack below the row, and tears the published record down.
-  enterSegment(
-    segName: string,
-    palette: Palette,
-    bgTemplate: Template<RichText> | undefined,
-    fgTemplate: Template<RichText> | undefined,
-  ): Style;
-  exitSegment(fragments: readonly RichText[]): readonly RichText[];
-  // [LAW:locality-or-seam] The focus transform, injected as a capability (rich-js
-  // owns the color math — see render.ts). Applied to the segment's baseStyle when
-  // it has an open menu (it contributed drops), so the whole focused segment —
-  // inline trigger + dropped body band — reads as highlighted.
-  focusTint(style: Style): Style;
-  // Resolve a segment name to its decl + compiled form (the driver closes over
-  // config.segments + the compiled segments).
-  lookupSegment(
-    name: string,
-  ):
-    | { readonly seg: SegmentDecl; readonly compiled: CompiledSegment }
-    | undefined;
-  // Continue the walk into a child node (parentVisible = this node's visibility).
-  renderChild(node: CompiledNode, parentVisible: boolean): RenderedLines;
-}
-
-// ─── Composition ───────────────────────────────────────────────────────────────
-
-// [LAW:dataflow-not-control-flow] A container's `direction` is the projection it
-// applies to its already-rendered child blocks — DATA selecting a fold, not a
-// branch that skips work. `vertical` STACKS (concatenate the children's line-
-// lists). The switch is exhaustive over `Direction`; adding `outline` to
-// DIRECTIONS forces a new arm here.
-//
-// [LAW:decomposition] `horizontal` composes ONLY row 0 across the seam — row 0 is
-// every child's FIRST line zipped (the inline powerline run, so the joiner caps
-// across the seam, no abut). Every line BELOW row 0 is a child's DROP (a menu body
-// dropping below its trigger, a genuinely multi-line segment): drops STACK full-
-// width in child order, never zipped. Multi-line side-by-side column alignment is
-// explicitly UNSUPPORTED — aligning two children's row-i cells would require
-// background-as-structure, and bg is never structural. For an all-single-line row
-// (no child has a drop) this is byte-identical to a plain per-row zip.
-function composeBlocks(
-  direction: Direction,
-  blocks: readonly RenderedLines[],
-): RenderedLines {
-  switch (direction) {
-    case "vertical":
-      return blocks.flatMap((b) => b);
-    case "horizontal": {
-      // [LAW:dataflow-not-control-flow] height 0 (every child hidden/empty) ⇒ the
-      // container contributes NO line — not one empty row. This is the value-driven
-      // identity of the fold, preserved from the per-row zip it replaces; a stray
-      // [[]] here would render as a spurious blank line.
-      const height = blocks.reduce((m, b) => Math.max(m, b.length), 0);
-      if (height === 0) return [];
-      const row0 = blocks.flatMap((b) => b[0] ?? []);
-      const drops = blocks.flatMap((b) => b.slice(1));
-      return [row0, ...drops];
-    }
-  }
-}
-
-// ─── The node-type contract + registry ──────────────────────────────────────────
-
-type NodeKind = LayoutNode["kind"];
-
-// [LAW:types-are-the-program] One contract per node kind, generic over the kind so
-// each entry's compile/render see their OWN narrowed node arm — never the union,
-// so no internal re-narrow guard. compile (registration: LayoutNode → compiled,
-// parse-once) and render (per-render: compiled → lines) are co-located per kind.
-export interface NodeType<K extends NodeKind> {
-  compile(
-    node: Extract<LayoutNode, { kind: K }>,
-    cctx: NodeCompileCtx,
-  ): Extract<CompiledNode, { kind: K }>;
-  render(
-    node: Extract<CompiledNode, { kind: K }>,
-    ctx: NodeRenderCtx,
-  ): RenderedLines;
-}
-
-const containerType: NodeType<"container"> = {
-  compile(node, cctx) {
-    return {
-      kind: "container",
-      direction: node.direction,
-      when: cctx.when,
-      children: node.children.map((child, i) =>
-        cctx.compileChild(child, `${cctx.path}.children[${i}]`),
-      ),
-    };
-  },
-  render(node, ctx) {
-    // [LAW:dataflow-not-control-flow] A container advances NO hue unit itself; its
-    // children do, walked in order so positional hue stays stable. Hidden or not,
-    // every child is rendered (parentVisible threads the gate) so hidden subtrees
-    // still advance the cursor.
-    return composeBlocks(
-      node.direction,
-      node.children.map((child) => ctx.renderChild(child, ctx.visible)),
-    );
-  },
-};
-
-const segmentType: NodeType<"segment"> = {
-  compile(node, cctx) {
-    return {
-      kind: "segment",
-      when: cctx.when,
-      name: node.name,
-    };
-  },
-  render(node, ctx) {
-    const found = ctx.lookupSegment(node.name);
-    // [LAW:no-defensive-null-guards] The loader validates every segment ref
-    // against the segments map and registerDslConfig compiles every declared
-    // segment; a miss is a caller bug (renderDsl given a mismatched compiled
-    // object).
-    if (!found) {
-      throw new Error(`Layout segment "${node.name}" has no matching segment`);
-    }
-    const { seg, compiled: segCompiled } = found;
-
-    // [LAW:single-enforcer] Advance the hue cursor BEFORE the visibility gate so a
-    // hidden segment still consumes its unit — siblings after it keep their
-    // positionally-stable colors regardless of which segments are hidden.
-    const hueShift = ctx.nextHueShift();
-    if (!ctx.visible) return [];
-
-    // [LAW:no-silent-failure] Wrap the whole render body in a try/catch so a
-    // partial-load consequence (e.g. a variable that failed to declare, leaving a
-    // MissingFieldError when the template or when-predicate accesses it) surfaces
-    // as a visible error cell rather than crashing the whole bar. The remaining
-    // segments render normally. This is the render-time complement to the per-
-    // variable catch in registerDslConfig — together they implement option-2
-    // partial rendering: the new config stays active, working segments render, and
-    // broken segments show an error cell.
-    try {
-      if (!evaluateWhen(segCompiled.when, ctx.scope)) return [];
-
-      // [LAW:dataflow-not-control-flow] The per-segment variability is WHICH
-      // palette — the base palette (per-segment override or basePalette)
-      // transposed by the render's look + this segment's hueShift, folded into
-      // ONE ThemeKey for a SINGLE transposePalette call (chaining two
-      // transpositions would double-pay OKLCH quantization and collide the
-      // transpose memo — see transposedPalette). An explicit per-segment
-      // `palette:` pin IGNORES the look, exactly as it ignores the session
-      // theme: the pin's presence is the discriminator, and its arm carries the
-      // identity look — a value choice, not a skipped operation.
-      const lookKey = segCompiled.palette !== undefined ? IDENTITY : ctx.look;
-      const palette = transposedPalette(
-        segCompiled.palette ?? ctx.basePalette,
-        {
-          ...lookKey,
-          hueShift: lookKey.hueShift + hueShift,
-        },
-      );
-
-      // [LAW:one-source-of-truth] ONE palette for this segment: its `bg:`, its
-      // `fg:`, and every `{{ color }}` in its body resolve from this same
-      // object. That is the whole reason the segment is entered before its body
-      // evaluates rather than after — a body coloured from a palette resolved
-      // independently of the cell it sits in is two palettes in one segment,
-      // and they diverge the moment a theme, look, or hue shift moves.
-      const resolvedStyle = ctx.enterSegment(
-        node.name,
-        palette,
-        segCompiled.bg,
-        segCompiled.fg,
-      );
-      const fragments = segCompiled.template.evaluate(ctx.scope);
-      // [LAW:decomposition] The open menu bodies, carried as out-of-band metadata
-      // on the evaluated fragments — invisible to the inline render, so a menu can
-      // sit anywhere in the template and content after it stays inline. Each
-      // becomes one full-width line stacked below the segment's row.
-      const drops = ctx.exitSegment(fragments);
-      // [LAW:dataflow-not-control-flow] Focus is the PRESENCE of a drop: a segment
-      // with an open menu (it contributed a body) lightens, so the whole focused
-      // segment — inline trigger + dropped band — reads as highlighted. No state
-      // re-read; the drop list IS the open-menu signal.
-      const baseStyle =
-        drops.length > 0 ? ctx.focusTint(resolvedStyle) : resolvedStyle;
-      const layout = {
-        width: seg.width ?? "auto",
-        justify: seg.justify ?? "left",
-        truncate: seg.truncate ?? "right",
-        baseStyle,
-        // [LAW:dataflow-not-control-flow] Padding is uniform across every line
-        // a segment contributes — inline rows AND dropped menu bands — one
-        // value, no per-line-kind branch. The picker reserves 2×padding at its
-        // pagination seam so a padded band still fits the width budget.
-        padding: ctx.padding,
-      } as const;
-
-      // [LAW:single-enforcer] Partition the segment's authored "\n" into visual
-      // lines BEFORE per-segment layout — width/justify/truncate then measure each
-      // line cleanly. A newline-free segment is the degenerate one-line case. Each
-      // laid line is ONE strip item: applySegmentLayout collapses a line's cells to
-      // 0-or-1 item (OSC-8 links survive as interior spans), so the joiner caps only
-      // at the segment's edges, never inside it.
-      const inlineLines = splitCellsIntoLines(
-        fragmentsToCells(fragments, baseStyle),
-      ).map((line) => applySegmentLayout(line, layout));
-      // Each open menu body is one full-width dropped line, in the segment's
-      // (focus-tinted) bg, stacked after the inline row(s). composeBlocks then
-      // drops every line below row 0 below the enclosing horizontal row.
-      const dropLines = drops.map((body) =>
-        applySegmentLayout(fragmentsToCells([body], baseStyle), layout),
-      );
-      const laidLines = [...inlineLines, ...dropLines];
-
-      if (ctx.perSegmentSink !== undefined) {
-        ctx.perSegmentSink.set(node.name, laidLines.flat());
-      }
-      return laidLines;
-    } catch (err) {
-      const message = (err as Error).message ?? String(err);
-      ctx.onSegmentError?.(node.name, message);
-      return [[new RichText(`⚠ ${node.name}: ${message}`)]];
-    }
-  },
-};
-
-// [LAW:single-enforcer] THE registry. `satisfies` forces an entry for every
-// LayoutNode kind — adding a kind to the union breaks compilation here until its
-// behavior is registered, so "register a type" is one mechanically-enforced act.
-const REGISTRY = {
-  container: containerType,
-  segment: segmentType,
-} satisfies { [K in NodeKind]: NodeType<K> };
-
-// [LAW:types-are-the-program] The one dispatch primitive. Indexing by a node's OWN
-// kind returns the entry built FOR that kind, so the pairing is sound by
-// construction; the cast only widens the static K to the union (TS cannot prove
-// the index/arm link across a heterogeneous registry). Every consumer calls
-// nodeType(node.kind).method(node) — no consumer re-switches on kind.
-export function nodeType(kind: NodeKind): NodeType<NodeKind> {
-  return REGISTRY[kind] as unknown as NodeType<NodeKind>;
-}