diff --git a/web/PARITY.md b/web/PARITY.md index 53cb1473..888aa805 100644 --- a/web/PARITY.md +++ b/web/PARITY.md @@ -26,16 +26,16 @@ Status legend: `todo` · `partial` (some of it works) · `done` (working + captu | P3 | Pipeline detail: stages, graph, versions, last run, content hash | `get_pipeline` | done — Summary/Graph/Source tabs; Summary shows content hash (monospace), latest version (`v{n}` or blank), created/updated, and a collapsed-by-default Versions section. Graph tab shows the browser guidance note plus the rendered workflow graph (P6) | | P4 | Templates gallery + template detail | `list_templates`, `validate` | done | | P5 | Create pipeline from a template (validate then submit) | `validate`, `submit` | todo | -| P6 | Workflow graph rendering (nodes, edges, stage panes) | `get_pipeline` | done (captured 2026-10-19: nodes + labelled outcome edges + success/failure terminals, an opened stage definition pane and the expanded view — `captures/08-pipeline-graph.png`, `captures/08a-pipeline-graph-stage-pane.png`, `captures/08b-pipeline-graph-expanded.png`). Reusable `src/graph.js` (`mount` + pure helpers: layout, edges, `error*`, lanes, fit/clamp/zoom, hit-test, stage-definition fields); definition view only, so R5's run-detail Graph tab stays todo. Pane labels match the app's own vocabulary (`Outcomes`, `Tools`) rather than the checklist's category words | +| P6 | Workflow graph rendering (nodes, edges, stage panes) | `get_pipeline` | done (captured 2026-10-19: nodes + labelled outcome edges + success/failure terminals, an opened stage definition pane and the expanded view — `captures/08-pipeline-graph.png`, `captures/08a-pipeline-graph-stage-pane.png`, `captures/08b-pipeline-graph-expanded.png`). Reusable `src/graph.js` (`mount` + pure helpers: layout, edges, `error*`, lanes, fit/clamp/zoom, hit-test, stage-definition fields); the definition view (every route executed, no legend) plus, since R5, a run-mode view driven by `runState` (executed/not-executed stages and routes, the Executed / Not executed legend, the live halo/elapsed badge). Pane labels match the app's own vocabulary (`Outcomes`, `Tools`) rather than the checklist's category words | ## Runs | # | Feature | Protocol | Status | | --- | --- | --- | --- | | R1 | Run history list with status roll-up | `list_runs` | done | | R2 | Filter by status, sort, "needs you" markers | client-side | partial (status/pipeline/time filter + sort implemented and captured; the per-row "needs you" mark has no Android counterpart and its wording is deferred to R15, still todo) | -| R3 | Run detail: run fields, steps/visits, targets, sessions | `get_run` | done — tabbed Summary / Input / Output / Timeline; the Timeline opens a per-visit stage pane with the headline rows (Status, Outcome, Duration, Visit `{v} / {max}`, Model target, Target, Session), the Verdict block (option chip + reason with inline artifact links) and the visit sections Artifacts / Session / Output / Input / This run / Stage definition. Captured 2026-10-19: `captures/20-run-430-summary.png`, `captures/23-run-430-timeline.png`, `captures/24-run-430-stage-artifacts.png`, `captures/25-run-440-verdict.png` | -| R4 | Summary tab incl. collapsible **Changes** viewer (raw + rendered diff) | `get_run` file changes | todo | -| R5 | Graph tab (per-stage panes, verdicts) | `get_run` | todo | +| R3 | Run detail: run fields, steps/visits, targets, sessions | `get_run` | done — tabbed Summary / Graph / Input / Output / Timeline; the Timeline opens a per-visit stage pane with the headline rows (Status, Outcome, Duration, Visit `{v} / {max}`, Model target, Target, Session), the Verdict block (option chip + reason with inline artifact links) and the visit sections Artifacts / Session / Output / Input / This run / Stage definition. Captured 2026-10-19: `captures/20-run-430-summary.png`, `captures/23-run-430-timeline.png`, `captures/24-run-430-stage-artifacts.png`, `captures/25-run-440-verdict.png` | +| R4 | Summary tab incl. collapsible **Changes** viewer (raw + rendered diff) | `get_run` file changes | done — a collapsed-by-default **Changes** section in the Summary tab (`{N} file(s) changed · ±stat · partial capture`; the empty variants read `Changes · capture unavailable` / `capture pending` / `partial capture` / `not recorded for this run` / `capture incomplete` / `no changes observed`) whose rows open a full-screen diff viewer with **Rendered** (each `@@` hunk header on a raised surface, old/new gutter numbers, the shared `+`/`-`/space line language) and **Raw patch** forms, Previous/Next file paging (disabled at the ends), a raw-patch copy control, Escape/backdrop/Close close, and honest binary/truncated/no-patch messages instead of a fabricated diff. Pure logic in `src/changes.js`. Captured 2026-10-19: `captures/28-run-438-changes-collapsed.png`, `captures/29-run-438-changes-expanded.png`, `captures/30-run-438-changes-diff-rendered.png`, `captures/31-run-438-changes-diff-raw.png`, `captures/32-run-442-changes-binary.png`, `captures/33-run-450-changes-truncated.png`, `captures/34-run-455-changes-pending.png` | +| R5 | Graph tab (per-stage panes, verdicts) | `get_run` | done — the run detail's Graph tab (between Summary and Input) mounts the shared `src/graph.js` renderer in run mode with the app's run note: a visited stage is executed (solid fill + border), an unvisited one hollow with a dashed muted border, a terminal executed only when a visit resolved to it, a route executed only when a visit produced that outcome (solid with an arrowhead; success first, error last, others alphabetical, `error*` for a fallback error route), the Executed / Not executed legend (runs only, never the definition view), and — while executing — the current stage's pulsing halo + elapsed badge (a static ring under `prefers-reduced-motion`; nothing for a finished run). Clicking a stage opens the existing visit pane at that stage's latest visit with its Verdict; Back/Escape close it and restore focus. The empty state is the exact `This server did not include the run graph.` (unit-tested; no live run currently carries a graph-less payload). Captured 2026-10-19: `captures/28-run-438-graph.png` (finished run 438: legend + executed styling + dashed untaken routes), `captures/29-run-438-graph-pane.png` (a graph-opened stage pane showing a Verdict), `captures/30-run-440-graph.png` (failed run 440: hollow/dashed not-executed stages) | | R6 | Input / Output field sections per stage | `get_run` | done — one collapsed section per recorded entry, expanded as a monospace block (primitives verbatim, arrays `, `-joined, objects `k=v` `, `-joined), empty states "No input recorded." / "No output recorded.". Captured 2026-10-19: `captures/21-run-430-input.png`, `captures/22-run-430-output.png`, `captures/27-run-output-empty.png` | | R7 | Timeline | `get_run` | done — one compact row per visit (`{stage} · visit {n}`, stage-outcome chip, paperclip when artifacts recorded, duration, description = first non-blank diagnostic line else `→ {target}`); empty state "No visits recorded.". Captured 2026-10-19: `captures/23-run-430-timeline.png`, `captures/26-run-428-timeline-empty.png` | | R8 | Artifacts gallery + full-screen viewer (images inline, others download/open) | `GET /artifacts/…` | done (captured 2026-10-19: `captures/04-run-430-artifacts.png`, `captures/05-artifact-viewer.png`) | @@ -52,7 +52,15 @@ choice: the visit's exported session is titled **Session** (the item text said "Session export"; Android's `STAGE_SESSION_TITLE` is `Session`), and the step's `session_id` renders as a **headline** row (Status, Outcome, Duration, Visit, Model target, Target, Session), so it is not repeated in the "This run" evidence -section. R5 (Graph tab) deliberately leaves the tab's body unimplemented. +section. R5's Graph tab now renders that same shared graph in run mode (see the +row above), reusing the visit pane this section describes. + +One wording decision from R4, recorded here as the app-authoritative choice: the +Changes disclosure's title **is** `runChangesHeader`, so a run that recorded files +reads `{N} file(s) changed · ±stat · …` with no `Changes · ` prefix — only the +empty-capture variants carry the `Changes · ` prefix — while the expanded body's +own summary line repeats the count and stat. The header is rendered verbatim, not +re-composed. ## Search | # | Feature | Protocol | Status | diff --git a/web/src/app.js b/web/src/app.js index 0f2a7907..8d643c23 100644 --- a/web/src/app.js +++ b/web/src/app.js @@ -34,6 +34,8 @@ import { } from "./artifacts.js"; import { PIPELINE_GRAPH_EMPTY, + RUN_GRAPH_MISSING, + RUN_GRAPH_NOTE, mount as mountGraph, } from "./graph.js"; import { @@ -97,6 +99,7 @@ import { runLabelFor, runDurationText, runTimeline, + runGraphState, nodeLabel, headlineFields, runStepFields, @@ -107,6 +110,29 @@ import { outcomeColorToken, stateGlyph, } from "./runDetail.js"; +import { + BINARY_DIFF_MESSAGE, + NO_LINE_CHANGES_MESSAGE, + TRUNCATED_PATCH_NOTE, + ChangeKind, + changeKindLabel, + changeKindTitle, + changePositionLabel, + changeRowMeta, + changeStat, + changesListSummary, + diffLineClass, + diffLineSymbol, + entryHasPatch, + gutterText, + gutterWidth, + noChangeDetail, + parseUnifiedPatch, + patchUnavailableReason, + runChanges, + runChangesHeader, + runChangesNote, +} from "./changes.js"; const STORAGE_KEY = "pipelines.web.serverUrl.v2"; @@ -156,6 +182,10 @@ const state = { // handle is dropped on every re-render so its listeners can never leak. pipelineGraph: null, pipelineGraphExpanded: false, + // The mounted run-mode graph (R5) on the run detail's Graph tab. Dropped on + // every re-render and on a run change, so its wheel/pointer/resize listeners + // and its elapsed timer can never leak. + runGraph: null, versionsExpanded: false, pipelinesLoaded: false, runsLoaded: false, @@ -311,6 +341,10 @@ function renderContent() { state.pipelineGraph.unmount(); state.pipelineGraph = null; } + if (state.runGraph) { + state.runGraph.unmount(); + state.runGraph = null; + } const nodes = []; if (state.error) { nodes.push(h("div", { class: "banner error" }, h("strong", { text: "Error: " }), state.error)); @@ -1135,12 +1169,13 @@ function closeMenu() { } /** - * The run detail: a tab strip (Summary / Input / Output / Timeline) over the - * selected tab's body, wired from the pure helpers in runDetail.js. Summary is - * the default and carries the run's identity, key/value rows and diagnostic; - * Input/Output are one collapsed section per recorded field; the Timeline is one - * compact row per visit that opens the stage pane. Every server string is set - * with textContent, never innerHTML. + * The run detail: a tab strip (Summary / Graph / Input / Output / Timeline) over + * the selected tab's body, wired from the pure helpers in runDetail.js. Summary + * is the default and carries the run's identity, key/value rows and diagnostic; + * the Graph tab mounts the shared workflow graph in run mode; Input/Output are + * one collapsed section per recorded field; the Timeline is one compact row per + * visit that opens the stage pane. Every server string is set with textContent, + * never innerHTML. */ function renderRunDetail() { const d = state.runDetail; @@ -1165,7 +1200,9 @@ function renderRunDetail() { ), ), ); - if (state.runTab === "input") { + if (state.runTab === "graph") { + pane.append(renderRunGraphTab(d)); + } else if (state.runTab === "input") { pane.append(renderRunFieldTab(d.input, "input", EMPTY_INPUT_MESSAGE)); } else if (state.runTab === "output") { pane.append(renderRunFieldTab(d.output, "output", EMPTY_OUTPUT_MESSAGE)); @@ -1178,6 +1215,41 @@ function renderRunDetail() { return pane; } +/** + * The Graph tab (R5): the run's own guidance note plus the shared workflow graph + * mounted in run mode, or the app's exact missing-graph sentence when the server + * sent no stages. The active stage pulses with its elapsed time while the run + * executes; clicking a stage opens the existing visit pane at that stage's most + * recent visit. The mount handle is tracked in `state.runGraph` so a re-render + * (or a tab/run change) always unmounts the previous wheel/pointer/resize + * listeners and the elapsed timer. + */ +function renderRunGraphTab(d) { + const wrap = h("div", { class: "run-tab-body" }); + const stages = d.graph?.stages ?? []; + if (!stages.length) { + wrap.append(h("div", { class: "run-empty muted", text: RUN_GRAPH_MISSING })); + return wrap; + } + wrap.append(h("p", { class: "graph-note muted", text: RUN_GRAPH_NOTE })); + const host = h("div", { class: "graph-host" }); + wrap.append(host); + state.runGraph = mountGraph(host, d.graph, { + runState: runGraphState(d), + onStageTap: (key) => openStagePane(key, latestVisitIndex(d, key)), + }); + return wrap; +} + +/** + * The visit index the graph opens for a stage: its most recent recorded visit + * (`visits.size - 1`, never negative), exactly as RunGraphTab computes it. + */ +function latestVisitIndex(d, key) { + const visits = runTimeline(d.steps ?? []).visitsByStage.get(key) ?? []; + return Math.max(0, visits.length - 1); +} + /** The Summary tab: identity, chip row, key/value rows, diagnostic and gallery. */ function renderRunSummaryTab(d) { const wrap = h("div", { class: "run-tab-body" }); @@ -1207,6 +1279,14 @@ function renderRunSummaryTab(d) { renderArtifactGallery(d.steps ?? []), ), ); + + // The run-level Changes (parity R4), collapsed by default like the Android + // summary: the observed workspace diff. Its header alone states the file count + // and aggregate stat until expanded, and every file row opens the diff viewer. + const changes = runChanges(d.steps ?? []); + wrap.append( + renderCollapsible("summary-changes", runChangesHeader(changes), () => renderChangesBody(changes)), + ); return wrap; } @@ -1299,6 +1379,285 @@ function renderCollapsible(key, title, bodyFn) { return wrap; } +// --- Changes (parity R4) --------------------------------------------------- + +/** + * The Changes section body: the file-list summary line, the honest capture note + * (when the capture was not complete) and then either the no-change detail or + * one clickable row per changed file in first-seen order. Every server string is + * set as text, never as markup. + */ +function renderChangesBody(changes) { + const body = h("div", { class: "changes" }); + body.append(h("div", { class: "changes-summary", text: changesListSummary(changes) })); + const note = runChangesNote(changes); + if (note.trim() !== "") body.append(h("div", { class: "changes-note muted", text: note })); + if (changes.files.length === 0) { + body.append(h("div", { class: "changes-empty muted", text: noChangeDetail(changes) })); + return body; + } + const list = h("div", { class: "changes-list" }); + changes.files.forEach((entry, index) => list.append(renderChangeRow(entry, index, changes.files))); + body.append(list); + return body; +} + +/** The tone class for a file's kind: added green, deleted red, else neutral. */ +function changeKindTone(kind) { + if (kind === ChangeKind.Added) return "ok"; + if (kind === ChangeKind.Deleted) return "bad"; + return "muted"; +} + +/** + * One changed-file row: the kind word in its hue, the path in monospace, the + * `+N -M` stat and the `changed by …` meta line. Clicking (or Enter/Space) opens + * the diff viewer on this file, whose position there confirms which row it is. + */ +function renderChangeRow(entry, index, files) { + const open = () => openChangeViewer(files, index); + const row = h("div", { + class: "change-row", + role: "button", + tabindex: "0", + "data-change-index": String(index), + "aria-label": `Open ${entry.path}`, + }); + row.addEventListener("click", open); + row.addEventListener("keydown", (event) => { + if (event.key === "Enter" || event.key === " ") { + event.preventDefault(); + open(); + } + }); + row.append(h("span", { class: `change-kind ${changeKindTone(entry.kind)}`, text: changeKindLabel(entry.kind) })); + const main = h("div", { class: "change-main" }); + main.append(h("div", { class: "change-path monospace", text: entry.path })); + main.append(h("div", { class: "change-meta muted", text: changeRowMeta(entry) })); + row.append(main); + const stat = h("div", { class: "change-stat" }); + if (entry.added > 0) stat.append(h("span", { class: "stat-add", text: `+${entry.added}` })); + if (entry.removed > 0) stat.append(h("span", { class: "stat-del", text: `-${entry.removed}` })); + row.append(stat); + return row; +} + +let changeViewerOverlay = null; +let changeViewerKeydown = null; +let changeViewerIndex = null; + +/** Close the diff viewer, returning focus to the row that opened it. */ +function closeChangeViewer() { + if (changeViewerKeydown) { + document.removeEventListener("keydown", changeViewerKeydown); + changeViewerKeydown = null; + } + const index = changeViewerIndex; + changeViewerOverlay?.remove(); + changeViewerOverlay = null; + changeViewerIndex = null; + if (index != null) { + document.querySelector(`.change-row[data-change-index="${index}"]`)?.focus(); + } +} + +/** + * The full-screen diff viewer for one changed file. It pages through the run's + * changed files exactly as the artifact viewer pages through a gallery's media + * (one shared index, previous/next affordances, Escape/the close button/backdrop + * dismissing), and shows both forms the brief requires, switchable from one + * control row: the **Rendered** reading (each hunk's `@@` header, the shared + * diff line language and the old/new gutter numbers) and the **Raw patch** (the + * server's unified patch verbatim in monospace). A file the server could not + * give a patch for (binary, truncated, or a capture that recorded none) shows the + * honest reason in place of a diff rather than a fabricated one. + */ +function openChangeViewer(files, startIndex) { + closeChangeViewer(); + if (!files?.length) return; + let index = Math.min(Math.max(Number(startIndex) || 0, 0), files.length - 1); + let form = "rendered"; + const overlay = h("div", { + class: "change-viewer", + role: "dialog", + "aria-modal": "true", + "aria-label": "Diff viewer", + }); + overlay.addEventListener("click", (event) => { + if (event.target === overlay) closeChangeViewer(); + }); + + const renderViewer = () => { + const entry = files[index]; + changeViewerIndex = index; + const stat = changeStat(entry.added, entry.removed); + const hasPatch = entryHasPatch(entry); + + const titles = h("div", { class: "change-viewer-titles" }); + const titleRow = h("div", { class: "change-viewer-title-row" }); + titleRow.append( + h("span", { class: `change-kind ${changeKindTone(entry.kind)}`, text: changeKindTitle(entry.kind) }), + ); + if (stat !== "") titleRow.append(h("span", { class: "change-viewer-stat monospace", text: stat })); + titles.append(titleRow); + titles.append(h("div", { class: "change-viewer-path monospace", text: entry.path })); + titles.append( + h("div", { + class: "change-viewer-position muted", + text: `${changePositionLabel(index, files.length)} · changed by ${(entry.steps ?? []).join(" → ")}`, + }), + ); + const head = h( + "div", + { class: "change-viewer-head" }, + titles, + h("button", { + class: "change-viewer-copy", + type: "button", + text: "Copy raw patch", + disabled: !hasPatch, + onclick: () => copyText(entry.patch ?? ""), + }), + h("button", { + class: "change-viewer-close", + type: "button", + text: "Close diff", + onclick: closeChangeViewer, + }), + ); + + const controls = h( + "div", + { class: "change-viewer-controls" }, + h("button", { + class: `change-form${form === "rendered" ? " active" : ""}`, + type: "button", + "data-form": "rendered", + text: "Rendered", + disabled: form === "rendered", + onclick: () => { + form = "rendered"; + renderViewer(); + }, + }), + h("button", { + class: `change-form${form === "raw" ? " active" : ""}`, + type: "button", + "data-form": "raw", + text: "Raw patch", + disabled: !hasPatch, + onclick: () => { + form = "raw"; + renderViewer(); + }, + }), + h("div", { class: "change-viewer-spacer" }), + h("button", { + class: "change-page", + type: "button", + "data-page": "prev", + text: "Previous file", + disabled: index === 0, + onclick: () => { + index = Math.max(index - 1, 0); + form = "rendered"; + renderViewer(); + }, + }), + h("button", { + class: "change-page", + type: "button", + "data-page": "next", + text: "Next file", + disabled: index === files.length - 1, + onclick: () => { + index = Math.min(index + 1, files.length - 1); + form = "rendered"; + renderViewer(); + }, + }), + ); + + const body = h("div", { class: "change-viewer-body" }); + if (entry.binary || !hasPatch) { + body.append( + h("div", { + class: "change-honest muted", + text: entry.binary ? BINARY_DIFF_MESSAGE : patchUnavailableReason(entry), + }), + ); + } else if (form === "raw") { + body.append(h("pre", { class: "change-raw monospace", text: entry.patch ?? "" })); + } else { + body.append(renderRenderedDiff(entry)); + } + + overlay.replaceChildren(head, controls, body); + }; + + renderViewer(); + document.body.append(overlay); + changeViewerOverlay = overlay; + changeViewerKeydown = (event) => { + if (event.key === "Escape") closeChangeViewer(); + }; + document.addEventListener("keydown", changeViewerKeydown); +} + +/** The rendered reading: the stat line, an optional truncation note, each hunk. */ +function renderRenderedDiff(entry) { + const wrap = h("div", { class: "change-diff" }); + const parsed = parseUnifiedPatch(entry.patch); + const statLine = h("div", { class: "change-diff-stat" }); + if (parsed.added > 0) statLine.append(h("span", { class: "stat-add", text: `+${parsed.added}` })); + if (parsed.removed > 0) statLine.append(h("span", { class: "stat-del", text: `-${parsed.removed}` })); + if (parsed.added === 0 && parsed.removed === 0) { + statLine.append(h("span", { class: "muted", text: NO_LINE_CHANGES_MESSAGE })); + } + wrap.append(statLine); + if (entry.truncated) wrap.append(h("div", { class: "change-diff-note muted", text: TRUNCATED_PATCH_NOTE })); + for (const hunk of parsed.hunks) wrap.append(renderHunk(hunk)); + return wrap; +} + +/** + * One `@@` hunk: its header on a raised surface, then its lines in a + * horizontally scrollable container, each with its old/new gutter numbers (blank + * on the absent side and on a `\ No newline` marker) and the shared + * `{symbol} {text}` coloured by kind. + */ +function renderHunk(hunk) { + const width = gutterWidth(hunk); + const wrap = h("div", { class: "change-hunk" }); + wrap.append(h("div", { class: "change-hunk-head", text: hunk.header })); + const lines = h("div", { class: "change-hunk-lines" }); + for (const line of hunk.lines) { + const gutter = line.noNewlineMarker + ? " ".repeat(width * 2 + 1) + : `${gutterText(line.oldLine, width)} ${gutterText(line.newLine, width)}`; + lines.append( + h( + "div", + { class: "change-line" }, + h("span", { class: "change-gutter", text: gutter }), + h("span", { class: `change-text ${diffLineClass(line.kind)}`, text: `${diffLineSymbol(line.kind)} ${line.text}` }), + ), + ); + } + wrap.append(lines); + return wrap; +} + +/** Copy arbitrary text (the raw patch) to the clipboard, best effort. */ +async function copyText(text) { + if (!text || !canCopyLink()) return; + try { + await navigator.clipboard.writeText(text); + } catch { + // Clipboard permission may be denied; the patch is still readable. + } +} + /** The Timeline tab: one compact row per visit, in step order. */ function renderRunTimelineTab(d) { const wrap = h("div", { class: "run-tab-body" }); @@ -1543,7 +1902,14 @@ function closeStagePane() { const row = [...document.querySelectorAll(".timeline-row")].find( (node) => node.dataset.stageKey === closing.stageKey && node.dataset.visitIndex === String(closing.visitIndex), ); - row?.focus(); + // A pane opened from the Timeline returns to its row; one opened from the Graph + // returns to the stage node that opened it (there is no timeline row then). + const focusTarget = + row ?? + [...document.querySelectorAll(".graph-node")].find( + (candidate) => candidate.dataset.key === closing.stageKey, + ); + focusTarget?.focus(); } /** Whether the configured server URL can resolve a server-relative artifact. */ @@ -2065,9 +2431,12 @@ async function selectPipeline(summary) { async function selectRun(id, { silent = false } = {}) { state.selectedRunId = id; if (!silent) { - state.runDetail = null; // A different run reseeds the detail: Summary tab, every section closed and - // no stage pane left over from the run the operator navigated away from. + // no stage pane left over from the run the operator navigated away from. Drop + // the mounted run graph first so a live run's timer can never outlive it. + state.runGraph?.unmount(); + state.runGraph = null; + state.runDetail = null; state.runTab = "summary"; state.runSections = new Set(); state.runStagePane = null; @@ -2172,11 +2541,16 @@ client.addEventListener("state", (event) => { render(); }); -// The stage pane is a modal dialog: Escape closes it (the artifact viewer, when -// it is stacked above, owns Escape first). Registered once; it is a no-op when -// no pane is open. +// The stage pane is a modal dialog: Escape closes it (a stacked overlay — the +// artifact viewer or the diff viewer, when either is above — owns Escape first). +// Registered once; it is a no-op when no pane is open. document.addEventListener("keydown", (event) => { - if (event.key === "Escape" && state.runStagePane && !document.querySelector(".artifact-viewer")) { + if ( + event.key === "Escape" && + state.runStagePane && + !document.querySelector(".artifact-viewer") && + !document.querySelector(".change-viewer") + ) { event.preventDefault(); closeStagePane(); } diff --git a/web/src/changes.js b/web/src/changes.js new file mode 100644 index 00000000..82ae9603 --- /dev/null +++ b/web/src/changes.js @@ -0,0 +1,554 @@ +// Pure, DOM-free logic for the run summary's Changes section and its diff +// viewer, ported from the Android client so the browser says and shows exactly +// the same things: +// ui/changes/RunChanges.kt changeKind, changeKindLabel, parseUnifiedPatch, +// runChanges, runChangesHeader, runChangesNote, +// changesListSummary, noChangeDetail, +// patchUnavailableReason, changeEntryTags, +// changeRowMeta, changePositionLabel, gutterWidth +// ui/changes/ChangeDiffViewer.kt the file row, the viewer header/controls/body +// and the honest no-diff/reason wording +// ui/chat/ChatDiffCard.kt diffLineSymbol / diffLineColor (the one diff +// line language shared with the chat edit card) +// +// Nothing here touches the DOM or imports the app: every function is pure so the +// wording, ordering, counting and patch parsing can be unit-tested without a +// browser. The section/viewer 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. + +// --------------------------------------------------------------------------- +// Change kind +// --------------------------------------------------------------------------- + +/** The three recorded kinds plus the safe `other` fallback for anything else. */ +export const ChangeKind = Object.freeze({ + Added: "added", + Modified: "modified", + Deleted: "deleted", + Other: "other", +}); + +/** + * Maps the server's kind token to a ChangeKind. The token is trimmed and + * lowercased; an unrecognised or blank kind stays `other` rather than being + * guessed, so a future server value is shown read-only instead of mislabelled. + * Pure. + */ +export function changeKind(kind) { + switch (str(kind).trim().toLowerCase()) { + case "added": + return ChangeKind.Added; + case "modified": + return ChangeKind.Modified; + case "deleted": + return ChangeKind.Deleted; + default: + return ChangeKind.Other; + } +} + +/** The word a file's kind is named by in the list and the diff header. */ +export function changeKindLabel(kind) { + switch (kind) { + case ChangeKind.Added: + return "added"; + case ChangeKind.Modified: + return "modified"; + case ChangeKind.Deleted: + return "deleted"; + default: + return "changed"; + } +} + +/** The kind word as the viewer header shows it, first letter capitalised. */ +export function changeKindTitle(kind) { + const label = changeKindLabel(kind); + return label.charAt(0).toUpperCase() + label.slice(1); +} + +// --------------------------------------------------------------------------- +// Unified patch parsing +// --------------------------------------------------------------------------- + +/** Which kind of line this is within a unified patch. */ +export const ChangeLineKind = Object.freeze({ + Context: "context", + Add: "add", + Remove: "remove", +}); + +/** + * Parses a server-recorded unified patch into hunks, lines, line numbers and + * the true `+N -M` stat. The server builds these patches with a Go unified-diff + * writer (internal/filediff), so the shape is a standard `---`/`+++` header, + * optional metadata lines, `@@ -a,b +c,d @@` hunk headers and a ` `/`+`/`-` + * body. Anything unrecognised (a truncated tail, an exotic header) is carried + * verbatim in `headerLines` when it sits before the first hunk, and otherwise + * kept as an unnumbered context line, so the raw view always has the exact + * source while the rendered view shows only lines it can stand behind. A blank + * patch parses to an empty result rather than a fabricated one. + */ +export function parseUnifiedPatch(patch) { + const text = patch == null ? "" : String(patch); + if (text.trim() === "") { + return { raw: "", headerLines: [], hunks: [], added: 0, removed: 0 }; + } + const rawLines = text.split("\n"); + const headers = []; + const hunks = []; + let current = null; + for (const line of rawLines) { + const hunkStart = parseHunkHeader(line); + if (hunkStart != null) { + if (current) hunks.push(current.build()); + current = new HunkBuilder(line, hunkStart.oldStart, hunkStart.oldCount, hunkStart.newStart, hunkStart.newCount); + } else if (line.startsWith("--- ") || line.startsWith("+++ ")) { + // An aggregated entry can contain one complete patch from each + // contributing stage. A new file header closes the preceding hunk + // instead of being rendered as an unnumbered context line in it. + if (current) { + hunks.push(current.build()); + current = null; + } + headers.push(line); + } else if (current == null) { + headers.push(line); + } else { + current.lines.push(parseBodyLine(line, current)); + } + } + if (current) hunks.push(current.build()); + let added = 0; + let removed = 0; + for (const hunk of hunks) { + for (const line of hunk.lines) { + if (line.kind === ChangeLineKind.Add) added++; + else if (line.kind === ChangeLineKind.Remove) removed++; + } + } + return { raw: text, headerLines: headers, hunks, added, removed }; +} + +/** + * Mutable accumulator for one hunk as it is parsed, carrying the running old/new + * line counters so each body line gets its gutter numbers without a second pass. + */ +class HunkBuilder { + constructor(header, oldStart, oldCount, newStart, newCount) { + this.header = header; + this.oldStart = oldStart; + this.oldCount = oldCount; + this.newStart = newStart; + this.newCount = newCount; + this.lines = []; + this.oldLine = oldStart; + this.newLine = newStart; + } + + build() { + return { + header: this.header, + oldStart: this.oldStart, + oldCount: this.oldCount, + newStart: this.newStart, + newCount: this.newCount, + lines: this.lines, + }; + } + + nextOld() { + return this.oldLine++; + } + + nextNew() { + return this.newLine++; + } +} + +/** + * The parsed `@@ -oldStart,oldCount +newStart,newCount @@` of a hunk header, or + * null when `line` is not one. A missing count defaults to 1 (the unified-diff + * rule) so a single-line hunk header is still read exactly. Pure. + */ +function parseHunkHeader(line) { + if (!line.startsWith("@@")) return null; + const end = line.indexOf("@@", 2); + if (end < 0) return null; + const ranges = tokenizeRanges(line.substring(2, end)); + return ranges == null ? null : { oldStart: ranges[0], oldCount: ranges[1], newStart: ranges[2], newCount: ranges[3] }; +} + +/** The four numbers of a hunk header's range text, or null when malformed. Pure. */ +function tokenizeRanges(body) { + const plus = body.indexOf("+"); + const old = plus === -1 ? body : body.slice(0, plus); + const next = plus === -1 ? "" : body.slice(plus + 1); + if (old === "" || next === "") return null; + const oldRange = parseRange(old); + if (oldRange == null) return null; + const newRange = parseRange(next); + if (newRange == null) return null; + return [oldRange[0], oldRange[1], newRange[0], newRange[1]]; +} + +/** One `-start,count` / `+start,count` side of a hunk header. Pure. */ +function parseRange(text) { + let trimmed = text.trim(); + if (trimmed.startsWith("-")) trimmed = trimmed.slice(1); + else if (trimmed.startsWith("+")) trimmed = trimmed.slice(1); + if (trimmed === "") return null; + const comma = trimmed.indexOf(","); + const startText = (comma === -1 ? trimmed : trimmed.slice(0, comma)).trim(); + const start = intOrNull(startText); + if (start == null) return null; + const countText = (comma === -1 ? "" : trimmed.slice(comma + 1)).trim(); + const count = countText === "" ? 1 : intOrNull(countText); + if (count == null) return null; + return [start, count]; +} + +/** One body line of a hunk, tagged and numbered from `builder`'s counters. */ +function parseBodyLine(line, builder) { + if (line.startsWith("+")) { + return { kind: ChangeLineKind.Add, text: line.slice(1), oldLine: 0, newLine: builder.nextNew(), noNewlineMarker: false }; + } + if (line.startsWith("-")) { + return { kind: ChangeLineKind.Remove, text: line.slice(1), oldLine: builder.nextOld(), newLine: 0, noNewlineMarker: false }; + } + if (line.startsWith("\\")) { + return { kind: ChangeLineKind.Context, text: line, oldLine: 0, newLine: 0, noNewlineMarker: true }; + } + if (line.startsWith(" ")) { + return { kind: ChangeLineKind.Context, text: line.slice(1), oldLine: builder.nextOld(), newLine: builder.nextNew(), noNewlineMarker: false }; + } + if (line === "") { + return { kind: ChangeLineKind.Context, text: "", oldLine: builder.nextOld(), newLine: builder.nextNew(), noNewlineMarker: false }; + } + // A truncated tail or an unexpected marker: keep the text, don't number it. + return { kind: ChangeLineKind.Context, text: line, oldLine: 0, newLine: 0, noNewlineMarker: false }; +} + +/** The widest line number in a hunk, so its gutter lines up across every row. */ +export function gutterWidth(hunk) { + let widest = 0; + for (const line of hunk?.lines ?? []) { + widest = Math.max(widest, Math.max(line.oldLine, line.newLine)); + } + return String(Math.max(widest, 1)).length; +} + +/** One gutter number padded to `width`; 0 means no number on that side. */ +export function gutterText(value, width) { + return value > 0 ? String(value).padStart(width) : " ".repeat(width); +} + +// --------------------------------------------------------------------------- +// Change aggregation (ui/changes/RunChanges.kt runChanges) +// --------------------------------------------------------------------------- + +/** + * Aggregates a run's stage steps into its Changes state. Pure and total over its + * input: a null `file_changes` on a step is a historical (or non-capturing) step + * and contributes nothing (it is never "no changes"); a present capture with no + * files is a real, observed no-change. Files are keyed by path and keep + * first-seen order, so a path several steps changed is one entry naming all of + * them. Later steps win the kind unless they only say "other", added/removed + * line counts sum, binary/truncated are OR'd, before_mode is first-seen and + * after_mode last-seen. + */ +export function runChanges(steps) { + const entries = new Map(); + let stepsWithChanges = 0; + let stepsPending = 0; + let partial = false; + let unavailable = false; + let missingCaptures = 0; + let skipped = 0; + let omitted = 0; + const diagnostics = new Set(); + + for (const step of steps ?? []) { + const changes = step?.file_changes; + if (changes == null) { + if (step?.status === "running" || step?.status === "waiting") stepsPending++; + else missingCaptures++; + continue; + } + stepsWithChanges++; + if (changes.status === "unavailable") unavailable = true; + if (changes.status === "partial") partial = true; + if (str(changes.diagnostic).trim() !== "") diagnostics.add(str(changes.diagnostic).trim()); + skipped += Number(changes.skipped) || 0; + omitted += Number(changes.omitted) || 0; + const stageText = str(step?.stage); + const stage = stageText.trim() === "" ? "stage" : stageText; + for (const file of changes.files ?? []) { + const path = str(file?.path); + if (path.trim() === "") continue; + const kind = changeKind(file?.kind); + const parsed = parseUnifiedPatch(file?.patch); + const existing = entries.get(path); + const mergedSteps = existing ? [...existing.steps] : []; + if (!mergedSteps.includes(stage)) mergedSteps.push(stage); + const patchParts = []; + if (existing && existing.patch != null) patchParts.push(existing.patch); + if (typeof file?.patch === "string" && file.patch.trim() !== "") patchParts.push(file.patch); + const joinedPatch = patchParts.join("\n"); + entries.set(path, { + path, + // A later step wins the kind: it is the observed state the run left. + kind: existing == null || kind !== ChangeKind.Other ? kind : existing.kind, + added: (existing?.added ?? 0) + parsed.added, + removed: (existing?.removed ?? 0) + parsed.removed, + binary: existing?.binary === true || file?.binary === true, + truncated: existing?.truncated === true || file?.truncated === true, + // Keep the first-seen before-mode and the last-seen after-mode, so the + // pair describes the run's net effect on the file. + beforeMode: existing && existing.beforeMode != null ? existing.beforeMode : nullable(file?.before_mode), + afterMode: file?.after_mode != null ? file.after_mode : existing?.afterMode ?? null, + otherModeChange: + existing?.otherModeChange === true || + (file?.before_mode != null && + file?.after_mode != null && + file.before_mode !== file.after_mode && + !file.binary && + parsed.added === 0 && + parsed.removed === 0), + steps: mergedSteps, + // Preserve every recorded textual patch for a path. A file may be + // changed by several stages, and retaining only the first one would + // make the displayed hunks disagree with the aggregate stat. + patch: joinedPatch.trim() !== "" ? joinedPatch : null, + }); + } + } + + const files = [...entries.values()]; + const pending = stepsWithChanges === 0 && stepsPending > 0; + const totalPartial = partial || files.some((file) => file.truncated) || omitted > 0; + return { + files, + stepsWithChanges, + stepsPending, + added: files.reduce((sum, file) => sum + file.added, 0), + removed: files.reduce((sum, file) => sum + file.removed, 0), + partial: totalPartial, + unavailable, + pending, + missingCaptures, + skipped, + omitted, + diagnostic: [...diagnostics].join(" "), + }; +} + +// --------------------------------------------------------------------------- +// Entry helpers (FileChangeEntry derived properties) +// --------------------------------------------------------------------------- + +/** True when a patch the operator can read is present. */ +export function entryHasPatch(entry) { + return !!(entry && entry.patch != null && entry.patch.trim() !== "" && !entry.binary); +} + +/** True when the recorded permissions differ and no content change explains it. */ +export function entryModeChanged(entry) { + return !!(entry && entry.beforeMode != null && entry.afterMode != null && entry.beforeMode !== entry.afterMode); +} + +/** The number of stages that changed this file. */ +export function entryStepCount(entry) { + return (entry?.steps ?? []).length; +} + +// --------------------------------------------------------------------------- +// Wording (ui/changes/RunChanges.kt + ChangeDiffViewer.kt) +// --------------------------------------------------------------------------- + +/** + * The Changes section header's one-line summary: the observed file count, the + * total `+N -M`, and the honest capture caveats. Wording never implies the + * server proved authorship — it reports the workspace change it observed. A run + * with no recorded change, an unavailable capture and a still-running one each + * say exactly that rather than showing a fabricated zero. + */ +export function runChangesHeader(changes) { + if (changes.unavailable) return "Changes · capture unavailable"; + if (changes.files.length === 0) { + if (changes.pending) return "Changes · capture pending"; + if (changes.partial) return "Changes · partial capture"; + if (changes.stepsWithChanges === 0) return "Changes · not recorded for this run"; + if (changes.missingCaptures > 0) return "Changes · capture incomplete"; + return "Changes · no changes observed"; + } + const stat = changeStat(changes.added, changes.removed); + const count = changes.files.length; + const label = + stat === "" + ? `${count} ${count === 1 ? "file" : "files"} changed` + : `${count} ${count === 1 ? "file" : "files"} changed · ${stat}`; + if (changes.partial) return `${label} · partial capture`; + if (changes.missingCaptures > 0) return `${label} · capture incomplete`; + return label; +} + +/** + * The honest one-line note under the header for a capture that is not complete, + * or "" when the capture was. The wording distinguishes an unavailable capture, a + * partial one (with its counts) and a capture that has recorded nothing yet. + */ +export function runChangesNote(changes) { + if (changes.unavailable) { + return str(changes.diagnostic).trim() !== "" + ? str(changes.diagnostic) + : "The workspace snapshot could not be compared; the changes below may be incomplete."; + } + let out = ""; + if (changes.partial) { + out = "Partial capture: some changes may be missing."; + const caveats = []; + if (changes.skipped > 0) caveats.push(`${changes.skipped} files skipped`); + if (changes.omitted > 0) caveats.push(`${changes.omitted} omitted`); + const truncated = changes.files.filter((file) => file.truncated).length; + if (truncated > 0) caveats.push(`${truncated} truncated`); + if (caveats.length > 0) out += ` (${caveats.join(", ")})`; + if (str(changes.diagnostic).trim() !== "") out += ` ${str(changes.diagnostic)}`; + } + if (changes.missingCaptures > 0) { + if (out !== "") out += " "; + out += `Missing capture: ${changes.missingCaptures} `; + out += changes.missingCaptures === 1 ? "stage did" : "stages did"; + out += " not record changes."; + } + return out.trim(); +} + +/** The `+N -M` stat, or "" when both counts are zero. Shared by header and row. */ +export function changeStat(added, removed) { + let out = ""; + if (added > 0) out += `+${added}`; + if (removed > 0) { + if (out !== "") out += " "; + out += `-${removed}`; + } + return out; +} + +/** + * The tags shown beside a file row: the traits that change how the entry must be + * read (binary, truncated, a mode-only change), never a fabricated diff. + */ +export function changeEntryTags(entry) { + const tags = []; + if (entry?.binary) tags.push("binary"); + if (entry?.truncated) tags.push("truncated"); + if (entry?.otherModeChange && !entry.binary) tags.push("mode change"); + return tags; +} + +/** The row's secondary line: which stage(s) changed it, and how to read it. */ +export function changeRowMeta(entry) { + let out = `changed by ${(entry?.steps ?? []).join(" → ")}`; + for (const tag of changeEntryTags(entry)) out += ` · ${tag}`; + if (entryModeChanged(entry) && !entry.binary) { + out += ` · mode ${entry.beforeMode ?? ""}→${entry.afterMode ?? ""}`; + } + return out; +} + +/** + * The file list's own summary line: the observed file count and the aggregate + * stat, with the same ambiguity-free wording as the header. + */ +export function changesListSummary(changes) { + const count = `${changes.files.length} ${changes.files.length === 1 ? "file" : "files"} changed`; + const stat = changeStat(changes.added, changes.removed); + return stat === "" ? count : `${count} · ${stat}`; +} + +/** Why no change is listed: a pending capture, an unavailable one, or a recorded none. */ +export function noChangeDetail(changes) { + if (changes.pending) return "The capture runs after the stage finishes; nothing is recorded yet."; + if (changes.unavailable) return "The workspace snapshot could not be compared, so no changes can be shown."; + if (changes.stepsWithChanges === 0) { + return "This run recorded no change capture (a historical step, or a stage that does not capture)."; + } + return "The captured snapshots were identical: the workspace was unchanged."; +} + +/** Why a file has no patch to render, in the entry's own recorded terms. */ +export function patchUnavailableReason(entry) { + if (entry?.truncated) { + return "The server truncated this file's patch at its capture limit; no diff text was recorded."; + } + if (entry?.otherModeChange) { + return `Only the file's mode changed (${entry.beforeMode ?? ""}→${entry.afterMode ?? ""}); the server recorded no text diff.`; + } + return "The server recorded this change without a patch."; +} + +/** The `N of M` position label the viewer shows for its open file. Pure. */ +export function changePositionLabel(index, count) { + return `${index + 1} of ${count}`; +} + +// The viewer's honest messages, exported so the renderer and the tests share one +// spelling of each. +export const BINARY_DIFF_MESSAGE = + "This is a binary file: the server recorded the change but has no textual diff to show."; +export const TRUNCATED_PATCH_NOTE = + "The server truncated this patch at its capture limit; the raw text is the whole record."; +export const NO_LINE_CHANGES_MESSAGE = "no line changes recorded"; + +// --------------------------------------------------------------------------- +// Diff line language (ui/chat/ChatDiffCard.kt diffLineSymbol/diffLineColor) +// --------------------------------------------------------------------------- + +/** The gutter symbol one line kind is drawn with (`+`/`-`/space). Pure. */ +export function diffLineSymbol(kind) { + switch (kind) { + case ChangeLineKind.Add: + return "+"; + case ChangeLineKind.Remove: + return "-"; + default: + return " "; + } +} + +/** + * The CSS class one line kind is drawn in: the app's success hue for an addition, + * its failure hue for a removal and the secondary on-surface role for context. + * The one place a diff line's class is decided, shared by every renderer. + */ +export function diffLineClass(kind) { + switch (kind) { + case ChangeLineKind.Add: + return "diff-add"; + case ChangeLineKind.Remove: + return "diff-remove"; + default: + return "diff-context"; + } +} + +// --------------------------------------------------------------------------- +// Internals +// --------------------------------------------------------------------------- + +/** An integer parsed from a strictly-numeric string, or null. */ +function intOrNull(text) { + return /^[+-]?\d+$/.test(text) ? Number.parseInt(text, 10) : null; +} + +/** A value kept as itself when present, else null (`?:` over nullable fields). */ +function nullable(value) { + return value == null ? null : value; +} + +/** A nullable value as a string ("" for null/undefined), for blank checks. */ +function str(value) { + return value == null ? "" : String(value); +} diff --git a/web/src/graph.js b/web/src/graph.js index 1816ba43..c93f8fb3 100644 --- a/web/src/graph.js +++ b/web/src/graph.js @@ -26,6 +26,7 @@ import { Protocol, isTerminal, resolveTarget } from "./protocol.js"; import { effectiveStageType } from "./templates.js"; +import { formatDuration, secondsSince } from "./runs.js"; // Re-exported so a caller (and the unit tests) can reach the shared "blank is // the model stage" rule from the graph module it belongs to without a second @@ -61,6 +62,19 @@ const DRAG_THRESHOLD = 4; /** The run tab's empty state when the server omitted the run graph (R5). */ export const RUN_GRAPH_MISSING = "This server did not include the run graph."; +/** + * The run tab's guidance note: the browser adaptation of RunGraphTab's own + * sentence, so the app's pinch/tap become mouse wheel/click while everything + * else (the live pulse, the settled finish, the executed/not-executed shapes) + * stays verbatim. + */ +export const RUN_GRAPH_NOTE = + "The running stage pulses with its elapsed time and executed routes flow; " + + "a finished run settles, and with animations off the running stage stays marked. " + + "Solid means executed, dashed and outlined not executed; executed success and " + + "failure routes are drawn thickest. Mouse wheel to zoom, drag to pan, " + + "click a stage for details."; + /** * The pipeline detail's empty state when the parsed definition declares no * stages. The template gallery has its own Android-authored analogue @@ -203,6 +217,18 @@ export function edgeIsExecuted(edge, runState) { return inSet(runState.takenRoutes, edge) || inSet(runState.takenRoutes, edge.id); } +/** + * The key of the stage a run is executing right now, else null. Only a live run + * (still `executing`) has an active stage, so a finished run never carries a + * halo or an elapsed badge. Pure: drawing, the elapsed badge and the tests share + * one definition of "active". + */ +export function activeStage(runState) { + if (runState == null || !runState.executing) return null; + const key = runState.currentStage; + return key == null || key === "" ? null : key; +} + // --------------------------------------------------------------------------- // Pure viewport maths (WorkflowGraph.kt) // --------------------------------------------------------------------------- @@ -895,19 +921,38 @@ function pathFromPoints(points) { * space does nothing. * * Options: - * runState — omitted for the definition view (every route executed); - * R5 passes `{ visitedStages, takenRoutes }` to dash the - * routes a run did not take. + * runState — omitted for the definition view (every route executed and + * no legend); R5 passes the `runGraphState(run)` shape + * ({ visitedStages, takenRoutes, currentStage, executing, + * currentStageStartedAt }) to render the run: executed nodes + * solid, unvisited ones hollow/dashed, executed routes + * arrowed, the live stage's halo + elapsed badge and the + * Executed / Not executed legend. + * animationsEnabled — honour the caller's animation gate. Defaults to the + * page's `prefers-reduced-motion` setting; when false the + * active stage keeps a static ring instead of pulsing. * expanded — start with the taller panel. - * onStageTap — called with the node key on a node click. + * onStageTap — called with the node key on a node click. When supplied + * (the run tab), the click opens the caller's own stage + * pane and no definition pane is drawn. * onExpandedChange — called with the new expanded flag on toggle. * metrics — layout metrics override (tests). * * Returns `{ unmount }`; call it before discarding the container so the wheel, - * pointer and resize listeners never leak. + * pointer, resize and elapsed-timer handles never leak. */ export function mount(container, graph, options = {}) { const runState = options.runState ?? null; + const activeKey = activeStage(runState); + const reducedMotion = + typeof window !== "undefined" && + typeof window.matchMedia === "function" && + window.matchMedia("(prefers-reduced-motion: reduce)").matches; + // The caller may force animations off; otherwise the page's motion preference + // decides. A finished run never animates regardless (activeKey is null then). + const animationsEnabled = + options.animationsEnabled === undefined ? !reducedMotion : Boolean(options.animationsEnabled); + const pulse = activeKey != null && animationsEnabled; const layout = layoutGraph(graph, options.metrics); const stagesByKey = new Map((graph?.stages ?? []).map((stage) => [stage.key, stage])); @@ -983,6 +1028,7 @@ export function mount(container, graph, options = {}) { // Node layer: real buttons, positioned in graph space. const nodeLayer = el("div", "graph-node-layer"); + let elapsedBadge = null; for (const node of layout.nodes) { const kind = graphNodeKind(node.terminal, node.key, stagesByKey.get(node.key)?.type); const button = el("button", `graph-node ${nodeKindClass(kind)}`, node.label); @@ -998,13 +1044,25 @@ export function mount(container, graph, options = {}) { ? `${node.label}, open details` : `Stage ${node.key}, ${node.type}, open details`, ); - if (!stageIsExecuted(node.key, runState)) button.classList.add("not-executed"); + const executed = stageIsExecuted(node.key, runState); + if (runState != null) button.classList.add(executed ? "executed" : "not-executed"); + if (node.key === activeKey) { + button.classList.add("active"); + if (pulse) button.classList.add("pulsing"); + const badge = el("span", "graph-elapsed"); + badge.setAttribute("aria-hidden", "true"); + button.append(badge); + elapsedBadge = badge; + } button.addEventListener("click", (event) => { if (dragged) { event.preventDefault(); return; } - selectNode(node.key); + // The run tab owns its own stage pane (the shared timeline visit pane), so + // a supplied handler replaces the definition pane rather than stacking on it. + if (typeof options.onStageTap === "function") options.onStageTap(node.key); + else selectNode(node.key); }); nodeLayer.append(button); } @@ -1026,7 +1084,27 @@ export function mount(container, graph, options = {}) { controls.append(fitButton, expandButton); viewport.append(controls); - // The definition pane, hidden until a node is clicked. + // The legend, only under a run (never the definition-only view): a solid, + // arrowed swatch means "executed", a dashed, arrowless one "not executed", + // matching what the graph draws. + if (runState != null) { + const legend = el("div", "graph-legend"); + legend.setAttribute("role", "note"); + legend.setAttribute("aria-label", "Executed and not executed routes"); + for (const entry of [ + { label: "Executed", executed: true }, + { label: "Not executed", executed: false }, + ]) { + const item = el("span", "graph-legend-entry"); + item.append(el("span", `graph-legend-swatch ${entry.executed ? "executed" : "not-executed"}`)); + item.append(el("span", "graph-legend-label", entry.label)); + legend.append(item); + } + viewport.append(legend); + } + + // The definition pane, hidden until a node is clicked (definition view only; + // the run tab opens its own pane through onStageTap instead). const pane = el("div", "graph-pane"); pane.hidden = true; root.append(viewport, pane); @@ -1122,7 +1200,28 @@ export function mount(container, graph, options = {}) { pane.replaceChildren(...children); pane.hidden = false; - if (typeof options.onStageTap === "function") options.onStageTap(key); + } + + // --- Elapsed badge (live run only) --------------------------------------- + + function updateElapsed() { + if (!elapsedBadge) return; + const seconds = secondsSince(runState?.currentStageStartedAt, Date.now()); + elapsedBadge.textContent = seconds == null ? "" : formatDuration(seconds); + } + + let elapsedTimer = null; + if (elapsedBadge != null) { + updateElapsed(); + // Tick only while the graph has a live stage with a known start; a still + // ring (reduced motion) and a finished run never wake up once a second. + if ( + pulse && + typeof setInterval === "function" && + String(runState?.currentStageStartedAt ?? "").trim() !== "" + ) { + elapsedTimer = setInterval(updateElapsed, 1000); + } } // --- Interactions -------------------------------------------------------- @@ -1230,6 +1329,10 @@ export function mount(container, graph, options = {}) { return { unmount() { + if (elapsedTimer != null) { + clearInterval(elapsedTimer); + elapsedTimer = null; + } resizeObserver?.disconnect(); viewport.removeEventListener("pointerdown", onPointerDown); viewport.removeEventListener("pointermove", onPointerMove); diff --git a/web/src/runDetail.js b/web/src/runDetail.js index 6e634666..e22c4384 100644 --- a/web/src/runDetail.js +++ b/web/src/runDetail.js @@ -36,9 +36,9 @@ import { effectiveStageType } from "./templates.js"; /** * The run-detail tabs, Summary first so it is the default selection. The Graph - * tab is present (Android `runDetailTabs`) but has no rendered body yet — it is - * the R5 item — so the renderer filters it out until then. The timeline keeps - * Android's stable key `steps` with the visible title `Timeline`. + * 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" }, @@ -48,8 +48,8 @@ export const RUN_DETAIL_TABS = [ { key: "steps", label: "Timeline" }, ]; -/** The tabs the browser currently renders (the Graph body is the R5 item). */ -export const RENDERED_RUN_TABS = RUN_DETAIL_TABS.filter((tab) => tab.key !== "graph"); +/** The tabs the browser renders: all of them, including the Graph body (R5). */ +export const RENDERED_RUN_TABS = RUN_DETAIL_TABS; // The empty-state sentences, exactly as the app spells them. export const EMPTY_INPUT_MESSAGE = "No input recorded."; @@ -330,6 +330,66 @@ export function graphEdges(graph) { 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) // --------------------------------------------------------------------------- diff --git a/web/styles.css b/web/styles.css index 1d021d37..fbc15bee 100644 --- a/web/styles.css +++ b/web/styles.css @@ -610,6 +610,74 @@ code { background: var(--surface-2); padding: 1px 6px; border-radius: 6px; font- } .graph-control:hover { border-color: var(--accent); color: var(--accent); } +/* The run-mode legend (R5), pinned top-start opposite the Fit/expand controls. + A solid, arrowed swatch means "executed"; a dashed, arrowless one "not + executed". Never shown for the definition-only view. */ +.graph-legend { + position: absolute; + top: 8px; + left: 8px; + z-index: 2; + display: flex; + gap: 12px; + align-items: center; + padding: 4px 8px; + border: 1px solid var(--border); + border-radius: 8px; + background: color-mix(in srgb, var(--surface) 85%, transparent); + font-size: 12px; + color: var(--muted); +} +.graph-legend-entry { display: inline-flex; gap: 6px; align-items: center; } +.graph-legend-swatch { + position: relative; + width: 26px; + border-top: 3px solid var(--muted); +} +.graph-legend-swatch.executed { border-top-color: var(--text); } +/* A small filled arrowhead on the executed swatch, matching the drawn head. */ +.graph-legend-swatch.executed::after { + content: ""; + position: absolute; + top: -6px; + right: -1px; + border-left: 7px solid var(--text); + border-top: 4px solid transparent; + border-bottom: 4px solid transparent; +} +.graph-legend-swatch.not-executed { border-top-style: dashed; } + +/* The live active stage (R5): a ring around the node plus a soft glow, pulsing + while the run executes and static when the user prefers reduced motion. */ +.graph-node.active { + border-color: var(--accent); + box-shadow: 0 0 0 3px color-mix(in srgb, var(--accent) 40%, transparent); +} +.graph-node.active.pulsing { animation: graph-halo-pulse 1.6s ease-in-out infinite; } +@keyframes graph-halo-pulse { + 0%, + 100% { box-shadow: 0 0 0 2px color-mix(in srgb, var(--accent) 55%, transparent); } + 50% { box-shadow: 0 0 0 7px color-mix(in srgb, var(--accent) 20%, transparent); } +} +@media (prefers-reduced-motion: reduce) { + .graph-node.active.pulsing { animation: none; } +} + +/* The live elapsed-time badge on the active node. */ +.graph-elapsed { + position: absolute; + bottom: -9px; + right: 6px; + padding: 0 5px; + border: 1px solid color-mix(in srgb, var(--accent) 45%, var(--border)); + border-radius: 999px; + background: var(--surface); + color: var(--accent); + font-size: 10px; + font-weight: 600; + line-height: 16px; +} + /* The definition pane opened from a node click. */ .graph-pane { display: grid; @@ -862,3 +930,101 @@ code { background: var(--surface-2); padding: 1px 6px; border-radius: 6px; font- .live-reconnecting .live-dot { opacity: 0.4; } .live-not-live { color: var(--muted); } .live-not-live .live-dot { opacity: 0.4; } + +/* --------------------------------------------------------------------------- + Run summary Changes (parity R4): the observed-file list and the full-screen + rendered/raw diff viewer. Hand-written, the app's dark palette. + --------------------------------------------------------------------------- */ + +.changes { display: grid; gap: 8px; } +.changes-summary { color: var(--accent); font-weight: 600; font-size: 13px; } +.changes-note { font-size: 12px; } +.changes-empty { font-size: 13px; } +.changes-list { display: grid; gap: 4px; } + +.change-row { + display: flex; + gap: 10px; + align-items: flex-start; + padding: 6px 8px; + border-radius: 8px; + cursor: pointer; +} +.change-row:hover { background: var(--surface-2); } +.change-row:focus-visible { outline: 2px solid var(--accent); outline-offset: 1px; } +.change-kind { font-weight: 600; font-size: 12px; min-width: 62px; } +.change-main { flex: 1; min-width: 0; display: grid; gap: 2px; } +.change-path { overflow-wrap: anywhere; } +.change-meta { font-size: 12px; } +.change-stat { display: flex; gap: 6px; font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 12px; } +.stat-add { color: var(--ok); } +.stat-del { color: var(--bad); } + +/* Full-screen diff viewer overlay (the artifact-viewer idiom). */ +.change-viewer { + position: fixed; + inset: 0; + z-index: 30; + display: flex; + flex-direction: column; + gap: 12px; + padding: 20px; + background: rgba(0, 0, 0, 0.86); +} +.change-viewer-head { display: flex; gap: 12px; align-items: flex-start; } +.change-viewer-titles { flex: 1; min-width: 0; display: grid; gap: 2px; } +.change-viewer-title-row { display: flex; gap: 10px; align-items: baseline; flex-wrap: wrap; } +.change-viewer-stat { font-size: 13px; } +.change-viewer-path { overflow-wrap: anywhere; } +.change-viewer-position { font-size: 12px; } +.change-viewer-controls { display: flex; gap: 8px; align-items: center; } +.change-viewer-spacer { flex: 1; } +.change-form { font-size: 12px; } +.change-form.active { border-color: var(--accent); color: var(--accent); } +.change-form:disabled { opacity: 0.45; } +.change-page:disabled { opacity: 0.4; cursor: not-allowed; } +.change-viewer-body { flex: 1; min-height: 0; overflow: auto; display: grid; gap: 16px; align-content: start; } + +.change-honest { + display: flex; + align-items: center; + justify-content: center; + height: 100%; + padding: 32px; + text-align: center; +} +.change-raw { + margin: 0; + padding: 12px; + border: 1px solid var(--border); + border-radius: 10px; + background: var(--surface-2); + font-size: 12px; + white-space: pre; + overflow: auto; +} + +.change-diff { display: grid; gap: 12px; align-content: start; } +.change-diff-stat { display: flex; gap: 8px; font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 12px; } +.change-diff-note { font-size: 12px; } +.change-hunk { border: 1px solid var(--border); border-radius: 8px; overflow: hidden; } +.change-hunk-head { + padding: 4px 8px; + background: var(--surface-2); + color: var(--accent); + font-family: ui-monospace, SFMono-Regular, Menlo, monospace; + font-size: 12px; +} +.change-hunk-lines { overflow-x: auto; background: var(--surface); padding: 6px 0; } +.change-line { + display: flex; + gap: 10px; + padding: 0 8px; + font-family: ui-monospace, SFMono-Regular, Menlo, monospace; + font-size: 12px; + white-space: pre; +} +.change-gutter { color: var(--muted); user-select: none; } +.diff-add { color: var(--ok); } +.diff-remove { color: var(--bad); } +.diff-context { color: var(--muted); } diff --git a/web/test/changes.test.mjs b/web/test/changes.test.mjs new file mode 100644 index 00000000..a15c3f96 --- /dev/null +++ b/web/test/changes.test.mjs @@ -0,0 +1,562 @@ +// Pure unit tests for the run summary's Changes section and its diff viewer: +// the kind mapping and labels, the unified-patch parser (hunks, line numbers, +// stat counts, the `\ No newline` marker and header closing), the cross-step +// aggregation (kind merge, stat sums, binary/truncated OR, mode first/last), +// every header/note/detail wording variant and the row/viewer helpers. +// No server, no DOM. +import { test } from "node:test"; +import assert from "node:assert/strict"; + +import { + ChangeKind, + ChangeLineKind, + BINARY_DIFF_MESSAGE, + NO_LINE_CHANGES_MESSAGE, + TRUNCATED_PATCH_NOTE, + changeEntryTags, + changeKind, + changeKindLabel, + changeKindTitle, + changePositionLabel, + changeRowMeta, + changeStat, + changesListSummary, + diffLineClass, + diffLineSymbol, + entryHasPatch, + entryModeChanged, + gutterText, + gutterWidth, + noChangeDetail, + parseUnifiedPatch, + patchUnavailableReason, + runChanges, + runChangesHeader, + runChangesNote, +} from "../src/changes.js"; + +// A step file-change with sane defaults, overridable per test. +function file(overrides = {}) { + return { path: "a.txt", kind: "modified", patch: "", ...overrides }; +} + +// A run step with a file_changes capture, overridable per test. +function step(overrides = {}) { + return { stage: "s", status: "completed", sequence: 1, file_changes: null, ...overrides }; +} + +// --------------------------------------------------------------------------- +// Kind mapping +// --------------------------------------------------------------------------- + +test("changeKind trims and lowercases, never inventing a kind", () => { + assert.equal(changeKind("added"), ChangeKind.Added); + assert.equal(changeKind(" Deleted "), ChangeKind.Deleted); + assert.equal(changeKind("MODIFIED"), ChangeKind.Modified); + assert.equal(changeKind("copied"), ChangeKind.Other); + assert.equal(changeKind(""), ChangeKind.Other); + assert.equal(changeKind(null), ChangeKind.Other); +}); + +test("changeKindLabel and changeKindTitle spell the app's words", () => { + assert.equal(changeKindLabel(ChangeKind.Added), "added"); + assert.equal(changeKindLabel(ChangeKind.Modified), "modified"); + assert.equal(changeKindLabel(ChangeKind.Deleted), "deleted"); + assert.equal(changeKindLabel(ChangeKind.Other), "changed"); + assert.equal(changeKindTitle(ChangeKind.Added), "Added"); + assert.equal(changeKindTitle(ChangeKind.Other), "Changed"); +}); + +// --------------------------------------------------------------------------- +// changeStat and changesListSummary +// --------------------------------------------------------------------------- + +test("changeStat omits a zero side and is blank when both are zero", () => { + assert.equal(changeStat(3, 2), "+3 -2"); + assert.equal(changeStat(3, 0), "+3"); + assert.equal(changeStat(0, 2), "-2"); + assert.equal(changeStat(0, 0), ""); +}); + +test("changesListSummary keeps the file(s) wording and appends the stat", () => { + const one = { files: [{}], added: 2, removed: 0 }; + assert.equal(changesListSummary(one), "1 file changed · +2"); + assert.equal(changesListSummary({ files: [{}, {}], added: 0, removed: 0 }), "2 files changed"); +}); + +// --------------------------------------------------------------------------- +// parseUnifiedPatch +// --------------------------------------------------------------------------- + +test("parseUnifiedPatch treats a blank patch as an empty diff", () => { + for (const blank of ["", " ", "\n", null, undefined]) { + assert.deepEqual(parseUnifiedPatch(blank), { + raw: "", + headerLines: [], + hunks: [], + added: 0, + removed: 0, + }); + } +}); + +test("parseUnifiedPatch numbers a single hunk and counts the body", () => { + const patch = [ + "--- a/x.txt", + "+++ b/x.txt", + "@@ -1,3 +1,3 @@", + " ctx", + "-old", + "+new", + " tail", + ].join("\n"); + const parsed = parseUnifiedPatch(patch); + assert.equal(parsed.raw, patch); + assert.deepEqual(parsed.headerLines, ["--- a/x.txt", "+++ b/x.txt"]); + assert.equal(parsed.hunks.length, 1); + const hunk = parsed.hunks[0]; + assert.equal(hunk.header, "@@ -1,3 +1,3 @@"); + assert.deepEqual([hunk.oldStart, hunk.oldCount, hunk.newStart, hunk.newCount], [1, 3, 1, 3]); + assert.deepEqual( + hunk.lines.map((line) => [line.kind, line.text, line.oldLine, line.newLine]), + [ + [ChangeLineKind.Context, "ctx", 1, 1], + [ChangeLineKind.Remove, "old", 2, 0], + [ChangeLineKind.Add, "new", 0, 2], + [ChangeLineKind.Context, "tail", 3, 3], + ], + ); + assert.equal(parsed.added, 1); + assert.equal(parsed.removed, 1); +}); + +test("parseUnifiedPatch defaults a missing count to 1", () => { + const parsed = parseUnifiedPatch("@@ -5 +7 @@\n-old\n+new"); + const hunk = parsed.hunks[0]; + assert.deepEqual([hunk.oldStart, hunk.oldCount, hunk.newStart, hunk.newCount], [5, 1, 7, 1]); + assert.equal(parsed.added, 1); + assert.equal(parsed.removed, 1); +}); + +test("parseUnifiedPatch flags a `\\ No newline` marker without numbering it", () => { + const parsed = parseUnifiedPatch( + ["@@ -1 +1 @@", "-one", "\\ No newline at end of file", "+two"].join("\n"), + ); + const lines = parsed.hunks[0].lines; + assert.equal(lines[1].noNewlineMarker, true); + assert.equal(lines[1].text, "\\ No newline at end of file"); + assert.equal(lines[1].oldLine, 0); + assert.equal(lines[1].newLine, 0); + assert.equal(lines[1].kind, ChangeLineKind.Context); +}); + +test("a `---`/`+++` header closes the current hunk instead of numbering into it", () => { + const parsed = parseUnifiedPatch( + [ + "--- a/x", + "+++ b/x", + "@@ -1 +1 @@", + "-old", + "+new", + "--- a/y", + "+++ b/y", + "@@ -1 +1 @@", + "-alt", + "+neu", + ].join("\n"), + ); + assert.equal(parsed.hunks.length, 2); + assert.deepEqual( + parsed.hunks[0].lines.map((line) => line.text), + ["old", "new"], + ); + assert.deepEqual( + parsed.hunks[1].lines.map((line) => line.text), + ["alt", "neu"], + ); + assert.equal(parsed.headerLines.filter((line) => line.startsWith("--- ")).length, 2); + assert.equal(parsed.added, 2); + assert.equal(parsed.removed, 2); +}); + +test("an unrecognised tail is kept as unnumbered context and header lines before a hunk are kept", () => { + const parsed = parseUnifiedPatch( + ["index abc..def 100644", "--- a/x", "+++ b/x", "@@ -1 +1 @@", "-old", "+new", "trailing junk"].join("\n"), + ); + assert.equal(parsed.headerLines[0], "index abc..def 100644"); + const tail = parsed.hunks[0].lines.at(-1); + assert.equal(tail.kind, ChangeLineKind.Context); + assert.equal(tail.text, "trailing junk"); + assert.equal(tail.oldLine, 0); + assert.equal(tail.newLine, 0); +}); + +test("a trailing newline becomes a numbered empty context line", () => { + const parsed = parseUnifiedPatch("@@ -1 +1 @@\n ctx\n"); + const lines = parsed.hunks[0].lines; + assert.equal(lines.length, 2); + assert.deepEqual([lines[1].text, lines[1].oldLine, lines[1].newLine], ["", 2, 2]); +}); + +// --------------------------------------------------------------------------- +// Aggregation +// --------------------------------------------------------------------------- + +test("a null capture that is running/waiting is pending, otherwise a missing capture", () => { + const running = runChanges([step({ status: "running" }), step({ status: "waiting" })]); + assert.equal(running.pending, true); + assert.equal(running.missingCaptures, 0); + assert.equal(running.stepsWithChanges, 0); + + const missing = runChanges([step({ status: "completed" }), step({ status: "failed" })]); + assert.equal(missing.pending, false); + assert.equal(missing.missingCaptures, 2); +}); + +test("a present capture with no files is a captured no-change", () => { + const changes = runChanges([ + step({ stage: "a", file_changes: { status: "complete", files: [] } }), + ]); + assert.equal(changes.stepsWithChanges, 1); + assert.deepEqual(changes.files, []); + assert.equal(changes.partial, false); + assert.equal(runChangesHeader(changes), "Changes · no changes observed"); + assert.equal(noChangeDetail(changes), "The captured snapshots were identical: the workspace was unchanged."); +}); + +test("the later step wins the kind, but `other` never downgrades it", () => { + const changes = runChanges([ + step({ stage: "a", file_changes: { status: "complete", files: [file({ path: "x", kind: "modified" })] } }), + step({ stage: "b", file_changes: { status: "complete", files: [file({ path: "x", kind: "added" })] } }), + ]); + assert.equal(changes.files.length, 1); + assert.equal(changes.files[0].kind, ChangeKind.Added); + assert.deepEqual(changes.files[0].steps, ["a", "b"]); + + const downgrade = runChanges([ + step({ stage: "a", file_changes: { status: "complete", files: [file({ path: "x", kind: "added" })] } }), + step({ stage: "b", file_changes: { status: "complete", files: [file({ path: "x", kind: "copied" })] } }), + ]); + assert.equal(downgrade.files[0].kind, ChangeKind.Added); +}); + +test("stat sums, binary/truncated OR and mode first/last-seen across steps", () => { + const changes = runChanges([ + step({ + stage: "a", + file_changes: { + status: "complete", + files: [ + file({ + path: "x", + kind: "modified", + patch: "@@ -1 +1 @@\n-old\n+new", + before_mode: "0644", + after_mode: "0644", + }), + ], + }, + }), + step({ + stage: "b", + file_changes: { + status: "complete", + files: [ + file({ + path: "x", + kind: "modified", + patch: "@@ -1 +1 @@\n-gone\n+kept", + binary: true, + truncated: true, + before_mode: "0755", + after_mode: "0755", + }), + ], + }, + }), + ]); + const entry = changes.files[0]; + assert.equal(entry.added, 2); + assert.equal(entry.removed, 2); + assert.equal(entry.binary, true); + assert.equal(entry.truncated, true); + assert.equal(entry.beforeMode, "0644"); // first-seen + assert.equal(entry.afterMode, "0755"); // last-seen + assert.equal(entryModeChanged(entry), true); + assert.equal(entryHasPatch(entry), false); // binary hides the patch + assert.equal(changes.added, 2); + assert.equal(changes.removed, 2); +}); + +test("changed-by lists the stage names in run order, deduped", () => { + const changes = runChanges([ + step({ stage: "implementer", file_changes: { status: "complete", files: [file({ path: "x" })] } }), + step({ stage: "reviewer", file_changes: { status: "complete", files: [file({ path: "x" })] } }), + step({ stage: "implementer", file_changes: { status: "complete", files: [file({ path: "x" })] } }), + ]); + assert.deepEqual(changes.files[0].steps, ["implementer", "reviewer"]); + assert.equal(changeRowMeta(changes.files[0]), "changed by implementer → reviewer"); +}); + +test("a blank stage name falls back to `stage` and blank paths are skipped", () => { + const changes = runChanges([ + step({ stage: " ", file_changes: { status: "complete", files: [file({ path: "x" }), file({ path: " " })] } }), + ]); + assert.equal(changes.files.length, 1); + assert.deepEqual(changes.files[0].steps, ["stage"]); +}); + +test("partial is OR'd from the capture status, a truncated file or any omitted count", () => { + assert.equal( + runChanges([step({ file_changes: { status: "partial", files: [] } })]).partial, + true, + ); + assert.equal( + runChanges([step({ file_changes: { status: "complete", files: [file({ truncated: true })] } })]).partial, + true, + ); + assert.equal( + runChanges([step({ file_changes: { status: "complete", files: [], omitted: 2 } })]).partial, + true, + ); +}); + +test("diagnostics from several captures are joined with a space, deduped", () => { + const changes = runChanges([ + step({ file_changes: { status: "partial", files: [], diagnostic: "why one" } }), + step({ file_changes: { status: "partial", files: [], diagnostic: "why one" } }), + step({ file_changes: { status: "partial", files: [], diagnostic: "why two" } }), + ]); + assert.equal(changes.diagnostic, "why one why two"); +}); + +// --------------------------------------------------------------------------- +// Header, note and detail wording +// --------------------------------------------------------------------------- + +test("runChangesHeader covers every empty-capture variant", () => { + assert.equal( + runChangesHeader({ unavailable: true, files: [], partial: false, pending: false, stepsWithChanges: 0, missingCaptures: 0 }), + "Changes · capture unavailable", + ); + assert.equal( + runChangesHeader({ unavailable: false, files: [], partial: false, pending: true, stepsWithChanges: 0, missingCaptures: 0 }), + "Changes · capture pending", + ); + assert.equal( + runChangesHeader({ unavailable: false, files: [], partial: true, pending: false, stepsWithChanges: 1, missingCaptures: 0 }), + "Changes · partial capture", + ); + assert.equal( + runChangesHeader({ unavailable: false, files: [], partial: false, pending: false, stepsWithChanges: 0, missingCaptures: 0 }), + "Changes · not recorded for this run", + ); + assert.equal( + runChangesHeader({ unavailable: false, files: [], partial: false, pending: false, stepsWithChanges: 1, missingCaptures: 1 }), + "Changes · capture incomplete", + ); + assert.equal( + runChangesHeader({ unavailable: false, files: [], partial: false, pending: false, stepsWithChanges: 2, missingCaptures: 0 }), + "Changes · no changes observed", + ); +}); + +test("runChangesHeader counts files, omits a zero stat side and appends the caveats", () => { + const one = { unavailable: false, partial: false, pending: false, stepsWithChanges: 1, missingCaptures: 0, added: 4, removed: 0, files: [{}] }; + assert.equal(runChangesHeader(one), "1 file changed · +4"); + + const many = { ...one, added: 0, removed: 0, files: [{}, {}] }; + assert.equal(runChangesHeader(many), "2 files changed"); + + const partial = { ...one, partial: true, added: 4, removed: 2, files: [{}, {}] }; + assert.equal(runChangesHeader(partial), "2 files changed · +4 -2 · partial capture"); + + const incomplete = { ...one, added: 4, removed: 2, files: [{}, {}], missingCaptures: 1 }; + assert.equal(runChangesHeader(incomplete), "2 files changed · +4 -2 · capture incomplete"); +}); + +test("runChangesNote spells the partial, missing and unavailable notes", () => { + assert.equal( + runChangesNote({ unavailable: true, diagnostic: "" }), + "The workspace snapshot could not be compared; the changes below may be incomplete.", + ); + assert.equal( + runChangesNote({ unavailable: true, diagnostic: "server says so" }), + "server says so", + ); + assert.equal( + runChangesNote({ + unavailable: false, + partial: true, + skipped: 8, + omitted: 0, + diagnostic: "Excluded protected files.", + files: [], + missingCaptures: 1, + }), + "Partial capture: some changes may be missing. (8 files skipped) Excluded protected files. " + + "Missing capture: 1 stage did not record changes.", + ); + assert.equal( + runChangesNote({ + unavailable: false, + partial: true, + skipped: 0, + omitted: 3, + diagnostic: "", + files: [{ truncated: true }, { truncated: true }], + missingCaptures: 2, + }), + "Partial capture: some changes may be missing. (3 omitted, 2 truncated) " + + "Missing capture: 2 stages did not record changes.", + ); + assert.equal(runChangesNote({ unavailable: false, partial: false, missingCaptures: 0 }), ""); + assert.equal( + runChangesNote({ unavailable: false, partial: false, missingCaptures: 1 }), + "Missing capture: 1 stage did not record changes.", + ); +}); + +test("noChangeDetail distinguishes pending, unavailable, not-recorded and unchanged", () => { + assert.equal( + noChangeDetail({ pending: true }), + "The capture runs after the stage finishes; nothing is recorded yet.", + ); + assert.equal( + noChangeDetail({ pending: false, unavailable: true }), + "The workspace snapshot could not be compared, so no changes can be shown.", + ); + assert.equal( + noChangeDetail({ pending: false, unavailable: false, stepsWithChanges: 0 }), + "This run recorded no change capture (a historical step, or a stage that does not capture).", + ); + assert.equal( + noChangeDetail({ pending: false, unavailable: false, stepsWithChanges: 2 }), + "The captured snapshots were identical: the workspace was unchanged.", + ); +}); + +test("changeEntryTags and changeRowMeta spell the tags and mode exactly", () => { + const binary = { binary: true, truncated: false, otherModeChange: true, beforeMode: "0644", afterMode: "0755", steps: ["a"] }; + assert.deepEqual(changeEntryTags(binary), ["binary"]); + assert.equal(changeRowMeta(binary), "changed by a · binary"); + + const truncated = { binary: false, truncated: true, otherModeChange: false, steps: ["a", "b"] }; + assert.deepEqual(changeEntryTags(truncated), ["truncated"]); + assert.equal(changeRowMeta(truncated), "changed by a → b · truncated"); + + const modeOnly = { binary: false, truncated: false, otherModeChange: true, beforeMode: "0644", afterMode: "0755", steps: ["a"] }; + assert.deepEqual(changeEntryTags(modeOnly), ["mode change"]); + assert.equal(changeRowMeta(modeOnly), "changed by a · mode change · mode 0644→0755"); +}); + +test("patchUnavailableReason names the truncation, the mode-only change, else the bare record", () => { + assert.equal( + patchUnavailableReason({ truncated: true }), + "The server truncated this file's patch at its capture limit; no diff text was recorded.", + ); + assert.equal( + patchUnavailableReason({ truncated: false, otherModeChange: true, beforeMode: "0644", afterMode: "0755" }), + "Only the file's mode changed (0644→0755); the server recorded no text diff.", + ); + assert.equal( + patchUnavailableReason({ truncated: false, otherModeChange: false }), + "The server recorded this change without a patch.", + ); +}); + +test("the viewer's honest messages are the app's exact wording", () => { + assert.equal( + BINARY_DIFF_MESSAGE, + "This is a binary file: the server recorded the change but has no textual diff to show.", + ); + assert.equal( + TRUNCATED_PATCH_NOTE, + "The server truncated this patch at its capture limit; the raw text is the whole record.", + ); + assert.equal(NO_LINE_CHANGES_MESSAGE, "no line changes recorded"); +}); + +// --------------------------------------------------------------------------- +// Viewer helpers +// --------------------------------------------------------------------------- + +test("changePositionLabel and gutterWidth line up", () => { + assert.equal(changePositionLabel(0, 3), "1 of 3"); + assert.equal(changePositionLabel(2, 3), "3 of 3"); + assert.equal(gutterWidth({ lines: [] }), 1); + assert.equal(gutterWidth({ lines: [{ oldLine: 9, newLine: 0 }, { oldLine: 0, newLine: 12 }] }), 2); + assert.equal(gutterText(0, 2), " "); + assert.equal(gutterText(7, 2), " 7"); +}); + +test("diffLineSymbol and diffLineClass are the app's one diff language", () => { + assert.equal(diffLineSymbol(ChangeLineKind.Add), "+"); + assert.equal(diffLineSymbol(ChangeLineKind.Remove), "-"); + assert.equal(diffLineSymbol(ChangeLineKind.Context), " "); + assert.equal(diffLineClass(ChangeLineKind.Add), "diff-add"); + assert.equal(diffLineClass(ChangeLineKind.Remove), "diff-remove"); + assert.equal(diffLineClass(ChangeLineKind.Context), "diff-context"); +}); + +// --------------------------------------------------------------------------- +// A full aggregate matches the section it renders +// --------------------------------------------------------------------------- + +test("runChanges derives run 438's shape: 22 files, partial, one missing capture", () => { + // Six steps, 23 recorded file rows for 22 unique paths, one step without a + // capture, every capture partial with a diagnostic. + const diag = "Excluded protected, symlinked, oversized or unreadable files; this is not a complete workspace diff."; + const patch = "@@ -1 +1 @@\n-old\n+new"; + const steps = [ + step({ + stage: "implementer", + file_changes: { + status: "partial", + skipped: 2, + diagnostic: diag, + files: [ + file({ path: "docs/notes.md", kind: "added", patch }), + file({ path: "internal/server/retry_test.go", kind: "modified", patch }), + file({ path: "internal/server/runner.go", kind: "modified", patch }), + ], + }, + }), + step({ stage: "reviewer", file_changes: { status: "partial", skipped: 2, diagnostic: diag, files: [] } }), + step({ + stage: "implementer", + file_changes: { + status: "partial", + skipped: 2, + diagnostic: diag, + files: [file({ path: "internal/server/retry_test.go", kind: "modified", patch })], + }, + }), + step({ stage: "reviewer", file_changes: { status: "partial", skipped: 2, diagnostic: diag, files: [] } }), + step({ stage: "ui_reviewer" }), + step({ + stage: "committer", + file_changes: { + status: "partial", + skipped: 2, + diagnostic: diag, + files: Array.from({ length: 19 }, (_, i) => file({ path: `android/file${i}.kt`, kind: "modified", patch })), + }, + }), + ]; + const changes = runChanges(steps); + assert.equal(changes.files.length, 22); + assert.equal(changes.stepsWithChanges, 5); + assert.equal(changes.missingCaptures, 1); + assert.equal(changes.partial, true); + assert.equal(changes.unavailable, false); + assert.equal(changes.pending, false); + assert.equal(changes.skipped, 10); + assert.equal(changes.files.find((f) => f.path === "internal/server/retry_test.go").added, 2); + assert.equal( + runChangesHeader(changes), + `22 files changed · +23 -23 · partial capture`, + ); + assert.ok(runChangesNote(changes).startsWith("Partial capture: some changes may be missing. (10 files skipped)")); + assert.ok(runChangesNote(changes).endsWith("Missing capture: 1 stage did not record changes.")); +}); diff --git a/web/test/graph.test.mjs b/web/test/graph.test.mjs index 9e62f673..8b957ec2 100644 --- a/web/test/graph.test.mjs +++ b/web/test/graph.test.mjs @@ -14,6 +14,7 @@ import { MAX_SCALE, PIPELINE_GRAPH_EMPTY, RUN_GRAPH_MISSING, + RUN_GRAPH_NOTE, NO_NODE_DETAILS, STAGE_DEFINITION_TITLE, configLabel, @@ -33,7 +34,11 @@ import { clampOffset, fitScale, zoomAbout, + stageIsExecuted, + edgeIsExecuted, + activeStage, } from "../src/graph.js"; +import { runGraphState } from "../src/runDetail.js"; // --------------------------------------------------------------------------- // Fixtures @@ -369,12 +374,119 @@ test("terminalFields lists the incoming routes into a terminal", () => { assert.deepEqual(terminalFields(twoStageGraph(), "#nope"), []); }); +// --------------------------------------------------------------------------- +// Run-mode execution state (R5: GraphSemantics RunGraphState.from) +// --------------------------------------------------------------------------- + +test("runGraphState resolves visited stages, taken routes and reached terminals", () => { + const run = { + executing: false, + current_stage: "committer", + steps: [ + { stage: "implementer", sequence: 1, status: "completed", outcome: "success", target: "reviewer" }, + { stage: "reviewer", sequence: 2, status: "completed", outcome: "rejected", target: "implementer" }, + { stage: "implementer", sequence: 3, status: "completed", outcome: "success", target: "reviewer" }, + { stage: "committer", sequence: 4, status: "completed", outcome: "success", target: "#success" }, + ], + }; + const state = runGraphState(run); + assert.deepEqual(state.visitedStages, ["implementer", "reviewer", "committer", "#success"]); + assert.equal(state.currentStage, "committer"); + assert.equal(state.executing, false); + assert.equal(state.currentStageStartedAt, null); + assert.deepEqual(state.takenRoutes, [ + "implementer\u0000success\u0000reviewer", + "reviewer\u0000rejected\u0000implementer", + "committer\u0000success\u0000#success", + ]); +}); + +test("runGraphState marks a terminal only when a visit resolved to it", () => { + // A `#` target resolves by outcome: error -> #failure, everything else -> #success. + const failed = runGraphState({ + executing: false, + steps: [{ stage: "impl", outcome: "error", target: "#" }], + }); + assert.deepEqual(failed.visitedStages, ["impl", "#failure"]); + assert.equal(stageIsExecuted("#failure", failed), true); + assert.equal(stageIsExecuted("#success", failed), false); + + const midRun = runGraphState({ + executing: false, + steps: [{ stage: "impl", outcome: "success", target: "review" }], + }); + assert.equal(stageIsExecuted("#success", midRun), false); + assert.equal(stageIsExecuted("#failure", midRun), false); + assert.equal(stageIsExecuted("review", midRun), false, "a target is not visited until a step lands on it"); +}); + +test("stageIsExecuted is true for a visited stage and for the definition view", () => { + const state = runGraphState({ + executing: false, + steps: [{ stage: "impl", outcome: "success", target: "review" }], + }); + assert.equal(stageIsExecuted("impl", state), true); + assert.equal(stageIsExecuted("review", state), false); + // The definition view passes no runState, so every stage is executed. + assert.equal(stageIsExecuted("review", null), true); +}); + +test("edgeIsExecuted is true only for a route a recorded visit produced", () => { + const state = runGraphState({ + executing: false, + steps: [ + { stage: "impl", outcome: "success", target: "review" }, + { stage: "review", outcome: "error", target: "#" }, + ], + }); + const taken = { source: "impl", outcome: "success", target: "review" }; + const byFallback = { source: "review", outcome: "error", target: "#failure" }; + const untaken = { source: "impl", outcome: "blocked", target: "#failure" }; + assert.equal(edgeIsExecuted(taken, state), true); + assert.equal(edgeIsExecuted(byFallback, state), true, "a resolved fallback route counts"); + assert.equal(edgeIsExecuted(untaken, state), false); + // The definition view draws every route executed. + assert.equal(edgeIsExecuted(untaken, null), true); +}); + +test("activeStage resolves only while the run is executing", () => { + const live = runGraphState({ + executing: true, + current_stage: "review", + steps: [ + { stage: "review", status: "running", started_at: "2026-01-01T00:00:00Z" }, + ], + }); + assert.equal(activeStage(live), "review"); + assert.equal(live.currentStageStartedAt, "2026-01-01T00:00:00Z"); + + const settled = runGraphState({ + executing: false, + current_stage: "review", + steps: [ + { stage: "review", status: "running", started_at: "2026-01-01T00:00:00Z" }, + ], + }); + assert.equal(activeStage(settled), null, "a finished run has no active stage"); + assert.equal(settled.currentStageStartedAt, null); + assert.equal(activeStage(null), null, "the definition view has no active stage"); +}); + +test("runGraphState falls back to the last visit's stage, else null", () => { + const state = runGraphState({ executing: false, steps: [{ stage: "a" }, { stage: "b" }] }); + assert.equal(state.currentStage, "b"); + assert.equal(runGraphState({ executing: false, steps: [] }).currentStage, null); + assert.equal(runGraphState({}).currentStage, null); +}); + // --------------------------------------------------------------------------- // Wording, exports and the no-innerHTML contract // --------------------------------------------------------------------------- test("the empty-state and pane wording matches the app's sentences", () => { assert.equal(RUN_GRAPH_MISSING, "This server did not include the run graph."); + assert.ok(RUN_GRAPH_NOTE.includes("pulses")); + assert.ok(RUN_GRAPH_NOTE.includes("Mouse wheel to zoom")); assert.equal(PIPELINE_GRAPH_EMPTY, "This pipeline has no stages."); assert.equal(NO_NODE_DETAILS, "No details recorded for this node."); assert.equal(STAGE_DEFINITION_TITLE, "Stage definition"); diff --git a/web/test/runDetail.test.mjs b/web/test/runDetail.test.mjs index b76a4af8..76f40c7a 100644 --- a/web/test/runDetail.test.mjs +++ b/web/test/runDetail.test.mjs @@ -79,10 +79,10 @@ test("RUN_DETAIL_TABS is the Android order, Summary first, Timeline keyed 'steps RUN_DETAIL_TABS.map((tab) => tab.label), ["Summary", "Graph", "Input", "Output", "Timeline"], ); - // The Graph body is the R5 item; only the other four render today. + // The Graph body (R5) now renders too, so every tab is present. assert.deepEqual( RENDERED_RUN_TABS.map((tab) => tab.label), - ["Summary", "Input", "Output", "Timeline"], + ["Summary", "Graph", "Input", "Output", "Timeline"], ); }); diff --git a/web/test/ui-smoke.mjs b/web/test/ui-smoke.mjs index 1514487a..2a6460f9 100644 --- a/web/test/ui-smoke.mjs +++ b/web/test/ui-smoke.mjs @@ -635,11 +635,14 @@ try { await page.waitForSelector(".list.runs .run-row", { timeout: 25000 }); await openRunDetail(430); - // The run-detail tabs, in the app's order (the Graph body is the R5 item). + // The run-detail tabs, in the app's order (Summary / Graph / Input / Output / + // Timeline; the Graph body is R5 and now rendered). const runTabs = await page.evaluate( `[...document.querySelectorAll(".detail .detail-tabs .detail-tab")].map((n) => n.textContent)`, ); - if (JSON.stringify(runTabs) !== JSON.stringify(["Summary", "Input", "Output", "Timeline"])) { + if ( + JSON.stringify(runTabs) !== JSON.stringify(["Summary", "Graph", "Input", "Output", "Timeline"]) + ) { throw new Error(`run tabs are wrong: ${runTabs.join(",")}`); } console.log(` run tabs: ${runTabs.join(" / ")}`); @@ -827,6 +830,137 @@ try { console.log(` timeline empty state: ${emptyTimeline}`); shots.push(await page.screenshot(`${out}/26-run-428-timeline-empty.png`)); + // R5: the run-detail Graph tab — the shared workflow graph in run mode. Run 438 + // is a finished run with several visits and the full outcome set: its graph + // shows the Executed / Not executed legend, solid executed nodes and arrowed + // executed routes, and dashed untaken routes. Clicking a stage opens the + // existing visit pane (with its Verdict) at that stage's latest visit. Run 440 + // shows the hollow, dashed nodes for the stages the failed run never reached. + step("opening run 438 and capturing its Graph tab (R5)"); + await page.click('.list.runs .run-row-meta[data-run-id="438"]'); + await page.waitForSelector(".detail .detail-tabs", { timeout: 25000 }); + await page.clickText(".detail .detail-tabs .detail-tab", "Graph"); + await page.waitForSelector(".run-detail .graph-note", { timeout: 15000 }); + const runGraphNote = await text(".run-detail .graph-note"); + if (!runGraphNote.includes("pulses with its elapsed time")) { + throw new Error(`unexpected run graph note: ${runGraphNote}`); + } + await page.waitForSelector(".run-detail .graph-node", { timeout: 15000 }); + await eventually(async () => { + const current = await graphState(); + return current != null && current.scale > 0; + }, { what: "the run graph to lay out" }); + + const legend = await page.evaluate( + `[...document.querySelectorAll(".run-detail .graph-legend .graph-legend-label")].map((n) => n.textContent)`, + ); + if (JSON.stringify(legend) !== JSON.stringify(["Executed", "Not executed"])) { + throw new Error(`the run graph legend is wrong: ${JSON.stringify(legend)}`); + } + const graph438 = await page.evaluate(`(() => ({ + executedNodes: document.querySelectorAll(".run-detail .graph-node.executed").length, + notExecutedNodes: document.querySelectorAll(".run-detail .graph-node.not-executed").length, + executedEdges: document.querySelectorAll(".run-detail .graph-edge-path.executed").length, + notExecutedEdges: document.querySelectorAll(".run-detail .graph-edge-path.not-executed").length, + arrowedEdges: document.querySelectorAll('.run-detail .graph-edge-path[marker-end]').length, + active: document.querySelectorAll(".run-detail .graph-node.active").length, + }))()`); + if (!graph438.executedNodes || !graph438.executedEdges || !graph438.notExecutedEdges) { + throw new Error(`run 438 should show executed stages and both executed/untaken routes: ${JSON.stringify(graph438)}`); + } + if (graph438.arrowedEdges !== graph438.executedEdges) { + throw new Error(`only executed routes carry an arrowhead: ${JSON.stringify(graph438)}`); + } + if (graph438.active !== 0) { + throw new Error(`a finished run must have no active halo: ${JSON.stringify(graph438)}`); + } + console.log( + ` run 438 graph: ${graph438.executedNodes} executed / ${graph438.notExecutedNodes} not-executed nodes, ` + + `${graph438.executedEdges} arrowed / ${graph438.notExecutedEdges} dashed routes, legend ${legend.join("/")}`, + ); + await page.rect(".run-detail .graph-viewport"); + shots.push(await page.screenshot(`${out}/28-run-438-graph.png`)); + + step("opening a stage's visit pane from the run 438 graph"); + await page.evaluate( + `document.querySelector('.run-detail .graph-node[data-key="ui_reviewer"]').click()`, + ); + await page.waitForSelector(".stage-pane", { timeout: 15000 }); + await page.waitForText("Verdict", { timeout: 15000 }); + const graphPane = await page.evaluate(`(() => ({ + title: document.querySelector(".stage-pane-title")?.textContent ?? "", + verdict: document.querySelector(".stage-pane .verdict .outcome-chip")?.textContent ?? "", + }))()`); + if (graphPane.title !== "ui_reviewer") { + throw new Error(`the graph-opened pane named the wrong stage: ${graphPane.title}`); + } + if (!graphPane.verdict) throw new Error("the graph-opened pane did not show a verdict"); + console.log(` graph-opened pane: ${graphPane.title} — verdict ${graphPane.verdict}`); + await page.rect(".stage-pane-sheet"); + shots.push(await page.screenshot(`${out}/29-run-438-graph-pane.png`)); + await page.click(".stage-pane-back"); + await eventually(() => page.evaluate(`!document.querySelector(".stage-pane")`), { + timeout: 5000, + what: "the graph stage pane to close", + }); + + step("opening run 440 to capture the hollow, not-executed stages (R5)"); + await page.click('.list.runs .run-row-meta[data-run-id="440"]'); + await page.waitForSelector(".detail .detail-tabs", { timeout: 25000 }); + await page.clickText(".detail .detail-tabs .detail-tab", "Graph"); + await page.waitForSelector(".run-detail .graph-node", { timeout: 15000 }); + const graph440 = await page.evaluate(`(() => ({ + executedNodes: document.querySelectorAll(".run-detail .graph-node.executed").length, + notExecutedNodes: document.querySelectorAll(".run-detail .graph-node.not-executed").length, + hollow: [...document.querySelectorAll(".run-detail .graph-node.not-executed")].every( + (n) => getComputedStyle(n).borderStyle === "dashed", + ), + }))()`); + if (!graph440.executedNodes || !graph440.notExecutedNodes) { + throw new Error(`run 440 should show visited and unvisited stages: ${JSON.stringify(graph440)}`); + } + if (!graph440.hollow) { + throw new Error(`an unvisited node is not hollow/dashed: ${JSON.stringify(graph440)}`); + } + console.log(` run 440 graph: ${graph440.executedNodes} executed / ${graph440.notExecutedNodes} not-executed (dashed) nodes`); + await page.rect(".run-detail .graph-viewport"); + shots.push(await page.screenshot(`${out}/30-run-440-graph.png`)); + + // R5: a live run's Graph tab — the current stage carries the pulsing halo and + // a ticking elapsed badge; a finished run (above) carries neither. Best effort: + // the run may stop before we look, so skip rather than fail if none is running. + step("opening a live run's Graph tab (R5: halo + elapsed badge)"); + const liveRunId = await page.evaluate(`(() => { + const row = [...document.querySelectorAll(".list.runs .run-row")].find((n) => n.querySelector(".chip-running")); + const meta = row?.querySelector(".run-row-meta[data-run-id]"); + return meta ? Number(meta.getAttribute("data-run-id")) : null; + })()`); + if (liveRunId == null) { + console.log(" -- no running run available; skipped the live graph halo capture"); + } else { + await page.click(`.list.runs .run-row-meta[data-run-id="${liveRunId}"]`); + await page.waitForSelector(".detail .detail-tabs", { timeout: 25000 }); + await page.clickText(".detail .detail-tabs .detail-tab", "Graph"); + await page.waitForSelector(".run-detail .graph-node", { timeout: 15000 }); + const live = await eventually( + async () => + page.evaluate(`(() => { + const active = document.querySelector(".run-detail .graph-node.active"); + if (!active) return null; + return { + activeKey: active.dataset.key ?? "", + pulsing: active.classList.contains("pulsing"), + badge: active.querySelector(".graph-elapsed")?.textContent ?? "", + }; + })()`), + { timeout: 15000, what: "the live run's active stage" }, + ); + if (!live.badge) throw new Error(`the active stage showed no elapsed badge: ${JSON.stringify(live)}`); + console.log(` live run ${liveRunId}: active stage ${live.activeKey} (pulsing=${live.pulsing}), badge ${live.badge}`); + await page.rect(".run-detail .graph-viewport"); + shots.push(await page.screenshot(`${out}/31-run-live-graph.png`)); + } + // The Output empty state, on the running run that has not produced output yet. step("opening the Output tab on a run with no output recorded"); const runningId = await page.evaluate(`(() => { @@ -920,6 +1054,277 @@ try { console.log(` recovered banner after window online: ${recoveredText}`); await shot("30-reconnect-recovered.png"); + // R4: the run Summary's collapsible Changes section and its rendered/raw diff + // viewer. Run 438 changed 22 unique files across 6 steps with every capture + // partial, so the header/row count are asserted against each other rather than + // against a hardcoded total. + const changesToggle = () => + page.evaluate(`(() => { + const t = [...document.querySelectorAll(".run-detail .collapsible .section-toggle")] + .find((n) => /\\d+ files? changed/.test(n.querySelector(".section-title")?.textContent ?? "")); + if (!t) return null; + return { + title: t.querySelector(".section-title")?.textContent ?? "", + expanded: t.getAttribute("aria-expanded"), + rows: t.parentElement?.querySelectorAll(".change-row").length ?? 0, + }; + })()`); + const expandChanges = async () => { + const marked = await page.evaluate(`(() => { + const t = [...document.querySelectorAll(".run-detail .collapsible .section-toggle")] + .find((n) => /\\d+ files? changed/.test(n.querySelector(".section-title")?.textContent ?? "")); + if (!t) return false; + t.scrollIntoView({ block: "center" }); + t.setAttribute("data-test-changes-toggle", "1"); + return true; + })()`); + if (!marked) throw new Error("no Changes section toggle rendered"); + await page.click("[data-test-changes-toggle='1']"); + await page.evaluate( + `document.querySelector("[data-test-changes-toggle='1']")?.removeAttribute("data-test-changes-toggle")`, + ); + await page.waitForSelector(".run-detail .changes-list .change-row", { timeout: 15000 }); + }; + const closeChangeViewer = async (how) => { + if (how === "escape") { + await page.evaluate( + `document.dispatchEvent(new KeyboardEvent("keydown", { key: "Escape", bubbles: true }))`, + ); + } else if (how === "backdrop") { + await page.evaluate(`document.querySelector(".change-viewer").click()`); + } else { + await page.click(".change-viewer-close"); + } + await eventually(() => page.evaluate(`!document.querySelector(".change-viewer")`), { + timeout: 5000, + what: `the diff viewer to close (${how})`, + }); + }; + + step("opening run 438: the collapsed Changes section (R4)"); + await page.click('.list.runs .run-row-meta[data-run-id="438"]'); + await page.waitForText("run 438 ·", { timeout: 25000 }); + await page.waitForSelector(".detail .detail-tabs", { timeout: 25000 }); + const collapsed = await changesToggle(); + if (!collapsed) throw new Error("run 438's Summary rendered no Changes section"); + if (collapsed.expanded !== "false") { + throw new Error(`the Changes section is not collapsed on first render: ${collapsed.expanded}`); + } + if (collapsed.rows !== 0) throw new Error(`a collapsed Changes section drew ${collapsed.rows} row(s)`); + const changesCount = Number((/^(\d+) files? changed/.exec(collapsed.title) ?? [])[1] ?? 0); + if (!changesCount) throw new Error(`the Changes header has no file count: ${collapsed.title}`); + if (!collapsed.title.includes("partial capture")) { + throw new Error(`run 438's Changes header should note the partial capture: ${collapsed.title}`); + } + console.log(` collapsed changes header: ${collapsed.title}`); + shots.push(await page.screenshot(`${out}/28-run-438-changes-collapsed.png`)); + + step("expanding the Changes section: the observed-file rows"); + await expandChanges(); + const expanded = await page.evaluate(`(() => ({ + summary: document.querySelector(".run-detail .changes-summary")?.textContent ?? "", + note: document.querySelector(".run-detail .changes-note")?.textContent ?? "", + rows: document.querySelectorAll(".run-detail .changes-list .change-row").length, + kinds: [...document.querySelectorAll(".run-detail .changes-list .change-kind")].map((n) => n.textContent), + expanded: [...document.querySelectorAll(".run-detail .collapsible .section-toggle")] + .find((n) => /\\d+ files? changed/.test(n.querySelector(".section-title")?.textContent ?? "")) + ?.getAttribute("aria-expanded"), + }))()`); + if (expanded.expanded !== "true") throw new Error("the Changes section did not expand"); + if (expanded.rows !== changesCount) { + throw new Error(`the Changes section drew ${expanded.rows} rows for a header count of ${changesCount}`); + } + if (!expanded.note.startsWith("Partial capture: some changes may be missing.")) { + throw new Error(`the partial-capture note is missing: ${expanded.note}`); + } + console.log(` expanded: ${expanded.summary} — ${expanded.rows} row(s)`); + console.log(` note: ${expanded.note}`); + console.log(` kinds: ${[...new Set(expanded.kinds)].join(", ")}`); + await page.evaluate(`document.querySelector(".run-detail .changes-list .change-row")?.scrollIntoView({ block: "center" })`); + shots.push(await page.screenshot(`${out}/29-run-438-changes-expanded.png`)); + + step("opening the rendered diff viewer on the first changed file"); + await page.click(".run-detail .changes-list .change-row"); + await page.waitForSelector(".change-viewer", { timeout: 15000 }); + const rendered = await page.evaluate(`(() => ({ + kind: document.querySelector(".change-viewer .change-kind")?.textContent ?? "", + path: document.querySelector(".change-viewer-path")?.textContent ?? "", + position: document.querySelector(".change-viewer-position")?.textContent ?? "", + renderedActive: document.querySelector('.change-form[data-form="rendered"]')?.classList.contains("active") ?? false, + renderedDisabled: document.querySelector('.change-form[data-form="rendered"]')?.disabled ?? null, + rawDisabled: document.querySelector('.change-form[data-form="raw"]')?.disabled ?? null, + hunks: document.querySelectorAll(".change-viewer .change-hunk").length, + lines: document.querySelectorAll(".change-viewer .change-line").length, + gutter: document.querySelector(".change-viewer .change-gutter")?.textContent ?? "", + adds: document.querySelectorAll(".change-viewer .change-text.diff-add").length, + removes: document.querySelectorAll(".change-viewer .change-text.diff-remove").length, + prevDisabled: document.querySelector('.change-page[data-page="prev"]')?.disabled ?? null, + }))()`); + if (!rendered.renderedActive || rendered.renderedDisabled !== true) { + throw new Error(`Rendered is not the default selected form: ${JSON.stringify(rendered)}`); + } + if (!rendered.path || !rendered.position.includes("of ")) { + throw new Error(`the viewer did not identify its file: ${JSON.stringify(rendered)}`); + } + if (!rendered.hunks || !rendered.lines) { + throw new Error(`the rendered viewer drew no hunks/lines: ${JSON.stringify(rendered)}`); + } + if (rendered.gutter.trim() === "") throw new Error("the rendered viewer drew no gutter numbers"); + if (rendered.prevDisabled !== true) throw new Error("Previous should be disabled on the first file"); + console.log( + ` rendered: ${rendered.kind} ${rendered.path} — ${rendered.position}; ` + + `${rendered.hunks} hunk(s), ${rendered.lines} line(s), ${rendered.adds}+/${rendered.removes}-`, + ); + shots.push(await page.screenshot(`${out}/30-run-438-changes-diff-rendered.png`)); + + step("switching the diff viewer to the Raw patch"); + await page.evaluate(`document.querySelector('.change-form[data-form="raw"]').click()`); + await page.waitForSelector(".change-viewer .change-raw", { timeout: 15000 }); + const raw = await page.evaluate(`(() => ({ + rawActive: document.querySelector('.change-form[data-form="raw"]')?.classList.contains("active") ?? false, + renderedDisabled: document.querySelector('.change-form[data-form="rendered"]')?.disabled ?? null, + text: document.querySelector(".change-viewer .change-raw")?.textContent ?? "", + }))()`); + if (!raw.rawActive) throw new Error("Raw patch did not become the selected form"); + if (!raw.text.includes("@@")) { + throw new Error(`the raw patch does not look like a unified diff: ${raw.text.slice(0, 80)}`); + } + console.log(` raw patch: ${raw.text.split("\n")[0]} (${raw.text.length} chars)`); + shots.push(await page.screenshot(`${out}/31-run-438-changes-diff-raw.png`)); + + step("paging between files: Next to the last, then Previous"); + await page.evaluate(`document.querySelector('.change-page[data-page="next"]').click()`); + await eventually( + async () => (await page.evaluate(`document.querySelector(".change-viewer-position")?.textContent ?? ""`)).startsWith("2 of "), + { what: "the viewer to page to file 2" }, + ); + await page.evaluate(`(() => { + for (let i = 0; i < 500; i += 1) { + const next = document.querySelector('.change-page[data-page="next"]'); + if (!next || next.disabled) break; + next.click(); + } + })()`); + const last = await page.evaluate(`(() => ({ + position: document.querySelector(".change-viewer-position")?.textContent ?? "", + nextDisabled: document.querySelector('.change-page[data-page="next"]')?.disabled ?? null, + prevDisabled: document.querySelector('.change-page[data-page="prev"]')?.disabled ?? null, + }))()`); + if (last.nextDisabled !== true) throw new Error("Next is not disabled on the last file"); + if (!last.position.startsWith(`${changesCount} of `)) { + throw new Error(`the viewer did not reach the last file: ${last.position}`); + } + console.log(` paged to the last file: ${last.position}`); + await page.evaluate(`document.querySelector('.change-page[data-page="prev"]').click()`); + await eventually( + async () => (await page.evaluate(`document.querySelector(".change-viewer-position")?.textContent ?? ""`)).startsWith(`${changesCount - 1} of `), + { what: "the viewer to page back" }, + ); + + step("closing the diff viewer with Escape returns focus to the row"); + await closeChangeViewer("escape"); + const restoredFocus = await page.evaluate( + `document.activeElement?.getAttribute?.("data-change-index") ?? ""`, + ); + // The viewer was paged back one file just before closing, so focus returns to + // that row (index changesCount - 2). + if (restoredFocus !== String(changesCount - 2)) { + throw new Error(`focus did not return to the opened row: ${restoredFocus}`); + } + console.log(` focus returned to change row ${restoredFocus}`); + + step("reopening and closing the diff viewer by a backdrop click"); + await page.click(".run-detail .changes-list .change-row"); + await page.waitForSelector(".change-viewer", { timeout: 15000 }); + await closeChangeViewer("backdrop"); + + // A binary capture: the honest message in place of a diff, and Raw disabled. + step("opening a binary capture (run 442): the honest message and a disabled Raw patch"); + await page.click('.list.runs .run-row-meta[data-run-id="442"]'); + await page.waitForText("run 442 ·", { timeout: 25000 }); + await page.waitForSelector(".detail .detail-tabs", { timeout: 25000 }); + await expandChanges(); + await page.click(".run-detail .changes-list .change-row"); + await page.waitForSelector(".change-viewer .change-honest", { timeout: 15000 }); + const binary = await page.evaluate(`(() => ({ + message: document.querySelector(".change-viewer .change-honest")?.textContent ?? "", + rawDisabled: document.querySelector('.change-form[data-form="raw"]')?.disabled ?? null, + hunks: document.querySelectorAll(".change-viewer .change-hunk").length, + }))()`); + if ( + binary.message !== + "This is a binary file: the server recorded the change but has no textual diff to show." + ) { + throw new Error(`the binary message is wrong: ${binary.message}`); + } + if (binary.rawDisabled !== true) throw new Error("Raw patch should be disabled for a binary file"); + if (binary.hunks !== 0) throw new Error("a binary file must not render a fabricated diff"); + console.log(` binary: ${binary.message}`); + shots.push(await page.screenshot(`${out}/32-run-442-changes-binary.png`)); + await closeChangeViewer("close"); + + // A truncated capture: the truncation reason, still no fabricated diff. + step("opening a truncated capture (run 450): the truncation reason"); + await page.click('.list.runs .run-row-meta[data-run-id="450"]'); + await page.waitForText("run 450 ·", { timeout: 25000 }); + await page.waitForSelector(".detail .detail-tabs", { timeout: 25000 }); + await expandChanges(); + const openedTruncated = await page.evaluate(`(() => { + const row = [...document.querySelectorAll(".run-detail .changes-list .change-row")] + .find((n) => (n.querySelector(".change-meta")?.textContent ?? "").includes("truncated")); + if (!row) return false; + row.click(); + return true; + })()`); + if (!openedTruncated) throw new Error("run 450's Changes list showed no truncated row"); + await page.waitForSelector(".change-viewer .change-honest", { timeout: 15000 }); + const truncated = await page.evaluate( + `document.querySelector(".change-viewer .change-honest")?.textContent ?? ""`, + ); + if ( + truncated !== + "The server truncated this file's patch at its capture limit; no diff text was recorded." + ) { + throw new Error(`the truncation reason is wrong: ${truncated}`); + } + console.log(` truncated: ${truncated}`); + shots.push(await page.screenshot(`${out}/33-run-450-changes-truncated.png`)); + await closeChangeViewer("close"); + + // A still-running run: its Changes header must be one of the two valid shapes + // for an in-flight capture (the empty `Changes · …` variant, or a file-count + // header), never a fabricated complete diff. Its live state decides which, so + // the probe accepts either rather than pinning one. + step("opening a running run's Changes header"); + const pendingRunId = await page.evaluate(`(() => { + const row = [...document.querySelectorAll(".list.runs .run-row")] + .find((n) => n.querySelector(".chip-running")); + const meta = row?.querySelector(".run-row-meta[data-run-id]"); + return meta ? Number(meta.getAttribute("data-run-id")) : null; + })()`); + if (pendingRunId == null) { + console.log(" -- no running run available; skipped the pending Changes header"); + } else { + await page.click(`.list.runs .run-row-meta[data-run-id="${pendingRunId}"]`); + await page.waitForSelector(".detail .detail-tabs", { timeout: 25000 }); + const pendingToggle = await page.evaluate(`(() => { + // A running run's Changes header has one of two valid shapes: the + // empty-capture form (Changes · capture pending / partial capture / + // capture incomplete) before any step has recorded files, or the + // file-count form ({N} file(s) changed · ±stat · …) once one has. Which + // one appears depends on how far the live capture has progressed, so the + // probe accepts either rather than assuming the empty variant. + return [...document.querySelectorAll(".run-detail .collapsible .section-toggle .section-title")] + .map((n) => n.textContent ?? "") + .find((t) => /^Changes · /.test(t) || /^\\d+ files? changed/.test(t)) ?? ""; + })()`); + if (!/^Changes · /.test(pendingToggle) && !/^\d+ files? changed/.test(pendingToggle)) { + throw new Error(`a running run's Changes header is wrong: ${pendingToggle}`); + } + console.log(` running run ${pendingRunId} changes header: ${pendingToggle}`); + shots.push(await page.screenshot(`${out}/34-run-${pendingRunId}-changes-pending.png`)); + } + console.log("\nUI SMOKE PASS"); for (const shot of shots) console.log(` ${shot}`); } catch (error) {