@bastani/atomic 0.9.16-alpha.2 → 0.9.16-alpha.4

package/dist/builtin/workflows/src/tui/graph-theme.ts

@@ -1,292 +0,0 @@
-/**
- * Catppuccin Mocha role-mapped tokens for the orchestrator overlay.
- *
- * cross-ref: DESIGN.md §2 (Colors), §4 (Elevation), §5 (Components)
- *            PRODUCT.md (Aesthetic Direction — Catppuccin Mocha canonical)
- *
- * Roles, not raw hex, are referenced by every renderer. A render-time
- * `deriveGraphTheme()` accepts an optional terminal-resolved theme so
- * adaptive palettes (light fallback, NO_COLOR pass-through) can supply
- * overrides without forking the renderer.
- */
-
-// ---------------------------------------------------------------------------
-// Canonical palette (Catppuccin Mocha)
-// ---------------------------------------------------------------------------
-
-const MOCHA = {
-	crust: "#11111b",
-	mantle: "#181825",
-	base: "#1e1e2e",
-	surface0: "#313244",
-	surface1: "#45475a",
-	surface2: "#585b70",
-	overlay0: "#6c7086",
-	overlay1: "#7f849c",
-	text: "#cdd6f4",
-	subtext0: "#a6adc8",
-	blue: "#89b4fa",
-	green: "#a6e3a1",
-	yellow: "#f9e2af",
-	red: "#f38ba8",
-	mauve: "#cba6f7",
-	sky: "#89dceb",
-	lavender: "#b4befe",
-} as const;
-
-/**
- * Optional generic theme overrides accepted by `deriveGraphTheme`.
- * Keys mirror the role names below; any field omitted falls back to Mocha.
- */
-export interface GenericTheme {
-	bg?: string;
-	backgroundPanel?: string;
-	backgroundToolSuccess?: string;
-	backgroundToolError?: string;
-	backgroundElement?: string;
-	surface?: string;
-	selection?: string;
-	border?: string;
-	borderDim?: string;
-	borderActive?: string;
-	text?: string;
-	textMuted?: string;
-	dim?: string;
-	toolTitle?: string;
-	toolOutput?: string;
-	accent?: string;
-	mauve?: string;
-	success?: string;
-	warning?: string;
-	info?: string;
-	error?: string;
-}
-
-/**
- * Role-mapped tokens consumed by every renderer in `src/tui/`.
- *
- * The `border*` family is split into three steps so components can pick
- * the right tonal weight: `borderDim` for quiet rules, `border` for the
- * default, `borderActive` for emphasised panels. Status colors map
- * one-to-one to the orchestrator's session vocabulary (DESIGN.md
- * "Status-Is-Truth" — never used decoratively).
- */
-export interface GraphTheme {
-	/** Strata, deepest first */
-	bg: string;
-	backgroundPanel: string;
-	backgroundToolSuccess: string;
-	backgroundToolError: string;
-	backgroundElement: string;
-	surface: string;
-	selection: string;
-
-	/** Borders, dimmest first */
-	border: string;
-	borderDim: string;
-	borderActive: string;
-
-	/** Text, brightest first */
-	text: string;
-	textMuted: string;
-	dim: string;
-	/** Host tool-card title (`toolTitle`, Catppuccin lavender). */
-	toolTitle: string;
-	/** Host tool-card body (`toolOutput`, usually the same as `text`). */
-	toolOutput: string;
-
-	/** Accents */
-	accent: string;
-	mauve: string;
-
-	/** Statuses */
-	success: string;
-	warning: string;
-	info: string;
-	error: string;
-}
-
-export function deriveGraphTheme(theme: GenericTheme = {}): GraphTheme {
-	return {
-		bg: theme.bg ?? MOCHA.base,
-		backgroundPanel: theme.backgroundPanel ?? MOCHA.surface0,
-		backgroundToolSuccess: theme.backgroundToolSuccess ?? theme.backgroundPanel ?? MOCHA.surface0,
-		backgroundToolError: theme.backgroundToolError ?? theme.backgroundPanel ?? MOCHA.surface0,
-		backgroundElement: theme.backgroundElement ?? MOCHA.surface0,
-		surface: theme.surface ?? MOCHA.crust,
-		selection: theme.selection ?? MOCHA.surface1,
-
-		border: theme.border ?? MOCHA.overlay0,
-		borderDim: theme.borderDim ?? MOCHA.surface2,
-		borderActive: theme.borderActive ?? MOCHA.overlay1,
-
-		text: theme.text ?? MOCHA.text,
-		textMuted: theme.textMuted ?? MOCHA.subtext0,
-		dim: theme.dim ?? MOCHA.overlay1,
-		toolTitle: theme.toolTitle ?? MOCHA.lavender,
-		toolOutput: theme.toolOutput ?? MOCHA.text,
-
-		accent: theme.accent ?? MOCHA.blue,
-		mauve: theme.mauve ?? MOCHA.mauve,
-
-		success: theme.success ?? MOCHA.green,
-		warning: theme.warning ?? MOCHA.yellow,
-		info: theme.info ?? MOCHA.sky,
-		error: theme.error ?? MOCHA.red,
-	};
-}
-
-// ---------------------------------------------------------------------------
-// Pi runtime theme bridge (additive)
-// ---------------------------------------------------------------------------
-
-/**
- * Structural subset of Pi's `Theme` class. The orchestrator overlay's
- * `ctx.ui.custom` factory receives a live `Theme` instance whose
- * concrete class lives in `@bastani/atomic`; we cannot import
- * that runtime type from a `.ts` extension shipped to pi without
- * pulling the entire host into our type graph. Instead we accept any
- * object that exposes the two ANSI accessors we need and feature-detect
- * at call time. Hosts that don't expose them — or test mocks that
- * pass `{}` — fall back to the Catppuccin defaults below.
- *
- * Both accessors return a pre-built SGR sequence such as
- * `\x1b[38;2;R;G;Bm` (truecolor) or `\x1b[38;5;Nm` (xterm-256), per
- * Pi's `Bun.color(..)` output. `parsePiAnsiToHex` converts those back
- * into `#rrggbb` tokens that the existing renderer pipeline consumes
- * via `hexToAnsi` / `hexBg`.
- */
-export interface PiRuntimeTheme {
-	getFgAnsi?: (color: string) => string;
-	getBgAnsi?: (color: string) => string;
-}
-
-/**
- * Standard xterm-256 palette converted to hex. The 6×6×6 colour cube
- * (indices 16–231) and the 24-step grayscale ramp (232–255) are
- * deterministic and shared across virtually every terminal; the basic
- * 0–15 slots are user-configurable, so for those indices we return
- * `undefined` and let the caller fall back to the Mocha defaults.
- */
-function xterm256ToHex(idx: number): string | undefined {
-	if (!Number.isInteger(idx) || idx < 0 || idx > 255) return undefined;
-	if (idx < 16) return undefined; // ambient terminal palette — unknown
-	if (idx >= 232) {
-		const level = 8 + (idx - 232) * 10;
-		const hex = level.toString(16).padStart(2, "0");
-		return `#${hex}${hex}${hex}`;
-	}
-	const cube = idx - 16;
-	const steps = [0, 95, 135, 175, 215, 255];
-	const r = steps[Math.floor(cube / 36)]!;
-	const g = steps[Math.floor((cube % 36) / 6)]!;
-	const b = steps[cube % 6]!;
-	return `#${[r, g, b].map((v) => v.toString(16).padStart(2, "0")).join("")}`;
-}
-
-/**
- * Parse a Pi ANSI colour sequence back to a `#rrggbb` token.
- * Accepts truecolor (`\x1b[38;2;R;G;Bm` / `\x1b[48;2;R;G;Bm`) and
- * xterm-256 (`\x1b[38;5;Nm` / `\x1b[48;5;Nm`). Default resets
- * (`\x1b[39m` / `\x1b[49m`) and any unparseable input return
- * `undefined`, signalling the caller to fall back to the Mocha token.
- */
-function parsePiAnsiToHex(ansi: string | undefined): string | undefined {
-	if (typeof ansi !== "string" || ansi.length === 0) return undefined;
-	const truecolor = /\x1b\[(?:38|48);2;(\d{1,3});(\d{1,3});(\d{1,3})m/.exec(ansi);
-	if (truecolor) {
-		const r = Math.min(255, Math.max(0, parseInt(truecolor[1]!, 10)));
-		const g = Math.min(255, Math.max(0, parseInt(truecolor[2]!, 10)));
-		const b = Math.min(255, Math.max(0, parseInt(truecolor[3]!, 10)));
-		return `#${[r, g, b].map((v) => v.toString(16).padStart(2, "0")).join("")}`;
-	}
-	const indexed = /\x1b\[(?:38|48);5;(\d{1,3})m/.exec(ansi);
-	if (indexed) {
-		return xterm256ToHex(parseInt(indexed[1]!, 10));
-	}
-	return undefined;
-}
-
-/**
- * Safely invoke a Pi theme accessor that may throw on unknown tokens.
- * Pi's `Theme.getFgAnsi` throws when the requested key is missing from
- * the current theme; we want feature detection without surfacing the
- * throw to overlay mount.
- */
-function tryPiAccessor(fn: ((color: string) => string) | undefined, color: string): string | undefined {
-	if (typeof fn !== "function") return undefined;
-	try {
-		return fn(color);
-	} catch {
-		return undefined;
-	}
-}
-
-function fgHex(theme: PiRuntimeTheme, color: string): string | undefined {
-	return parsePiAnsiToHex(tryPiAccessor(theme.getFgAnsi, color));
-}
-
-function bgHex(theme: PiRuntimeTheme, color: string): string | undefined {
-	return parsePiAnsiToHex(tryPiAccessor(theme.getBgAnsi, color));
-}
-
-/**
- * Build a `GraphTheme` from a live Pi `Theme`-shaped object.
- *
- * Mapping rationale (see `node_modules/@bastani/atomic
- * /src/modes/theme/theme.ts` for the canonical Pi token names):
- *
- *  - Strata: Pi has no first-class panel stratum but exposes
- *    `customMessageBg` / `toolPendingBg` / `selectedBg` as restrained
- *    surfaces. We map them to `backgroundElement` / `backgroundPanel`
- *    / `selection` and leave `bg` on the Mocha base so the canvas
- *    stays consistent with the rest of the extension's renderers.
- *  - Borders: `borderMuted → borderDim`, `border → border`,
- *    `borderAccent → borderActive`. The `dim` Pi token feeds
- *    `GraphTheme.dim`; `muted` feeds `textMuted`.
- *  - Accents / statuses: direct one-to-one. Pi has no `info` token,
- *    so we fall back to `accent` and finally `MOCHA.sky` to keep
- *    DESIGN.md's status palette intact.
- *
- * Any token that cannot be resolved (host without these accessors,
- * non-truecolor terminal default, or out-of-palette xterm index)
- * falls back through `deriveGraphTheme` to the canonical Catppuccin
- * Mocha defaults — the overlay must always render with a stable
- * palette even if the host theme is mid-load or absent.
- */
-export function deriveGraphThemeFromPiTheme(theme: unknown): GraphTheme {
-	if (!theme || typeof theme !== "object") return deriveGraphTheme({});
-	const t = theme as PiRuntimeTheme;
-	const accent = fgHex(t, "accent");
-	const overrides: GenericTheme = {
-		backgroundPanel: bgHex(t, "toolPendingBg") ?? bgHex(t, "customMessageBg"),
-		backgroundToolSuccess: bgHex(t, "toolSuccessBg") ?? bgHex(t, "toolPendingBg") ?? bgHex(t, "customMessageBg"),
-		backgroundToolError: bgHex(t, "toolErrorBg") ?? bgHex(t, "toolPendingBg") ?? bgHex(t, "customMessageBg"),
-		backgroundElement: bgHex(t, "customMessageBg") ?? bgHex(t, "toolPendingBg"),
-		selection: bgHex(t, "selectedBg"),
-		border: fgHex(t, "border"),
-		borderDim: fgHex(t, "borderMuted"),
-		borderActive: fgHex(t, "borderAccent"),
-
-		text: fgHex(t, "text") ?? fgHex(t, "customMessageText"),
-		textMuted: fgHex(t, "muted"),
-		dim: fgHex(t, "dim"),
-		toolTitle: fgHex(t, "toolTitle"),
-		toolOutput: fgHex(t, "toolOutput") ?? fgHex(t, "text") ?? fgHex(t, "customMessageText"),
-
-		accent,
-		success: fgHex(t, "success"),
-		warning: fgHex(t, "warning"),
-		info: accent, // Pi has no `info` token — accent is the closest match.
-		error: fgHex(t, "error"),
-	};
-	// Strip undefined keys so `deriveGraphTheme` falls back to MOCHA for
-	// each one individually rather than overwriting good defaults.
-	const cleaned: GenericTheme = {};
-	for (const [k, v] of Object.entries(overrides)) {
-		if (typeof v === "string" && v.length > 0) {
-			(cleaned as Record<string, string>)[k] = v;
-		}
-	}
-	return deriveGraphTheme(cleaned);
-}

package/dist/builtin/workflows/src/tui/graph-view-constants.ts

@@ -1,49 +0,0 @@
-export const HINT_KEYS: Array<{ key: string; label: string }> = [
-	{ key: "ctrl+x", label: "return to main chat" },
-	{ key: "↵", label: "open stage chat" },
-	{ key: "↑↓←→", label: "navigate" },
-	{ key: "/", label: "stages" },
-];
-
-export const COMPACT_HINT_KEYS: Array<{ key: string; label: string }> = [
-	{ key: "ctrl+x", label: "return to main chat" },
-	{ key: "↵", label: "stage chat" },
-];
-
-/** Read-only `ctx.tool` detail: scrolling first, then the way back. */
-export const TOOL_DETAIL_HINT_KEYS: Array<{ key: string; label: string }> = [
-	{ key: "ctrl+x", label: "return to graph" },
-	{ key: "↑↓ pgup/pgdn", label: "scroll" },
-];
-
-export const COMPACT_TOOL_DETAIL_HINT_KEYS: Array<{ key: string; label: string }> = [
-	{ key: "ctrl+x", label: "graph" },
-	{ key: "↑↓", label: "scroll" },
-];
-
-/**
- * Bottom mode pill. The status bar mirrors the top header band: a
- * three-row chrome strip with an outlined pill flush-left and hints
- * flowing right of it on the centre row.
- */
-export const MODE_PILL_LABEL = "GRAPH";
-
-/**
- * Animation tick period. Overlay re-renders fire on this cadence so
- * duration counters tick from active elapsed time (freezing while paused)
- * and the running-stage border lerps between `borderDim` and
- * `warning` without a key press. The host-supplied `requestRender`
- * gate prevents work while the overlay is hidden or unfocused.
- * GraphView also skips ticks when nothing is animating — no running or
- * awaiting_input stage and no prompt caret — so large idle graphs do not
- * burn ~10 full paints/sec (#2100).
- */
-export const ANIMATION_TICK_MS = 100;
-
-/**
- * Full lerp period of `pulseT` for running-stage borders, in ms.
- * `pulsePhase ∈ [0, 1)` cycles every `PULSE_PERIOD_MS` so the sine
- * eased lerp inside `pickBorder` traces one full breath per cycle.
- */
-export const PULSE_PERIOD_MS = 2000;
-export const GRAPH_SCROLL_STEP_COLS = 4;

package/dist/builtin/workflows/src/tui/graph-view-graph-render.ts

@@ -1,157 +0,0 @@
-import type { RunSnapshot } from "../shared/store-types.js";
-import { hexBg, hexToAnsi, RESET } from "./color-utils.js";
-import { GraphCanvas } from "./graph-canvas.js";
-import { PULSE_PERIOD_MS } from "./graph-view-constants.js";
-import { GraphViewRenderHelpers } from "./graph-view-render-helpers.js";
-import { NODE_H, NODE_W } from "./layout.js";
-import { renderNodeCard } from "./node-card.js";
-
-interface Placement {
-	startCol: number;
-	width: number;
-	line: string;
-}
-
-/** Graph body rendering and horizontal canvas management. */
-export abstract class GraphViewGraphRenderer extends GraphViewRenderHelpers {
-	protected _renderGraph(
-		width: number,
-		viewportTop: number,
-		viewportRows: number,
-		renderRun?: RunSnapshot | null,
-	): string[] {
-		const safeRows = Math.max(0, Math.floor(viewportRows));
-		const run = renderRun !== undefined ? renderRun : this._getCurrentRun();
-		if (!run || this.cachedLayout.length === 0) {
-			this.lastGraphViewport = null;
-			this.graphNodeHitRects = [];
-			this.lastGraphTopPad = 0;
-			this.lastGraphVisibleRows = safeRows;
-			const lines = Array.from({ length: safeRows }, () => "");
-			if (safeRows > 0) {
-				const dim = hexToAnsi(this.graphTheme.dim);
-				lines[Math.floor((safeRows - 1) / 2)] = this._centerCanvasContent(
-					`${dim}waiting for stage events…${RESET}`,
-					width,
-				);
-			}
-			return lines;
-		}
-
-		const graphInner = Math.max(1, width - 4);
-		const { canvasWidth, totalRows, bands, edges } = this.cachedRenderGeometry;
-		const leftMargin = Math.max(2, canvasWidth <= graphInner ? Math.floor((graphInner - canvasWidth) / 2) : 2);
-		const viewportWidth = Math.max(1, width - leftMargin);
-		const fullCanvasWidth = Math.max(canvasWidth, viewportWidth);
-		this.lastGraphViewport = { leftMargin, viewportWidth };
-
-		const safeTop = Math.max(0, Math.min(totalRows, Math.floor(viewportTop)));
-		const graphRows = Math.max(0, Math.min(safeRows, totalRows - safeTop));
-		const viewportBottom = safeTop + graphRows;
-		this._clampGraphHorizontalScroll(fullCanvasWidth, viewportWidth);
-		const topPad = safeTop === 0 && totalRows <= safeRows ? Math.min(3, Math.floor((safeRows - totalRows) / 2)) : 0;
-		this.lastGraphTopPad = topPad;
-		this.lastGraphVisibleRows = graphRows;
-		const viewportLeft = this.graphScrollColOffset;
-		const viewportRight = viewportLeft + viewportWidth;
-		const pulsePhase = (Date.now() % PULSE_PERIOD_MS) / PULSE_PERIOD_MS;
-		const edgeCanvas = new GraphCanvas({
-			top: safeTop,
-			bottom: viewportBottom,
-			left: viewportLeft,
-			right: viewportRight,
-		});
-		const edgeColor = this.graphTheme.borderDim;
-		for (const edge of edges) {
-			if (
-				edge.bottom <= safeTop ||
-				edge.top >= viewportBottom ||
-				edge.right <= viewportLeft ||
-				edge.left >= viewportRight
-			) {
-				continue;
-			}
-			this._plotEdge(edgeCanvas, edge.parentX, edge.parentY, edge.childX, edge.childY, edgeColor);
-		}
-		const edgeLines = edgeCanvas.toLines();
-		const placements = new Map<number, Placement[]>();
-		for (let bandIndex = this._firstVisibleLayoutBand(safeTop); bandIndex < bands.length; bandIndex++) {
-			const band = bands[bandIndex]!;
-			if (band.top >= viewportBottom) break;
-			for (const ni of band.nodeIndices) {
-				const node = this.cachedLayout[ni]!;
-				if (node.x + NODE_W <= viewportLeft || node.x >= viewportRight) continue;
-				const cardLines = renderNodeCard(node.stage, {
-					width: NODE_W,
-					height: NODE_H,
-					focused: ni === this.focusedIndex,
-					pulsePhase,
-					theme: this.graphTheme,
-					stages: this.cachedDisplayStages,
-					queuedMessageCount: this._stageQueuedMessageCount(node.stage),
-				});
-				const visibleLeft = Math.max(node.x, viewportLeft);
-				const visibleRight = Math.min(node.x + NODE_W, viewportRight);
-				for (let li = 0; li < cardLines.length; li++) {
-					const globalRow = node.y + li;
-					if (globalRow < safeTop || globalRow >= viewportBottom) continue;
-					const localRow = globalRow - safeTop;
-					let bucket = placements.get(localRow);
-					if (!bucket) {
-						bucket = [];
-						placements.set(localRow, bucket);
-					}
-					bucket.push({
-						startCol: visibleLeft - viewportLeft,
-						width: visibleRight - visibleLeft,
-						line: this._sliceColumns(cardLines[li]!, visibleLeft - node.x, visibleRight - node.x),
-					});
-				}
-			}
-		}
-
-		const bg = hexBg(this.graphTheme.bg);
-		const leftPad = `${bg}${" ".repeat(leftMargin)}${RESET}`;
-		const composed = Array.from({ length: safeRows }, () => "");
-		for (let localRow = 0; localRow < graphRows; localRow++) {
-			const line = this._composeRow(edgeLines[localRow] ?? "", placements.get(localRow) ?? [], edgeColor);
-			composed[topPad + localRow] = `${leftPad}${this._padCanvas(line, viewportWidth)}`;
-		}
-		return composed;
-	}
-
-	protected _recordGraphNodeHitRects(graphStartRow: number, visibleRowCount: number): void {
-		const viewport = this.lastGraphViewport;
-		if (!viewport || visibleRowCount <= 0) {
-			this.graphNodeHitRects = [];
-			return;
-		}
-
-		const visibleTop = graphStartRow;
-		const visibleBottom = graphStartRow + visibleRowCount;
-		const viewportLeft = viewport.leftMargin;
-		const viewportRight = viewport.leftMargin + viewport.viewportWidth;
-		const rects: typeof this.graphNodeHitRects = [];
-		const viewportTop = this._graphScrollTop();
-		const viewportBottom = Math.min(this.cachedRenderGeometry.totalRows, viewportTop + visibleRowCount);
-		const { bands } = this.cachedRenderGeometry;
-		for (let bandIndex = this._firstVisibleLayoutBand(viewportTop); bandIndex < bands.length; bandIndex++) {
-			const band = bands[bandIndex]!;
-			if (band.top >= viewportBottom) break;
-			for (const index of band.nodeIndices) {
-				const node = this.cachedLayout[index]!;
-				const top = graphStartRow + node.y - viewportTop;
-				const bottom = top + NODE_H;
-				const left = viewport.leftMargin + node.x - this.graphScrollColOffset;
-				const right = left + NODE_W;
-				const clippedTop = Math.max(visibleTop, top);
-				const clippedBottom = Math.min(visibleBottom, bottom);
-				const clippedLeft = Math.max(viewportLeft, left);
-				const clippedRight = Math.min(viewportRight, right);
-				if (clippedTop >= clippedBottom || clippedLeft >= clippedRight) continue;
-				rects.push({ index, top: clippedTop, bottom: clippedBottom, left: clippedLeft, right: clippedRight });
-			}
-		}
-		this.graphNodeHitRects = rects;
-	}
-}