@groeponline/pi-wishcraft 1.4.0 → 1.4.5

package/src/render/layout.ts

@@ -0,0 +1,137 @@
+// Pure layout for the v2 powerline. No fs, no git, no theme reload.
+// ponytail: this is a refactor target. The legacy getResponsiveLayout stays
+// in place until U12 cutover; the v2 entry point is the only public surface
+// for the new pipeline. Width classes follow the existing renderer
+// (status-line-renderers.ts): small <60, medium <120, wide otherwise.
+
+import { visibleWidth } from "@earendil-works/pi-tui";
+
+export type WidthClass = "small" | "medium" | "wide";
+
+export interface LayoutSegment {
+  id: string;
+  text: string;
+  priority: number;
+  /**
+   * Optional visual height (rows). When > 1 the segment's `text` is split
+   * on `\n` and rendered across that many rows; other segments on the same
+   * lane pad empty rows below their content. The lane's rowCount is the
+   * max height across its rendered segments, so a tall rail creates a
+   * 3-row block beneath the rest of the line without disturbing their
+   * own row(s).
+   */
+  height?: number;
+}
+
+export interface LayoutConfig {
+  primary: string[];
+  secondary: string[];
+  separator: string;
+  maxWidth: number;
+}
+
+export interface LayoutResult {
+  primary: LayoutSegment[];
+  secondary: LayoutSegment[];
+  dropped: LayoutSegment[];
+  widthClass: WidthClass;
+  /** Max visual row count across rendered primary segments (>=1). */
+  primaryRowCount: number;
+  /** Max visual row count across rendered secondary segments (>=1). */
+  secondaryRowCount: number;
+}
+
+function widthClassFor(width: number): WidthClass {
+  if (width < 60) return "small";
+  if (width < 120) return "medium";
+  return "wide";
+}
+
+function segmentLineWidth(seg: LayoutSegment): number {
+  let max = 0;
+  for (const line of seg.text.split("\n")) {
+    const w = visibleWidth(line);
+    if (w > max) max = w;
+  }
+  return max;
+}
+
+function segmentHeight(seg: LayoutSegment): number {
+  if (seg.height && seg.height > 1) return seg.height;
+  // ponytail: derive from text so a 3-line rail without an explicit
+  // height still renders as 3 rows. Trailing empty lines are noise from
+  // upstream trims — don't promote them to extra rows.
+  const nonEmpty = seg.text.split("\n").filter((line) => line.length > 0);
+  return Math.max(1, nonEmpty.length);
+}
+
+function laneFor(seg: LayoutSegment, config: LayoutConfig): "primary" | "secondary" | null {
+  if (config.primary.includes(seg.id)) return "primary";
+  if (config.secondary.includes(seg.id)) return "secondary";
+  return null;
+}
+
+export function computeLaneLayout(
+  segments: LayoutSegment[],
+  width: number,
+  config: LayoutConfig,
+): LayoutResult {
+  const cap = Math.max(0, Math.min(width, config.maxWidth));
+  const separatorWidth = visibleWidth(config.separator);
+  const primary: LayoutSegment[] = [];
+  const secondary: LayoutSegment[] = [];
+  const dropped: LayoutSegment[] = [];
+  // Sort by priority desc once; then assign by lane membership and width.
+  const sorted = [...segments].sort((a, b) => b.priority - a.priority);
+  let primaryUsed = 0;
+  let secondaryUsed = 0;
+  for (const seg of sorted) {
+    const lane = laneFor(seg, config);
+    if (lane === null) {
+      dropped.push(seg);
+      continue;
+    }
+    if (segmentLineWidth(seg) === 0) {
+      dropped.push(seg);
+      continue;
+    }
+    const w = segmentLineWidth(seg);
+    // Each lane owns its own budget: a primary segment must not push a
+    // secondary segment off the line. Separator width is charged only when
+    // a segment follows another in the same lane.
+    const used = lane === "primary" ? primaryUsed : secondaryUsed;
+    const addedWidth = used === 0 ? w : separatorWidth + w;
+    if (used + addedWidth > cap) {
+      dropped.push(seg);
+      continue;
+    }
+    (lane === "primary" ? primary : secondary).push(seg);
+    if (lane === "primary") primaryUsed += addedWidth;
+    else secondaryUsed += addedWidth;
+  }
+
+  // Honor the original primary/secondary order in the config so callers
+  // expect model->context->git->queue rather than priority-sorted.
+  const primaryOrder = new Map(config.primary.map((id, i) => [id, i]));
+  primary.sort((a, b) => (primaryOrder.get(a.id) ?? 0) - (primaryOrder.get(b.id) ?? 0));
+  const secondaryOrder = new Map(config.secondary.map((id, i) => [id, i]));
+  secondary.sort((a, b) => (secondaryOrder.get(a.id) ?? 0) - (secondaryOrder.get(b.id) ?? 0));
+
+  const primaryRowCount = primary.reduce(
+    (m, s) => Math.max(m, segmentHeight(s)),
+    1,
+  );
+  const secondaryRowCount = secondary.reduce(
+    (m, s) => Math.max(m, segmentHeight(s)),
+    1,
+  );
+
+  return {
+    primary,
+    secondary,
+    dropped,
+    widthClass: widthClassFor(width),
+    primaryRowCount,
+    secondaryRowCount,
+  };
+}

package/src/render/motion-candidates.ts

@@ -0,0 +1,52 @@
+/**
+ * motion-candidates — tick-driven rail renderers (the autoresearch lab).
+ * Only `lanternSigil` is wired as the active streaming rail; the rest
+ * were evaluated and discarded (see `.auto/log.jsonl`).
+ *
+ * Each returns a single 12-col line, or a 3-line string when it spans
+ * multiple rows (the layout's `height` + paint's row loop honour it).
+ * Joep: "denk is aan wat OMP als intro heeft maar dan anders" — a
+ * centered, breathing lantern sigil is the anders-than-OMP step.
+ */
+
+const W = 12;
+
+/** lantern sigil — 3-row animated identity, the OMP-intro step-up.
+ * Centered `#`-block lantern, sways and breathes. No braille, no shade
+ * blocks, no font assumptions — works on every terminal, every font.
+ *   "    ##    "
+ *   "  ######  "
+ *   "   ####   "
+ * (left/right columns trimmed to 12 cols; breathing adds a denser row).
+ */
+const LANTERN_ROWS: readonly string[] = [
+  "    ##    ",
+  "  ######  ",
+  "   ####   ",
+];
+const LANTERN_ROWS_BREATHE: readonly string[] = [
+  "    ##    ",
+  " ####### ",
+  "   ####   ",
+];
+function center(s: string, w = W): string {
+  if (s.length === w) return s;
+  if (s.length > w) return s.slice(0, w);
+  const pad = Math.floor((w - s.length) / 2);
+  return " ".repeat(pad) + s + " ".repeat(w - s.length - pad);
+}
+function sway(s: string, n: number): string {
+  if (n === 0) return s;
+  if (n > 0) return (" ".repeat(n) + s).slice(0, W).padEnd(W, " ");
+  return (s + " ".repeat(-n)).slice(0, W).padEnd(W, " ");
+}
+
+export function lanternSigil(tick: number, _ascii: boolean): string[] {
+  // Pure `#`-lantern — no braille, no shade blocks, no font
+  // assumptions. Works on every terminal, every font. The lantern
+  // identity comes from the shape, not the glyph set.
+  const s = Math.round(Math.sin(tick * 0.3) * 1);
+  const inhale = (tick % 8) < 5;
+  const rows = inhale ? LANTERN_ROWS : LANTERN_ROWS_BREATHE;
+  return rows.map((r) => center(sway(r, s)));
+}

package/src/render/motion-rail.ts

@@ -0,0 +1,99 @@
+/**
+ * Motion rail (v2). Renders the Signal activity rail — the animated
+ * sweep/compact rail plus activity label — as a first-class layout segment.
+ * Extracted from the legacy v1 Signal renderer (src/signal/render.ts,
+ * deleted in the U12 cutover); rail semantics are unchanged: idle = flat
+ * rail, streaming = travelling head + trail, compacting = inward heads.
+ */
+
+import { sweepPosition, trailGlyph } from "../motion/index.ts";
+import type { SignalRuntime } from "../signal/controller.ts";
+import type { SignalSpec } from "../config/types.ts";
+import { ansi, colorEnabled, getFgAnsiCode } from "../theme/colors.ts";
+import { lanternSigil } from "./motion-candidates.ts";
+
+export function renderActivity(
+  runtime: SignalRuntime,
+  spec: SignalSpec,
+  ascii = false,
+): string {
+  const label = runtime.activity || "ready";
+  const open = spec.caps.leftOpen ?? "";
+  const close = spec.caps.leftClose ?? "";
+  const dim = getFgAnsiCode("sep");
+  const hot = getFgAnsiCode("accent");
+  const reset = colorEnabled() ? ansi.reset : "";
+  // One glyph family, directional comet: light `─` track, fixed solid
+  // head, and a short box-drawing trail ONLY behind the head. Idle is a
+  // calm flat rail (no cycling glyphs — the old shade-block cloud read
+  // muddy across three unrelated glyph families).
+  const RAIL_WIDTH = 12;
+  const track = ascii ? "-" : "─";
+  const head = ascii ? "o" : "●";
+  const railColor = runtime.active ? hot : dim;
+  let railBlock: string;
+  if (!runtime.active) {
+    railBlock = track.repeat(RAIL_WIDTH);
+  } else if (runtime.activity === "compacting") {
+    // Compact state: two heads travel inward and compress a heavy core —
+    // visually distinct from the sweep so compaction reads at a glance.
+    railBlock = renderCompactRail(runtime.tick, RAIL_WIDTH, ascii);
+  } else {
+    const pos = sweepPosition(runtime.tick, RAIL_WIDTH, true);
+    const built: string[] = [];
+    for (let i = 0; i < RAIL_WIDTH; i++) {
+      if (i === pos) built.push(head);
+      else if (i < pos) built.push(trailGlyph(Math.min(pos - i, 4), ascii));
+      else built.push(track);
+    }
+    railBlock = built.join("");
+  }
+  // Active state: 3-row lantern sigil ONLY for the streaming/working
+  // activity. Each row is wrapped individually with the lane color
+  // so rows 1+ don't inherit an empty ANSI state from row 0.
+  if (runtime.active && !ascii && runtime.activity === "streaming") {
+    const sigilRows = lanternSigil(runtime.tick, false);
+    const [r0, ...rest] = sigilRows;
+    const framed = `${spec.separators.left}${r0} ${label}${spec.separators.right}`;
+    const allRows = [framed, ...rest];
+    const colored = (row: string) => `${railColor}${row}${reset}`;
+    // open brackets on the first row, close on the last row, color on
+    // every row so the whole sigil reads as one amber block.
+    const rows = allRows.map((row, i) => {
+      const prefix = i === 0 ? open : "";
+      const suffix = i === allRows.length - 1 ? close : "";
+      return `${prefix}${colored(row)}${suffix}`;
+    });
+    railBlock = rows.join("\n");
+    return railBlock;
+  }
+  const rail = `${spec.separators.left}${railBlock}${spec.separators.right}`;
+  return `${railColor}${open}${rail}${close}${reset} ${label}`;
+}
+
+/**
+ * Compact rail: two heads travel inward toward center, compressing the rail.
+ * Gives compaction a distinct visual signature vs the generic sweep.
+ */
+function renderCompactRail(
+  tick: number,
+  width: number,
+  ascii: boolean,
+): string {
+  const half = Math.floor(width / 2);
+  // Heads oscillate from the edges toward center and back.
+  const span = half;
+  const phase = tick % (span * 2);
+  const inward = phase < span ? phase : span * 2 - phase;
+  const leftPos = inward;
+  const rightPos = width - 1 - inward;
+  const head = ascii ? "*" : "●";
+  const core = ascii ? "=" : "━";
+  const track = ascii ? "-" : "─";
+  let built = "";
+  for (let i = 0; i < width; i++) {
+    if (i === leftPos || i === rightPos) built += head;
+    else built += i > leftPos && i < rightPos ? core : track;
+  }
+  return built;
+}

package/src/render/paint.ts

@@ -0,0 +1,64 @@
+// Cheap paint assembly. Consumes a layout and produces terminal-ready
+// strings. No fs, no git, no theme reload — those are upstream of layout.
+
+import { visibleWidth } from "@earendil-works/pi-tui";
+
+export interface PaintedLane {
+  id: string;
+  text: string;
+  bg: string;
+  fg: string;
+}
+
+export interface PaintedLayout {
+  primary: PaintedLane[];
+  secondary: PaintedLane[];
+  dropped: PaintedLane[];
+  widthClass: "small" | "medium" | "wide";
+  primaryRowCount?: number;
+  secondaryRowCount?: number;
+}
+
+const RESET = "\x1b[0m";
+
+export function paintLane(lane: PaintedLane): string {
+  return `${lane.bg}${lane.fg}${lane.text}${RESET}`;
+}
+
+export function paintLayout(layout: PaintedLayout, separator: string): string {
+  const rows = layout.primaryRowCount ?? 1;
+  const sepPad = " ".repeat(visibleWidth(separator));
+  const out: string[] = [];
+  for (let r = 0; r < rows; r++) {
+    const rowOut: string[] = [];
+    for (let i = 0; i < layout.primary.length; i++) {
+      if (i > 0 && r === 0) rowOut.push(separator);
+      if (i > 0 && r > 0) rowOut.push(sepPad);
+      rowOut.push(paintLaneRow(layout.primary[i]!, r));
+    }
+    out.push(rowOut.join(""));
+  }
+  return out.join("\n");
+}
+
+export function paintSecondary(layout: PaintedLayout, separator: string): string {
+  const rows = layout.secondaryRowCount ?? 1;
+  const sepPad = " ".repeat(visibleWidth(separator));
+  const out: string[] = [];
+  for (let r = 0; r < rows; r++) {
+    const rowOut: string[] = [];
+    for (let i = 0; i < layout.secondary.length; i++) {
+      if (i > 0 && r === 0) rowOut.push(separator);
+      if (i > 0 && r > 0) rowOut.push(sepPad);
+      rowOut.push(paintLaneRow(layout.secondary[i]!, r));
+    }
+    out.push(rowOut.join(""));
+  }
+  return out.join("\n");
+}
+
+function paintLaneRow(lane: PaintedLane, row: number): string {
+  const lines = lane.text.split("\n");
+  const line = lines[row] ?? "";
+  return `${lane.bg}${lane.fg}${line}${RESET}`;
+}

package/src/render/v2-adapter.ts

@@ -0,0 +1,70 @@
+// v2 render adapter: wires the pure layout + paint into a top/secondary
+// string pair matching the shape that status-line-renderers.ts consumers
+// (renderPowerlinePrimaryLines / renderPowerlineSecondaryLines) already
+// expect. This is the U12 cutover entry point. v1 paths remain in place
+// until a follow-up PR deletes them after live-golden verification.
+//
+// ponytail: this is a delegating adapter, not a replacement. The
+// status-line-renderers.ts consumers stay on v1 until v2 is exercised
+// against real presets; the adapter exists so consumers can opt in via a
+// single import swap once that is done.
+
+import { computeLaneLayout, type LayoutSegment, type WidthClass } from "./layout.ts";
+import { paintLayout, paintSecondary, type PaintedLane } from "./paint.ts";
+
+export interface V2Segment extends LayoutSegment {}
+
+export interface V2LaneConfig {
+  primary: string[];
+  secondary: string[];
+  /** Separator between painted lanes; styled separators carry ANSI. */
+  separator?: string;
+}
+
+export interface V2RenderResult {
+  topContent: string;
+  secondaryContent: string;
+  dropped: LayoutSegment[];
+  widthClass: WidthClass;
+}
+
+const SEPARATOR = " | ";
+
+function toPainted(seg: LayoutSegment): PaintedLane {
+  return {
+    id: seg.id,
+    text: seg.text,
+    bg: "",
+    fg: "",
+  };
+}
+
+export function renderPowerlineV2(
+  segments: V2Segment[],
+  width: number,
+  config: V2LaneConfig,
+): V2RenderResult {
+  const separator = config.separator ?? SEPARATOR;
+  const layout = computeLaneLayout(segments, width, {
+    primary: config.primary,
+    secondary: config.secondary,
+    separator,
+    maxWidth: width,
+  });
+
+  const painted = {
+    primary: layout.primary.map(toPainted),
+    secondary: layout.secondary.map(toPainted),
+    dropped: [] as PaintedLane[],
+    widthClass: layout.widthClass,
+    primaryRowCount: layout.primaryRowCount,
+    secondaryRowCount: layout.secondaryRowCount,
+  };
+
+  return {
+    topContent: paintLayout(painted, separator),
+    secondaryContent: paintSecondary(painted, separator),
+    dropped: layout.dropped,
+    widthClass: layout.widthClass,
+  };
+}

package/src/render/v2-entry.ts

@@ -0,0 +1,132 @@
+/**
+ * v2 status-line entry (U12 cutover). Composes the single render path:
+ * segments render through the per-segment fault-isolated `renderSegment`
+ * boundary, the motion rail renders as a first-class layout segment, and
+ * lanes flow through `computeLaneLayout` + `paintLayout`. The legacy v1
+ * three-lane renderer (src/signal/render.ts) is deleted; rail semantics
+ * live on in ./motion-rail.ts.
+ *
+ * Priority scheme preserves the v1 reading order left -> rail -> right:
+ * left segments 10_000-i, rail 5_000, right segments 1_000-i. Under width
+ * pressure computeLaneLayout drops the lowest priorities first, so the
+ * right lane yields before the rail, and the rail before the left —
+ * matching v1's "preserve model/git first, then context/queue" squeeze.
+ */
+
+import type {
+  PresetDef,
+  SegmentContext,
+  SignalSpec,
+  StatusLineLayout,
+  StatusLineSegmentId,
+  StatusLineSeparatorStyle,
+} from "../config/types.ts";
+import { mergeSegmentsWithCustomItems } from "../config/powerline-config.ts";
+import { renderSegment } from "../segments/index.ts";
+import { getContributedSignalSources } from "../extension/contrib/registry.ts";
+import { getSeparator } from "../theme/separators.ts";
+import { ansi, colorEnabled, getFgAnsiCode } from "../theme/colors.ts";
+import { renderActivity } from "./motion-rail.ts";
+import { renderPowerlineV2, type V2Segment } from "./v2-adapter.ts";
+import type { SignalRuntime } from "../signal/controller.ts";
+
+export interface StatusLineV2Options {
+  separatorStyle: StatusLineSeparatorStyle;
+  signal: SignalSpec;
+  ascii?: boolean;
+  layout?: StatusLineLayout | null;
+  disabledSegments?: StatusLineSegmentId[];
+}
+
+const ANSI_CONTROL_RE =
+  /\x1B(?:\][^\x07]*(?:\u0007|\x1B\\)|\[[0-?]*[ -/]*[@-~]|[@-_])|\x9B[0-?]*[ -/]*[@-~]|\x9D[^\x07]*(?:\u0007|\x1B\\)/g;
+
+function contributedTexts(ctx: SegmentContext): string[] {
+  const out: string[] = [];
+  for (const src of getContributedSignalSources()) {
+    try {
+      const raw = src.render?.(ctx);
+      if (!raw || typeof raw !== "string") continue;
+      const content = raw.trim();
+      if (!content.replace(ANSI_CONTROL_RE, "").trim()) continue;
+      // ponytail: fault-isolated — a throwing or empty source never takes the line down
+      out.push(content);
+    } catch {
+      // skip failing contribution
+    }
+  }
+  return out;
+}
+
+function styledSeparator(separator: string): string {
+  const color = getFgAnsiCode("sep");
+  const reset = colorEnabled() ? ansi.reset : "";
+  return ` ${color}${separator}${reset} `;
+}
+
+export function renderStatusLineV2(
+  ctx: SegmentContext,
+  preset: PresetDef,
+  runtime: SignalRuntime,
+  width: number,
+  options: StatusLineV2Options,
+): { topContent: string; secondaryContent: string } {
+  const merged = mergeSegmentsWithCustomItems(
+    preset,
+    ctx.effectiveCustomItems,
+    {
+      layout: options.layout ?? null,
+      disabledSegments: options.disabledSegments ?? [],
+    },
+  );
+
+  const segments: V2Segment[] = [];
+  const primary: string[] = [];
+
+  const pushSegment = (id: StatusLineSegmentId, priority: number): void => {
+    try {
+      const rendered = renderSegment(id, ctx);
+      if (!rendered.visible || !rendered.content) return;
+      segments.push({ id, text: rendered.content, priority });
+      primary.push(id);
+    } catch {
+      // renderSegment is the established per-segment error boundary; a
+      // throwing segment never blanks the line.
+    }
+  };
+
+  merged.leftSegments.forEach((id, i) => pushSegment(id, 10_000 - i));
+
+  const rail = renderActivity(runtime, options.signal, options.ascii);
+  segments.push({ id: "signal", text: rail, priority: 5_000 });
+  primary.push("signal");
+
+  merged.rightSegments.forEach((id, i) => pushSegment(id, 1_000 - i));
+  contributedTexts(ctx).forEach((text, i) => {
+    const id = `contrib:${i}`;
+    segments.push({ id, text, priority: 900 - i });
+    primary.push(id);
+  });
+
+  merged.secondarySegments.forEach((id, i) => {
+    try {
+      const rendered = renderSegment(id, ctx);
+      if (!rendered.visible || !rendered.content) return;
+      segments.push({ id, text: rendered.content, priority: 500 - i });
+    } catch {
+      // Keep secondary segments behind the same fault boundary as primary.
+    }
+  });
+
+  const separatorGlyph = getSeparator(options.separatorStyle).left;
+  const result = renderPowerlineV2(segments, width, {
+    primary,
+    secondary: [...merged.secondarySegments],
+    separator: styledSeparator(separatorGlyph),
+  });
+
+  return {
+    topContent: result.topContent,
+    secondaryContent: result.secondaryContent,
+  };
+}