tickmarkr 1.79.0 → 1.81.0

package/dist/tui/cockpit/run-cockpit.js

@@ -0,0 +1,248 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box } from "ink";
+import { cloneElement, } from "react";
+import { GLYPHS, PLAIN_COMPACT_LOCKUP, } from "../../brand.js";
+import { allocateBandColumns, BandLines, BodyText, CockpitGrid, composeBandLine, JournalRowPanel, KEYBAR_KEYS, Keybar, Panel, PANEL_CHROME_ROWS, ProgressMeter, StatTile, StatusStrip, } from "./components.js";
+import { RUN_PANEL_FOCUS_ORDER, RUN_KEY_BINDINGS, } from "./keys.js";
+import { resolveCockpitLayout, } from "./layout.js";
+export { deriveRunCockpitData } from "./derive.js";
+export { PANEL_CHROME_ROWS } from "./components.js";
+const APPROVED_SIDE_RAIL_COLUMN_FLOOR = 80;
+const NARROW_HEADER_ALLOCATION = {
+    chromeColumns: 0,
+    minimumReadableColumns: 1,
+};
+/**
+ * How many rows one line of body text occupies once the renderer wraps it into
+ * `columns`. This mirrors the renderer's own word wrap — greedy, and breaking a
+ * word that cannot fit on a line of its own — so a frame can charge a panel the
+ * rows it will really occupy instead of a hand-tuned constant.
+ */
+export function wrappedRows(text, columns) {
+    if (columns < 1)
+        return 1;
+    let rows = 1;
+    let used = 0;
+    for (const [index, word] of text.split(" ").entries()) {
+        // ponytail: code points, not display columns — every glyph the cockpit
+        // draws is one column wide. Reach for a width table only if it stops being.
+        const length = [...word].length;
+        if (index !== 0) {
+            if (used >= columns) {
+                rows += 1;
+                used = 0;
+            }
+            used += 1;
+        }
+        if (length > columns) {
+            const startsThisLine = 1 + Math.floor((length - (columns - used) - 1) / columns);
+            if (Math.floor((length - 1) / columns) < startsThisLine) {
+                rows += 1;
+                used = 0;
+            }
+            for (let taken = 0; taken < length; taken += 1) {
+                if (used < columns)
+                    used += 1;
+                else {
+                    rows += 1;
+                    used = 1;
+                }
+            }
+            continue;
+        }
+        if (used > 0 && used + length > columns) {
+            rows += 1;
+            used = 0;
+        }
+        used += length;
+    }
+    return rows;
+}
+/** The rows a bordered panel occupies when its body wraps into `columns`. */
+export function panelRows(lines, columns) {
+    return lines.reduce((rows, line) => rows + composeBandLine(line, columns).length, PANEL_CHROME_ROWS);
+}
+function IdentityHeader({ data, columns, secondary = true, }) {
+    const lockup = PLAIN_COMPACT_LOCKUP.split("\n");
+    if (columns < APPROVED_SIDE_RAIL_COLUMN_FLOOR) {
+        const primary = [
+            { title: "", lines: [lockup[0] ?? "tickmarkr"] },
+            {
+                title: "",
+                lines: [`v${data.binaryVersion} · binary ${GLYPHS.pass}`],
+            },
+        ];
+        const secondaryBand = [
+            { title: "", lines: [lockup[1] ?? "tickmarkr"] },
+            {
+                title: "",
+                lines: [
+                    `${data.runId} · ${data.branch}  ${data.status} · ${data.elapsed}`,
+                ],
+            },
+        ];
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(NarrowHeaderBand, { columns: columns, content: primary, rightStrong: true }), secondary && (_jsx(NarrowHeaderBand, { columns: columns, content: secondaryBand }))] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsx(BodyText, { emphasis: "strong", children: lockup[0] ?? "tickmarkr" }), _jsxs(BodyText, { emphasis: "strong", children: ["v", data.binaryVersion, " \u00B7 binary ", GLYPHS.pass] })] }), secondary && (_jsxs(Box, { justifyContent: "space-between", children: [_jsx(BodyText, { emphasis: "strong", children: lockup[1] ?? "tickmarkr" }), _jsxs(BodyText, { children: [data.runId, " \u00B7 ", data.branch, "  ", data.status, " \u00B7 ", data.elapsed] })] }))] }));
+}
+function NarrowHeaderBand({ columns, content, rightStrong = false, }) {
+    const widths = allocateBandColumns(columns, content, NARROW_HEADER_ALLOCATION);
+    return (_jsxs(CockpitGrid, { columns: columns, columnContents: content, allocation: NARROW_HEADER_ALLOCATION, children: [_jsx(BandLines, { columns: Math.max(1, widths[0]), lines: content[0].lines, emphasis: "strong" }), _jsx(Box, { alignItems: "flex-end", flexDirection: "column", children: _jsx(BandLines, { columns: Math.max(1, widths[1]), lines: content[1].lines, emphasis: rightStrong ? "strong" : "normal" }) })] }));
+}
+function NavigationPanel({ focused = false }) {
+    return (_jsxs(Panel, { title: "VIEWS", width: 16, focused: focused, children: [_jsxs(BodyText, { emphasis: "strong", children: [GLYPHS.pointer, " Run"] }), _jsx(BodyText, { children: "  Tasks" }), _jsx(BodyText, { children: "  Gates" }), _jsx(BodyText, { children: "  Journal" }), _jsx(BodyText, { children: "  Fleet" })] }));
+}
+function KeysPanel({ focused = false }) {
+    return (_jsx(Panel, { title: "KEYS", width: 16, focused: focused, children: KEYBAR_KEYS.run.map((item) => (_jsxs(Box, { children: [_jsx(BodyText, { emphasis: "strong", children: item.key }), _jsxs(BodyText, { children: [" ", item.label] })] }, item.key))) }));
+}
+/** The journal rows an interaction state leaves visible. */
+function visibleJournalRows(rows, interaction) {
+    const query = interaction?.filterQuery.trim().toLowerCase() ?? "";
+    if (query === "")
+        return rows;
+    return rows.filter((row) => row.text.toLowerCase().includes(query));
+}
+function SizedJournalPanel({ rows, bodyRows, title, selection, }) {
+    const visible = rows.slice(0, bodyRows);
+    const emptyRows = Math.max(0, bodyRows - visible.length);
+    const journal = JournalRowPanel({ rows: visible, title, selection });
+    const journalProps = journal.props;
+    return cloneElement(journal, {}, journalProps.children, emptyRows > 0 ? _jsx(Box, { height: emptyRows }, "journal-space") : null);
+}
+/** A body panel (help overlay, opened event) padded to the journal's rows. */
+function SizedLinesPanel({ title, lines, bodyRows, }) {
+    const visible = lines.slice(0, bodyRows);
+    const emptyRows = Math.max(0, bodyRows - visible.length);
+    return (_jsxs(Panel, { title: title, children: [visible.map((line, index) => (_jsx(BodyText, { children: line }, `${index}:${line}`))), emptyRows > 0 && _jsx(Box, { height: emptyRows })] }));
+}
+/** The lines the help overlay draws: every advertised key and its promise. */
+function helpLines() {
+    return RUN_KEY_BINDINGS.map((binding) => `${binding.key} ${binding.label}`);
+}
+/** The lines the opened-event view draws for one journal row. */
+function eventLines(row) {
+    return [`${row.time} · ${row.state}`, row.text];
+}
+/**
+ * What the journal's slot of the RUN panel draws under an interaction state:
+ * the help overlay while ? is up, the opened event while ⏎'s choice stands,
+ * otherwise the journal itself — narrowed by the filter, marked at the
+ * selection, titled with the open / prompt.
+ */
+function JournalBody({ data, interaction, bodyRows, }) {
+    const rows = visibleJournalRows(data.journalRows, interaction);
+    if (interaction?.help === true) {
+        return _jsx(SizedLinesPanel, { title: "HELP", lines: helpLines(), bodyRows: bodyRows });
+    }
+    const opened = interaction?.opened ?? null;
+    if (opened !== null && opened < rows.length) {
+        return (_jsx(SizedLinesPanel, { title: "EVENT", lines: eventLines(rows[opened]), bodyRows: bodyRows }));
+    }
+    return (_jsx(SizedJournalPanel, { rows: rows, bodyRows: bodyRows, title: interaction?.filterPrompt === true
+            ? `JOURNAL /${interaction.filterQuery}`
+            : undefined, selection: interaction === undefined || interaction.selection < 0
+            ? undefined
+            : interaction.selection }));
+}
+function RunStats({ data, mode, }) {
+    if (mode === "summary") {
+        return (_jsx(BodyText, { children: `tasks ${data.tasks.done}/${data.tasks.total} · gates ${data.gates.passed}/${data.gates.total} · pass ${data.passRate.value}%` }));
+    }
+    return (_jsxs(CockpitGrid, { children: [_jsx(StatTile, { label: "TASKS", value: `${data.tasks.done}/${data.tasks.total}`, samples: data.tasks.samples }), _jsx(StatTile, { label: "GATES", value: `${data.gates.passed}/${data.gates.total}`, samples: data.gates.samples }), _jsx(StatTile, { label: "PASS RATE", value: `${data.passRate.value}%`, samples: data.passRate.samples })] }));
+}
+function ApprovedProgress({ data, caption, }) {
+    return (_jsxs(Panel, { title: "PROGRESS", children: [_jsx(ProgressMeter, { value: data.progress, width: 28 }), caption && _jsx(BodyText, { emphasis: "dim", children: data.progressCaption })] }));
+}
+function CompactProgress({ data, caption, meterWidth = 28, }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", flexWrap: "nowrap", children: [_jsx(BodyText, { emphasis: "strong", children: "PROGRESS " }), _jsx(ProgressMeter, { value: data.progress, width: meterWidth })] }), caption && _jsx(BodyText, { emphasis: "dim", children: data.progressCaption })] }));
+}
+function pairedTextRows(left, right, columns) {
+    const leftWidth = [...left].length;
+    const rightWidth = [...right].length;
+    const required = leftWidth + rightWidth;
+    if (required <= columns)
+        return 1;
+    const leftColumns = Math.max(1, Math.floor((Math.max(1, columns) * leftWidth) / required));
+    const rightColumns = Math.max(1, Math.max(1, columns) - leftColumns);
+    return Math.max(wrappedRows(left, leftColumns), wrappedRows(right, rightColumns));
+}
+function narrowHeaderRows(left, right, columns) {
+    const content = [
+        { title: "", lines: [left] },
+        { title: "", lines: [right] },
+    ];
+    const widths = allocateBandColumns(columns, content, NARROW_HEADER_ALLOCATION);
+    return Math.max(...content.map((column, index) => composeBandLine(column.lines[0], Math.max(1, widths[index])).length));
+}
+function headerRowsFor(layout, data, columns) {
+    const lockup = PLAIN_COMPACT_LOCKUP.split("\n");
+    const measure = columns < APPROVED_SIDE_RAIL_COLUMN_FLOOR
+        ? narrowHeaderRows
+        : pairedTextRows;
+    const primaryRows = measure(lockup[0] ?? "tickmarkr", `v${data.binaryVersion} · binary ${GLYPHS.pass}`, columns);
+    if (!layout.elements.secondaryHeader)
+        return primaryRows;
+    return primaryRows + measure(lockup[1] ?? "tickmarkr", `${data.runId} · ${data.branch}  ${data.status} · ${data.elapsed}`, columns);
+}
+function compactJournalRows(rows, layout, data, columns) {
+    const statRows = layout.stats.mode === "tiles" ? 5 : 1;
+    const progressRows = layout.elements.progressBar
+        ? 1 + (layout.elements.progressCaption ? 1 : 0)
+        : 0;
+    const fixedRows = headerRowsFor(layout, data, columns)
+        + 2 // permanent status strip and keybar
+        + 3 // outer RUN panel border and title
+        + statRows
+        + progressRows
+        + 3; // journal border and title
+    return Math.max(1, Math.min(layout.journalRows, Math.floor(rows) - fixedRows));
+}
+function LadderRunPanel({ data, layout, columns, rows, compactMeterWidth, interaction, focused = true, }) {
+    const compactBodyRows = compactJournalRows(rows, layout, data, columns);
+    // The approved bordered progress panel has the same meter/caption as the
+    // compact form plus its border, title row and closing border. It is restored
+    // only after the resolved ladder has retained every full-arrangement element
+    // and the journal can pay those three chrome rows without disappearing.
+    const approvedProgressChromeRows = 3;
+    const approvedArrangement = layout.elements.secondaryHeader
+        && layout.elements.progressBar
+        && layout.elements.progressCaption
+        && layout.stats.mode === "tiles"
+        && compactBodyRows > approvedProgressChromeRows;
+    const journalBodyRows = approvedArrangement
+        ? compactBodyRows - approvedProgressChromeRows
+        : compactBodyRows;
+    return (_jsxs(Panel, { title: "RUN", focused: focused, flexGrow: 1, children: [_jsx(RunStats, { data: data, mode: layout.stats.mode }), layout.elements.progressBar && (approvedArrangement
+                ? (_jsx(ApprovedProgress, { data: data, caption: layout.elements.progressCaption }))
+                : (_jsx(CompactProgress, { data: data, caption: layout.elements.progressCaption, meterWidth: compactMeterWidth }))), _jsx(JournalBody, { data: data, interaction: interaction, bodyRows: journalBodyRows })] }));
+}
+function LegacyRunPanel({ data, interaction, focused = true, }) {
+    const rows = visibleJournalRows(data.journalRows, interaction);
+    return (_jsxs(Panel, { title: "RUN", focused: focused, flexGrow: 1, children: [_jsx(RunStats, { data: data, mode: "tiles" }), _jsxs(Panel, { title: "PROGRESS", children: [_jsx(ProgressMeter, { value: data.progress, width: 28 }), _jsx(BodyText, { emphasis: "dim", children: data.progressCaption })] }), _jsx(JournalBody, { data: data, interaction: interaction, bodyRows: rows.length })] }));
+}
+export function RunCockpitFrame({ data, columns, rows, interaction, }) {
+    const focus = interaction === undefined
+        ? 0
+        : interaction.panel % RUN_PANEL_FOCUS_ORDER.length;
+    const focusedPanel = RUN_PANEL_FOCUS_ORDER[focus] ?? "RUN";
+    // Follow mode reports its on state as a status-strip item carrying the
+    // brand's reserved active-toggle glyph; off it draws nothing, so the pinned
+    // frame is untouched.
+    const statusItems = interaction?.follow === true
+        ? [...data.statusItems, { state: "active", text: "Follow" }]
+        : data.statusItems;
+    if (rows === undefined) {
+        return (_jsxs(Box, { flexDirection: "column", width: columns, children: [_jsx(IdentityHeader, { data: data, columns: columns }), _jsxs(Box, { flexDirection: "row", gap: 1, children: [_jsx(NavigationPanel, { focused: focusedPanel === "VIEWS" }), _jsx(LegacyRunPanel, { data: data, interaction: interaction, focused: focusedPanel === "RUN" }), _jsx(KeysPanel, { focused: focusedPanel === "KEYS" })] }), _jsx(StatusStrip, { items: statusItems, width: columns }), _jsx(Keybar, { surface: "run", width: columns })] }));
+    }
+    const layout = resolveCockpitLayout(columns, rows);
+    if (layout.renderer === "plain")
+        return _jsx(_Fragment, {});
+    const showSideRails = columns >= APPROVED_SIDE_RAIL_COLUMN_FLOOR;
+    const contentLayout = showSideRails
+        ? layout
+        : {
+            ...layout,
+            stats: { ...layout.stats, mode: "summary", rows: 1 },
+        };
+    return (_jsxs(Box, { flexDirection: "column", width: columns, children: [_jsx(IdentityHeader, { data: data, columns: columns, secondary: layout.elements.secondaryHeader }), _jsxs(Box, { flexDirection: "row", gap: showSideRails ? 1 : 0, children: [showSideRails && _jsx(NavigationPanel, { focused: focusedPanel === "VIEWS" }), _jsx(LadderRunPanel, { data: data, layout: contentLayout, columns: columns, rows: rows, compactMeterWidth: showSideRails ? undefined : 24, interaction: interaction, focused: focusedPanel === "RUN" }), showSideRails && _jsx(KeysPanel, { focused: focusedPanel === "KEYS" })] }), _jsx(StatusStrip, { items: statusItems, width: columns }), _jsx(Keybar, { surface: "run", width: columns })] }));
+}

package/dist/tui/cockpit/setup-cockpit.d.ts

@@ -0,0 +1,44 @@
+import { type ReactElement } from "react";
+import { type TickmarkrConfig } from "../../config/config.js";
+import { type ComponentState, type JournalRow } from "./components.js";
+import type { DemoCaptures } from "./demo.js";
+import { type SetupInteractionState, type SetupKeyBinding } from "./keys.js";
+export type SetupCockpitData = {
+    readonly binaryVersion: string;
+    readonly harnesses: readonly {
+        readonly id: string;
+        readonly version: string;
+        readonly modelCount: number;
+        readonly state: ComponentState;
+        readonly stateWord: string;
+    }[];
+    readonly deniedChannels: readonly {
+        readonly channel: string;
+        readonly reason: string;
+    }[];
+    readonly counts: {
+        readonly found: number;
+        readonly authenticated: number;
+        readonly routable: number;
+    };
+    readonly config: TickmarkrConfig;
+    readonly overlayDiff: string;
+    readonly stagedChanges: readonly string[];
+    readonly reviewRows: readonly JournalRow[];
+    readonly overlayTarget: string;
+};
+export declare function deriveSetupCockpitData(captures: DemoCaptures, binaryVersion: string): SetupCockpitData;
+/**
+ * The contracted ladder (§5.4) governs the elements every surface shares. The
+ * detail panels below it are the setup body, so they surrender first, from the
+ * bottom of this list upward: what a step is *about* outlives what merely
+ * describes the fleet.
+ */
+export declare const SETUP_DETAIL_ORDER: readonly ["detected", "consultsAndReviewers", "overlayDiff", "fleetAndGates"];
+export declare function SetupCockpitFrame({ data, columns, rows, interaction, bindings, }: {
+    data: SetupCockpitData;
+    columns: number;
+    rows?: number;
+    interaction?: SetupInteractionState;
+    bindings?: readonly SetupKeyBinding[];
+}): ReactElement;