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

package/dist/builtin/workflows/src/tui/layout.ts

@@ -1,150 +0,0 @@
-/**
- * DAG layout engine: flat stage list → 2D grid.
- * cross-ref: spec §5.4.1, v0.x packages/atomic-sdk/src/components/layout.ts
- */
-import type { StageSnapshot } from "../shared/store-types.js";
-
-export const NODE_W = 24;
-export const NODE_H = 5;
-
-export interface LayoutNode {
-	stage: StageSnapshot;
-	col: number;
-	row: number;
-	x: number;
-	y: number;
-}
-
-export interface LayoutOpts {
-	colGap?: number;
-	rowGap?: number;
-	/**
-	 * `horizontal` (default): depth flows left → right. `col → x`, `row → y`.
-	 * `vertical`: depth flows top → bottom. `col → y`, `row → x`.
-	 *
-	 * `col` and `row` retain their semantic identity (depth × sibling-index)
-	 * in both orientations — only the projection to pixel space swaps. This
-	 * keeps unit tests addressing `col/row` orientation-agnostic.
-	 */
-	orientation?: "horizontal" | "vertical";
-}
-
-/**
- * Assign each stage a (col, row) via BFS from roots.
- * Parallel stages share the same column; sequential stages increment column.
- */
-export function computeLayout(stages: readonly StageSnapshot[], opts: LayoutOpts = {}): LayoutNode[] {
-	const colGap = opts.colGap ?? 4;
-	const rowGap = opts.rowGap ?? 3;
-
-	if (stages.length === 0) return [];
-
-	const idSet = new Set(stages.map((s) => s.id));
-
-	// Map from id → stage
-	const byId = new Map<string, StageSnapshot>();
-	for (const s of stages) byId.set(s.id, s);
-
-	// Assign columns via BFS (longest path from root)
-	const colMap = new Map<string, number>();
-
-	// Topological BFS: process nodes whose all parents have been assigned
-	const inDegree = new Map<string, number>();
-	const children = new Map<string, string[]>();
-
-	for (const s of stages) {
-		const validParents = s.parentIds.filter((pid) => idSet.has(pid));
-		inDegree.set(s.id, validParents.length);
-		for (const pid of validParents) {
-			if (!children.has(pid)) children.set(pid, []);
-			children.get(pid)!.push(s.id);
-		}
-	}
-
-	// Roots: nodes with no valid parents
-	const queue: string[] = [];
-	for (const s of stages) {
-		if (inDegree.get(s.id) === 0) {
-			queue.push(s.id);
-			colMap.set(s.id, 0);
-		}
-	}
-
-	// BFS assigning col = max(parent cols) + 1
-	const visited = new Set<string>();
-	let qi = 0;
-	while (qi < queue.length) {
-		const id = queue[qi++]!;
-		if (visited.has(id)) continue;
-		visited.add(id);
-
-		const stage = byId.get(id)!;
-		const validParents = stage.parentIds.filter((pid) => idSet.has(pid));
-		let myCol = 0;
-		for (const pid of validParents) {
-			myCol = Math.max(myCol, (colMap.get(pid) ?? 0) + 1);
-		}
-		colMap.set(id, myCol);
-
-		const kids = children.get(id) ?? [];
-		for (const kid of kids) {
-			const deg = (inDegree.get(kid) ?? 1) - 1;
-			inDegree.set(kid, deg);
-			if (deg === 0) queue.push(kid);
-		}
-	}
-
-	// Handle any nodes not visited (cycles or disconnected) - assign next col
-	for (const s of stages) {
-		if (!colMap.has(s.id)) colMap.set(s.id, 0);
-	}
-
-	// Group by column, assign rows
-	const colGroups = new Map<number, string[]>();
-	for (const [id, col] of colMap) {
-		if (!colGroups.has(col)) colGroups.set(col, []);
-		colGroups.get(col)!.push(id);
-	}
-
-	const orientation = opts.orientation ?? "horizontal";
-
-	// Vertical orientation centres each depth's sibling band around the
-	// widest depth so single-child rows sit beneath the centre of the parent
-	// fan-out instead of left-aligning. The shift is computed as the
-	// difference between the widest band's centre and this band's centre,
-	// in pixel cells — not in whole-column steps, otherwise a 1-of-even
-	// row lands under one sibling rather than between two.
-	const bandWidth = (count: number): number => (count > 0 ? count * NODE_W + (count - 1) * colGap : 0);
-	const widestBand = (() => {
-		let max = 0;
-		for (const ids of colGroups.values()) {
-			if (ids.length > max) max = ids.length;
-		}
-		return max;
-	})();
-	const widestCentre = bandWidth(widestBand) / 2;
-	const centreShift = new Map<number, number>();
-	for (const [depth, ids] of colGroups) {
-		const centre = bandWidth(ids.length) / 2;
-		centreShift.set(depth, Math.round(widestCentre - centre));
-	}
-
-	const rowIndex = new Map<string, number>();
-	for (const ids of colGroups.values()) {
-		for (let i = 0; i < ids.length; i++) {
-			rowIndex.set(ids[i]!, i);
-		}
-	}
-
-	const nodes: LayoutNode[] = [];
-	for (const s of stages) {
-		const col = colMap.get(s.id) ?? 0;
-		const row = rowIndex.get(s.id) ?? 0;
-		const x =
-			orientation === "vertical" ? row * (NODE_W + colGap) + (centreShift.get(col) ?? 0) : col * (NODE_W + colGap);
-		const y = orientation === "vertical" ? col * (NODE_H + rowGap) : row * (NODE_H + rowGap);
-		nodes.push({ stage: s, col, row, x, y });
-	}
-
-	return nodes;
-}

package/dist/builtin/workflows/src/tui/mouse-input.ts

@@ -1,61 +0,0 @@
-export type TerminalMouseProtocol = "sgr" | "x10";
-export type TerminalMouseAction = "press" | "release";
-export type TerminalMouseWheelDirection = "up" | "down" | "left" | "right";
-
-export interface TerminalMouseEvent {
-	readonly protocol: TerminalMouseProtocol;
-	readonly action: TerminalMouseAction;
-	readonly buttonCode: number;
-	/** Zero-based terminal column. */
-	readonly col: number;
-	/** Zero-based terminal row. */
-	readonly row: number;
-}
-
-/** Parse one complete SGR or legacy X10 terminal mouse sequence. */
-export function parseTerminalMouseInput(data: string): TerminalMouseEvent | null {
-	const sgr = data.match(/^\x1b\[<(\d+);(\d+);(\d+)([Mm])$/);
-	if (sgr) {
-		const oneBasedCol = Number.parseInt(sgr[2]!, 10);
-		const oneBasedRow = Number.parseInt(sgr[3]!, 10);
-		if (oneBasedCol < 1 || oneBasedRow < 1) return null;
-		return {
-			protocol: "sgr",
-			action: sgr[4] === "M" ? "press" : "release",
-			buttonCode: Number.parseInt(sgr[1]!, 10),
-			col: oneBasedCol - 1,
-			row: oneBasedRow - 1,
-		};
-	}
-
-	if (!data.startsWith("\x1b[M") || data.length !== 6) return null;
-	const buttonCode = data.charCodeAt(3) - 32;
-	const col = data.charCodeAt(4) - 33;
-	const row = data.charCodeAt(5) - 33;
-	if (buttonCode < 0 || col < 0 || row < 0) return null;
-	return {
-		protocol: "x10",
-		action: (buttonCode & (64 | 32)) === 0 && (buttonCode & 3) === 3 ? "release" : "press",
-		buttonCode,
-		col,
-		row,
-	};
-}
-
-export function terminalMouseWheelDirection(event: TerminalMouseEvent): TerminalMouseWheelDirection | null {
-	if (event.action !== "press" || (event.buttonCode & 64) === 0) return null;
-	const direction = event.buttonCode & 3;
-	if (direction === 0) return "up";
-	if (direction === 1) return "down";
-	if (direction === 2) return "left";
-	return "right";
-}
-
-export function isTerminalLeftMousePress(event: TerminalMouseEvent): boolean {
-	return (
-		event.action === "press" &&
-		(event.buttonCode & 64) === 0 &&
-		(event.buttonCode & 32) === 0 &&
-		(event.buttonCode & 3) === 0
-	);
-}

package/dist/builtin/workflows/src/tui/node-card.ts

@@ -1,357 +0,0 @@
-/**
- * DAG node card — rounded, status-coloured, with an accent focus tab.
- *
- * Visual contract (DESIGN.md §5):
- *  - Rounded border `╭╮╰╯` only. No square or ASCII art.
- *  - Border colour carries status. `running` pulses via sine lerp
- *    against the dim border (focus locks the pulse). `paused`,
- *    `completed` / `failed` stay status-coloured regardless of focus.
- *    `pending` sits on `borderDim` and lifts to `borderActive` when focused.
- *  - When focused, the centred title segment becomes a compact accent
- *    tab painted with `theme.accent` bg + `theme.surface` fg + bold.
- *    The tab is the only focus signal — the surrounding border is
- *    reserved for status. No `[focused]` text, no glow, no resize.
- *  - Single centred duration line in the body, coloured by status.
- *
- * Reuses the existing `paint(...)` color-utils helper (a thin wrapper
- * over `hexBg` + `hexToAnsi` + `BOLD` + `RESET`) so the tab matches
- * the same ANSI shape Pi's renderer uses for every other styled run.
- *
- * cross-ref:
- *   - github.com/bastani-inc/atomic packages/atomic-sdk/src/components/node-card.tsx
- *   - DESIGN.md §5 "Node Cards (orchestrator graph)"
- *   - src/tui/graph-theme.ts `deriveGraphThemeFromPiTheme` — the
- *     accent/surface tokens used below are sourced from Pi's live
- *     `Theme` when the overlay mounts.
- */
-
-import type { StageSnapshot, StageStatus } from "../shared/store-types.js";
-import { elapsedStageMs } from "../shared/timing.js";
-import { BOLD, hexBg, hexToAnsi, lerpColor, paint, RESET } from "./color-utils.js";
-import type { GraphTheme } from "./graph-theme.js";
-import { NODE_H, NODE_W } from "./layout.js";
-import { wrapIdentifierLines } from "./run-identity-rows.js";
-import { fmtDuration, statusIcon } from "./status-helpers.js";
-import { truncateToWidth, visibleWidth } from "./text-helpers.js";
-
-export interface NodeCardOpts {
-	width?: number;
-	height?: number;
-	focused?: boolean;
-	/** 0–1; ignored when status is terminal (complete/failed). */
-	pulsePhase?: number;
-	theme: GraphTheme;
-	/** Run stages, used to resolve blockedByStageId into a short upstream name. */
-	stages?: readonly StageSnapshot[];
-	/**
-	 * Pending steering/follow-up messages on this stage's live session. A
-	 * nonzero count claims the final body row so a queued message stays visible
-	 * while the user is detached from the stage chat.
-	 */
-	queuedMessageCount?: number;
-}
-
-/** Sine-eased pulse `t ∈ [0, 1]`. Phase 0 ≈ quiet, 0.5 ≈ peak. */
-function pulseT(phase: number): number {
-	return (Math.sin(phase * Math.PI * 2 - Math.PI / 2) + 1) / 2;
-}
-
-/** Normalize a caller-supplied queue count to a non-negative whole number. */
-function queuedBadgeCount(count: number | undefined): number {
-	if (typeof count !== "number" || !Number.isFinite(count)) return 0;
-	return Math.max(0, Math.trunc(count));
-}
-
-function queuedBadgeText(count: number): string {
-	return `✉ ${count} queued`;
-}
-
-function pickBorder(status: StageStatus, focused: boolean, phase: number, theme: GraphTheme): string {
-	switch (status) {
-		case "running":
-			// Focus locks the pulse at peak. Status colour wins either way.
-			if (focused) return theme.warning;
-			return lerpColor(theme.borderDim, theme.warning, pulseT(phase));
-		case "paused":
-			return theme.warning;
-		case "awaiting_input":
-			if (focused) return theme.info;
-			return lerpColor(theme.borderDim, theme.info, pulseT(phase));
-		case "completed":
-			return theme.success;
-		case "failed":
-			return theme.error;
-		case "blocked":
-			return theme.dim;
-		case "skipped":
-			return theme.dim;
-		default:
-			// Pending has no semantic colour; the focused-tab carries the
-			// cursor signal, so we only lift the border one step.
-			return focused ? theme.borderActive : theme.borderDim;
-	}
-}
-
-function durationColor(status: StageStatus, theme: GraphTheme): string {
-	switch (status) {
-		case "running":
-			return theme.warning;
-		case "paused":
-			return theme.warning;
-		case "awaiting_input":
-			return theme.info;
-		case "completed":
-			return theme.success;
-		case "failed":
-			return theme.error;
-		default:
-			return theme.dim;
-	}
-}
-
-function blockedBadgeText(stage: StageSnapshot, stages: readonly StageSnapshot[] | undefined, width: number): string {
-	const base = "↑ blocked";
-	const blockedBy = stage.blockedByStageId;
-	if (!blockedBy) return base;
-
-	const upstream = stages?.find((s) => s.id === blockedBy)?.name ?? blockedBy;
-	const withUpstream = `${base} by ${upstream}`;
-	if (visibleWidth(withUpstream) <= width) return withUpstream;
-	return base;
-}
-
-function durationText(stage: StageSnapshot): string {
-	const elapsed = elapsedStageMs(stage);
-	return elapsed === undefined ? "—" : fmtDuration(elapsed);
-}
-
-function metaText(stage: StageSnapshot): string {
-	if (stage.topologyState === "unavailable") return "topology unavailable";
-	const deps = stage.parentIds.length;
-	const dependencyText = deps === 0 ? "root" : deps === 1 ? "1 dep" : `${deps} deps`;
-	return dependencyText;
-}
-
-function workflowChildRunRows(stage: StageSnapshot, width: number): string[] {
-	const child = stage.workflowChild ?? stage.workflowChildRun;
-	if (child === undefined) return [];
-	return wrapIdentifierLines(child.runId, Math.max(1, width), "run ", "").map((row) => `${row.prefix}${row.chunk}`);
-}
-
-function workflowChildMetaText(stage: StageSnapshot): string | undefined {
-	const completed = stage.workflowChild;
-	if (completed !== undefined) {
-		// #2140 moved the child run id onto its own wrapped row, so the meta
-		// line carries only the output count. Prefer the payload-free
-		// `outputCount` the compact graph projection supplies; fall back to
-		// counting a full `outputs` map on the legacy snapshot path.
-		const outputCount = completed.outputCount ?? Object.keys(completed.outputs).length;
-		return outputCount === 1 ? "1 out" : `${outputCount} outs`;
-	}
-	if (stage.workflowChildRun !== undefined) return "live";
-	return undefined;
-}
-
-function joinCompactStatusMeta(status: string, meta: string, width: number): string {
-	const candidates = [`${status} · ${meta}`, `${status} ·${meta}`, `${status}· ${meta}`, `${status}·${meta}`];
-	return candidates.find((candidate) => visibleWidth(candidate) <= width) ?? meta;
-}
-
-function statusLabel(status: StageStatus): string {
-	switch (status) {
-		case "awaiting_input":
-			return "awaiting input";
-		case "completed":
-			return "complete";
-		default:
-			return status.replace(/_/g, " ");
-	}
-}
-
-function truncate(s: string, maxWidth: number): string {
-	if (maxWidth <= 0) return "";
-	if (visibleWidth(s) <= maxWidth) return s;
-	return truncateToWidth(s, maxWidth, "…");
-}
-
-/**
- * Centre a visible string inside `width` cells, wrapping it with `fg`
- * (and optional bold) ANSI escapes. The visible width is computed before
- * the colour escapes are added so padding stays correct. `bg` is
- * re-emitted around the coloured run so trailing pad cells stay on the
- * card stratum instead of dropping to the terminal default.
- */
-function centreColored(content: string, width: number, fg: string, bg: string, opts: { bold?: boolean } = {}): string {
-	const safe = truncate(content, width);
-	const safeWidth = visibleWidth(safe);
-	const pad = Math.max(0, width - safeWidth);
-	const left = Math.max(0, Math.floor(pad / 2));
-	const right = Math.max(0, pad - left);
-	const bold = opts.bold ? BOLD : "";
-	return `${bg}${" ".repeat(left)}` + `${hexToAnsi(fg)}${bold}${safe}${RESET}` + `${bg}${" ".repeat(right)}`;
-}
-
-/**
- * Build the title slot — the run of cells between the rounded corners
- * on the top border. Returns a pre-styled fragment plus its visible
- * width so the caller can pad the surrounding dashes correctly.
- *
- * When `focused`, the slot reads as a small accent-coloured tab:
- *   `╭── stage ──╮`
- * Otherwise it falls back to the historical bold-title shape:
- *   `╭── stage ──╮`
- *
- * The visible-width contract is preserved (length of the title slot
- * is included in the dash math) so the card geometry never shifts
- * between the two states — focus only changes the styling of the
- * existing slot, not its size.
- */
-function buildTitleSlot(
-	name: string,
-	innerWidth: number,
-	focused: boolean,
-	theme: GraphTheme,
-	cardBg: string,
-	compact = false,
-): { slot: string; visibleWidth: number } {
-	const maxName = Math.max(2, compact ? innerWidth - 1 : innerWidth - 4);
-	const safeName = truncate(name, maxName);
-	if (focused) {
-		// Flanking spaces sit on the accent tab so the pill reads as a
-		// single coloured run. Use `paint` to combine bg + fg + bold +
-		// RESET in one ANSI sequence, then re-prime the card stratum so
-		// the dashes outside the slot stay on the body bg.
-		const tabText = compact ? safeName : ` ${safeName} `;
-		const styled = `${paint(tabText, theme.surface, {
-			bg: theme.accent,
-			bold: true,
-		})}${cardBg}`;
-		return { slot: styled, visibleWidth: visibleWidth(tabText) };
-	}
-	const titleRaw = compact ? safeName : ` ${safeName} `;
-	const styled = `${BOLD}${titleRaw}${RESET}${cardBg}`;
-	return { slot: styled, visibleWidth: visibleWidth(titleRaw) };
-}
-
-/**
- * Render a stage as a multi-line card string.
- * Returns array of exactly `height` lines, each `width` cells wide.
- */
-export function renderNodeCard(stage: StageSnapshot, opts: NodeCardOpts): string[] {
-	const width = opts.width ?? NODE_W;
-	const height = opts.height ?? NODE_H;
-	const focused = opts.focused ?? false;
-	const phase = opts.pulsePhase ?? 0;
-	const theme = opts.theme;
-
-	const borderHex = pickBorder(stage.status, focused, phase, theme);
-	const bc = hexToAnsi(borderHex);
-	// Card stratum bg — painted explicitly on every cell so internal
-	// RESETs never let the terminal default leak through as a shadow
-	// strip on the right/bottom of the card. Per DESIGN.md the card
-	// background is `base` (same as the canvas), so this paints flush
-	// with the body bg and only the border outline reads visually.
-	const bg = hexBg(theme.bg);
-	const innerWidth = Math.max(2, width - 2);
-
-	// Child workflow boundaries use the compact title path so their workflow
-	// identity remains visible without changing the fixed card geometry.
-	const child = stage.workflowChild ?? stage.workflowChildRun;
-	const { slot: titleSlot, visibleWidth: titleVisibleWidth } = buildTitleSlot(
-		child === undefined ? stage.name : `↳ ${child.workflow}`,
-		innerWidth,
-		focused,
-		theme,
-		bg,
-		child !== undefined,
-	);
-	const titleStart = Math.max(1, Math.floor((innerWidth - titleVisibleWidth) / 2));
-	const titleEnd = titleStart + titleVisibleWidth;
-	const topMiddle =
-		`${bc}${"─".repeat(titleStart)}` + `${titleSlot}${bc}` + `${"─".repeat(Math.max(0, innerWidth - titleEnd))}`;
-	const top = `${bg}${bc}╭${topMiddle}╮${RESET}`;
-	const bottom = `${bg}${bc}╰${"─".repeat(innerWidth)}╯${RESET}`;
-
-	// A tool card is a fixed-size graph node, not a result preview: the read-only
-	// detail view owns args, result, error, and timing. The body is constant in
-	// every state so the card stops competing with it, while the status, meta,
-	// and dependency rows below keep their own content.
-	const bodyText =
-		stage.nodeKind === "tool"
-			? "durable tool"
-			: stage.status === "blocked"
-				? blockedBadgeText(stage, opts.stages, innerWidth)
-				: durationText(stage);
-	const bodyHex = durationColor(stage.status, theme);
-	const statusText = `${statusIcon(stage.status)} ${stage.toolStatus ?? statusLabel(stage.status)}`;
-	const statusLine =
-		`${bg}${bc}│${RESET}` +
-		centreColored(statusText, innerWidth, bodyHex, bg, {
-			bold: stage.status === "running" || stage.status === "awaiting_input",
-		}) +
-		`${bg}${bc}│${RESET}`;
-	const durLine =
-		`${bg}${bc}│${RESET}` +
-		centreColored(bodyText, innerWidth, bodyHex, bg, {
-			bold: stage.status === "blocked",
-		}) +
-		`${bg}${bc}│${RESET}`;
-
-	const contentRows = Math.max(0, height - 2);
-	const metaLine = `${bg}${bc}│${RESET}${centreColored(metaText(stage), innerWidth, theme.dim, bg)}${bg}${bc}│${RESET}`;
-	const childRunLines = workflowChildRunRows(stage, innerWidth).map(
-		(row) => `${bg}${bc}│${RESET}${centreColored(row, innerWidth, theme.dim, bg)}${bg}${bc}│${RESET}`,
-	);
-	const queuedCount = queuedBadgeCount(opts.queuedMessageCount);
-	const childMeta = workflowChildMetaText(stage);
-	const childSummary =
-		childMeta === undefined
-			? undefined
-			: joinCompactStatusMeta(statusText, queuedCount > 0 ? queuedBadgeText(queuedCount) : childMeta, innerWidth);
-	const childSummaryLine =
-		childSummary === undefined
-			? undefined
-			: `${bg}${bc}│${RESET}` +
-				centreColored(childSummary, innerWidth, bodyHex, bg, {
-					bold: stage.status === "running" || stage.status === "awaiting_input",
-				}) +
-				`${bg}${bc}│${RESET}`;
-
-	const interior: string[] =
-		stage.status === "awaiting_input"
-			? [
-					statusLine,
-					`${bg}${bc}│${RESET}` +
-						centreColored("waiting for response", innerWidth, theme.info, bg) +
-						`${bg}${bc}│${RESET}`,
-					`${bg}${bc}│${RESET}` +
-						centreColored("↵ enter to respond", innerWidth, theme.dim, bg) +
-						`${bg}${bc}│${RESET}`,
-				]
-			: childSummaryLine === undefined
-				? [durLine, statusLine, metaLine]
-				: [...childRunLines, childSummaryLine];
-
-	// A queued steer/follow-up is invisible once the user leaves the stage chat,
-	// so it claims one existing body row rather than competing for space inside a
-	// line that would truncate. Child boundaries pack it beside status except when
-	// the awaiting-input interior leaves its redundant response row available.
-	const preferredBadgeRow =
-		stage.status === "awaiting_input" ? 1 : childSummaryLine === undefined ? interior.length - 1 : -1;
-
-	// Pad / clip to exactly `height` lines.
-	while (interior.length < contentRows) {
-		interior.push(`${bg}${bc}│${RESET}${bg}${" ".repeat(innerWidth)}${bg}${bc}│${RESET}`);
-	}
-	if (interior.length > contentRows) interior.length = contentRows;
-
-	if (queuedCount > 0 && interior.length > 0 && preferredBadgeRow >= 0) {
-		const badgeRow = preferredBadgeRow < interior.length ? preferredBadgeRow : interior.length - 1;
-		interior[badgeRow] =
-			`${bg}${bc}│${RESET}` +
-			centreColored(queuedBadgeText(queuedCount), innerWidth, theme.info, bg, { bold: true }) +
-			`${bg}${bc}│${RESET}`;
-	}
-
-	return [top, ...interior, bottom];
-}