Merge branch 'main' into web-connection

Integrate main's run-detail Changes (R4) and Graph (R5) work with the
connection banner/reconnect/foreground-recovery/live-badge work (T3/T4/T5).

Conflicts resolved by keeping both independent additions:
- web/styles.css: the .conn-*/.live-* rules and the .change-*/.diff-* rules
  are separate blocks; both retained under their own comment headers.
- web/test/ui-smoke.mjs: both capture sequences retained (T3/T4/T5 writes
  28-connected-banner/29-disconnected-banner/30-reconnect-recovered; R4/R5
  writes its own distinct 28-34 run-change captures), so no filename collides.

Checks after the merge: node --check on all touched JS/MJS; node --test test/
225 pass / 0 fail; node test/ui-smoke.mjs --out <worktree>/captures UI SMOKE
PASS against ws://127.0.0.1:8080/connect, including the connected banner +
build line + live badge, the disconnected retry banner, the online-event
recovery, and main's R4/R5 captures.
This commit is contained in:
2026-10-19 04:11:50 +01:00
10 changed files with 2381 additions and 37 deletions
+388 -14
View File
@@ -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();
}
+554
View File
@@ -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);
}
+112 -9
View File
@@ -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);
+65 -5
View File
@@ -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)
// ---------------------------------------------------------------------------