tickmarkr 1.78.0 → 1.80.0

package/dist/tui/cockpit/derive.js

@@ -0,0 +1,390 @@
+export const SPARKLINE_BUCKET_WINDOW = 12;
+const MINUTE_MS = 60_000;
+const SPARKLINE_BUCKET_WIDTH_LADDER_MINUTES = [
+    1,
+    5,
+    10,
+    30,
+    60,
+    120,
+    360,
+    720,
+    1_440,
+];
+export function selectSparklineBucketWidthMs(elapsedMs) {
+    const safeElapsedMs = Math.max(0, Number.isFinite(elapsedMs) ? elapsedMs : 0);
+    const requiredMinutes = safeElapsedMs / SPARKLINE_BUCKET_WINDOW / MINUTE_MS;
+    const selected = SPARKLINE_BUCKET_WIDTH_LADDER_MINUTES.find((minutes) => minutes >= requiredMinutes);
+    if (selected !== undefined)
+        return selected * MINUTE_MS;
+    let coarsened = SPARKLINE_BUCKET_WIDTH_LADDER_MINUTES.at(-1);
+    while (coarsened < requiredMinutes)
+        coarsened *= 2;
+    return coarsened * MINUTE_MS;
+}
+function recordValue(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function parseSource(raw) {
+    const events = [];
+    const defects = [];
+    for (const [index, line] of raw.split("\n").entries()) {
+        if (!line.trim())
+            continue;
+        try {
+            const parsed = recordValue(JSON.parse(line));
+            const data = recordValue(parsed?.data);
+            if (!parsed
+                || typeof parsed.ts !== "string"
+                || typeof parsed.event !== "string"
+                || !data
+                || (parsed.taskId !== undefined && typeof parsed.taskId !== "string")) {
+                defects.push({ line: index + 1, raw: line });
+                continue;
+            }
+            events.push({
+                line: index + 1,
+                ts: parsed.ts,
+                event: parsed.event,
+                ...(typeof parsed.taskId === "string" ? { taskId: parsed.taskId } : {}),
+                data,
+            });
+        }
+        catch {
+            defects.push({ line: index + 1, raw: line });
+        }
+    }
+    return { events, defects };
+}
+function assignmentFrom(value) {
+    const assignment = recordValue(value);
+    return assignment
+        && typeof assignment.adapter === "string"
+        && typeof assignment.model === "string"
+        ? { adapter: assignment.adapter, model: assignment.model }
+        : undefined;
+}
+function elapsedReading(first, last) {
+    const seconds = Math.max(0, Math.floor((Date.parse(last) - Date.parse(first)) / 1_000));
+    const hours = Math.floor(seconds / 3_600);
+    const minutes = Math.floor((seconds % 3_600) / 60);
+    const remainder = seconds % 60;
+    const padded = (part) => String(part).padStart(2, "0");
+    return `${padded(hours)}:${padded(minutes)}:${padded(remainder)}`;
+}
+function defaultDaemonLiveness(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function latestLifecycle(events) {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index].event;
+        if (event === "superseded")
+            return "superseded";
+        if (event === "run-end")
+            return "completed";
+        if (event === "run-start" || event === "run-resume")
+            return "active";
+    }
+    return "active";
+}
+function daemonPid(events) {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if ((event.event === "run-start" || event.event === "run-resume")
+            && typeof event.data.pid === "number") {
+            return event.data.pid;
+        }
+    }
+    return undefined;
+}
+function deriveTasks(events, interrupted) {
+    const tasks = new Map();
+    const task = (taskId, index, ts) => {
+        const existing = tasks.get(taskId);
+        if (existing)
+            return existing;
+        const created = {
+            id: taskId,
+            dispatches: [],
+            state: "pending",
+            lastIndex: index,
+            lastTs: ts,
+            phase: "pending",
+        };
+        tasks.set(taskId, created);
+        return created;
+    };
+    for (const [index, event] of events.entries()) {
+        if (!event.taskId)
+            continue;
+        if (event.event === "task-dispatch") {
+            const fact = task(event.taskId, index, event.ts);
+            const recordedAttempt = event.data.attempt;
+            fact.dispatches.push({
+                index,
+                ts: event.ts,
+                attempt: typeof recordedAttempt === "number"
+                    ? Math.max(1, Math.floor(recordedAttempt) + 1)
+                    : fact.dispatches.length + 1,
+                assignment: assignmentFrom(event.data.assignment),
+            });
+            fact.state = "running";
+            fact.phase = "worker";
+            fact.lastIndex = index;
+            fact.lastTs = event.ts;
+            continue;
+        }
+        if (event.event === "phase-start") {
+            const fact = task(event.taskId, index, event.ts);
+            fact.phase = typeof event.data.phase === "string" ? event.data.phase : fact.phase;
+            fact.lastIndex = index;
+            fact.lastTs = event.ts;
+            continue;
+        }
+        const state = {
+            "task-done": "done",
+            "task-failed": "failed",
+            "task-human": "human",
+            "task-approved": "pending",
+        }[event.event];
+        if (state) {
+            const fact = task(event.taskId, index, event.ts);
+            fact.state = state;
+            fact.lastIndex = index;
+            fact.lastTs = event.ts;
+        }
+    }
+    if (interrupted) {
+        for (const fact of tasks.values()) {
+            if (fact.state === "running" || fact.state === "pending") {
+                fact.state = "interrupted";
+            }
+        }
+    }
+    return tasks;
+}
+function taskAttempt(fact) {
+    return fact.dispatches.at(-1)?.attempt ?? Math.max(1, fact.dispatches.length);
+}
+function taskActor(fact) {
+    const assignment = fact.dispatches.at(-1)?.assignment;
+    return assignment ? `${assignment.adapter}:${assignment.model}` : "unassigned";
+}
+function changedActingAdapter(fact) {
+    const first = fact.dispatches[0]?.assignment?.adapter;
+    const last = fact.dispatches.at(-1)?.assignment?.adapter;
+    return first !== undefined && last !== undefined && first !== last;
+}
+function spotlightTask(tasks) {
+    return [...tasks.values()]
+        .filter((fact) => fact.dispatches.length > 0)
+        .sort((left, right) => Number(changedActingAdapter(right)) - Number(changedActingAdapter(left))
+        || taskAttempt(right) - taskAttempt(left)
+        || right.lastIndex - left.lastIndex)[0];
+}
+function defectRow(defect) {
+    const excerpt = defect.raw.trim().replace(/\s+/g, " ").slice(0, 64);
+    return {
+        id: `defect:${defect.line}`,
+        time: `L${defect.line}`,
+        state: "fail",
+        text: `fail · DEFECT · source line ${defect.line} unparseable${excerpt ? ` · ${excerpt}` : ""}`,
+    };
+}
+function eventTime(ts) {
+    const parsed = Date.parse(ts);
+    return Number.isFinite(parsed)
+        ? new Date(parsed).toISOString().slice(11, 19)
+        : ts.slice(0, 8);
+}
+/**
+ * The outcome an event records about itself, in every form the committed
+ * sources use: an unsuccessful result flag, an unsuccessful outcome flag, an
+ * event name reporting a failure, a non-zero exit status, or a run-end whose
+ * tip verification reads failed.
+ */
+function recordsFailure(event) {
+    return event.event.includes("failed")
+        || event.data.pass === false
+        || event.data.ok === false
+        || (typeof event.data.exitCode === "number" && event.data.exitCode !== 0)
+        || (event.event === "run-end" && event.data.tipVerify === "failed");
+}
+function recordsSuccess(event) {
+    return event.event === "task-done"
+        || event.event === "merge"
+        || event.data.pass === true
+        || event.data.ok === true
+        || (event.event === "run-end" && event.data.tipVerify !== "failed");
+}
+/**
+ * A row depicts the event it names: the event's own recorded outcome decides
+ * the state, never the state its task reached later. Only a task with no
+ * terminal event in a run whose daemon is gone lends its interruption, because
+ * no event records that ending — the interruption is the run's present truth.
+ * Every state carries its word, so meaning never rides on hue alone.
+ */
+function eventPresentation(event, task) {
+    if (event.event === "escalation" || event.event === "task-human") {
+        return { state: "warn", word: "warn" };
+    }
+    if (recordsFailure(event))
+        return { state: "fail", word: "fail" };
+    if (recordsSuccess(event))
+        return { state: "pass", word: "pass" };
+    if (task?.state === "interrupted") {
+        return { state: "warn", word: "interrupted" };
+    }
+    return { state: "neutral", word: "neutral" };
+}
+function historyRow(event, tasks, spotlight, newest, runStatus) {
+    const task = event.taskId === undefined ? undefined : tasks.get(event.taskId);
+    const { state, word } = eventPresentation(event, task);
+    // The spotlight entry must keep the task, its attempt and its acting adapter
+    // inside the narrowest band's width budget — that budget cannot pay for the
+    // separators and the event name, so the state word and the run's status
+    // (what the newest event recorded) ride after the adapter instead.
+    const text = newest && spotlight !== undefined
+        ? `${spotlight.id} attempt ${taskAttempt(spotlight)} ${taskActor(spotlight)} ${word}${word === runStatus ? "" : ` ${runStatus}`}`
+        : task !== undefined
+            ? `${task.id} ${word} · ${event.event}`
+            : `${word} · ${event.event}`;
+    return {
+        id: `event:${event.line}`,
+        time: eventTime(event.ts),
+        state,
+        text,
+    };
+}
+function journalRows(events, tasks, defects, runStatus) {
+    const spotlight = spotlightTask(tasks);
+    const history = [...events].reverse().map((event, index) => historyRow(event, tasks, spotlight, index === 0, runStatus));
+    return [...[...defects].reverse().map(defectRow), ...history];
+}
+function bucketedMetricSamples(events) {
+    const taskSamples = Array.from({ length: SPARKLINE_BUCKET_WINDOW }, () => null);
+    const gateTotals = Array.from({ length: SPARKLINE_BUCKET_WINDOW }, () => 0);
+    const gatePasses = Array.from({ length: SPARKLINE_BUCKET_WINDOW }, () => 0);
+    const firstMs = Date.parse(events[0].ts);
+    const lastMs = Date.parse(events.at(-1).ts);
+    const bucketWidthMs = selectSparklineBucketWidthMs(lastMs - firstMs);
+    const windowStartMs = lastMs - bucketWidthMs * SPARKLINE_BUCKET_WINDOW;
+    const completedTasks = new Set();
+    for (const event of events) {
+        const eventMs = Date.parse(event.ts);
+        if (!Number.isFinite(eventMs))
+            continue;
+        const bucket = Math.max(0, Math.min(SPARKLINE_BUCKET_WINDOW - 1, Math.floor((eventMs - windowStartMs) / bucketWidthMs)));
+        if (event.event === "task-done"
+            && event.taskId
+            && !completedTasks.has(event.taskId)) {
+            completedTasks.add(event.taskId);
+            taskSamples[bucket] = (taskSamples[bucket] ?? 0) + 1;
+        }
+        if (event.event === "gate-result") {
+            gateTotals[bucket] = gateTotals[bucket] + 1;
+            if (event.data.pass === true) {
+                gatePasses[bucket] = gatePasses[bucket] + 1;
+            }
+        }
+    }
+    return {
+        tasks: taskSamples,
+        gates: gateTotals.map((total, index) => total === 0 ? null : gatePasses[index]),
+        passRate: gateTotals.map((total, index) => total === 0 ? null : Math.round((gatePasses[index] / total) * 100)),
+    };
+}
+function tipVerificationPassed(events) {
+    const eventVerdicts = events.flatMap((event) => {
+        if (event.event === "tip-verify-failed")
+            return [false];
+        if (event.event === "tip-verify")
+            return [event.data.pass === true];
+        return [];
+    });
+    const endVerdicts = events.flatMap((event) => event.event === "run-end" && typeof event.data.tipVerify === "string"
+        ? [event.data.tipVerify === "passed"]
+        : []);
+    return eventVerdicts.length > 0
+        && endVerdicts.length > 0
+        && eventVerdicts.every(Boolean)
+        && endVerdicts.every(Boolean);
+}
+export function deriveRunCockpitData(source, binaryVersion, options = {}) {
+    const { events, defects } = parseSource(source.raw);
+    if (events.length === 0)
+        throw new Error(`empty cockpit capture: ${source.fileName}`);
+    const start = events.find((event) => event.event === "run-start");
+    if (!start)
+        throw new Error(`capture has no run-start: ${source.fileName}`);
+    const lifecycle = latestLifecycle(events);
+    const pid = daemonPid(events);
+    const alive = lifecycle !== "active"
+        ? false
+        : pid !== undefined && (options.isDaemonAlive ?? defaultDaemonLiveness)(pid);
+    const interrupted = !alive;
+    const tasks = deriveTasks(events, interrupted);
+    const taskFacts = [...tasks.values()];
+    const done = taskFacts.filter((task) => task.state === "done").length;
+    const failed = taskFacts.filter((task) => task.state === "failed").length;
+    const human = taskFacts.filter((task) => task.state === "human").length;
+    const hasInterruptedTask = taskFacts.some((task) => task.state === "interrupted");
+    const gateEvents = events.filter((event) => event.event === "gate-result");
+    const passed = gateEvents.filter((event) => event.data.pass === true).length;
+    const passRate = gateEvents.length === 0 ? 0 : Math.round((passed / gateEvents.length) * 100);
+    const progress = tasks.size === 0 ? 0 : Math.round((done / tasks.size) * 100);
+    const escalated = events.filter((event) => event.event === "escalation").length;
+    const tipPassed = tipVerificationPassed(events);
+    const spotlight = spotlightTask(tasks);
+    const samples = bucketedMetricSamples(events);
+    const runStatus = failed > 0
+        ? "failed"
+        : lifecycle === "superseded" || hasInterruptedTask
+            ? "interrupted"
+            : lifecycle === "completed"
+                ? "done"
+                : interrupted
+                    ? "interrupted"
+                    : "running";
+    return {
+        binaryVersion,
+        runId: source.fileName.replace(/(?:\.interrupted)?\.journal\.jsonl$/, ""),
+        branch: typeof start.data.branch === "string" ? start.data.branch : "unknown",
+        status: runStatus,
+        elapsed: elapsedReading(events[0].ts, events.at(-1).ts),
+        tasks: {
+            done,
+            total: tasks.size,
+            samples: samples.tasks,
+        },
+        gates: {
+            passed,
+            total: gateEvents.length,
+            samples: samples.gates,
+        },
+        passRate: {
+            value: passRate,
+            samples: samples.passRate,
+        },
+        progress,
+        progressCaption: spotlight
+            ? `${spotlight.id} · ${spotlight.phase} · attempt ${taskAttempt(spotlight)} · ${taskActor(spotlight)}`
+            : "- · pending · attempt 1 · unassigned",
+        journalRows: journalRows(events, tasks, defects, runStatus),
+        statusItems: [
+            { state: tipPassed ? "pass" : "fail", text: `tip-verify ${tipPassed ? "passed" : "FAILED"}` },
+            { state: "pass", text: `done ${done}` },
+            { state: failed > 0 ? "fail" : "neutral", text: `failed ${failed}` },
+            { state: human > 0 ? "warn" : "neutral", text: `human ${human}` },
+            { state: escalated > 0 ? "warn" : "neutral", text: `escalated ${escalated}` },
+        ],
+    };
+}

package/dist/tui/cockpit/layout.d.ts

@@ -0,0 +1,76 @@
+export declare const COCKPIT_ROW_FLOOR = 14;
+export declare const COCKPIT_COLUMN_FLOOR = 40;
+export declare const FULL_JOURNAL_ROWS = 3;
+/**
+ * Ordered from highest priority (last surrendered) to lowest (first
+ * surrendered). A minimum row preserves an element in the compact frame; its
+ * preferred rows restore the full presentation before the next step receives
+ * any rows. The stats minimum is its one-line summary, not the full tiles.
+ */
+declare const ORDERED_POLICY: readonly [{
+    readonly element: "keybar";
+    readonly minimumRows: 1;
+    readonly preferredRows: 1;
+}, {
+    readonly element: "statusStrip";
+    readonly minimumRows: 1;
+    readonly preferredRows: 1;
+}, {
+    readonly element: "primaryHeader";
+    readonly minimumRows: 1;
+    readonly preferredRows: 1;
+}, {
+    readonly element: "progressBar";
+    readonly minimumRows: 1;
+    readonly preferredRows: 1;
+}, {
+    readonly element: "journal";
+    readonly minimumRows: 1;
+    readonly preferredRows: 3;
+}, {
+    readonly element: "progressCaption";
+    readonly minimumRows: 0;
+    readonly preferredRows: 1;
+}, {
+    readonly element: "statTiles";
+    readonly minimumRows: 1;
+    readonly preferredRows: 2;
+}, {
+    readonly element: "secondaryHeader";
+    readonly minimumRows: 0;
+    readonly preferredRows: 1;
+}];
+type PolicyElement = (typeof ORDERED_POLICY)[number]["element"];
+type RowAllocation = Record<PolicyElement, number>;
+export declare const LAYOUT_PRIORITY: readonly PolicyElement[];
+export declare const FULL_LAYOUT_ROWS: number;
+export type CockpitArrangement = "stacked" | "folded-keys" | "three-column";
+export interface FrameCockpitLayout {
+    renderer: "frame";
+    arrangement: CockpitArrangement;
+    elements: {
+        version: true;
+        keybar: true;
+        statusStrip: true;
+        primaryHeader: true;
+        progressBar: boolean;
+        progressCaption: boolean;
+        secondaryHeader: boolean;
+    };
+    stats: {
+        mode: "tiles" | "summary";
+        rows: number;
+        figures: readonly ["tasks", "gates", "pass"];
+    };
+    journalRows: number;
+    rowAllocation: {
+        chrome: number;
+    } & RowAllocation;
+}
+export interface PlainCockpitLayout {
+    renderer: "plain";
+    arrangement: "plain";
+}
+export type CockpitLayout = FrameCockpitLayout | PlainCockpitLayout;
+export declare function resolveCockpitLayout(columns: number, rows: number): CockpitLayout;
+export {};

package/dist/tui/cockpit/layout.js

@@ -0,0 +1,84 @@
+export const COCKPIT_ROW_FLOOR = 14;
+export const COCKPIT_COLUMN_FLOOR = 40;
+export const FULL_JOURNAL_ROWS = 3;
+const FRAME_CHROME_ROWS = 8;
+/**
+ * Ordered from highest priority (last surrendered) to lowest (first
+ * surrendered). A minimum row preserves an element in the compact frame; its
+ * preferred rows restore the full presentation before the next step receives
+ * any rows. The stats minimum is its one-line summary, not the full tiles.
+ */
+const ORDERED_POLICY = [
+    { element: "keybar", minimumRows: 1, preferredRows: 1 },
+    { element: "statusStrip", minimumRows: 1, preferredRows: 1 },
+    { element: "primaryHeader", minimumRows: 1, preferredRows: 1 },
+    { element: "progressBar", minimumRows: 1, preferredRows: 1 },
+    { element: "journal", minimumRows: 1, preferredRows: FULL_JOURNAL_ROWS },
+    { element: "progressCaption", minimumRows: 0, preferredRows: 1 },
+    { element: "statTiles", minimumRows: 1, preferredRows: 2 },
+    { element: "secondaryHeader", minimumRows: 0, preferredRows: 1 },
+];
+export const LAYOUT_PRIORITY = ORDERED_POLICY.map(({ element }) => element);
+export const FULL_LAYOUT_ROWS = FRAME_CHROME_ROWS +
+    ORDERED_POLICY.reduce((rows, step) => rows + step.preferredRows, 0);
+function arrangementFor(columns) {
+    if (columns >= 120)
+        return "three-column";
+    if (columns >= 90)
+        return "folded-keys";
+    return "stacked";
+}
+function allocateRows(rows) {
+    const allocation = Object.fromEntries(ORDERED_POLICY.map(({ element }) => [element, 0]));
+    let available = rows - FRAME_CHROME_ROWS;
+    // Preserve each element's compact form. At the contracted floor these
+    // minima consume the budget exactly.
+    for (const step of ORDERED_POLICY) {
+        const granted = Math.min(step.minimumRows, available);
+        allocation[step.element] = granted;
+        available -= granted;
+    }
+    // Restore full forms in priority order, never funding a lower-priority
+    // element while a higher-priority element remains compact.
+    for (const step of ORDERED_POLICY) {
+        const wanted = step.preferredRows - allocation[step.element];
+        const granted = Math.min(wanted, available);
+        allocation[step.element] += granted;
+        available -= granted;
+    }
+    // Once every element is full, journal history is the sole useful sink.
+    allocation.journal += available;
+    return allocation;
+}
+export function resolveCockpitLayout(columns, rows) {
+    if (!Number.isFinite(columns) ||
+        !Number.isFinite(rows) ||
+        columns < COCKPIT_COLUMN_FLOOR ||
+        rows < COCKPIT_ROW_FLOOR) {
+        return { renderer: "plain", arrangement: "plain" };
+    }
+    const allocation = allocateRows(Math.floor(rows));
+    return {
+        renderer: "frame",
+        arrangement: arrangementFor(Math.floor(columns)),
+        elements: {
+            version: true,
+            keybar: true,
+            statusStrip: true,
+            primaryHeader: true,
+            progressBar: allocation.progressBar > 0,
+            progressCaption: allocation.progressCaption > 0,
+            secondaryHeader: allocation.secondaryHeader > 0,
+        },
+        stats: {
+            mode: allocation.statTiles > 1 ? "tiles" : "summary",
+            rows: allocation.statTiles,
+            figures: ["tasks", "gates", "pass"],
+        },
+        journalRows: allocation.journal,
+        rowAllocation: {
+            chrome: FRAME_CHROME_ROWS,
+            ...allocation,
+        },
+    };
+}

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

@@ -0,0 +1,19 @@
+import { type ReactElement } from "react";
+import type { RunCockpitData } from "./derive.js";
+export { deriveRunCockpitData } from "./derive.js";
+export type { RunCockpitData } from "./derive.js";
+export { PANEL_CHROME_ROWS } from "./components.js";
+/**
+ * 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 declare function wrappedRows(text: string, columns: number): number;
+/** The rows a bordered panel occupies when its body wraps into `columns`. */
+export declare function panelRows(lines: readonly string[], columns: number): number;
+export declare function RunCockpitFrame({ data, columns, rows, }: {
+    data: RunCockpitData;
+    columns: number;
+    rows?: number;
+}): ReactElement;