tickmarkr 1.79.0 → 1.81.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/keys.d.ts

@@ -0,0 +1,149 @@
+/**
+ * THE key contract for the run cockpit. This registry is the single source of
+ * truth for both halves of a key: what the keybar advertises and what the key
+ * does. The keybar's entries are derived from these bindings (`keybarEntries`),
+ * so a key with no registered handler cannot be drawn — an advertised key that
+ * does nothing is not expressible.
+ */
+/** The subset of an ink key event the run bindings discriminate on. */
+export type RunKeyEvent = {
+    readonly input: string;
+    readonly key: {
+        readonly upArrow?: boolean;
+        readonly downArrow?: boolean;
+        readonly leftArrow?: boolean;
+        readonly return?: boolean;
+        readonly tab?: boolean;
+        readonly escape?: boolean;
+        readonly backspace?: boolean;
+        readonly delete?: boolean;
+        readonly ctrl?: boolean;
+    };
+};
+/**
+ * The observable interaction state of the run surface. RunCockpitFrame renders
+ * every field of it — selection pointer, panel focus, opened event, follow
+ * indicator, filter prompt, help overlay — so the initial state below renders
+ * byte-identical to a frame that carries no interaction state at all, and every
+ * transition away from it is a change an operator can see.
+ */
+export type RunInteractionState = {
+    /** The journal row the pointer marks — moved by ↑↓, -1 while nothing is selected. */
+    readonly selection: number;
+    /** The focused panel, index into RUN_PANEL_FOCUS_ORDER — cycled by Tab. */
+    readonly panel: number;
+    /** The selection opened by ⏎, or null once ← returns from it. */
+    readonly opened: number | null;
+    /** Follow mode — toggled by f; drawn as a status-strip indicator while on. */
+    readonly follow: boolean;
+    /** The / prompt is open and taking filter text. */
+    readonly filterPrompt: boolean;
+    /** The text the journal is narrowed to — empty shows every row. */
+    readonly filterQuery: string;
+    /** Help overlay — toggled by ?. */
+    readonly help: boolean;
+    /** Quit requested by q. */
+    readonly quit: boolean;
+};
+export declare function initialRunInteractionState(): RunInteractionState;
+/**
+ * The panels Tab cycles focus through, in cycle order; index 0 is the focus
+ * the surface opens with, so the initial frame is the one the anchors pin.
+ */
+export declare const RUN_PANEL_FOCUS_ORDER: readonly ["RUN", "VIEWS", "KEYS"];
+export type RunKeyBinding = {
+    /** The glyph the keybar draws, e.g. "↑↓". */
+    readonly key: string;
+    /** The promise the keybar draws next to the glyph, e.g. "Move". */
+    readonly label: string;
+    /** Whether a key event activates this binding. */
+    readonly matches: (event: RunKeyEvent) => boolean;
+    /** The state transition the label promises. */
+    readonly apply: (state: RunInteractionState, event: RunKeyEvent) => RunInteractionState;
+    /**
+     * How a binding that carries on/off state reports it — the brand's reserved
+     * toggle glyphs, never bracket toggles. Present exactly on the bindings
+     * whose state is on/off.
+     */
+    readonly report?: (state: RunInteractionState) => string;
+};
+/** A toggle's on/off report: the brand's reserved glyphs, never brackets. */
+export declare function toggleReport(label: string, on: boolean): string;
+/**
+ * Every key the run surface advertises, in keybar order. Each entry carries
+ * its handler, so advertisement and behaviour cannot drift apart.
+ */
+export declare const RUN_KEY_BINDINGS: readonly RunKeyBinding[];
+/** The panels the setup surface cycles through, in their painted order. */
+export declare const SETUP_PANEL_FOCUS_ORDER: readonly ["SETUP", "HARNESSES", "KEYS"];
+/**
+ * The observable state owned by setup's bindings. Its initial value is the
+ * already-pinned setup frame: step two, the harness body focused, nothing
+ * selected, no modal action open. Every handler moves away from that state in
+ * a way SetupCockpitFrame paints.
+ */
+export type SetupInteractionState = {
+    readonly selection: number;
+    readonly panel: number;
+    readonly step: number;
+    readonly selected: readonly number[];
+    readonly all: boolean;
+    readonly probeRevision: number;
+    readonly savePrompt: boolean;
+    readonly saved: boolean;
+    readonly help: boolean;
+    readonly quit: boolean;
+};
+export declare function initialSetupInteractionState(): SetupInteractionState;
+export type SetupKeyBinding = {
+    readonly key: string;
+    readonly label: string;
+    readonly matches: (event: RunKeyEvent) => boolean;
+    readonly apply: (state: SetupInteractionState, event: RunKeyEvent) => SetupInteractionState;
+    readonly report?: (state: SetupInteractionState) => string;
+};
+/**
+ * Every setup advertisement and handler, in the exact order the surface has
+ * always drawn. The global six are registered here with setup semantics; the
+ * six setup-only bindings follow them on the same surface registry.
+ */
+export declare const SETUP_KEY_BINDINGS: readonly SetupKeyBinding[];
+/** One surface-aware registry serves both cockpit renderers and dispatchers. */
+export declare const SURFACE_KEY_BINDINGS: {
+    readonly run: readonly RunKeyBinding[];
+    readonly setup: readonly SetupKeyBinding[];
+};
+/** Save confirmation owns input until it is accepted or dismissed. */
+export declare function applySetupPromptInput(event: RunKeyEvent, state: SetupInteractionState): SetupInteractionState | undefined;
+/**
+ * The transitions of the open / prompt. The prompt is not an advertised key,
+ * so it has no binding — but its transitions live here beside the registry
+ * because they rewrite the same interaction state: characters grow the query,
+ * backspace shrinks it, ⏎ applies it (the journal stays narrowed), escape
+ * cancels it. Anything else the prompt swallows unchanged.
+ */
+export declare function applyFilterInput(event: RunKeyEvent, state: RunInteractionState): RunInteractionState | undefined;
+/** What an advertisement looks like once the handler is stripped away. */
+export type KeybarEntry = {
+    readonly key: string;
+    readonly label: string;
+};
+/**
+ * The keybar's entries, derived from a binding registry. This is the only way
+ * a keybar list is produced: remove a handler and its entry disappears.
+ */
+export declare function keybarEntries(bindings: readonly {
+    readonly key: string;
+    readonly label: string;
+}[]): readonly KeybarEntry[];
+/** The binding a key event activates, or undefined when no handler owns it. */
+export declare function resolveRunKeyBinding(bindings: readonly RunKeyBinding[], event: RunKeyEvent): RunKeyBinding | undefined;
+/**
+ * Send a key event to the registry: the matching binding's handler produces
+ * the next interaction state. An event no handler owns changes nothing.
+ */
+export declare function dispatchRunKey(event: RunKeyEvent, state: RunInteractionState, bindings?: readonly RunKeyBinding[]): RunInteractionState | undefined;
+/** The setup binding a key event activates, or undefined when none owns it. */
+export declare function resolveSetupKeyBinding(bindings: readonly SetupKeyBinding[], event: RunKeyEvent): SetupKeyBinding | undefined;
+/** Send a key event through the setup half of the shared surface registry. */
+export declare function dispatchSetupKey(event: RunKeyEvent, state: SetupInteractionState, bindings?: readonly SetupKeyBinding[]): SetupInteractionState | undefined;