// Pure, DOM-free logic for the run-detail tabs and the stage pane, ported from // the Android client so the browser says and shows exactly the same things: // ui/screens/RunDetailScreen.kt the tab set (RUN_DETAIL_TABS) // ui/screens/RunSummaryTab.kt the summary rows and identity line // ui/screens/RunFieldSectionsTab.kt input/output field sections // ui/screens/Timeline.kt runTimeline, timelineDescription, hasArtifacts // ui/graph/StageDetailPane.kt runStepFields, headline/evidence split, // stageSectionSpecs, stageDefinitionFields, // controlVisitLabel, clampVisitIndex // ui/graph/StageVerdict.kt verdictReasonSegments, referencedVerdictArtifacts // ui/Format.kt displayText/displayMap, fileChangeLine, // notificationLine, fileChangesSummary // data/protocol/GraphSemantics.kt nodeLabel, outcome ordering, edge labels // ui/graph/GraphPalette.kt the curated graph-only outcome palette // // Nothing here touches the DOM or imports the app: every function is pure so the // wording, ordering, counting and formatting can be unit-tested without a // browser. The tab/pane wiring lives in app.js. Every server-provided string is // only ever compared or rendered, never parsed as markup; the caller sets it // with textContent. import { runIdentity, visitCount, formatDuration, durationSeconds, secondsSince, formatLocalTimestamp, runStateOf, } from "./runs.js"; import { presentedArtifacts, sessionExportArtifact, stageArtifacts, visitArtifacts, displayVisit } from "./artifacts.js"; import { changeStat, parseUnifiedPatch, runChanges, runChangesHeader } from "./changes.js"; import { effectiveStageType } from "./templates.js"; // --------------------------------------------------------------------------- // Tabs // --------------------------------------------------------------------------- /** * The run-detail tabs, Summary first so it is the default selection. The Graph * tab sits between Summary and Input (R5) and mounts the shared workflow graph * in run mode. The timeline keeps Android's stable key `steps` with the visible * title `Timeline`. */ export const RUN_DETAIL_TABS = [ { key: "summary", label: "Summary" }, { key: "graph", label: "Graph" }, { key: "input", label: "Input" }, { key: "output", label: "Output" }, { key: "steps", label: "Timeline" }, ]; /** * The tabs the browser renders. Input and Output are run Summary sections now * (alongside Artifacts and Files changed), not separate tabs; the stable keys * `input`/`output` remain in RUN_DETAIL_TABS for Android parity and old routes. */ export const RENDERED_RUN_TABS = [ { key: "summary", label: "Summary" }, { key: "graph", label: "Graph" }, { key: "steps", label: "Timeline" }, ]; // The empty-state sentences, exactly as the app spells them. export const EMPTY_INPUT_MESSAGE = "No input recorded."; export const EMPTY_OUTPUT_MESSAGE = "No output recorded."; export const EMPTY_TIMELINE_MESSAGE = "No visits recorded."; export const NO_STAGE_DETAILS_MESSAGE = "No details recorded for this node."; /** The original run prompt, without display formatting or a fallback source. */ export function originalRunPrompt(run) { return typeof run?.input?.prompt === "string" ? run.input.prompt : undefined; } /** The stage-pane section titles (Android StageDetailPane constants). */ export const STAGE_ARTIFACTS_TITLE = "Artifacts"; export const STAGE_SESSION_TITLE = "Session"; export const STAGE_EVIDENCE_TITLE = "This run"; export const STAGE_DEFINITION_TITLE = "Stage definition"; // --------------------------------------------------------------------------- // Field display (ui/Format.kt displayText / displayMap) // --------------------------------------------------------------------------- /** * Compact rendering of an arbitrary JSON value for read-only display: a * primitive verbatim, an array `, `-joined, an object `k=v` `, `-joined. * Mirrors Format.kt JsonElement.displayText (a JSON null reads `null`). */ export function displayText(value) { if (Array.isArray(value)) return value.map((item) => displayText(item)).join(", "); if (value !== null && typeof value === "object") { return Object.entries(value) .map(([key, item]) => `${key}=${displayText(item)}`) .join(", "); } if (value === undefined) return "null"; return String(value); } /** * A field map rendered one `key: value` line per entry, in insertion order. * Mirrors Format.kt Map?.displayMap (a null/empty map is * the empty string). */ export function displayMap(map) { if (!map) return ""; return Object.entries(map) .map(([key, value]) => `${key}: ${displayText(value)}`) .join("\n"); } /** * The input/output tab's sections, one per map entry in insertion order: the * entry's own key as the title (falling back to the section prefix so it is * never empty) and the value's display text. Mirrors * RunFieldSectionsTab.fieldSectionTitle + displayText. */ export function fieldSections(map, keyPrefix) { if (!map) return []; return Object.entries(map).map(([key, value]) => ({ key, title: fieldSectionTitle(key, keyPrefix), value: displayText(value), })); } /** A field section's title: the field's own name, else the section prefix. */ export function fieldSectionTitle(key, keyPrefix) { const text = String(key ?? ""); return text.trim() === "" ? keyPrefix : text; } // --------------------------------------------------------------------------- // Run summary (ui/screens/RunSummaryTab.kt) // --------------------------------------------------------------------------- /** * The summary rows in Android order: Pipeline `id {id} · v{version}`, Stage, the * resource-wait line only when `resource_wait` is set, Workspace, Content hash * (monospace), Started, Finished, the live-aware Duration, `Retry of run {n}` * when set, and the Diagnostic block. Blank values are omitted so no empty row * is ever drawn. Each entry is tagged with a `kind` so the renderer can style * and (for `duration`) live-update it. */ export function summaryRows(run, nowMillis, options = {}) { if (!run) return []; const rows = []; const kv = (key, value, monospace = false) => { const text = String(value ?? ""); if (text.trim() === "") return; rows.push({ kind: "kv", key, value: text, monospace }); }; if (Number(run.pipeline_id) > 0) { rows.push({ kind: "pipeline", key: "Pipeline", value: `id ${run.pipeline_id} · v${run.version ?? 0}`, pipelineId: Number(run.pipeline_id), pipelineName: String(run.name ?? ""), version: Number(run.version) || 0, }); } else { kv("Pipeline", `id ${run.pipeline_id ?? 0} · v${run.version ?? 0}`); } kv("Stage", run.current_stage); const wait = resourceWaitLine(run); if (wait) rows.push({ kind: "wait", value: wait }); kv("Workspace", run.workspace); kv("Content hash", run.content_hash, true); kv("Started", formatLocalTimestamp(run.created_at, options)); kv("Finished", formatLocalTimestamp(run.finished_at, options)); const duration = runDurationText(run, nowMillis); if (duration != null) rows.push({ kind: "duration", key: "Duration", value: duration }); if (Number(run.retry_of) > 0) kv("Retry of", `run ${run.retry_of}`); if (String(run.diagnostic ?? "").trim() !== "") { rows.push({ kind: "block", key: "Diagnostic", value: String(run.diagnostic) }); } return rows; } /** * The resource-wait line, `Waiting for resource {name}`, only when the run is * waiting on a resource. Mirrors RunSummaryTab's `run.resourceWait?.let { ... }` * and ResourceWait.statusLabel. */ export function resourceWaitLine(run) { if (!run || run.resource_wait == null) return ""; return `Waiting for resource ${String(run.resource_wait.resource ?? "")}`; } /** * The run's identity line: `run {id} · {recorded visits} · {completed visits}`, * the same recorded/completed vocabulary the runs list and the server use. * Mirrors RunSummaryTab's buildString. */ export function runIdentityLine(run) { if (!run) return ""; const recorded = visitCount((run.steps ?? []).length, "recorded"); const completed = visitCount(Number(run.completed_steps) || 0, "completed"); return `run ${run.id} · ${recorded} · ${completed}`; } /** * The run's primary label (stored title, else the pipeline name), from the one * runIdentity helper the runs list also uses so the two never disagree. */ export function runLabelFor(run) { return runIdentity(run?.title, run?.name).label; } /** * The summary's Duration value: live elapsed while executing, else the stored * total. Mirrors Format.kt runDurationText (null when unavailable, so the caller * omits the row). */ export function runDurationText(run, nowMillis) { if (!run) return null; if (run.executing) { const elapsed = secondsSince(run.created_at, nowMillis); return elapsed == null ? null : formatDuration(elapsed); } const total = durationSeconds(run.created_at, run.finished_at); return total == null ? null : formatDuration(total); } // --------------------------------------------------------------------------- // Timeline (ui/screens/Timeline.kt) // --------------------------------------------------------------------------- /** * The run's timeline plus each stage's ordered visits, derived in one pass. * Stages keep first-appearance order; a stage's visits are ordered by sequence. * One entry per recorded visit, in step order, with the display visit number, * the outcome chip label (`outcome` else `status`), whether the visit recorded * artifacts, its duration and its one-line description. Pure and total over an * empty list and blank control/outcome fields. Mirrors `runTimeline`. */ export function runTimeline(steps) { const list = steps ?? []; if (list.length === 0) return { entries: [], visitsByStage: new Map() }; const visitsByStage = new Map(); for (const step of list) { const stage = step?.stage ?? ""; if (!visitsByStage.has(stage)) visitsByStage.set(stage, []); visitsByStage.get(stage).push(step); } const indexByStageSequence = new Map(); for (const [stage, visits] of visitsByStage) { [...visits] .sort((a, b) => (a?.sequence ?? 0) - (b?.sequence ?? 0)) .forEach((visit, index) => indexByStageSequence.set(`${stage}\u0000${visit?.sequence ?? 0}`, index)); } const entries = list.map((step) => { const index = indexByStageSequence.get(`${step?.stage ?? ""}\u0000${step?.sequence ?? 0}`) ?? 0; return { step, stageKey: step?.stage ?? "", visit: displayVisit(step, index), visitIndex: index, outcomeLabel: String(step?.outcome ?? "").trim() !== "" ? String(step.outcome) : String(step?.status ?? ""), hasArtifacts: hasArtifacts(step), duration: stepDuration(step), description: timelineDescription(step), }; }); const orderedVisits = new Map(); for (const [stage, visits] of visitsByStage) { orderedVisits.set( stage, [...visits].sort((a, b) => (a?.sequence ?? 0) - (b?.sequence ?? 0)), ); } return { entries, visitsByStage: orderedVisits }; } /** * The brief one-line description after a visit's name: the first non-blank * diagnostic line, else the resolved target, else nothing (never fabricated). */ export function timelineDescription(step) { const diagnostic = String(step?.diagnostic ?? ""); const line = diagnostic.split(/\r?\n/).find((candidate) => candidate.trim() !== ""); if (line != null) return line.trim(); const target = String(step?.target ?? ""); if (target.trim() !== "") return `→ ${nodeLabel(target)}`; return ""; } /** * Whether a visit recorded any presented artifact. The retired session markdown * is not presented, so it never counts. Composes the one presentedArtifacts * filter so the timeline and the pane never disagree. */ export function hasArtifacts(step) { return presentedArtifacts(step).length > 0; } /** Human duration between a step's timestamps, or null when unavailable. */ export function stepDuration(step) { const seconds = durationSeconds(step?.started_at, step?.finished_at); return seconds == null ? null : formatDuration(seconds); } // --------------------------------------------------------------------------- // Graph semantics (data/protocol/GraphSemantics.kt, Message.kt) // --------------------------------------------------------------------------- export const SUCCESS_END = "#success"; export const FAILURE_END = "#failure"; /** A node label: the success/failure terminal shorthand, else the key itself. */ export function nodeLabel(key) { if (key === SUCCESS_END) return "SUCCESS"; if (key === FAILURE_END) return "FAILURE"; return String(key ?? ""); } /** Whether a resolved target is an explicit terminal. */ export function isTerminal(target) { return target === SUCCESS_END || target === FAILURE_END; } /** Mirrors Protocol.resolveTarget: preserve `#` as the outcome's terminal. */ export function resolveTarget(outcome, target) { if (target !== "#") return target; return outcome === "error" ? FAILURE_END : SUCCESS_END; } /** A stage's outcomes (edge keys) in the app's order: success, others, error. */ export function stageOutcomes(stage) { return Object.keys(stage?.edges ?? {}).sort((a, b) => { const pa = a === "success" ? 0 : a === "error" ? 2 : 1; const pb = b === "success" ? 0 : b === "error" ? 2 : 1; return pa - pb || (a < b ? -1 : a > b ? 1 : 0); }); } /** Every definition edge in stable order. Mirrors Graph.edges(). */ export function graphEdges(graph) { const result = []; for (const stage of graph?.stages ?? []) { for (const outcome of stageOutcomes(stage)) { const target = resolveTarget(outcome, stage.edges[outcome]); result.push({ source: stage.key, outcome, target, label: outcome === "error" && stage.fallback_error ? "error*" : outcome, }); } } return result; } /** * Which stages and routes a run actually recorded, for the graph's execution * highlighting. Mirrors Android `RunGraphState.from` (GraphSemantics.kt:91-116): * every step's stage key is a visited stage (insertion order), a step with a * non-blank outcome and target contributes a taken route * `{source, outcome, resolvedTarget}` (recorded as a `source\0outcome\0target` * key the graph matches) and, when that resolved target is a terminal, marks the * terminal visited too. `currentStage` is the run's own stage, else the last * visit's stage, else null; `executing` mirrors the run; `currentStageStartedAt` * is the running visit's start for the active stage, only while executing. Pure * and DOM-free so the renderer and the tests share one definition. */ export function runGraphState(run) { const visitedStages = []; const seenStages = new Set(); const takenRoutes = []; const seenRoutes = new Set(); const steps = run?.steps ?? []; const visit = (key) => { if (key == null || seenStages.has(key)) return; seenStages.add(key); visitedStages.push(key); }; for (const step of steps) { visit(step?.stage); const outcome = String(step?.outcome ?? ""); const target = String(step?.target ?? ""); if (target.trim() !== "" && outcome.trim() !== "") { const resolved = resolveTarget(outcome, target); const route = `${step?.stage}\u0000${outcome}\u0000${resolved}`; if (!seenRoutes.has(route)) { seenRoutes.add(route); takenRoutes.push(route); } if (isTerminal(resolved)) visit(resolved); } } const lastStage = steps.length > 0 ? steps[steps.length - 1]?.stage : ""; const rawCurrent = String(run?.current_stage ?? "").trim() !== "" ? run.current_stage : lastStage; const currentStage = String(rawCurrent ?? "").trim() !== "" ? String(rawCurrent) : null; const executing = Boolean(run?.executing); let currentStageStartedAt = null; if (executing && currentStage != null) { for (let index = steps.length - 1; index >= 0; index -= 1) { const step = steps[index]; if (step?.stage === currentStage && step?.status === "running") { const started = String(step?.started_at ?? ""); if (started.trim() !== "") currentStageStartedAt = started; break; } } } return { visitedStages, takenRoutes, currentStage, executing, currentStageStartedAt }; } // --------------------------------------------------------------------------- // Stage pane (ui/graph/StageDetailPane.kt) // --------------------------------------------------------------------------- /** One labelled row/block of stage detail, rendered by the pane. */ function field(label, value, mono = false, block = false) { return { label, value, mono, block }; } /** * The always-visible run-side identity/result labels of a step. The item's * headline list adds `Session` beside the app's six, so a visit that recorded a * session id shows it up top with the rest of its result facts. */ export const STAGE_HEADLINE_LABELS = new Set([ "Status", "Outcome", "Target", "Duration", "Visit", "Model target", "Session", ]); /** The always-visible run-side identity/result fields of a step's evidence. */ export function headlineFields(fields) { return (fields ?? []).filter((entry) => STAGE_HEADLINE_LABELS.has(entry.label)); } /** * The remaining run evidence (diagnostic, transcript, agent, file changes, * notifications) that belongs in the collapsible "This run" section: the * headline facts and the input/output result blocks are surfaced elsewhere. */ export function evidenceFields(fields) { return (fields ?? []).filter( (entry) => !STAGE_HEADLINE_LABELS.has(entry.label) && entry.label !== "Input" && entry.label !== "Output", ); } /** * The pure run view of one step: status, outcome, duration, visit against the * control's max visits, target, session id, agent flag, diagnostic, transcript, * the step's input/output, a file-change summary, changed files and notification * receipts. Blank fields are skipped, so no empty row is ever emitted. Mirrors * `runStepFields`. */ /** What an empty turn body reads as, matching input.md's own marker. */ const NO_TURN_OUTPUT = "_(no output)_"; /** * A turn's value map carries the whole markdown body under the single key * `markdown`. Returns that body so the pane can render it as the document it is; * null means an ordinary map that still needs its keys shown. */ function turnBody(map) { if (!map || typeof map !== "object") return null; const keys = Object.keys(map); if (keys.length !== 1 || keys[0] !== "markdown" || typeof map.markdown !== "string") return null; return map.markdown; } export function runStepFields(step) { const fields = []; if (step == null) return fields; if (str(step.status).trim() !== "") fields.push(field("Status", str(step.status))); if (str(step.outcome).trim() !== "") fields.push(field("Outcome", str(step.outcome))); const duration = stepDuration(step); if (duration != null) fields.push(field("Duration", duration)); const control = step.control; if (control) { if (Number(control.max_visits) > 0 || Number(control.visit) > 0) { fields.push(field("Visit", controlVisitLabel(control))); } const modelTarget = str(control.model_target); if (modelTarget.trim() !== "") fields.push(field("Model target", modelTarget)); } if (str(step.target).trim() !== "") fields.push(field("Target", str(step.target))); if (str(step.session_id).trim() !== "") fields.push(field("Session", str(step.session_id), true)); if (step.agent_active) fields.push(field("Agent", "active")); if (str(step.diagnostic).trim() !== "") fields.push(field("Diagnostic", str(step.diagnostic), false, true)); if (str(step.transcript).trim() !== "") fields.push(field("Transcript", str(step.transcript), false, true)); if (step.input && Object.keys(step.input).length > 0) { const body = turnBody(step.input); fields.push( body == null ? field("Input", displayMap(step.input), false, true) : field("Input", body.trim() === "" ? NO_TURN_OUTPUT : body, false, true), ); } if (step.output && Object.keys(step.output).length > 0) { const body = turnBody(step.output); fields.push( body == null ? field("Output", displayMap(step.output), false, true) : field("Output", body.trim() === "" ? NO_TURN_OUTPUT : body, false, true), ); } const changes = step.file_changes; if (changes) { const summary = fileChangesSummary(changes); if (summary.trim() !== "") fields.push(field("File changes", summary)); const files = changes.files ?? []; if (files.length > 0) { fields.push(field("Changed files", files.map((file) => fileChangeLine(file)).join("\n"), false, true)); } } for (const receipt of step.notifications ?? []) { if (str(receipt?.status).trim() !== "" || str(receipt?.destination).trim() !== "") { fields.push(field("Notification", notificationLine(receipt))); } } return fields; } /** * The stage definition view: key + type title, prompt, output, edges with their * outcomes and resolved terminals, configs, tools, limits and memory sources. * Only non-blank fields are emitted. Mirrors `stageDefinitionFields`. */ export function stageDefinitionFields(stage) { const fields = []; if (stage == null) return fields; fields.push(field("Type", effectiveStageType(stage.type))); if (str(stage.prompt).trim() !== "") fields.push(field("Prompt", str(stage.prompt), false, true)); if (str(stage.output).trim() !== "") fields.push(field("Output", str(stage.output), false, true)); const outcomes = stageOutcomes(stage).map((outcome) => { const target = resolveTarget(outcome, String(stage.edges?.[outcome] ?? "")); const suffix = isTerminal(target) ? " (terminal)" : ""; return `${outcome} → ${nodeLabel(target)}${suffix}`; }); if (outcomes.length > 0) fields.push(field("Outcomes", outcomes.join("\n"), false, true)); const configs = stage.configs ?? {}; for (const key of Object.keys(configs).sort()) { const value = str(configs[key]); if (value.trim() !== "") fields.push(field(configLabel(key), value)); } const tools = stage.blocks?.tools; if (str(tools).trim() !== "") fields.push(field("Tools", str(tools), false, true)); const limits = stage.limits; if (limits) { if (Number(limits.max_visits) > 0) fields.push(field("Max visits", String(limits.max_visits))); const on = limits.on ?? []; if (on.length > 0) fields.push(field("Limit on", on.join(", "))); } const memory = stage.memory; if (memory && Object.keys(memory).length > 0) { const value = Object.entries(memory) .map(([key, source]) => `${key}: ${source}`) .join("\n"); fields.push(field("Memory", value, false, true)); } const notify = stage.notify; if (notify) { const on = notify.on ?? []; if (on.length > 0) fields.push(field("Notify on", on.join(", "))); if (str(notify.destination).trim() !== "") fields.push(field("Notify destination", str(notify.destination))); const artifacts = notify.artifacts ?? []; if (artifacts.length > 0) fields.push(field("Notify artifacts", artifacts.join(", "))); } return fields; } /** The config key's display label (mirrors StageDetailPane.configLabel). */ export function configLabel(key) { switch (key) { case "provider": return "Provider"; case "model": return "Model"; case "retries": return "Retries"; case "timeout": return "Timeout"; case "budget_usd": return "Budget (USD)"; case "budget_tokens": return "Budget (tokens)"; case "harness": return "Harness"; default: return key; } } /** Incoming routes into a terminal node, for a pane opened on a terminal. */ export function terminalFields(graph, key) { const lines = graphEdges(graph) .filter((edge) => edge.target === key) .map((edge) => `${edge.source} · ${edge.label} → ${nodeLabel(key)}`); return lines.length === 0 ? [] : [field("Incoming routes", lines.join("\n"), false, true)]; } /** * The shared visit label for a step's control evidence, e.g. * `3 / 5 (limit reached)` (or just `3` when no max is recorded). Mirrors * `controlVisitLabel`. */ export function controlVisitLabel(control) { const visit = Number(control?.visit) || 0; const max = Number(control?.max_visits) || 0; const base = max > 0 ? `${visit} / ${max}` : String(visit); return base + (control?.limit_reached ? " (limit reached)" : ""); } /** Clamps a visit index into `[0, count)`; an empty list yields 0. */ export function clampVisitIndex(index, count) { if (count <= 0) return 0; return Math.min(Math.max(Number(index) || 0, 0), count - 1); } /** * The ordered sections of the stage pane for one stage and visit: a run pane * leads with the visit's Artifacts gallery, then its exported Session when it * has one, then Output, Input and the remaining evidence (`This run`); the * stage's own definition is last. Blank field sections are skipped; the * artifacts section always shows for a reached visit. Mirrors * `stageSectionSpecs`. */ /** * Whether a recorded field value is markdown rather than plain text: a heading, a * fenced block, a bullet/ordered list or a table. The new stage turns write * markdown bodies (`# outcome` …), while historical steps store plain maps; this * keeps the old ones rendering as code. */ export function looksLikeMarkdown(value) { const text = typeof value === "string" ? value : ""; if (!text) return false; return /^#{1,6}\s/m.test(text) || /```/.test(text) || /^\s*(?:[-*]|\d+\.)\s+/m.test(text) || /^\|.+\|/m.test(text); } /** * The stage pane's body sections for one visit: what the stage produced (its * non-system artifacts) and what it changed. The turn files, session export and * stage definition live behind Audit & debug, so the pane stays about the work. */ export function stageSectionSpecs(stageKey, graph, runSteps, visitIndex, runContext, allSteps = null) { const specs = []; const steps = runSteps ?? []; const selectedStep = steps[clampVisitIndex(visitIndex, steps.length)]; if (runContext && selectedStep != null) { const used = visitArtifacts(selectedStep, allSteps ?? steps).length; specs.push({ key: "artifacts", title: `${STAGE_ARTIFACTS_TITLE} · ${used} recorded`, artifacts: true }); if (selectedStep.file_changes != null) { specs.push({ key: "changes", title: runChangesHeader(runChanges([selectedStep])), changes: true }); } } return specs; } // --------------------------------------------------------------------------- // Verdict (ui/graph/StageVerdict.kt) // --------------------------------------------------------------------------- /** * The recorded artifacts a verdict refers to: its referenced names resolved to * the visit's recorded artifacts, in recorded order and deduplicated by name. A * name the server never recorded is dropped. Mirrors * `referencedVerdictArtifacts`. */ export function referencedVerdictArtifacts(verdict, artifacts) { const names = verdict?.artifacts ?? []; if (names.length === 0) return []; const wanted = new Set(names); const seen = new Set(); const referenced = []; for (const artifact of artifacts ?? []) { const name = str(artifact?.name); if (name === "" || seen.has(name)) continue; seen.add(name); if (wanted.has(name)) referenced.push(artifact); } return referenced; } /** * Splits a reason into literal runs and references to the recorded artifacts it * names (by full name or basename). At the same index a longer token wins. With * nothing to reference the whole reason is one literal segment; an empty reason * yields no segments. Mirrors `verdictReasonSegments`. */ export function verdictReasonSegments(reason, references) { const text = String(reason ?? ""); if (text === "") return []; const list = references ?? []; if (list.length === 0) return [{ text }]; const tokens = []; for (const artifact of list) { const name = str(artifact?.name); tokens.push([name, artifact]); const base = artifactBaseName(name); if (base !== "" && base !== name) tokens.push([base, artifact]); } tokens.sort((a, b) => b[0].length - a[0].length); const segments = []; let literal = ""; let index = 0; while (index < text.length) { const match = tokens.find(([token]) => text.startsWith(token, index)); if (!match) { literal += text[index]; index++; } else { if (literal !== "") { segments.push({ text: literal }); literal = ""; } segments.push({ text: match[0], artifact: match[1] }); index += match[0].length; } } if (literal !== "") segments.push({ text: literal }); return segments; } /** The last path segment of a recorded artifact name (`shots/x.png` → `x.png`). */ export function artifactBaseName(name) { const text = str(name); const slash = Math.max(text.lastIndexOf("/"), text.lastIndexOf("\\")); return slash === -1 ? text : text.slice(slash + 1); } // --------------------------------------------------------------------------- // Formatting (ui/Format.kt) // --------------------------------------------------------------------------- /** * One changed-file line, e.g. `modified src/a.kt +3 -2 (truncated)`. The kind, * path and binary/truncated markers are Format.kt's exact spelling; the `+N -M` * stat is added when the recorded patch is readable (not binary) and parses to * at least one hunk, so a line never claims a line count it could not read. A * binary file keeps its marker and never gets a text stat. */ export function fileChangeLine(file) { const base = `${str(file?.kind)} ${str(file?.path)}`; const binary = file?.binary ? " (binary)" : ""; const truncated = file?.truncated ? " (truncated)" : ""; let stat = ""; if (!file?.binary) { const patch = str(file?.patch); if (patch.trim() !== "") { const parsed = parseUnifiedPatch(patch); if (parsed.hunks.length > 0) stat = changeStat(parsed.added, parsed.removed); } } return base + (stat !== "" ? ` ${stat}` : "") + binary + truncated; } /** One notification receipt, e.g. `delivered → ntfy · ok`, skipping a blank diagnostic. */ export function notificationLine(receipt) { const diagnostic = str(receipt?.diagnostic); const suffix = diagnostic.trim() !== "" ? ` · ${diagnostic}` : ""; return `${str(receipt?.status)} → ${str(receipt?.destination)}${suffix}`; } /** * A compact file-change summary, e.g. * `partial (2 files), 1 skipped, 3 omitted · Excluded protected files.`. * The status word, file count, skipped and omitted counts are the capture's own * honest facts; the trimmed diagnostic follows after ` · ` when present. Blank * parts are omitted, and an entirely blank change set renders as "". */ export function fileChangesSummary(changes) { let text = ""; const status = str(changes?.status).trim(); if (status !== "") text += status; const files = changes?.files ?? []; if (files.length > 0) { if (text !== "") text += " "; text += `(${files.length} files)`; } if (Number(changes?.skipped) > 0) { if (text !== "") text += ", "; text += `${changes.skipped} skipped`; } if (Number(changes?.omitted) > 0) { if (text !== "") text += ", "; text += `${changes.omitted} omitted`; } const diagnostic = str(changes?.diagnostic).trim(); if (diagnostic !== "") { if (text !== "") text += " · "; text += diagnostic; } return text; } // --------------------------------------------------------------------------- // Outcome colours (ui/graph/GraphPalette.kt, WorkflowGraph.outcomeColor) // --------------------------------------------------------------------------- /** * The fixed palette for the graph-only flow outcomes (rejected/exhausted/retry/ * approved/fast/missing) plus the reserved fallback slots. Mirrors * GraphPalette.colors. */ export const FLOW_OUTCOME_COLORS = [ "#F5A3A3", // rejected "#F5B37A", // exhausted "#7FD4E8", // retry "#C0A3F5", // approved "#F0E07A", // fast "#F5A3D0", // missing "#D8C98A", // fallback "#9FD8C0", // fallback "#D8A8C0", // fallback ]; const KNOWN_FLOW_OUTCOMES = ["rejected", "exhausted", "retry", "approved", "fast", "missing"]; /** * The stable palette index for an outcome with no run-state meaning: known flow * outcomes get their curated slot, everything else a stable fallback slot. * Mirrors GraphPalette.outcomeColorIndex. */ export function flowOutcomeIndex(outcome) { const known = KNOWN_FLOW_OUTCOMES.indexOf(outcome); if (known !== -1) return known; const fallbackStart = KNOWN_FLOW_OUTCOMES.length; const fallbackCount = FLOW_OUTCOME_COLORS.length - fallbackStart; if (fallbackCount <= 0) return 0; return fallbackStart + (Math.abs(hashString(outcome)) % fallbackCount); } /** * The colour token for an outcome/stage status: a run-state word takes the * shared status palette (`state {state}`), any other flow outcome its curated * palette slot (`flow {index}`). The renderer maps the token onto a CSS class so * the timeline and the verdict block agree. Mirrors WorkflowGraph.outcomeColor. */ export function outcomeColorToken(outcome, status) { const state = runStateOf(String(outcome ?? "").trim() !== "" ? outcome : status); if (state !== "unknown") return `state ${state}`; return `flow ${flowOutcomeIndex(String(outcome ?? "").trim() !== "" ? outcome : status)}`; } /** A distinct glyph per run state, echoing the app's one-glyph-per-state set. */ export function stateGlyph(state) { switch (state) { case "running": return "▶"; case "queued": return "◷"; case "waiting": return "✋"; case "succeeded": return "✓"; case "failed": return "✕"; case "canceled": return "⊘"; case "interrupted": return "❚❚"; case "blocked": return "■"; case "skipped": return "⏭"; case "active": return "⚡"; default: return "?"; } } // --------------------------------------------------------------------------- // Internals // --------------------------------------------------------------------------- function str(value) { return value == null ? "" : String(value); } /** A small, stable 31-bit string hash (Kotlin String.hashCode analogue). */ function hashString(value) { let hash = 0; for (let i = 0; i < value.length; i++) { hash = (hash * 31 + value.charCodeAt(i)) | 0; } return hash; }