diff --git a/android/README.md b/android/README.md index 7ee2ec77..60654da8 100644 --- a/android/README.md +++ b/android/README.md @@ -108,15 +108,31 @@ stops it. declaration order, with `#failure`/`#success` terminals sharing a lower row and arrows entering their top borders (an `error -> #failure` route leaves its source's bottom); labelled outcome edges (`error*` marks the implicit - fallback), loops and branches, pan/zoom, and run highlighting (executed routes - highlighted, others dimmed) plus a screen-reader description. Edges are drawn as + fallback), loops and branches, pan/zoom, and run highlighting (under a run the + executed stage/route is a solid full-colour stroke with an arrowhead and a + filled, normal-bordered node, while a not-executed one is a dashed, arrowless + muted stroke with a hollow, dashed-bordered node and a muted label; an executed + `success`/`error` route is drawn noticeably heavier with a stronger same-hue + stroke and a larger arrowhead so pass/fail dominates; a one-line legend names + both states) plus a screen-reader + description. Edges are drawn as axis-aligned orthogonal polylines like the TUI (`routePoints` computes the path once per layout and stores it on `EdgeLayout.points`), and each arrowhead points along its route's final segment rather than the from-to chord. Pinch zoom is anchored to the gesture centroid: the pure `zoomAbout` keeps the content point under the fingers fixed (clamped to `MIN_SCALE`/`MAX_SCALE`) and the existing pan clamp is applied afterwards, so the content no longer slides - away from the fingers. + away from the fingers. The visual language is a modern surface, not a terminal + diagram: a stage is a rounded rectangle (the theme's `shapes.medium`) and a + terminal a pill, both filled with a tonal surface tinted with the node's + semantic hue behind a soft border (not a flat fill plus hard outline); the node + name and the outcome labels use the app's type scale (`cardTitle`/`label`, no + ad-hoc sizes, no all-caps, terminal `Success`/`Failure` in their own colour); + edges draw with round caps/joins and every right-angle bend is rounded by one + `ROUTE_CORNER_RADIUS` control offset over the unchanged stored polyline, with a + filled arrowhead proportional to its stroke and the outcome label on a rounded + tonal chip rather than raw text over the canvas; node and per-edge-track spacing + are named dp tokens. - One shared graph-panel height (`collapsedGraphHeight`/`expandedGraphHeight`) replaces the former 360.dp and 340.dp literals, so both detail screens render the graph at the same size: about 58% of the window height floored at a height @@ -1278,7 +1294,6 @@ has exactly three pane levels (`MasterPane.List/Detail/Stage`, `MAX_PANE_DEPTH = centred lines and ellipsizes (e.g. `Pipelines maintenance - plan implem…`) rather than being rotated. - ## Run stage pane leads with the run's results (16 Oct 2026) A stage opened from a run no longer leads with its own definition. The pane now @@ -2321,3 +2336,945 @@ Evidence (macOS, JDK 17 from Homebrew `openjdk@17`, Not verified in this pass: whether `:app:lintDebug` stays at its two pre-existing `NewApi` errors (it was not run). +## An app-owned run-status palette (16 Oct 2026) + +Run status had the wrong hue for its two most important states because it was +mapped onto Material roles: `primary` (mint) made a **running** run read green and +`tertiary` (amber) made a **succeeded** run read yellow. `android/` only; nothing +in the Pipelines server, its Go source, the Docker/compose files or the installer +was touched, no dependency was added, no run was started from the app, and the +attached Pixel 10 Pro Fold was never installed on or driven (every `adb`/emulator +command targeted `emulator-5556`; lane A's `emulator-5554` was not used). + +- **A new app-owned palette.** `ui/components/RunStatusPalette.kt` defines one + `Entry(colour, rationale)` per status, fixed (not scheme-derived) so a status + reads the same on every device, with a one-line reason each: Running/Active + blue, Succeeded green, Failed the app error red, Interrupted amber, Canceled + muted grey, Queued neutral grey, Unknown the low-key surface grey. + `runStateColor` is now a pure function over this palette (no `MaterialTheme`), so + it is asserted in a plain JVM test. Each state keeps its distinct material glyph + and text label, so status is never colour alone. +- **The graph outcome palette is unchanged.** `GraphPalette` and the terminal + `success`/`error` roles are untouched; run status and stage outcome stay + different vocabularies. The runs-list **Timeline** step chips (and their leading + glyphs) previously rendered through `runStateOf`/`StatusChip`, i.e. the run-status + mapping, so they were pointed at the graph's outcome palette instead: they now + call the shared `graphColors(scheme)` factory (extracted from `WorkflowGraph`, + which uses it too) and `outcomeColor`, so a step chip agrees with the graph. + The run header and runs-list cards keep the run-status palette. +- **Shared helper.** `ui/components/RunStatus.kt` gained `ColoredChip(label, + colour, icon, …)` — the single pill layout now used by both `StatusChip` (run + status) and the Timeline's outcome chip, instead of a second copy. + +Evidence (macOS, JDK 17 from Homebrew `openjdk@17`, Gradle 8.11.1, +`ANDROID_HOME=/Users/alan/Library/Android/sdk`, `ANDROID_SDK_ROOT` set, +`--offline`): + +- `gradle :app:testDebugUnitTest` reported **143 tests, 0 failures, 0 errors** + (new `RunStatusPaletteTest`: WCAG-AA contrast ≥ 4.5:1 for every status colour + against `DarkSurface 0xFF0E1513`, Succeeded green and ≠ `DarkTertiary`, Running/ + Active blue and ≠ `DarkPrimary`, Failed = `DarkError`, Interrupted amber and ≠ + Failed, Queued near-grey and ≠ Running, and a non-blank rationale per status). + `gradle :app:assembleDebug` succeeded (18,009,527-byte debug APK, sha256 + `17f52f23e40f4ba0c524ac2929adfd6a8f39353e68ccdeedb2e029019225e350`). +- On `emulator-5556` (`FoldB_API_36`, 2208x1840, density 420) in dark mode + (`adb shell cmd uimode night yes`) against the live server + `ws://10.0.2.2:8080/connect`, driven with `adb shell input` and `uiautomator + dump`. Every capture below was written with `android/scripts/capture_png.sh -s + emulator-5556` (which names the SurfaceFlinger display id and validates the PNG + magic bytes), and a validated screenshot was pixel-sampled to read the rendered + colour back: + - **Before** (pre-change tree, `git stash` build): runs-list usage values were + Succeeded `#F2C879` (amber), Running card `#6FD3B8` (mint); a run header read + `#F2C879` (succeeded) and `#6FD3B8` (running) — the reported bug, `captures` in + `runs_list_before.png`, `run_header_before.png`, `run_header_running_before.png`. + - **After**: runs-list usage values were Succeeded `#7FE0A8` (green), Failed + `#FFB4AB` (error red), Canceled `#889391` (muted), Interrupted `#E8C06A` + (amber), Active `#7FB2F0` (blue); the running card was `#7FB2F0` and the + succeeded card `#7FE0A8` (`runs_list_after.png`). A run header read `#7FE0A8` + (succeeded) and `#7FB2F0` (running) (`run_header_after.png`, + `run_header_running_after.png`). + - **Timeline agrees with the graph**: before, a graph-only outcome still went + through the run-status mapping — an `approved` step chip sampled `#BEC9C5` + (the run-status `Unknown` grey). After, the `success` step chip sampled + `#F2C879` (the graph's tertiary terminal role) and the `approved` chip + `#C0A3F5` (`GraphPalette` index 5), both equal to the graph's `outcomeColor` + (`run_timeline_before.png`, `run_timeline_after.png`). + - `adb -s emulator-5556 logcat -d` contained 0 `FATAL EXCEPTION` / `E + AndroidRuntime` lines (the only app-matched lines were expected + `InputDispatcher … Consumer closed input channel` warnings from the + force-stop/reinstall). +- **APK publish.** `app/build/outputs/apk/debug/app-debug.apk` was copied to + `…/artifacts/69/1/pipelines-debug-wip-cd85f69.apk` (`cd85f69` = `git rev-parse + --short HEAD`); `shasum -a 256` matched. `curl -I + http://10.0.0.249:8080/artifacts/69/1/pipelines-debug-wip-cd85f69.apk` (LAN + address from `ipconfig getifaddr en0`) returned `HTTP/1.1 200 OK`, + `Content-Type: application/vnd.android.package-archive`, `Content-Length: + 18009527`; a streamed `GET | shasum -a 256` equalled the local file. At 17.2 MiB + it exceeds the server's 8 MiB per-file inventory cap, so it is served by direct + URL only. + +### Re-verified against the committed tree (run 72, 16 Oct 2026) + +The change above is committed at `24584d8`; re-checked independently on that exact +tree (JDK 17 from Homebrew `openjdk@17`, Gradle 8.11.1, `--offline`): + +- `gradle --offline :app:testDebugUnitTest --rerun` → **143 tests, 0 failures, 0 + errors** (`RunStatusPaletteTest` 7/7, including the per-status WCAG-AA contrast + check). `gradle --offline :app:assembleDebug` succeeded; the APK is 18,009,527 + bytes, sha256 `17f52f23e40f4ba0c524ac2929adfd6a8f39353e68ccdeedb2e029019225e350`. +- Before/after captured on `emulator-5556` (`sdk_gphone16k_arm64`, 2208x1840, + density 420, dark mode) with `android/scripts/capture_png.sh -s emulator-5556`. + The pre-change build was produced from a clean `git archive cd85f69` tree (never + a working-tree stash), and each capture was pixel-sampled to read the rendered + colour back: + - **Before**: runs-list usage Succeeded `#F2C879` (amber) and Active `#6FD3B8` + (mint); run 69 header `#F2C879`, run 72 header `#6FD3B8`; the `approved` + Timeline chip `#BEC9C5` (run-status `Unknown` grey). + - **After**: Succeeded `#7FE0A8` (green), Failed `#FFB4AB`, Canceled `#889391`, + Interrupted `#E8C06A`, Active `#7FB2F0`; run 69 header `#7FE0A8`, run 72 header + `#7FB2F0`; the `approved` Timeline chip `#C0A3F5` (graph palette index 5) while + the `success` chip stays `#F2C879` (the graph's tertiary role), so a step chip + agrees with the graph. `logcat` after a fresh launch had 0 `FATAL EXCEPTION` / + `E AndroidRuntime` lines. +- **APK publish.** `app/build/outputs/apk/debug/app-debug.apk` copied to + `…/artifacts/72/1/pipelines-debug-wip-24584d8.apk` (`24584d8` = `git rev-parse + --short HEAD`); `curl -I + http://10.0.0.249:8080/artifacts/72/1/pipelines-debug-wip-24584d8.apk` returned + `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`, + `Content-Length: 18009527`, and a streamed `GET | shasum -a 256` matched. + +## Last-run facts on every pipeline row (16 Oct 2026) + +`android/` only. No server field was added: the whole run history already arrives +from `list_runs` (`internal/pipeline/runs.go`, id DESC), so the join is +client-side. + +- **Pure join.** `ui/screens/PipelineLastRun.kt` adds `pipelineRunBadges(runs, now)`, + which folds the history onto a `Map` keyed by + pipeline id with `runId`, `state` (`runStateOf`), `ranAgo` and `duration`. + Recency comes from the run timestamps, not the input order — the higher run id + breaks an exact tie (or a missing/blank `created_at`), so an unsorted or + partial response is still correct. `PipelineRunBadge.metaLine()` formats + `ago · duration · run N` and drops any fragment that is genuinely absent (a + still-running run has no `finished_at`); it never prints a blank separator. + `formatRanAgo` mirrors the `formatDuration` integer rhythm (`just now`, then + `Nm ago`/`Nh ago`/`Nd ago`) and clamps clock skew to `just now`. A pipeline with + no run is simply absent from the map and the row prints the explicit + `NO_RUNS_RECORDED` + ("no runs recorded") instead of a blank line. The last-run line is withheld + until `runsState.data != null` (`runsKnown`), so a not-yet-loaded history never + makes the false "no runs recorded" claim. +- **Row.** `PipelineListScreen.kt` refreshes runs alongside pipelines, anchors + "now" once per composition (`remember`), and renders the chip + meta line in a + `Row` under the unchanged title/secondary lines; the selected-row highlight is + untouched. +- **Tests.** `test/.../PipelineLastRunTest.kt` (10 cases) covers most-recent-wins + on unsorted input, no runs, unknown pipeline id, equal timestamps, an + unparseable timestamp, an unknown status word (`RunState.Unknown`, id still + rendered), each `formatRanAgo` scale plus blank/bad input, and the + `NO_RUNS_RECORDED` wording. + +Verified on this tree (macOS, JDK 17 from Homebrew `openjdk@17`, Gradle 9.7.1, +`ANDROID_HOME=/Users/alan/Library/Android/sdk`): + +- `gradle :app:testDebugUnitTest` → **153 tests, 0 failures, 0 errors, 0 + skipped** (`PipelineLastRunTest` 10/10). +- `gradle :app:assembleDebug --rerun-tasks --no-build-cache` succeeded → + `app-debug.apk` **17,863,337 bytes**, sha256 + `b22550660c1ce9f42719eb5a32a296055d9f3df97fa0fd94bb26fa3868730506`. This is a + full rebuild of the current tree; the review's blocker was that the earlier + published `artifacts/83/1/pipelines-debug-wip-5444390.apk` (17,997,811 bytes, + sha256 `0fb07207…`) was a different revision of `PipelineListScreen.kt`, so it + has been rebuilt and republished (see below). +- Screenshots on `emulator-5556` (`FoldB_API_36`, 2208x1840, density 420, dark + mode) with `android/scripts/capture_png.sh -s emulator-5556`: the narrow window + via `adb shell wm size 1080x2340`, the wide window at the default 2208x1840 + (`wm size reset`). Both show the running run omitting its duration, the failed + and canceled rows carrying `ago · duration · run N`, and pipeline id 3 "Plan, + implement, review" printing `no runs recorded`. +- **APK publish.** Copied to + `…/artifacts/83/3/pipelines-debug-wip-5444390.apk` (`5444390` = `git rev-parse + --short HEAD`). `curl -I + http://10.0.0.249:8080/artifacts/83/3/pipelines-debug-wip-5444390.apk` returned + `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`, + `Content-Length: 17863337`, and a streamed `GET | shasum -a 256` returned the + same `b2255066…` as the local file. The same APK was installed on the emulator + and the pulled installed `base.apk` hashed to `b2255066…`, so the reviewed + source is what was actually rendered. + +## Remembered sort options for the pipelines and runs lists (16 Oct 2026) + +Both list top bars gained a sort control that opens the choices plus a Reset, and +the choice is remembered per list across restarts. `android/` only; nothing in +the Pipelines server, its Go source, the Docker/compose files or the installer was +touched, no dependency was added (the icons come from the already-declared +`material-icons-extended`), no run was started from the app, and the attached +Pixel 10 Pro Fold was never installed on or driven (every `adb`/emulator command +targeted `emulator-5556`). + +- **Pure comparators.** `ui/screens/ListSort.kt` defines the `PipelineSort` + (`ServerOrder` default, `NameAsc`, `NameDesc`, `RecentRun`, `FewestStages`, + `MostStages`) and `RunSort` (`NewestFirst` default, `OldestFirst`, + `LongestDuration`, `ShortestDuration`, `PipelineName`, `Status`) enums plus one + pure `pipelineComparator`/`runComparator` per sort and the `sortPipelines`/ + `sortRuns` helpers. Every comparator ends in an explicit tie-break, so equal + primary keys always order the same way; a blank/unparseable timestamp and a run + with no recorded duration (still executing) sort last regardless of direction + instead of crashing. `ServerOrder` is a zero comparator, so the stable sort + preserves the server's own order exactly. `RecentRun` uses the shared + per-pipeline latest-run fold (`latestRunByPipeline`, extracted from the + last-run badge join in `PipelineLastRun.kt`) rather than folding the history + twice. +- **Shared time helpers.** `ui/Format.kt` gained `parseInstant` (moved out of + `PipelineLastRun.kt`) and `durationSeconds`; the existing `formatDuration` now + delegates to `durationSeconds`, so the printed duration and the sort key can + never disagree. +- **Shared control.** `ui/components/SortMenu.kt` is the one top-bar control both + screens use: an `IconButton` (its own glyph and content description, so it + cannot collide with the adjacent Refresh action or a future search entry point) + opening a `DropdownMenu` of the options — the active one carries a leading + check glyph, not colour alone — then a divider and Reset. It has no geometry + literals and anchors correctly at both window widths. The glyph is + `Icons.AutoMirrored.Filled.Sort` (the RTL-aware form, so no `Icons.Default.Sort` + deprecation warning at build time and the arrow mirrors correctly). +- **Persistence.** `data/SettingsRepository.kt` stores each choice as its stable + storage key (`pipeline_sort`, `run_sort`) with a `StateFlow`, exactly like the + server URL/workspace; `AppViewModel` exposes them and their setters. The list + screens resolve the stored string with `PipelineSort.fromStorage`/ + `RunSort.fromStorage`, which fall back to the default for a stale, unknown or + blank value (the repository stays unaware of the UI enums). +- **Grouping.** `groupRunsByDay` now takes the ordering comparator and preserves + the order it produces (the default is still newest first, so the default output + is unchanged); the run list groups by day in that order and sorts within a day + by the same comparator. + +Verified on this tree (macOS, Homebrew JDK 25 (`openjdk@25`), Gradle 9.7.1, +`ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--offline`): + +- `gradle --offline :app:testDebugUnitTest --rerun-tasks` → the 21 test-result XMLs + aggregate to **167 tests, 0 failures, 0 errors, 0 skipped** (the new + `ListSortTest` has 13 cases covering the storage fallback for both enums, server + order, case-insensitive name/stage sorts with their id/name tie-breaks, + recent-run no-run-last and run-id tie-breaks, newest/oldest with unparseable + timestamps last, duration longest/shortest with a still-executing run last and + equal-duration tie-break, pipeline-name/status sorts, and that equal keys order + identically whatever the input order; `RunGroupingTest` gained an explicit-order + case). `compileDebugKotlin` emits no warnings. +- `gradle --offline :app:assembleDebug --rerun-tasks --no-build-cache` (a full + rebuild, so the published binary is exactly this tree) succeeded → + `app-debug.apk` **17,879,721 bytes**, sha256 + `cb68fbb13e469e81c15837ba95314a2ab40f1f29f4769e4a615bbc0ce4636a30`. +- On `emulator-5556` (`FoldB_API_36`, 2208x1840, density 420, dark mode) against + the live server `ws://10.0.2.2:8080/connect`, driven with `adb shell input` and + `uiautomator dump`; every capture below was written with + `android/scripts/capture_png.sh -s emulator-5556` (validated PNG, named display + id) into `…/artifacts/87/1/`. The live server's pipeline set churns while the + maintenance workflow runs, so the concrete names differ between captures, but + each ordering was read back from the accessibility tree: + - Wide (2208x1840 ≈ 841dp): tapping `Sort pipelines` opened the six options plus + `Reset` (`01_wide_pipelines_sort_open.png`); choosing `Name Z–A` reordered the + list to descending names and stored `pipeline_sort=name_desc` + (`02_wide_pipelines_name_za.png`). `Sort runs` opened the six run options plus + `Reset` (`03_wide_runs_sort_open.png`); `Oldest first` showed run 1 → 2 → 3 and + stored `run_sort=oldest_first` (`04_wide_runs_oldest_first.png`). The sort icon + and the adjacent `Refresh` stay separate actions at both widths (the icon's own + `Sort pipelines`/`Sort runs` content description sits left of `Refresh …`). + - **Persistence proof.** After setting pipelines `Name Z–A` and runs + `Oldest first`, `run-as net.awan.pipelines cat shared_prefs/pipelines_settings.xml` + showed `pipeline_sort=name_desc`, `run_sort=oldest_first`. `am force-stop + net.awan.pipelines` (verified `pidof` empty) then `am start` and a fresh + `uiautomator dump` showed the pipelines list still in descending-name order + (`05_wide_pipelines_name_za_after_relaunch.png`) and the runs list still oldest + first, run 1 → 2 → 3 (`06_wide_runs_oldest_first_after_relaunch.png`), with no + interaction. + - `Reset` on the pipelines menu restored the server order (id 1 → 5 → 11 → 6 → + 4 → 9 → 3) and stored `pipeline_sort=server_order`; `Reset` on the runs menu + restored `run_sort=newest_first` and run 87 → 86 → 85 → 84 → 83 → 82 + (`10_narrow_runs_reset_newest_first.png`). + - Narrow (`adb shell wm size 1080x2340` ≈ 411dp; `wm size reset` afterwards): + both `Sort pipelines` and `Sort runs` opened their menus + (`07_narrow_runs_sort_open.png`); `Status` ordered Canceled → Failed → Failed … + and stored `run_sort=status` (`08_narrow_runs_status_sort.png`); `Most recent + run` ordered the rows by recency 10h → 3d → 3d → 4d → 4d → 5d and put the + runless pipeline (`no runs recorded`) last, storing `pipeline_sort=recent_run` + (`09_narrow_pipelines_recent_run.png`). + - **Stale-key tolerance on device.** With `pipeline_sort` and `run_sort` set to + `garbage_key` in `shared_prefs/pipelines_settings.xml` (verified via `run-as … + cat`, then replaced by push + `run-as … cp`) and the app force-stopped and + relaunched, the pipelines list came back in the server's order (id 1 → 5 → 11 → + 6 → 4 → 9 → 3, `11_narrow_pipelines_stale_key_falls_back_to_server_order.png`) + and the runs list in newest-first (run 87 → 86 → 85), with no crash. + - `adb -s emulator-5556 logcat -d | grep -c 'FATAL EXCEPTION'` and `… | grep -c + 'E AndroidRuntime'` each returned 0; no run was started from the app. +- **APK publish.** `app-debug.apk` was copied to + `~/.local/share/pipelines/data/artifacts/87/1/pipelines-debug-wip-3480461.apk` + (`3480461` = `git rev-parse --short HEAD`); `shasum -a 256` matched. `curl -I + http://10.0.0.249:8080/artifacts/87/1/pipelines-debug-wip-3480461.apk` returned + `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`, + `Content-Length: 17879721`, and a streamed `GET | shasum -a 256` returned the + same `cb68fbb1…` as the local file. The deterministic full-rebuild APK was + installed on `emulator-5556` (`adb -s emulator-5556 install -r`) and the pulled + installed `base.apk` hashed to `cb68fbb1…`, so the reviewed source is what was + actually rendered. At 17.1 MiB it exceeds the server's 8 MiB per-file inventory + cap, so it is served by direct URL only. + +Not verified in this pass: `:app:lintDebug` was not run (its only reported issues +are the two pre-existing `NewApi` errors for `android:windowLightNavigationBar`); +a real hardware fold to the cover display was not exercised (narrow was produced +with `wm size`); no before/after baseline build was captured, since the change is +additive and the default orders are asserted unchanged by the `ServerOrder`/ +`NewestFirst` unit tests. + +## Filters for the runs and pipelines lists (16 Oct 2026) + +Both list top bars gained a filter control, remembered per list across restarts +like the sort. `android/` only; nothing in the Pipelines server, its Go source, +the Docker/compose files or the installer was touched, no dependency was added +(the one new glyph, `Icons.Default.FilterList`, is from the already-declared +`material-icons-extended`), no run was started from the app, and the attached +Pixel 10 Pro Fold was never installed on or driven (every `adb`/emulator command +targeted `emulator-5556`). + +- **Pure predicates.** `ui/screens/ListFilter.kt` defines `RunTimeRange` + (`AnyTime` default, `Today`, `Last7Days`, `Last30Days`), `RunPresence` + (`Any` default, `HasRuns`, `NoRuns`) and the `RunFilters`/`PipelineFilters` + data classes plus one pure predicate per facet (`runMatchesStatuses`, + `runMatchesPipeline`, `runMatchesTimeRange`, `pipelineMatchesPresence`, + `pipelineMatchesLastRunStatus`) and the AND-combining `filterRuns`/ + `filterPipelines`. A default filter narrows nothing; an empty status set means + "any status". The status options are the server's own run vocabulary + (queued/running/succeeded/failed/canceled/interrupted), not the app-only + `active`/`unknown` buckets. A time window is inclusive calendar days ending + today (last 7 = today + the six days before), and a blank, unparseable or + future-dated timestamp never matches a finite window. A pipeline with no run + has no last-run status, so a selected status never matches it. `fromStorage` + tolerates stale/unknown/blank values by returning the default, and + `encodeRunStates`/`decodeRunStates` round-trip the status set as the server + status words in ordinal order. +- **Runs list.** Status (multi-select), pipeline (single-select from the + distinct pipelines already present in the run history, named by their runs, so + no extra fetch) and the time range, combined with AND. +- **Pipelines list.** The existing name search stays a separate field; the new + filter adds has-runs / no-runs and the most-recent run's status (multi-select). + Both pipeline facets depend on the run history, so `filterPipelines` leaves the + list unfiltered until that history is known rather than briefly hiding every + row. +- **Shared control.** `ui/components/FilterMenu.kt` is the one top-bar control + both screens use: an `IconButton` carrying a numeric active-filter count badge + (so "filters active" is never colour alone) opening the caller's sections plus + a divider and one Clear filters action (disabled when nothing is active). Its + `optionContent` slot receives a `dismiss` callback, so single-select entries + close the menu while multi-select toggles keep it open; `FilterCheckItem` is + the shared leading-check row. It has no geometry literals and anchors + correctly at both window widths. +- **Empty states.** `ui/components/States.kt`'s `EmptyState` gained optional + `actionLabel`/`onAction`. Both lists now distinguish "nothing exists" (no + action) from "nothing matches the current filters" (a Clear filters action); + the pipelines list also says when the name search and the filters together + match nothing. The clear action resets that list's filters (and, on Pipelines, + the search) without touching the other list. +- **Persistence.** `data/SettingsRepository.kt` stores each facet under its own + stable key (`run_filter_statuses`, `run_filter_pipeline`, + `run_filter_time_range`, `pipeline_filter_presence`, + `pipeline_filter_run_statuses`) with a `StateFlow`, exactly like the sorts; + `AppViewModel` exposes them and their setters. The screens resolve the stored + strings with `RunFilters.fromStorage`/`PipelineFilters.fromStorage` (the + repository stays unaware of the UI enums). +- **Shared time helper.** The run screen's file-private `runDate` was removed in + favour of `ListFilter.kt`'s `runLocalDate`, so the day-grouping label and the + time-range predicate share one parse. `groupRunsByDay` is unchanged. + +Verified on this tree (macOS, Homebrew JDK 25 (`openjdk@25`), Gradle 9.7.1, +`ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--offline`): + +- `gradle --offline :app:testDebugUnitTest --rerun-tasks` → the 22 test-result + XMLs aggregate to **183 tests, 0 failures, 0 errors, 0 skipped** (up from 167; + the new `ListFilterTest` has 16 cases covering stored-value parsing/fallback, + encode/decode round-trip and garbage tolerance, empty-status "any", the status + union, pipeline id vs any, the inclusive time windows and blank/future + timestamps, the AND combination of every facet, presence has/no-runs, last-run + status excluding runless pipelines, the `runsKnown` guard, and the + distinct/sorted pipeline options). +- `gradle --offline :app:assembleDebug --rerun-tasks --no-build-cache` (a full + rebuild, so the published binary is exactly this tree) succeeded → + `app-debug.apk` **17,912,489 bytes**, sha256 + `eaa34c0b030511c2e4de1964dc4e905e62e822e876b5c0128bfff4d918933fc5`. +- On `emulator-5556` (`sdk_gphone16k_arm64`, 2208x1840, dark mode) against the + live server `ws://10.0.2.2:8080/connect`, driven with `adb shell input` and + `uiautomator dump`; every capture below was written with + `android/scripts/capture_png.sh -s emulator-5556` (validated PNG, named display + id) into `…/artifacts/89/1/`: + - Selecting status `failed` narrowed the runs list to the failed runs and + showed the badge `1` (`01_runs_filtered_failed.png`), read back from the + accessibility tree. + - The runs `Filter runs` menu opened with its Status, Pipeline and Time range + sections, the active-count badge and `Clear filters` + (`02_runs_filter_menu_open.png`). + - **Filtered-empty state.** Adding pipeline `Complete a Task` to the `failed` + status matched run 43, but the contradictory `running` status (no `Complete + a Task` run is running) yielded no match: the list showed `No runs match the + current filters.` with a `Clear filters` button and badge `2` + (`03_runs_filtered_empty.png`); the button restored the full list and removed + the badge. + - The pipelines `Filter pipelines` menu carries the Runs (Any/Has runs/No runs) + and Last run status sections, the badge and `Clear filters` + (`05_pipelines_filter_menu_open.png`). `Has runs` + last-run status + `succeeded` narrowed the list to its succeeded-last-run pipelines + (`04_pipelines_filtered_has_runs_succeeded.png`); `No runs` + last-run status + `succeeded` is contradictory and showed `No pipelines match the current + filters.` with `Clear filters` and badge `2` + (`06_pipelines_filtered_empty.png`); the button restored the list and cleared + only the pipelines filter (the runs filter was left intact). + - **Persistence proof.** With runs status `failed` and pipelines `has_runs` + + last-run status `succeeded`, `run-as net.awan.pipelines cat + shared_prefs/pipelines_settings.xml` showed `run_filter_statuses=failed`, + `pipeline_filter_presence=has_runs`, `pipeline_filter_run_statuses=succeeded`. + `am force-stop net.awan.pipelines` (verified `pidof` empty) then `am start` + and a fresh `uiautomator dump` showed the pipelines list still narrowed with + badge `2` (`07_pipelines_filtered_after_relaunch.png`) and the runs list still + filtered to `failed` with badge `1` + (`08_runs_filtered_after_relaunch.png`), with no interaction. + - `adb -s emulator-5556 logcat -d | grep -c 'FATAL EXCEPTION'` and `… | grep -c + 'E AndroidRuntime'` each returned 0; no run was started from the app. +- **APK publish.** `app-debug.apk` was copied to + `~/.local/share/pipelines/data/artifacts/89/1/pipelines-debug-wip-1c925d7.apk` + (`1c925d7` = `git rev-parse --short HEAD`); `shasum -a 256` matched. `curl -I + http://10.0.0.249:8080/artifacts/89/1/pipelines-debug-wip-1c925d7.apk` + returned `HTTP/1.1 200 OK`, `Content-Type: + application/vnd.android.package-archive`, `Content-Length: 17912489`, and a + streamed `GET | shasum -a 256` returned the same `eaa34c0b…` as the local file. + The deterministic full-rebuild APK was installed on `emulator-5556` + (`adb -s emulator-5556 install -r`) and the pulled installed `base.apk` hashed + to `eaa34c0b…`, so the reviewed source is what was actually rendered. At + 17.1 MiB it exceeds the server's 8 MiB per-file inventory cap, so it is served + by direct URL only. + +Not verified in this pass: `:app:lintDebug` was not run; a real hardware fold to +the cover display was not exercised (all captures were at the inner panel's +2208x1840 width, so no narrow-width capture of the filter menu was taken); the +time-range facet was unit-tested but not exercised on device, and no before/after +baseline build was captured, since the change is additive and the default filters +are asserted to narrow nothing by the unit tests. + +### Filter menu overflow and accessibility (16 Oct 2026) + +A UI review of the pass above found the runs `DropdownMenu` grew unbounded with +the distinct-pipeline count (N=8 made it fill the whole window), clipping the +`Clear filters` item under the bottom gesture inset, and that neither the +active-filter count nor the checked facets were exposed to accessibility. Fixed +in `ui/components/FilterMenu.kt` only (`android/`, no new dependency): + +- **Bounded menu.** `filterMenuMaxHeight(screenHeightDp)` caps the menu at + `0.85 ×` the window height (window-derived, like the graph's height helpers, so + no new geometry literal), so the menu scrolls internally instead of growing + past the window as `N` rises. +- **Reset always visible.** The single `Clear filters` action is now a leading + header row (`Filters` + the reset `TextButton`, disabled when nothing is + active), so it is fully in view on open and never below the fold or clipped. +- **Above the navigation inset.** A trailing spacer of + `WindowInsets.navigationBars` bottom padding keeps the last option clear of the + gesture area at maximum scroll. +- **Accessible state.** The icon's description now folds in the count + (`filterMenuDescription`, e.g. "Filter runs, 2 filters active"), and + `FilterCheckItem` exposes `toggleableState` plus `Role.Checkbox`, so TalkBack + announces the count and which facet is checked. + +Re-verified on this tree (Homebrew JDK 25, Gradle 9.7.1, +`ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--offline`): + +- `gradle --offline :app:testDebugUnitTest --rerun-tasks` → **185 tests, 0 + failures** (new `FilterMenuTest`: the height helper's proportional/positive + growth and the description's 0/1/2/negative wording). +- `gradle --offline :app:assembleDebug` succeeded → `app-debug.apk` **18,005,500 + bytes**, sha256 `7351c13b…`. +- On `emulator-5556` (2208x1840, density 420, dark mode) against + `ws://10.0.2.2:8080/connect`, captured with `android/scripts/capture_png.sh -s + emulator-5556` into `…/artifacts/89/4/`: + - The runs menu now has window `[1210,75]–[1945,1639]` (1564px = the 596dp cap), + ending ~138px above the gesture exclusion (y=1777); `Filters`/`Clear filters` + sit at the top (y=133–186) and after four swipes the last item `Last 30 days` + is at y=1466–1519, fully visible with the nav spacer below it + (`02_runs_filter_menu.png`). + - `uiautomator dump` reports the runs filter rows `checkable=true` with the + selected row `checked=true` (`Any time`), and the icon `content-desc` is + `Filter runs, 2 filters active` / `Filter runs, 1 filter active` matching + the badge (`03_runs_filtered_failed.png`, `01_runs_filtered_empty.png`). + - The pipelines menu (`Filters`/`Clear filters` at the top, `Runs` and `Last run + status` sections) is `[1542,93]–[1945,1622]`, also above the inset + (`04_pipelines_filter_menu.png`); `Has runs` + last-run `succeeded` filtered + the list (`05_…png`), `No runs` + `succeeded` showed `No pipelines match the + current filters.` with `Clear filters` (`06_…png`). + - **Persistence proof.** `am force-stop net.awan.pipelines` (verified `pidof` + empty) then `am start` and a fresh dump showed the pipelines screen still + filtered (badge `2`) and the runs list still `Filter runs, 1 filter active` + (`07_…png`, `08_…png`), with no interaction. + - `adb -s emulator-5556 logcat -d | grep -c 'FATAL EXCEPTION'` and `… | grep -c + 'E AndroidRuntime'` each returned 0. +- **APK publish.** `app-debug.apk` copied to + `…/artifacts/89/4/pipelines-debug-wip-1c925d7.apk` (`1c925d7` = `git rev-parse + --short HEAD`); `shasum -a 256` matched. `curl` against + `http://10.0.0.75:8080/artifacts/89/4/pipelines-debug-wip-1c925d7.apk` returned + `HTTP 200`, `Content-Type: application/vnd.android.package-archive`, + `Content-Length: 18005500`. + +Not verified: the **"nothing exists"** variants (`No pipelines are defined on this +server.` / `No runs have been recorded yet.`) were not captured — the live server +has both pipelines and runs, `list_runs` is not workspace-scoped, and the task +forbids touching the server's data, so there was no empty source to render them +against; the branch is unit-covered only indirectly. A real hardware fold and +`:app:lintDebug` were again not exercised. + +## Executed vs not-executed is structural, with a legend (16 Oct 2026) + +`android/` only. Nothing in the Pipelines server, its Go source, the Docker/ +compose files or the installer was touched, no dependency was added, no run was +started from the app, and every `adb`/emulator command targeted `emulator-5556` +(lane A's `emulator-5554` was never used; the attached Pixel was never installed +on or driven). + +- **The two states differ by shape, fill and border style, not by a faded tint.** + `ui/graph/WorkflowGraph.kt` now draws an executed route as a solid full-colour + stroke **with** its arrowhead, and a not-executed route as a dashed muted + stroke **without** an arrowhead. A node the run visited is filled with its + normal border; a node it did not is hollow (no fill) with a dashed muted border + and a muted-but-legible `onSurfaceVariant` label. The old `alpha = 0.25f` / + `0.3f` dimming is gone, so the distinction survives a screenshot, a dim screen + and a colour-blind reader. +- **Shared, testable predicates.** `stageIsExecuted(key, runState)` and + `edgeIsExecuted(edge, runState)` (both `runState == null` ⇒ executed) replace + the private `EdgeLayout.isExecuted` and the inline `visitedStages` check, so + drawing and the screen-reader `graphDescription` share one definition. +- **Dash token.** `INACTIVE_DASH_INTERVALS = floatArrayOf(14f, 10f)` is the one + line-style token; `INACTIVE_DASH_EFFECT` is the lazily-built `PathEffect` used + by both the not-executed edges and the not-executed node borders, so it is + never rebuilt per frame. Node/edge geometry keeps the existing layout + tokens/insets — the only new literals are the dash rhythm and the compact + legend swatch, not graph geometry. +- **Compact legend.** `GRAPH_LEGEND` (a solid, arrowed swatch labelled + `Executed`; a dashed, arrowless swatch labelled `Not executed`) is drawn as a + one-line `Row` pinned to the graph's top-start, opposite the Fit/expand + controls, so it stays visible with the top of the panel even on a short/narrow + window. It renders only when a run is selected. +- **The definition-only view is untouched.** With no `runState` every + stage/route is executed, so the graph renders exactly as before (solid, filled, + arrowed) and the legend is not composed — confirmed against the pipeline Graph + tab. (Superseded later the same day: the pass/fail change below now widens an + executed `success`/`error` route in this view too.) +- The run-detail Graph tab's help line was updated from "highlighted … dimmed" to + "solid … dashed and outlined". + +Verification (macOS; Homebrew `openjdk@17` at +`JAVA_HOME=/opt/homebrew/opt/openjdk@17/libexec/openjdk.jdk/Contents/Home`, +Gradle 8.11.1, `ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--offline`): + +- `gradle --offline clean :app:testDebugUnitTest :app:assembleDebug` → + **188 tests, 0 failures, 0 errors**; `WorkflowGraphTest` **34** tests (3 new: + the executed predicates over the definition view and a `RunGraphState`, the + dash pattern being a positive even-length rhythm, and the legend naming both + states with executed first). The clean `:app:assembleDebug` produced + `app-debug.apk` **17,912,489 bytes**, sha256 + `49631a3a2763bf1d9232eb9e7c8f9ff3edd719355ac0a99b7c91f7f40c3a1cc5` (two clean + rebuilds were byte-identical; this is the published artifact). +- A partly-executed run (run 77, pipeline id 11 "Focused tweak - implement review + commit": `implementer`, `reviewer`, `ui_reviewer` ran, `committer` did not) was + opened in the app against the live server `ws://10.0.2.2:8080/connect` in dark + mode, driven with `adb shell input`, and every capture below was written with + `android/scripts/capture_png.sh -s emulator-5556` (validated PNG magic bytes; + the fold emulator has two displays, so a `screencap` redirect must never be + used). Captures are in `…/artifacts/93/1/`: + - **Narrow** 1080x1920 @ density 480 (≈360dp): `[implementer]`, `[reviewer]`, + `[ui_reviewer]` and `[FAILURE]` are filled with solid, arrowed routes between + the visited stages and into `#failure`; `[committer]` and `[SUCCESS]` are + hollow with dashed borders, and every other route is dashed with no arrowhead + (`graph_partly_exec_narrow_1x.png`). + - **Narrow, 2x** at 2160x3840 @ density 960 (same 360dp): the same graph at + double the pixel density, dashes and arrowheads clearly resolved + (`graph_partly_exec_narrow_2x.png`). + - **Wide** 2208x1840 @ density 420 (≈841dp): `graph_partly_exec_wide_1x.png`; + **wide 2x** at 4416x3680 @ density 840: `graph_partly_exec_wide_2x.png`; a + colour 2x crop of the graph and legend `graph_partly_exec_wide_1x_zoom.png`. + - **Grayscale check.** Greyscale conversions (`PIL` `Image.convert('L')`) of + the narrow-2x and wide-1x captures, plus a 2x greyscale crop, keep the + distinction: the executed routes are continuous solid lines with arrowheads + and the nodes fill, while the not-executed routes are broken dashed lines and + the nodes are hollow outlines (`graph_partly_exec_narrow_2x_gray.png`, + `graph_partly_exec_wide_1x_gray.png`, + `graph_partly_exec_wide_1x_gray_zoom.png`). + - **Definition-only view unchanged.** Captured the pipeline Graph tab (no run) + on a pre-change build (a `54af453` worktree) and on this build; the graph pane + is pixel-identical (no legend on either side). A + `PIL ImageChops.difference` over the graph pane (`x 1150–2208, y 150–1500`) + reported `bbox None` / `0` differing pixels of 1,428,300 / max channel diff + `0`. Before/after pair: `def_before_p8.png` / `def_after_p8.png` (pipeline 8 + Graph tab); the same source's pipeline-11 Graph tab after is + `graph_definition_only_wide_1x.png`. + - `adb -s emulator-5556 logcat -d` contained 0 `FATAL EXCEPTION` and 0 + `E AndroidRuntime` lines. +- **APK publish.** `app-debug.apk` copied to + `…/artifacts/93/1/pipelines-debug-wip-54af453.apk` (`54af453` = `git rev-parse + --short HEAD`); `shasum -a 256` matched. `curl -I + http://10.0.0.249:8080/artifacts/93/1/pipelines-debug-wip-54af453.apk` (`10.0.0.249` + from `ipconfig getifaddr en0`) returned `HTTP/1.1 200 OK`, + `Content-Type: application/vnd.android.package-archive`, `Content-Length: + 17912489`, and a streamed `GET | shasum -a 256` equalled the local file. At + ~17.1 MiB the APK exceeds the server's 8 MiB per-file inventory cap, so it is + served by direct URL only. + +Not verified in this pass: `:app:lintDebug`, the light theme, and a real hardware +fold (the wide/narrow layouts were produced with `wm size`/`wm density`); the +on-device captures used the debug build of this source, while the published APK +is a clean rebuild of the same source. + +## Pass/fail edges are the loudest lines (16 Oct 2026) + +`android/` only. Nothing outside `android/` was touched, no dependency was added, +no run was started from the app, and every `adb`/emulator command targeted +`emulator-5556` (lane A's `emulator-5554` was never used; the attached device was +never installed on or driven). + +- **Two decisive outcomes, drawn heavier.** `ui/graph/WorkflowGraph.kt` now + treats `success` (pass) and `error` (fail) as the emphasised outcomes + (`isPassFailOutcome`). An executed pass/fail edge is drawn at + `PASSFAIL_EDGE_STROKE = 7f` — noticeably heavier than the previous `3f` — with + a stronger, more saturated stroke and a filled arrowhead proportional to its + own width (`edgeArrowHeadSize`, i.e. `strokeWidth * ARROW_HEAD_SCALE` with + `ARROW_HEAD_SCALE = 4`: 28f for this 7f pass/fail stroke, 12f for a normal + executed route), so pass/fail is obvious at a glance and from a distance. +- **Other lines stay finer.** Every other executed outcome keeps `EDGE_STROKE = + 3f`, and a not-executed edge uses the finer `INACTIVE_EDGE_STROKE = 2.5f`, so + the two emphasised outcomes dominate. No outcome hue changed. +- **Stronger, same-hue stroke.** `boostSaturation(color, factor)` in + `ui/graph/GraphPalette.kt` scales HSV saturation by `PASSFAIL_SATURATION = + 1.6f`, clamping at 1 while preserving hue, value and alpha. On the dark theme + the executed `success` stroke moves from `#F2C879` (hue 39.2°) to a vivid + `#F2AF30`-ish core (hue 39.3°, measured pixel `(242,175,48)`) and the executed + `error` stroke from `#FFB4AB` (hue 6.4°) to a stronger `(255,135,121)` (hue + 6.3°); the measured pixel hues match their unboosted originals, so meaning is + not conveyed by a new colour. A non-pass/fail or not-executed edge keeps its + exact outcome colour. +- **Widths come from named tokens, not call sites.** `edgeStrokeWidth`, + `edgeArrowHeadSize` and `edgeStrokeColor` pick the token for an edge; the old + `12f` arrowhead literal is gone (the draw scope takes the size as a + parameter). The legend swatch keeps the base `EDGE_STROKE`/`ARROW_HEAD_SIZE` + because it names the generic executed/not-executed states, not pass/fail. +- **Definition-only view.** With no run selected every route counts as executed, + so the definition graph now shows the same pass/fail emphasis (still no + legend). The run Graph tab help line now adds "Executed success and failure + routes are drawn thickest." + +Verification (macOS; Homebrew `openjdk@17`, +`JAVA_HOME=/opt/homebrew/opt/openjdk@17/libexec/openjdk.jdk/Contents/Home`, +Gradle 8.11.1 at +`~/.gradle/wrapper/dists/gradle-8.11.1-bin/…/gradle-8.11.1/bin/gradle`, +`ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--offline`): + +- `gradle --offline clean :app:testDebugUnitTest :app:assembleDebug` → + **193 tests, 0 failures, 0 errors**; `WorkflowGraphTest` **36** (2 new: the + executed pass/fail edge is the widest and its arrowhead scales, and only + `success`/`error` are pass/fail outcomes) and `GraphPaletteTest` **10** (3 new: + `boostSaturation` raises saturation while keeping hue/value/alpha, is safe and + clamped at the edges, and only executed pass/fail strokes are saturated + further). The clean `:app:assembleDebug` produced `app-debug.apk` + **17,912,489 bytes**, sha256 + `ce63722b851ce26322da69fa47bdc91958c3d7db3e339c1340efc3e04b6780f8`. +- **Before/after on a run with both a success and an error edge.** Run 77 + (pipeline 11 "Focused tweak - implement review commit", failed at `ui_reviewer` + with `error`) was opened in the app against the live server + `ws://10.0.2.2:8080/connect` in dark mode; its taken routes include a `success` + and an `error` edge. "Before" is HEAD `9c47527` (the six edited files stashed, + rebuilt, installed; verified by the help line without "thickest"); "after" is + this change. Captures were written with + `android/scripts/capture_png.sh -s emulator-5556`: + - **Wide** 2208x1840 @ density 420 (≈841dp): `before_wide_1x.png` / + `after_wide_1x.png`. At the panel's fit scale the executed success/error + stroke's saturated core measures **1px before, 3px after** (sampled at the + same x), while the dashed non-pass/fail routes stay ~1px. + - **Wide 2x** 4416x3680 @ density 840: `before_wide_2x.png` / + `after_wide_2x.png`. + - Cropped graph panes `before_wide_{1x,2x}_graphcrop.png` / + `after_wide_{1x,2x}_graphcrop.png` and stacked before/after sheets + `compare_wide_1x.png` / `compare_wide_2x.png` show the two amber `success` + edges and the red `error` edge as the boldest lines after the change, with + the dashed `blocked`/`rejected`/`approved`/`skipped` routes and the + not-executed `committer`/`SUCCESS` edges unchanged. + - `adb -s emulator-5556 logcat -d` contained 0 `FATAL EXCEPTION` and 0 + `E AndroidRuntime` lines. +- **APK publish.** `app-debug.apk` copied to + `…/artifacts/98/1/pipelines-debug-wip-9c47527.apk` (`9c47527` = `git rev-parse + --short HEAD`); `shasum -a 256` matched. `curl -I + http://10.0.0.249:8080/artifacts/98/1/pipelines-debug-wip-9c47527.apk` (`10.0.0.249` + from `ipconfig getifaddr en0`) returned `HTTP/1.1 200 OK`, + `Content-Type: application/vnd.android.package-archive`, `Content-Length: + 17912489`, and a streamed `GET | shasum -a 256` equalled the local file. The + APK exceeds the server's per-file inventory cap, so it is served by direct URL + only. + +Not verified in this pass: `:app:lintDebug`, the light theme, and a real hardware +fold (the wide layout was produced with `wm size`/`wm density`); the on-device +captures used the debug build of this source, while the published APK is a clean +rebuild of the same source. + +## A modern visual language for the workflow graph (16 Oct 2026) + +The graph read like an old terminal diagram (flat fills, hard outlines, sharp +right angles, `[bracketed]` all-caps labels, small arrowheads, raw text over the +canvas). This pass gives it a modern surface language without changing any +information or any hue. `android/` only; no dependency was added (the graph's +corner comes from the theme's own shape scale), no run was started from the app, +and every `adb`/emulator command targeted `emulator-5556` (lane A's +`emulator-5554` was never used; the attached Pixel was never installed on or +driven). The only modified tracked files are the four under `android/` shown in +`git status --short` below; the capture runs also leave untracked scratch +directories at the repo root (`.ui_review*/`), so a bare `git status --short` is +not clean and the "nothing outside `android/` touched" claim is only about the +change itself, not those untracked captures. + +- **Nodes are rounded and tonal, terminals are pills.** `WorkflowGraph.kt` reads + `MaterialTheme.shapes.medium` once per composition for a stage's corner and + gives a terminal a full pill (`height/2`), so a terminal is visibly not a stage. + The fill is a *tonal surface*: the new pure `tonalFill(surface, accent, + fraction)` blends a raised `surfaceContainerHigh` with a subtle fraction of the + node's semantic colour (`NEUTRAL_TINT`/`KIND_TINT` for a stage by kind, + `TERMINAL_TINT` for a terminal's success/error hue), and the hard outline is + replaced by a soft `outlineVariant` border (`NODE_BORDER`, strengthened for a + selected stage with `NODE_BORDER_SELECTED`). Every kind's hue survives; the + terminal fill now genuinely tints the outcome hue. +- **Type comes from the app's scale.** The node name uses the app's `cardTitle` + role and the outcome labels its `label` role (no ad-hoc `13.sp`/`11.sp`), with + the theme's own line height and letter spacing; the `[brackets]` and the + all-caps `SUCCESS`/`FAILURE` are gone — the graph shows `Success`/`Failure` in + the terminal's own colour (the new pure `nodeDisplayLabel`; the shared + `GraphSemantics.nodeLabel` the TUI-mirroring panes use is untouched). +- **Edges are smoother, with one control offset and matched arrowheads.** The + stored route is still the axis-aligned polyline (`routePoints`, and its layout + tests, are unchanged), but drawing now rounds every right-angle bend with the + single `ROUTE_CORNER_RADIUS` control offset (the pure `cornerCutRadius` clamps a + short adjacent segment to half its length so two cut-backs can never meet), + uses `StrokeCap.Round`/`StrokeJoin.Round`, and scales the filled arrowhead to + the line with one `ARROW_HEAD_SCALE` (`edgeArrowHeadSize = edgeStrokeWidth * + ARROW_HEAD_SCALE`). Labels sit on a rounded *tonal chip* (`tonalFill` of the + raised surface with the label's own colour) instead of raw text over the canvas. +- **More breathing room, from named tokens.** Node width/height, the horizontal + gap, the graph padding, the per-edge lane spacing and track step, and the + terminal-row gap are now named dp tokens (no inline geometry literals); the + values grew so nodes and the per-edge tracks have visibly more room, and the + collapsed-panel floor grew to `320.dp` to still fit a 4-stage graph with its + terminal row. +- **Nothing semantic changed.** The executed/not-executed structural split (solid + full-colour + arrowhead vs dashed muted + no arrowhead; filled vs hollow/dashed + node), the pass/fail emphasis (heavier, same-hue, more-saturated stroke with the + largest head), the selected-stage invert, ntfy/custom/model kind tints, the + `error*` fallback label, the legend, the active halo/elapsed badge, the flow + dots and the screen-reader description are all kept. `graphColors` and + `outcomeColor` keep their field names, so the Timeline step chips that share + them still agree with the graph. + +Verification (macOS, Homebrew JDK 25 `openjdk@25`, Gradle 9.7.1, +`ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--offline`): + +- `gradle --offline :app:testDebugUnitTest --rerun-tasks` → `BUILD SUCCESSFUL`; + the test-result XMLs aggregate to **207 tests, 0 failures, 0 errors, 0 + skipped** (4 new: `WorkflowGraphTest` for the readable node labels, the + arrowhead proportional to its stroke and the corner-cut clamp, and + `GraphPaletteTest` for `tonalFill`). `compileDebugKotlin` emitted no warnings + (the deprecated `quadraticBezierTo` was replaced by `quadraticTo`). +- `gradle --offline :app:assembleDebug` → `BUILD SUCCESSFUL`; `app-debug.apk` is + **17,928,873 bytes**, sha256 + `ba5bcc467989425b69aad2ae70799c0cf4d9eaf54be30243b4631fb7e94916b3`. +- On `emulator-5556` (`FoldB_API_36`, dark mode) against the live server + `ws://10.0.2.2:8080/connect`, driven with `adb shell input` and `uiautomator + dump`. Every capture was written with `android/scripts/capture_png.sh -s + emulator-5556` (validated PNG magic bytes, named display id) into + `~/.local/share/pipelines/data/artifacts/108/1/`. The three cases are a + definition-only graph (pipeline 3 "Plan, implement, review", 4 stages), a + partly executed run (run 94, failed at `committer`: `implementer`/`reviewer`/ + `ui_reviewer` and the failed `committer` executed, `Success` not) and its + selected (current) stage. Widths: **wide** 2208x1840 @ density 420 (≈841dp) and **narrow** + 1080x1920 @ density 480 (≈360dp); **2x** doubles the pixel size and density + (4416x3680 @840 and 2160x3840 @960), so the same dp layout is rendered at + double the pixels. "Before" is a clean `git archive 8b39c08` tree (never a + working-tree stash) built and installed; "after" is this tree. + - `{before,after}_wide_1x_definition.png`, `{before,after}_wide_2x_definition.png`, + `{before,after}_narrow_1x_definition.png`, `{before,after}_narrow_2x_definition.png` + — the definition graph; before shows `[planner]`/`[FAILURE]` rectangular + nodes with hard 90° routes and raw labels, after shows rounded, tonal nodes, + pill terminals and chipped labels. + - `{before,after}_wide_1x_run.png`, `{before,after}_wide_2x_run.png`, + `{before,after}_narrow_1x_run.png`, `{before,after}_narrow_2x_run.png` — run + 94; `implementer`/`reviewer`/`ui_reviewer` were visited and the failed + `committer` was visited too (it was entered and then failed), so all four + stages are filled and the selected `committer` inverts (light `inverseSurface` + fill, solid primary border); the executed `success`/`error` routes are the + boldest lines, and the not-executed `Success` terminal is hollow with a dashed + border (the `Failure` terminal, reached by the executed `error` edge, is + filled). The invert applies only to an *executed* stage; a selected + *not-executed* stage is instead drawn hollow with a dashed primary border + (`drawNodes`' not-executed branch), so selection is legible in either state. + - `{before,after}_{wide,narrow}_{1x,2x}_selected.png` — a 2x crop of the + selected `committer` node (its primary border and rounded shape after vs the + sharper `[committer]` before). + - `compare_wide_1x_definition.png`, `compare_wide_1x_run.png`, + `compare_narrow_1x_definition.png`, `compare_narrow_1x_run.png` — stacked + before/after sheets for the 1x narrow and wide cases. + - `adb -s emulator-5556 logcat -d` contained 0 `FATAL EXCEPTION` and 0 `E + AndroidRuntime` lines after a fresh launch and a Runs/Graph sweep; no run was + started from the app. The emulator's display was reset to its native + 2208x1840 @420 afterwards. +- **APK publish.** `app-debug.apk` was copied to + `~/.local/share/pipelines/data/artifacts/108/1/pipelines-debug-wip-8b39c08.apk` + (`8b39c08` = `git rev-parse --short HEAD`); `shasum -a 256` matched. `curl -I + http://10.0.0.249:8080/artifacts/108/1/pipelines-debug-wip-8b39c08.apk` (LAN + address from `ipconfig getifaddr en0`) returned `HTTP/1.1 200 OK`, + `Content-Type: application/vnd.android.package-archive`, `Content-Length: + 17928873`, and a streamed `GET | shasum -a 256` returned the same `ba5bcc46…` + as the local file. At 17.1 MiB it exceeds the server's 8 MiB per-file inventory + cap, so it is served by direct URL only. + +Not verified in this pass: `:app:lintDebug` (its only reported issues are the two +pre-existing `NewApi` errors for `android:windowLightNavigationBar`); the light +theme; the active/animating halo, elapsed badge and flow dots (the run 94 graph +is a finished run, so it renders settled — those live-run visuals are unchanged +by this pass and are covered by `GraphMotionTest`); a real hardware fold +(narrow/wide were produced with `wm size`/`wm density`); and a greyscale pass (the +executed/not-executed distinction is still structural, but only colour captures +were taken). The crops are derived from the full captures with PIL; the +full-size PNGs above are the primary evidence. + +### Review follow-up and re-verification (16 Oct 2026) + +A follow-up pass addressed the review findings on the code above. The rendered +surface is unchanged (the token conversion maps the former pixel literals onto the +same device-scaled geometry), and `android/` is still the only modified tree; the +untracked `.ui_review*/` scratch captures at the repo root are not part of it. + +- **Duplication.** The two near-identical rounded tonal chips (the edge outcome + labels and the active-stage elapsed badge) are now one + `DrawScope.drawTonalChip(textTopLeft, textSize, color)` helper; both call sites + pass the accent tinted into `labelBackground`, so the chip geometry lives once. +- **Redundant geometry.** `cornerCutRadius` now takes the adjacent segment lengths + the caller has already measured (`cornerCutRadius(inLength, outLength, radius)`), + so `roundedRoutePath` computes each corner's two `hypot`s once instead of twice. +- **Redundant width.** The new pure `arrowHeadSizeFor(strokeWidth)` is the one + arrowhead-from-stroke mapping; `drawEdgePaths` passes the width it has just + computed (`arrowHeadSizeFor(width)`) instead of re-deriving it, and + `edgeArrowHeadSize` delegates to the same function. +- **Geometry tokens.** `ROUTE_CORNER_RADIUS` (`7.dp`) and the chip + `EDGE_CHIP_PAD_X`/`EDGE_CHIP_PAD_Y`/`EDGE_CHIP_CORNER` (`2.dp`/`1.dp`/`2.dp`) are + dp tokens like the rest of the new graph geometry, not raw pixel literals. + +Re-run checks (same environment as above): + +- `gradle --offline :app:testDebugUnitTest` → `BUILD SUCCESSFUL`; the test-result + XMLs aggregate to **207 tests, 0 failures, 0 errors, 0 skipped** (the + `cornerCutRadius` test now exercises the length-based clamp). +- `gradle --offline :app:compileDebugKotlin --rerun-tasks` → `BUILD SUCCESSFUL` + with no `w:` warnings. +- `gradle --offline :app:assembleDebug --rerun-tasks` → `BUILD SUCCESSFUL`; + `app-debug.apk` is **17,928,873 bytes**, sha256 + `ab99e734b0b190294ebfad8d342caf599286cefda23a0faf39f0244496e3af1a`. (A full + `--rerun-tasks` rebuild is byte-reproducible — two consecutive runs produced + this same hash — whereas incremental packaging is not, so the published APK is + the `--rerun-tasks` one.) +- Smoke captures on `emulator-5556` (native 2208x1840 @420) with the rebuilt APK + (`adb -s emulator-5556 install -r app/build/outputs/apk/debug/app-debug.apk`), + written via `android/scripts/capture_png.sh -s emulator-5556`: + `followup_wide_1x_definition.png` (the pipeline 3 definition graph) and + `followup_wide_1x_run106.png` (run 106, all four stages visited) in + `~/.local/share/pipelines/data/artifacts/108/3/`. Both render the rounded tonal + nodes, pill terminals and chipped labels; run 106 shows the executed stages + filled, the selected `committer` inverted (light fill, solid primary border) and + the not-executed `Failure` terminal hollow with a dashed border — the same + structural executed/not-executed split, unchanged. `adb -s emulator-5556 logcat + -d | grep -cE 'FATAL EXCEPTION|E AndroidRuntime'` is `0`; the display was not + resized (still native 2208x1840 @420). +- **APK publish (this pass).** The rebuilt APK was copied to + `~/.local/share/pipelines/data/artifacts/108/3/pipelines-debug-wip-8b39c08.apk` + (`8b39c08` = `git rev-parse --short HEAD`). `curl -I + http://10.0.0.249:8080/artifacts/108/3/pipelines-debug-wip-8b39c08.apk` returned + `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`, + `Content-Length: 17928873`, and a streamed `GET | shasum -a 256` returned the + same `ab99e734…` as the local file. + +### Second review follow-up (16 Oct 2026) + +Two remaining findings on the modernised graph were fixed. The rendered surface is +unchanged — the first is a same-value refactor, the second a doc-only correction — +so the before/after captures above still describe the output. + +- **One label colour, not two.** `drawEdgeLabels` declared `accent` and + `textColor` holding the identical value (both `outcomeColor(...)` when the edge + executed, else `colors.labelText`); they are now the single `labelColor`, used for + both the label text and its chip tint. No pixel changes. +- **README cites the live arrowhead token.** The dated "Pass/fail edges" section + cited the removed `PASSFAIL_ARROW_HEAD_SIZE = 20f`; it now describes the current + mapping (`edgeArrowHeadSize` = `strokeWidth * ARROW_HEAD_SCALE`, i.e. 28f + pass/fail and 12f normal), matching `WorkflowGraph.kt`. + +Re-verified (Homebrew `openjdk@25`, Gradle 9.7.1, +`ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--offline`): + +- `gradle --offline :app:compileDebugKotlin --rerun-tasks` → `BUILD SUCCESSFUL` + with no `w:` warnings. +- `gradle --offline :app:testDebugUnitTest --rerun-tasks` → `BUILD SUCCESSFUL`; + the test-result XMLs aggregate to **207 tests, 0 failures, 0 errors, 0 skipped**. +- `gradle --offline :app:assembleDebug --rerun-tasks` → `BUILD SUCCESSFUL`; + `app-debug.apk` is **17,928,873 bytes**, sha256 + `c95fab884d392a2b3df6170ec2e16ccc4fdf6f1fef4e946425f5dcda56c881a7`, reproducibly + (two consecutive `--rerun-tasks` rebuilds matched). +- Smoke captures on `emulator-5556` (native 2208x1840 @420) with this APK, written + via `android/scripts/capture_png.sh -s emulator-5556`: + `followup2_wide_1x_launch.png`, `followup2_wide_1x_definition.png` (pipeline 3) + and `followup2_wide_1x_run.png` (run 109, partly executed) in + `~/.local/share/pipelines/data/artifacts/108/5/`. The definition graph renders + rounded tonal stages, pill terminals (filled `Failure`/`Success`) and chipped + labels; run 109 fills the visited stages, inverts the selected `committer` + (light fill, solid primary border) and leaves the not-executed `Failure` terminal + hollow with a dashed border. `adb -s emulator-5556 logcat -d | grep -cE 'FATAL + EXCEPTION|E AndroidRuntime'` is `0`. +- **APK publish (this pass).** The rebuilt APK was copied to + `~/.local/share/pipelines/data/artifacts/108/5/pipelines-debug-wip-8b39c08.apk` + (`8b39c08` = `git rev-parse --short HEAD`); `curl -I + http://10.0.0.249:8080/artifacts/108/5/pipelines-debug-wip-8b39c08.apk` returned + `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`, + `Content-Length: 17928873`. + +### Re-verification with a fresh before/after capture set (run 117, 16 Oct 2026) + +The source is unchanged from the sections above; this pass re-ran every check on +it and produced a fresh, complete before/after capture set in +`~/.local/share/pipelines/data/artifacts/117/1/`. `android/` remains the only +modified tree (the untracked `.caps117/` scratch captures at the repo root and the +older `.ui_review*/` directories are not part of the change). No run was started +from the app, only `emulator-5556` was ever addressed, and its display was reset to +native 2208x1840 @420 at the end. + +- `gradle --offline :app:assembleDebug --rerun-tasks` → `BUILD SUCCESSFUL`; + `app-debug.apk` is **17,928,873 bytes**, sha256 + `c95fab884d392a2b3df6170ec2e16ccc4fdf6f1fef4e946425f5dcda56c881a7` (identical to + the "Second review follow-up" build above). +- `gradle --offline :app:testDebugUnitTest --rerun-tasks` → `BUILD SUCCESSFUL`; + the test-result XMLs aggregate to **207 tests, 0 failures, 0 errors, 0 skipped** + (the new `tonalFill`, `nodeDisplayLabel`, `arrowHeadScalesWithTheStrokeItTerminates` + and `cornerCutNeverExceedsHalfTheShorterSegment` tests included). +- **Captures.** The same four display configurations as the first pass + (`wm size`/`wm density`: wide 2208x1840 @420 and its 2x 4416x3680 @840; narrow + 1080x1920 @420 and its 2x 2160x3840 @840), each for the pipeline 3 + definition-only graph and the partly executed run 109 (the selected `committer`), + written with `android/scripts/capture_png.sh -s emulator-5556`: + `{before,after}_{wide,narrow}_{1x,2x}_{definition,run}.png`, the 2x-upscaled + `{before,after}_{wide,narrow}_{1x,2x}_selected.png` node crops, and the stacked + `compare_{wide,narrow}_1x_{definition,run}.png` sheets. The `before` images were + rebuilt from `HEAD` (the four tracked files stashed, `assembleDebug`, captured, + then the stash popped and the after build reproduced the same sha256); they show + the sharp-cornered flat fills, `[bracketed]` all-caps labels and thin raw-text + routes, while the `after` images show the rounded tonal stages, pill terminals + (`Failure` hollow/dashed when not executed, `Success` filled) and chipped labels. + `adb -s emulator-5556 logcat -d | grep -cE 'FATAL EXCEPTION|E AndroidRuntime'` + is `0`. +- **APK publish (this pass).** Copied to + `~/.local/share/pipelines/data/artifacts/117/1/pipelines-debug-wip-8b39c08.apk`; + `curl -I http://10.0.0.249:8080/artifacts/117/1/pipelines-debug-wip-8b39c08.apk` + returned `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`, + `Content-Length: 17928873`. + diff --git a/android/app/src/main/java/net/awan/pipelines/data/SettingsRepository.kt b/android/app/src/main/java/net/awan/pipelines/data/SettingsRepository.kt index f29a9c8e..230761d9 100644 --- a/android/app/src/main/java/net/awan/pipelines/data/SettingsRepository.kt +++ b/android/app/src/main/java/net/awan/pipelines/data/SettingsRepository.kt @@ -21,6 +21,34 @@ class SettingsRepository(context: Context) { private val _workspace = MutableStateFlow(prefs.getString(KEY_WORKSPACE, "").orEmpty()) val workspace: StateFlow = _workspace.asStateFlow() + // The chosen list orderings, stored as their stable storage keys. The value + // is resolved (with a default fallback for a stale/unknown key) by the list + // screens, so this repository stays unaware of the UI's sort enums. + private val _pipelineSort = MutableStateFlow(prefs.getString(KEY_PIPELINE_SORT, "").orEmpty()) + val pipelineSort: StateFlow = _pipelineSort.asStateFlow() + + private val _runSort = MutableStateFlow(prefs.getString(KEY_RUN_SORT, "").orEmpty()) + val runSort: StateFlow = _runSort.asStateFlow() + + // The chosen list filters, stored as their stable storage keys/encodings and + // resolved (with a default fallback for a stale/unknown value) by the list + // screens, so this repository stays unaware of the UI's filter enums. + private val _runFilterStatuses = MutableStateFlow(prefs.getString(KEY_RUN_FILTER_STATUSES, "").orEmpty()) + val runFilterStatuses: StateFlow = _runFilterStatuses.asStateFlow() + + private val _runFilterPipeline = MutableStateFlow(prefs.getString(KEY_RUN_FILTER_PIPELINE, "").orEmpty()) + val runFilterPipeline: StateFlow = _runFilterPipeline.asStateFlow() + + private val _runFilterTimeRange = MutableStateFlow(prefs.getString(KEY_RUN_FILTER_TIME_RANGE, "").orEmpty()) + val runFilterTimeRange: StateFlow = _runFilterTimeRange.asStateFlow() + + private val _pipelineFilterPresence = MutableStateFlow(prefs.getString(KEY_PIPELINE_FILTER_PRESENCE, "").orEmpty()) + val pipelineFilterPresence: StateFlow = _pipelineFilterPresence.asStateFlow() + + private val _pipelineFilterRunStatuses = + MutableStateFlow(prefs.getString(KEY_PIPELINE_FILTER_RUN_STATUSES, "").orEmpty()) + val pipelineFilterRunStatuses: StateFlow = _pipelineFilterRunStatuses.asStateFlow() + fun setServerUrl(value: String) { val trimmed = value.trim() _serverUrl.value = trimmed @@ -33,11 +61,53 @@ class SettingsRepository(context: Context) { prefs.edit().putString(KEY_WORKSPACE, trimmed).apply() } + fun setPipelineSort(value: String) { + _pipelineSort.value = value + prefs.edit().putString(KEY_PIPELINE_SORT, value).apply() + } + + fun setRunSort(value: String) { + _runSort.value = value + prefs.edit().putString(KEY_RUN_SORT, value).apply() + } + + fun setRunFilterStatuses(value: String) { + _runFilterStatuses.value = value + prefs.edit().putString(KEY_RUN_FILTER_STATUSES, value).apply() + } + + fun setRunFilterPipeline(value: String) { + _runFilterPipeline.value = value + prefs.edit().putString(KEY_RUN_FILTER_PIPELINE, value).apply() + } + + fun setRunFilterTimeRange(value: String) { + _runFilterTimeRange.value = value + prefs.edit().putString(KEY_RUN_FILTER_TIME_RANGE, value).apply() + } + + fun setPipelineFilterPresence(value: String) { + _pipelineFilterPresence.value = value + prefs.edit().putString(KEY_PIPELINE_FILTER_PRESENCE, value).apply() + } + + fun setPipelineFilterRunStatuses(value: String) { + _pipelineFilterRunStatuses.value = value + prefs.edit().putString(KEY_PIPELINE_FILTER_RUN_STATUSES, value).apply() + } + /** True only when the user has explicitly supplied both required values. */ fun isConfigured(): Boolean = _serverUrl.value.isNotBlank() && _workspace.value.isNotBlank() private companion object { const val KEY_SERVER_URL = "server_url" const val KEY_WORKSPACE = "workspace" + const val KEY_PIPELINE_SORT = "pipeline_sort" + const val KEY_RUN_SORT = "run_sort" + const val KEY_RUN_FILTER_STATUSES = "run_filter_statuses" + const val KEY_RUN_FILTER_PIPELINE = "run_filter_pipeline" + const val KEY_RUN_FILTER_TIME_RANGE = "run_filter_time_range" + const val KEY_PIPELINE_FILTER_PRESENCE = "pipeline_filter_presence" + const val KEY_PIPELINE_FILTER_RUN_STATUSES = "pipeline_filter_run_statuses" } } diff --git a/android/app/src/main/java/net/awan/pipelines/data/protocol/GraphSemantics.kt b/android/app/src/main/java/net/awan/pipelines/data/protocol/GraphSemantics.kt index 6e09e422..7cd5066a 100644 --- a/android/app/src/main/java/net/awan/pipelines/data/protocol/GraphSemantics.kt +++ b/android/app/src/main/java/net/awan/pipelines/data/protocol/GraphSemantics.kt @@ -75,6 +75,17 @@ data class RunGraphState( val visitedStages: Set, val takenRoutes: Set, val currentStage: String?, + /** + * True while the server still reports the run as executing. The graph only + * animates a live run; a finished one is drawn settled and static. + */ + val executing: Boolean = false, + /** + * RFC3339 start of the visit currently running for [currentStage], or null + * when the run is not live or that visit's start is unknown. The graph uses + * it for the live ticking elapsed time on the active node. + */ + val currentStageStartedAt: String? = null, ) { companion object { fun from(run: RunDetail): RunGraphState { @@ -91,7 +102,17 @@ data class RunGraphState( val current = run.currentStage.ifEmpty { run.steps.lastOrNull()?.stage ?: "" } - return RunGraphState(stages, routes, current.ifEmpty { null }) + val stage = current.ifEmpty { null } + // Only a live run carries a ticking active stage; the matching running + // step's start keeps the timer on the same node as the halo. + val runningSince = if (run.executing && stage != null) { + run.steps.lastOrNull { it.stage == stage && it.status == "running" } + ?.startedAt + ?.takeIf { it.isNotBlank() } + } else { + null + } + return RunGraphState(stages, routes, stage, run.executing, runningSince) } } } diff --git a/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt b/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt index 37b1a14a..d29e9ea8 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt @@ -48,6 +48,17 @@ class AppViewModel( val configuredServerUrl: StateFlow = settings.serverUrl val configuredWorkspace: StateFlow = settings.workspace + /** The stored pipeline/run sort keys; the list screens resolve them to a sort. */ + val pipelineSort: StateFlow = settings.pipelineSort + val runSort: StateFlow = settings.runSort + + /** The stored pipeline/run filter keys; the list screens resolve them to filters. */ + val runFilterStatuses: StateFlow = settings.runFilterStatuses + val runFilterPipeline: StateFlow = settings.runFilterPipeline + val runFilterTimeRange: StateFlow = settings.runFilterTimeRange + val pipelineFilterPresence: StateFlow = settings.pipelineFilterPresence + val pipelineFilterRunStatuses: StateFlow = settings.pipelineFilterRunStatuses + private val _serverUrlDraft = MutableStateFlow(settings.serverUrl.value) val serverUrlDraft: StateFlow = _serverUrlDraft.asStateFlow() @@ -153,6 +164,20 @@ class AppViewModel( fun disconnect() = repository.disconnect() + fun setPipelineSort(storageKey: String) = settings.setPipelineSort(storageKey) + + fun setRunSort(storageKey: String) = settings.setRunSort(storageKey) + + fun setRunFilterStatuses(value: String) = settings.setRunFilterStatuses(value) + + fun setRunFilterPipeline(value: String) = settings.setRunFilterPipeline(value) + + fun setRunFilterTimeRange(value: String) = settings.setRunFilterTimeRange(value) + + fun setPipelineFilterPresence(value: String) = settings.setPipelineFilterPresence(value) + + fun setPipelineFilterRunStatuses(value: String) = settings.setPipelineFilterRunStatuses(value) + private fun awaitConnected() { viewModelScope.launch { val connected = withTimeoutOrNull(CONNECT_TIMEOUT_MILLIS) { diff --git a/android/app/src/main/java/net/awan/pipelines/ui/Format.kt b/android/app/src/main/java/net/awan/pipelines/ui/Format.kt index 3556c023..eccc2799 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/Format.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/Format.kt @@ -12,15 +12,43 @@ import net.awan.pipelines.data.protocol.RunStep import net.awan.pipelines.data.protocol.StageArtifact import net.awan.pipelines.data.protocol.StageFileChanges -/** Human duration between two RFC3339 timestamps, or null when unavailable. */ -fun formatDuration(start: String, end: String): String? { - if (start.isBlank() || end.isBlank()) return null - return runCatching { - val seconds = Duration.between(OffsetDateTime.parse(start), OffsetDateTime.parse(end)).seconds - if (seconds < 0) null else formatDuration(seconds) - }.getOrNull() +/** + * Parses an RFC3339 timestamp, or null when blank or unparseable. The single + * parser every time-reading the UI shares, so a bad timestamp is handled the + * same way everywhere. + */ +internal fun parseInstant(text: String): OffsetDateTime? { + if (text.isBlank()) return null + return runCatching { OffsetDateTime.parse(text) }.getOrNull() } +/** + * Non-negative whole seconds between two RFC3339 timestamps, or null when either + * is blank/unparseable or the end precedes the start. The numeric counterpart of + * [formatDuration] (which delegates here), so a sort key and the printed + * duration can never disagree. + */ +internal fun durationSeconds(start: String, end: String): Long? { + val from = parseInstant(start) ?: return null + val to = parseInstant(end) ?: return null + return Duration.between(from, to).seconds.takeIf { it >= 0 } +} + +/** Human duration between two RFC3339 timestamps, or null when unavailable. */ +fun formatDuration(start: String, end: String): String? = + durationSeconds(start, end)?.let(::formatDuration) + +/** + * Non-negative whole seconds from a [start] RFC3339 timestamp to [nowMillis] + * (wall-clock epoch millis), or null when [start] is blank/unparseable. Clamps a + * future/unparseable elapsed to 0 so a live timer never prints a negative or a + * nonsensical value. The one derivation behind the run graph's ticking elapsed + * time, so it is pure and testable without the Compose runtime. + */ +internal fun secondsSince(start: String, nowMillis: Long): Long? = + parseInstant(start)?.let { ((nowMillis - it.toInstant().toEpochMilli()) / 1000).coerceAtLeast(0) } + + /** * Human duration for a whole number of seconds. The single formatting rule for * every duration the UI shows (list meta, usage average, run summary, step diff --git a/android/app/src/main/java/net/awan/pipelines/ui/components/FilterMenu.kt b/android/app/src/main/java/net/awan/pipelines/ui/components/FilterMenu.kt new file mode 100644 index 00000000..7e6cca69 --- /dev/null +++ b/android/app/src/main/java/net/awan/pipelines/ui/components/FilterMenu.kt @@ -0,0 +1,178 @@ +package net.awan.pipelines.ui.components + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.WindowInsets +import androidx.compose.foundation.layout.asPaddingValues +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.heightIn +import androidx.compose.foundation.layout.navigationBars +import androidx.compose.foundation.layout.padding +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.Check +import androidx.compose.material.icons.filled.FilterList +import androidx.compose.material3.Badge +import androidx.compose.material3.BadgedBox +import androidx.compose.material3.DropdownMenu +import androidx.compose.material3.DropdownMenuItem +import androidx.compose.material3.HorizontalDivider +import androidx.compose.material3.Icon +import androidx.compose.material3.IconButton +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.platform.LocalConfiguration +import androidx.compose.ui.semantics.Role +import androidx.compose.ui.semantics.role +import androidx.compose.ui.semantics.semantics +import androidx.compose.ui.semantics.toggleableState +import androidx.compose.ui.state.ToggleableState +import androidx.compose.ui.unit.Dp +import androidx.compose.ui.unit.dp +import net.awan.pipelines.ui.theme.pipelinesText + +/** + * The tallest a list-filter menu may grow, as a fraction of the window height. + * Derived from the window rather than a fixed row count so the menu stays inside + * the window and clear of the navigation inset no matter how many distinct + * pipelines the runs list contributes (N made the old menu unbounded); beyond + * this the menu scrolls internally. + */ +internal fun filterMenuMaxHeight(screenHeightDp: Int): Dp = (screenHeightDp * 0.85f).dp + +/** + * The filter icon's content description. With active filters the count is spoken + * ("Filter runs, 2 filters active") so the badge is not a purely visual signal; + * with none the plain [base] stands. + */ +internal fun filterMenuDescription(base: String, activeCount: Int): String = when { + activeCount <= 0 -> base + activeCount == 1 -> "$base, 1 filter active" + else -> "$base, $activeCount filters active" +} + +/** + * The shared list-filter control: a top-bar icon carrying an active-filter count + * badge, opening the caller's [optionContent] plus one [resetLabel] action. It is + * its own action with a distinct glyph and content description, so it cannot + * collide with the adjacent sort or refresh actions, and the same control serves + * both list widths (a `DropdownMenu` is not width-dependent geometry). + * + * [activeCount] is drawn as a numeric badge (0 hides it) and folded into the + * icon's description, so "filters are active" is never colour alone and the + * count is announced. The menu is capped at a window-derived [filterMenuMaxHeight] + * and the reset action is the first item, so the reset is always in view on open + * and the last option is reachable by scrolling rather than clipped; a trailing + * navigation-bar spacer keeps the final option above the gesture inset. + * [optionContent] receives a `dismiss` callback: a single-select entry calls it to + * close the menu, while a multi-select toggle simply omits it to keep the menu + * open. + */ +@Composable +fun FilterMenu( + activeCount: Int, + contentDescription: String, + resetLabel: String, + onReset: () -> Unit, + modifier: Modifier = Modifier, + optionContent: @Composable (dismiss: () -> Unit) -> Unit, +) { + var expanded by remember { mutableStateOf(false) } + val maxMenuHeight = filterMenuMaxHeight(LocalConfiguration.current.screenHeightDp) + val bottomInset = WindowInsets.navigationBars.asPaddingValues().calculateBottomPadding() + Box(modifier) { + BadgedBox( + badge = { + if (activeCount > 0) { + Badge { Text(activeCount.toString()) } + } + }, + ) { + IconButton(onClick = { expanded = true }) { + Icon( + Icons.Default.FilterList, + contentDescription = filterMenuDescription(contentDescription, activeCount), + ) + } + } + DropdownMenu( + expanded = expanded, + onDismissRequest = { expanded = false }, + modifier = Modifier.heightIn(max = maxMenuHeight), + ) { + Row( + modifier = Modifier.fillMaxWidth().padding(start = 16.dp, end = 4.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.SpaceBetween, + ) { + Text( + text = "Filters", + style = pipelinesText().label, + color = MaterialTheme.colorScheme.primary, + ) + TextButton( + onClick = { + onReset() + expanded = false + }, + enabled = activeCount > 0, + ) { + Text(resetLabel) + } + } + HorizontalDivider() + optionContent { expanded = false } + Spacer(Modifier.height(bottomInset)) + } + } +} + +/** + * One checkable filter entry, sharing the sort menu's leading-check idiom so the + * active value is conveyed by a glyph as well as by text, and exposing the + * checked state to accessibility ([toggleableState] plus [Role.Checkbox]) so + * TalkBack announces which facet is selected rather than only the label. The + * caller decides whether to dismiss: a single-select option closes the menu, a + * multi-select toggle leaves it open so several values can be gathered. + */ +@Composable +fun FilterCheckItem( + label: String, + checked: Boolean, + onClick: () -> Unit, +) { + DropdownMenuItem( + text = { Text(label) }, + onClick = onClick, + modifier = Modifier.semantics { + role = Role.Checkbox + toggleableState = if (checked) ToggleableState.On else ToggleableState.Off + }, + leadingIcon = { + if (checked) { + Icon(Icons.Default.Check, contentDescription = null) + } + }, + ) +} + +/** A small section caption inside a filter menu (Status/Pipeline/Time range). */ +@Composable +fun FilterSectionHeader(label: String) { + Text( + text = label, + style = pipelinesText().label, + color = MaterialTheme.colorScheme.primary, + modifier = Modifier.padding(horizontal = 12.dp, vertical = 8.dp), + ) +} diff --git a/android/app/src/main/java/net/awan/pipelines/ui/components/RunStatus.kt b/android/app/src/main/java/net/awan/pipelines/ui/components/RunStatus.kt index 8f12953c..900fb7ae 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/components/RunStatus.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/components/RunStatus.kt @@ -17,7 +17,6 @@ import androidx.compose.material.icons.filled.Error import androidx.compose.material.icons.filled.PauseCircle import androidx.compose.material.icons.filled.Schedule import androidx.compose.material3.Icon -import androidx.compose.material3.MaterialTheme import androidx.compose.material3.Text import androidx.compose.runtime.Composable import androidx.compose.runtime.getValue @@ -65,15 +64,12 @@ fun runStateOf(status: String): RunState = when (status.trim().lowercase()) { else -> RunState.Unknown } -/** Colour family for a state, sourced from the app-owned scheme (never colour-only). */ -@Composable -fun runStateColor(state: RunState): Color = when (state) { - RunState.Running, RunState.Active -> MaterialTheme.colorScheme.primary - RunState.Queued -> MaterialTheme.colorScheme.secondary - RunState.Succeeded -> MaterialTheme.colorScheme.tertiary - RunState.Failed, RunState.Interrupted -> MaterialTheme.colorScheme.error - RunState.Canceled, RunState.Unknown -> MaterialTheme.colorScheme.onSurfaceVariant -} +/** + * Colour family for a state, from the app-owned [RunStatusPalette] (never + * colour-only: every chip also carries its glyph and label). Pure, so it can be + * asserted in a plain JVM unit test. + */ +fun runStateColor(state: RunState): Color = RunStatusPalette.of(state).color /** A distinct glyph per state, all from the standard filled material icon set. */ fun runStateIcon(state: RunState): ImageVector = when (state) { @@ -115,41 +111,65 @@ fun RunStatusIcon( } /** - * A colour-coded chip pairing a state glyph with its text label. Its container, - * label and glyph all ease to the new state's colour under [MotionQuick] (the - * glyph's own tint animates in [RunStatusIcon], in step), so a run whose status - * changes while the screen is open visibly transitions instead of silently - * swapping a colour; the chip is identical to the old one once settled. + * A pill pairing a glyph with its text label, coloured by the caller. Shared by + * the run-status chip and the timeline's step-outcome chip so both render one + * shape and neither repeats the layout. The glyph always carries a + * [contentDescription], so state/outcome is never colour alone. Its container, + * label and glyph all ease to the new colour under [MotionQuick], so a status or + * outcome change while the screen is open visibly transitions instead of + * silently swapping a colour; the chip is identical once settled. */ @Composable -fun StatusChip( +internal fun ColoredChip( label: String, - state: RunState, + color: Color, + icon: ImageVector, + contentDescription: String? = label, modifier: Modifier = Modifier, ) { - val color by animateColorAsState( - targetValue = runStateColor(state), + val animatedColor by animateColorAsState( + targetValue = color, animationSpec = MotionQuick.spec(), label = "status-chip-color", ) Row( modifier = modifier .clip(RoundedCornerShape(50)) - .background(color.copy(alpha = 0.16f)) + .background(animatedColor.copy(alpha = 0.16f)) .padding(horizontal = 8.dp, vertical = 2.dp), verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(4.dp), ) { - RunStatusIcon(state, contentDescription = label, modifier = Modifier.size(14.dp)) + Icon( + imageVector = icon, + contentDescription = contentDescription, + tint = animatedColor, + modifier = Modifier.size(14.dp), + ) Text( text = label, - color = color, + color = animatedColor, fontWeight = FontWeight.Medium, style = pipelinesText().label, ) } } +/** A colour-coded chip pairing a state glyph with its text label. */ +@Composable +fun StatusChip( + label: String, + state: RunState, + modifier: Modifier = Modifier, +) { + ColoredChip( + label = label, + color = runStateColor(state), + icon = runStateIcon(state), + modifier = modifier, + ) +} + /** Convenience: the run's own status word plus its colour-coded chip. */ @Composable fun RunStatusChip(state: RunState, modifier: Modifier = Modifier) { diff --git a/android/app/src/main/java/net/awan/pipelines/ui/components/RunStatusPalette.kt b/android/app/src/main/java/net/awan/pipelines/ui/components/RunStatusPalette.kt new file mode 100644 index 00000000..5c6d973b --- /dev/null +++ b/android/app/src/main/java/net/awan/pipelines/ui/components/RunStatusPalette.kt @@ -0,0 +1,70 @@ +package net.awan.pipelines.ui.components + +import androidx.compose.ui.graphics.Color +import net.awan.pipelines.ui.theme.DarkError + +/** + * The app-owned run-status palette. + * + * Run status is a *different vocabulary* from the graph's stage outcomes + * ([net.awan.pipelines.ui.graph.GraphPalette]): a run that is `running` is not a + * `skipped` stage, and a `succeeded` run is not the amber the theme uses for a + * positive *stage* outcome. Borrowing Material roles therefore put the wrong hue + * on the two states that matter most — `primary` (mint) made a *running* run read + * green and `tertiary` (amber) made a *succeeded* run read yellow. + * + * Every entry below is instead a deliberate, fixed colour with an explicit + * meaning, tuned for the dark Pipelines surface (`DarkSurface 0xFF0E1513`, + * over which the chip label is drawn). The contrast of each colour against that + * surface is *measured* by `RunStatusPaletteTest`, never judged by eye. Status is + * never colour-only: every entry keeps its own material glyph ([runStateIcon]) + * and its text label ([RunState.label]). + */ +internal object RunStatusPalette { + + /** One status colour plus the one-line reason it is that hue. */ + data class Entry(val color: Color, val rationale: String) + + /** In progress: the conventional blue. Green would read as already finished. */ + private val Running = + Entry(Color(0xFF7FB2F0), "blue: in progress; green would read as already finished") + + /** Finished well: the conventional green. Amber/tertiary would read as a warning. */ + private val Succeeded = + Entry(Color(0xFF7FE0A8), "green: completed successfully; amber would read as a warning") + + /** Failure: the app's error red, the one alarm colour the scheme already owns. */ + private val Failed = + Entry(DarkError, "the app error red: an explicit failure, never a soft warning hue") + + /** Stopped by the operator mid-flight: amber, a warning that is not a failure. */ + private val Interrupted = + Entry(Color(0xFFE8C06A), "amber: stopped by the operator, a warning distinct from failure red") + + /** Operator-cancelled: muted grey so a deliberate stop is quiet, not alarming. */ + private val Canceled = + Entry(Color(0xFF889391), "muted grey: an operator cancel is quiet, not the failure red") + + /** Waiting to start: neutral grey, deliberately not a hue that reads as running. */ + private val Queued = + Entry(Color(0xFF9AA6A2), "neutral grey: waiting, clearly not the in-progress blue") + + /** Unknown/blank status: the safe, low-key fallback. */ + private val Unknown = + Entry(Color(0xFFBEC9C5), "neutral surface grey: an unrecognised status stays low-key") + + /** + * The entry for [state]. [RunState.Active] shares [Running] (it is the server's + * `active` usage bucket, i.e. work in progress). Pure, so the palette is + * unit-testable without the Compose runtime. + */ + fun of(state: RunState): Entry = when (state) { + RunState.Running, RunState.Active -> Running + RunState.Succeeded -> Succeeded + RunState.Failed -> Failed + RunState.Interrupted -> Interrupted + RunState.Canceled -> Canceled + RunState.Queued -> Queued + RunState.Unknown -> Unknown + } +} diff --git a/android/app/src/main/java/net/awan/pipelines/ui/components/SortMenu.kt b/android/app/src/main/java/net/awan/pipelines/ui/components/SortMenu.kt new file mode 100644 index 00000000..9f3b5436 --- /dev/null +++ b/android/app/src/main/java/net/awan/pipelines/ui/components/SortMenu.kt @@ -0,0 +1,70 @@ +package net.awan.pipelines.ui.components + +import androidx.compose.foundation.layout.Box +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.automirrored.filled.Sort +import androidx.compose.material.icons.filled.Check +import androidx.compose.material3.DropdownMenu +import androidx.compose.material3.DropdownMenuItem +import androidx.compose.material3.HorizontalDivider +import androidx.compose.material3.Icon +import androidx.compose.material3.IconButton +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Modifier + +/** + * The shared list-sort control: a top-bar icon that opens [options] plus a + * divider and a Reset entry. It is deliberately its own action with a distinct + * glyph and content description, so it cannot collide with the adjacent Refresh + * action or a future top-bar search entry point; a `DropdownMenu` anchors to the + * icon and works at both window widths (it is not width-dependent geometry). + * + * [selected] draws a leading check on its row, so the active choice is conveyed + * by a glyph as well as by text, never by colour alone. + */ +@Composable +fun SortMenu( + options: List, + selected: T, + label: (T) -> String, + contentDescription: String, + onSelect: (T) -> Unit, + onReset: () -> Unit, + modifier: Modifier = Modifier, +) { + var expanded by remember { mutableStateOf(false) } + Box(modifier) { + IconButton(onClick = { expanded = true }) { + Icon(Icons.AutoMirrored.Filled.Sort, contentDescription = contentDescription) + } + DropdownMenu(expanded = expanded, onDismissRequest = { expanded = false }) { + options.forEach { option -> + DropdownMenuItem( + text = { Text(label(option)) }, + onClick = { + onSelect(option) + expanded = false + }, + leadingIcon = { + if (option == selected) { + Icon(Icons.Default.Check, contentDescription = null) + } + }, + ) + } + HorizontalDivider() + DropdownMenuItem( + text = { Text("Reset") }, + onClick = { + onReset() + expanded = false + }, + ) + } + } +} diff --git a/android/app/src/main/java/net/awan/pipelines/ui/components/States.kt b/android/app/src/main/java/net/awan/pipelines/ui/components/States.kt index e44d47f3..5aeb805b 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/components/States.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/components/States.kt @@ -50,8 +50,18 @@ fun ErrorState(message: String, onRetry: (() -> Unit)? = null, modifier: Modifie } } +/** + * An empty-list message. [actionLabel]/[onAction] add one recovery action (the + * "nothing matches the current filters" case offers Clear filters); both are + * omitted for the "nothing exists" case, where there is nothing to clear. + */ @Composable -fun EmptyState(message: String, modifier: Modifier = Modifier) { +fun EmptyState( + message: String, + modifier: Modifier = Modifier, + actionLabel: String? = null, + onAction: (() -> Unit)? = null, +) { Column( modifier = modifier.fillMaxSize().padding(24.dp), horizontalAlignment = Alignment.CenterHorizontally, @@ -63,6 +73,11 @@ fun EmptyState(message: String, modifier: Modifier = Modifier) { style = MaterialTheme.typography.bodyLarge, color = MaterialTheme.colorScheme.onSurfaceVariant, ) + if (actionLabel != null && onAction != null) { + Button(onClick = onAction, modifier = Modifier.padding(top = 16.dp)) { + Text(actionLabel) + } + } } } @@ -84,8 +99,12 @@ sealed interface LoadPhase { /** The load failed and there is no data to fall back to. */ data class Error(val message: String) : LoadPhase - /** The load succeeded but there is nothing to show; [message] explains it. */ - data class Empty(val message: String) : LoadPhase + /** + * The load succeeded but there is nothing to show; [message] explains it and + * [actionLabel] optionally labels one recovery action (the "nothing matches + * the current filters" case offers Clear filters). + */ + data class Empty(val message: String, val actionLabel: String? = null) : LoadPhase /** The loaded content. */ data object Content : LoadPhase @@ -96,7 +115,8 @@ sealed interface LoadPhase { * no data wins, then a load with no data, then an empty result; anything else is * [LoadPhase.Content]. [emptyMessage] is non-null exactly when the pane is empty * and is the text to show, captured so a fading-out empty branch never reads a - * changed query. + * changed query; [emptyActionLabel] labels the one recovery action offered with + * that text (both are captured at classification). * * When stale data is present neither loading nor an error replaces it: the * screen keeps showing the data and surfaces the error inline, so [hasData] @@ -107,10 +127,11 @@ fun listLoadPhase( error: String?, hasData: Boolean, emptyMessage: String?, + emptyActionLabel: String? = null, ): LoadPhase = when { error != null && !hasData -> LoadPhase.Error(error) loading && !hasData -> LoadPhase.Loading - emptyMessage != null -> LoadPhase.Empty(emptyMessage) + emptyMessage != null -> LoadPhase.Empty(emptyMessage, emptyActionLabel) else -> LoadPhase.Content } diff --git a/android/app/src/main/java/net/awan/pipelines/ui/graph/GraphMotion.kt b/android/app/src/main/java/net/awan/pipelines/ui/graph/GraphMotion.kt new file mode 100644 index 00000000..d18ab670 --- /dev/null +++ b/android/app/src/main/java/net/awan/pipelines/ui/graph/GraphMotion.kt @@ -0,0 +1,99 @@ +package net.awan.pipelines.ui.graph + +import net.awan.pipelines.data.protocol.GraphEdge +import net.awan.pipelines.data.protocol.RunGraphState +import kotlin.math.PI +import kotlin.math.sin + +/** + * How a stage node is drawn under a run: + * + * - [Active]: the stage the live run is executing right now; it carries a + * pulsing halo, and its live elapsed time is drawn under its label. + * - [Visited]: a stage the run already visited (or any stage in the + * definition-only view); it settles into its static fill/border. + * - [Unvisited]: a stage the run did not reach; drawn hollow, never animating. + * + * A finished run has no [Active] node, so nothing animates once it stops. + */ +internal enum class NodeMotion { Active, Visited, Unvisited } + +/** + * How an edge is drawn under a run: + * + * - [Flowing]: an executed route while the run is live; its stroke carries a + * moving dot that reads the direction of travel. + * - [Settled]: an executed route under a finished run; a plain static stroke. + * - [Unvisited]: a route the run did not take; dashed and arrowless. + */ +internal enum class EdgeMotion { Flowing, Settled, Unvisited } + +/** + * Whether the graph may animate at all, from the three independent gates: + * the run must still be executing (never animate a finished run), the system + * must have animations enabled (honour the OS/animation-scale setting), and the + * graph must be on screen (a backgrounded graph is paused). Pure, so the + * decision is asserted in a unit test rather than inferred from a frame clock. + * + * When this is false while the run is live, the graph still marks the active + * stage statically (see [ACTIVE_HALO_STATIC_ALPHA] and the drawn elapsed time), + * so "animations off" is a static but unmistakable running state, not a blank. + */ +internal fun graphShouldAnimate( + runState: RunGraphState?, + animationsEnabled: Boolean, + onScreen: Boolean, +): Boolean = runState?.executing == true && animationsEnabled && onScreen + +/** + * The motion state of the stage [key] under [runState]. Pure and the single + * definition the drawing and the tests share: the definition-only view + * ([runState] == null) is entirely visited/static, an unvisited key is idle, and + * only the stage the live run is on is [NodeMotion.Active]. The live stage wins + * over the visited check, so it is unmistakably active even in the brief window + * before its step has been recorded in [RunGraphState.visitedStages]. + */ +internal fun nodeMotion(key: String, runState: RunGraphState?): NodeMotion = when { + runState == null -> NodeMotion.Visited + runState.executing && key == runState.currentStage -> NodeMotion.Active + key !in runState.visitedStages -> NodeMotion.Unvisited + else -> NodeMotion.Visited +} + +/** + * The motion state of [edge] under [runState]: an executed route flows while the + * run is live and settles once it finishes, and an untaken route is idle. The + * definition-only view ([runState] == null) is settled (static), as before. + */ +internal fun edgeMotion(edge: GraphEdge, runState: RunGraphState?): EdgeMotion = when { + !edgeIsExecuted(edge, runState) -> EdgeMotion.Unvisited + runState?.executing == true -> EdgeMotion.Flowing + else -> EdgeMotion.Settled +} + +/** + * The active-node halo strength for a 0..1 animation [phase]: a smooth + * sinusoid that rises and falls once per cycle, never stepping between two + * values (a pulse, not a blink). Bounded to `[PULSE_MIN, PULSE_MAX]` so the + * halo is always visible and never fully transparent, and periodic in [phase] + * so it is seamless at the wrap. Pure, so the rhythm is asserted without any + * frame-timing. + */ +internal fun pulseAlpha(phase: Float): Float { + val t = ((phase % 1f) + 1f) % 1f + val wave = (sin(t * 2.0 * PI) + 1.0) / 2.0 + return (PULSE_MIN + (PULSE_MAX - PULSE_MIN) * wave).toFloat() +} + +/** Faintest the active halo ever gets; never invisible, never a blink-off. */ +private const val PULSE_MIN = 0.35f + +/** Strongest the active halo gets at the peak of a pulse. */ +private const val PULSE_MAX = 0.9f + +/** + * The fixed active-halo strength drawn when animation is off (the system + * setting, or a paused graph): clearly marked, just not moving. Within the + * [pulseAlpha] range so the static state looks like a frozen pulse. + */ +internal const val ACTIVE_HALO_STATIC_ALPHA = 0.85f diff --git a/android/app/src/main/java/net/awan/pipelines/ui/graph/GraphPalette.kt b/android/app/src/main/java/net/awan/pipelines/ui/graph/GraphPalette.kt index cf5d5b9c..b15bfca8 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/graph/GraphPalette.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/graph/GraphPalette.kt @@ -94,6 +94,36 @@ internal fun graphNodeKind(terminal: Boolean, key: String, type: String?): Graph else -> GraphNodeKind.Custom } +/** + * A more vivid version of [color] with the same hue, value and alpha: the HSV + * saturation is scaled by [factor] and clamped to 1. Used to make an executed + * pass/fail edge stroke stronger without changing its outcome hue, so both + * terminal colours get more punch while staying recognisably success/failure. + * + * Pure sRGB maths. A non-finite/non-positive [factor], an achromatic colour or + * one already at full saturation returns [color] unchanged, so callers never get + * NaN and every input is safe. + */ +internal fun boostSaturation(color: Color, factor: Float): Color { + if (!factor.isFinite() || factor <= 0f) return color + val r = color.red + val g = color.green + val b = color.blue + val max = maxOf(r, g, b) + val min = minOf(r, g, b) + val delta = max - min + if (max <= 0f || delta <= 0f) return color + val current = delta / max + val saturation = (current * factor).coerceAtMost(1f) + if (saturation <= current) return color + val hue = (when (max) { + r -> ((g - b) / delta + 6f) % 6f + g -> (b - r) / delta + 2f + else -> (r - g) / delta + 4f + }) * 60f + return Color.hsv(hue, saturation, max, color.alpha) +} + /** * WCAG relative luminance of [color] (sRGB), the building block of the WCAG * contrast ratio. Pure so the palette's legibility is measured in a unit test diff --git a/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt b/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt index 89becda9..e6aea6be 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt @@ -1,10 +1,18 @@ package net.awan.pipelines.ui.graph +import android.animation.ValueAnimator +import androidx.compose.animation.core.LinearEasing +import androidx.compose.animation.core.RepeatMode +import androidx.compose.animation.core.animateFloat +import androidx.compose.animation.core.infiniteRepeatable +import androidx.compose.animation.core.rememberInfiniteTransition +import androidx.compose.animation.core.tween import androidx.compose.foundation.Canvas import androidx.compose.foundation.ExperimentalFoundationApi import androidx.compose.foundation.background import androidx.compose.foundation.gestures.detectTapGestures import androidx.compose.foundation.gestures.detectTransformGestures +import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.Row import androidx.compose.foundation.layout.fillMaxSize @@ -18,14 +26,17 @@ import androidx.compose.material.icons.Icons import androidx.compose.material.icons.filled.FitScreen import androidx.compose.material.icons.filled.Fullscreen import androidx.compose.material.icons.filled.FullscreenExit +import androidx.compose.material3.ColorScheme import androidx.compose.material3.Icon import androidx.compose.material3.IconButton import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Text import androidx.compose.runtime.Composable import androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.getValue import androidx.compose.runtime.mutableFloatStateOf import androidx.compose.runtime.mutableIntStateOf +import androidx.compose.runtime.mutableLongStateOf import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember import androidx.compose.runtime.rememberCoroutineScope @@ -34,10 +45,14 @@ import androidx.compose.runtime.setValue import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.compose.ui.draw.clipToBounds +import androidx.compose.ui.geometry.CornerRadius import androidx.compose.ui.geometry.Offset import androidx.compose.ui.geometry.Size import androidx.compose.ui.graphics.Color import androidx.compose.ui.graphics.Path +import androidx.compose.ui.graphics.PathEffect +import androidx.compose.ui.graphics.StrokeCap +import androidx.compose.ui.graphics.StrokeJoin import androidx.compose.ui.graphics.TransformOrigin import androidx.compose.ui.graphics.drawscope.DrawScope import androidx.compose.ui.graphics.drawscope.Stroke @@ -52,18 +67,21 @@ import androidx.compose.ui.semantics.contentDescription import androidx.compose.ui.semantics.onClick import androidx.compose.ui.semantics.role import androidx.compose.ui.semantics.semantics +import androidx.compose.ui.text.TextLayoutResult import androidx.compose.ui.text.TextMeasurer -import androidx.compose.ui.text.TextStyle import androidx.compose.ui.text.drawText -import androidx.compose.ui.text.font.FontWeight import androidx.compose.ui.text.rememberTextMeasurer import androidx.compose.ui.unit.Dp import androidx.compose.ui.unit.IntOffset import androidx.compose.ui.unit.IntSize import androidx.compose.ui.unit.dp -import androidx.compose.ui.unit.sp +import androidx.lifecycle.Lifecycle +import androidx.lifecycle.compose.LocalLifecycleOwner +import androidx.lifecycle.compose.currentStateAsState import kotlin.math.abs +import kotlin.math.hypot import kotlin.math.roundToInt +import kotlinx.coroutines.delay import kotlinx.coroutines.launch import net.awan.pipelines.data.protocol.Graph import net.awan.pipelines.data.protocol.GraphEdge @@ -72,6 +90,31 @@ import net.awan.pipelines.data.protocol.GraphSemantics import net.awan.pipelines.data.protocol.Protocol import net.awan.pipelines.data.protocol.RunGraphState import net.awan.pipelines.data.protocol.edges +import net.awan.pipelines.ui.formatDuration +import net.awan.pipelines.ui.secondsSince +import net.awan.pipelines.ui.theme.GRAPH_ACTIVE_HALO_GAP +import net.awan.pipelines.ui.theme.GRAPH_ACTIVE_HALO_STROKE +import net.awan.pipelines.ui.theme.GRAPH_EDGE_CHIP_CORNER +import net.awan.pipelines.ui.theme.GRAPH_EDGE_CHIP_PAD_X +import net.awan.pipelines.ui.theme.GRAPH_EDGE_CHIP_PAD_Y +import net.awan.pipelines.ui.theme.GRAPH_EDGE_LANE_SPACING +import net.awan.pipelines.ui.theme.GRAPH_EDGE_TRACK_STEP +import net.awan.pipelines.ui.theme.GRAPH_ELAPSED_INSET +import net.awan.pipelines.ui.theme.GRAPH_FIT_PADDING +import net.awan.pipelines.ui.theme.GRAPH_LEGEND_SWATCH_HEIGHT +import net.awan.pipelines.ui.theme.GRAPH_LEGEND_SWATCH_WIDTH +import net.awan.pipelines.ui.theme.GRAPH_MIN_VISIBLE +import net.awan.pipelines.ui.theme.GRAPH_NODE_BORDER +import net.awan.pipelines.ui.theme.GRAPH_NODE_BORDER_SELECTED +import net.awan.pipelines.ui.theme.GRAPH_NODE_H_GAP +import net.awan.pipelines.ui.theme.GRAPH_NODE_MIN_HEIGHT +import net.awan.pipelines.ui.theme.GRAPH_NODE_PORT_SPACING +import net.awan.pipelines.ui.theme.GRAPH_NODE_WIDTH +import net.awan.pipelines.ui.theme.GRAPH_PAD +import net.awan.pipelines.ui.theme.GRAPH_ROUTE_CORNER_RADIUS +import net.awan.pipelines.ui.theme.GRAPH_TERMINAL_ROW_GAP +import net.awan.pipelines.ui.theme.PipelinesTextStyles +import net.awan.pipelines.ui.theme.pipelinesText internal data class NodeLayout( val key: String, @@ -136,8 +179,16 @@ internal data class ZoomResult(val offset: Offset, val scale: Float) * Node/edge/outcome semantics come from [GraphSemantics] and [edges], mirroring * internal/tui/graph.go: content-sized stage nodes, labelled outcome edges with * the `error*` fallback marker, `#success`/`#failure` terminals and loop routes. - * When [runState] is supplied, executed stages/routes are highlighted and the - * rest dimmed; when it is null the full definition is shown. + * When [runState] is supplied, an executed stage/route is drawn solid and + * full-colour with an arrowhead (nodes filled with a normal border) while a + * not-executed one is dashed and arrowless (nodes hollow with a muted, legible + * label), so the two states differ in shape, fill and border style rather than + * by a faded tint and survive a screenshot, a dim screen and a colour-blind + * reader; a one-line legend names both states. An executed `success`/`error` + * edge is drawn noticeably heavier with a stronger, same-hue stroke and a larger + * arrowhead, so the two decisive outcomes are the loudest lines in the graph. + * When [runState] is null the full definition is shown, with the same pass/fail + * emphasis (every route counts as executed) and no legend. * * A tap that lands inside a node (stage or terminal) calls [onStageTap] with the * node key; tapping empty space does nothing. Pan/zoom keep working because the @@ -166,38 +217,20 @@ fun WorkflowGraph( val description = remember(graph, runState) { graphDescription(graph, runState) } val scheme = MaterialTheme.colorScheme - val colors = remember(scheme) { - GraphColors( - // The two terminal roles stay scheme roles so their meaning is kept. - success = scheme.tertiary, - error = scheme.error, - // Every other outcome uses the one curated, legible palette for both - // its stroke and its label text, so a curve and its label always agree. - palette = GraphPalette.colors, - // Node fills differ by kind (see [GraphNodeKind]): model (neutral), - // ntfy (amber), other/custom (green), and the two terminals. - nodeFill = scheme.surfaceVariant, - nodeNtfyFill = scheme.tertiaryContainer, - nodeCustomFill = scheme.primaryContainer, - // A selected node inverts (light fill / dark text) plus a 4px border, - // so selection reads in either appearance and never relies on colour. - nodeFillActive = scheme.inverseSurface, - nodeTextActive = scheme.inverseOnSurface, - nodeBorder = scheme.outline, - nodeBorderActive = scheme.primary, - nodeText = scheme.onSurface, - terminalFill = scheme.secondaryContainer, - terminalErrorFill = scheme.errorContainer, - labelBackground = scheme.surface, - labelText = scheme.onSurfaceVariant, - ) - } + val colors = remember(scheme) { graphColors(scheme) } + // The graph's type roles come from the app's one type scale (never ad-hoc + // sizes), and the corner radius from the app's shape scale rather than a raw + // literal; a terminal overrides it with a full pill in drawNodes. + val text = pipelinesText() + val nodeCornerPx = with(density) { MaterialTheme.shapes.medium.topStart.toPx(Size.Zero, this) } + val nodeBorderPx = with(density) { GRAPH_NODE_BORDER.toPx() } + val nodeBorderSelectedPx = with(density) { GRAPH_NODE_BORDER_SELECTED.toPx() } // node key -> stage type, derived once per graph (never per frame) so node // kind/colour and the spoken description share one lookup. val stageTypeByKey = remember(graph) { graph.stages.associate { it.key to it.type } } - val fitPaddingPx = with(density) { FIT_PADDING.toPx() } - val minVisiblePx = with(density) { MIN_VISIBLE.toPx() } + val fitPaddingPx = with(density) { GRAPH_FIT_PADDING.toPx() } + val minVisiblePx = with(density) { GRAPH_MIN_VISIBLE.toPx() } var scale by remember { mutableFloatStateOf(1f) } var offset by remember { mutableStateOf(Offset.Zero) } @@ -231,6 +264,48 @@ fun WorkflowGraph( ) } + // Motion gates, all pure and testable (see GraphMotion.kt): only a live run, + // with animations enabled and the graph on screen, animates. Never animate a + // finished run; pause when the graph is off screen or when the OS animation + // setting is off. ValueAnimator.areAnimatorsEnabled() reflects the system + // "Remove animations"/animation-scale setting; it is re-read on resume. + val lifecycleState by LocalLifecycleOwner.current.lifecycle.currentStateAsState() + val onScreen = lifecycleState.isAtLeast(Lifecycle.State.RESUMED) + val animationsEnabled = remember(onScreen) { ValueAnimator.areAnimatorsEnabled() } + val animate = graphShouldAnimate(runState, animationsEnabled, onScreen) + val phase = rememberPulsePhase(animate) + + // The active stage's live ticking elapsed time. The loop only runs while + // animating, so a finished run, a paused/off-screen graph and an + // animations-disabled device never wake up once a second; in those cases the + // value is a static snapshot for a clearly marked running state. + val activeStartedAt = runState?.currentStageStartedAt + var nowMillis by remember { mutableLongStateOf(System.currentTimeMillis()) } + LaunchedEffect(animate, activeStartedAt) { + if (!animate || activeStartedAt.isNullOrBlank()) return@LaunchedEffect + while (true) { + nowMillis = System.currentTimeMillis() + delay(ELAPSED_TICK_MILLIS) + } + } + // Measured once per second (never per frame) so the canvas draw adds no + // allocation for the timer. + val elapsedLayout = remember(activeStartedAt, nowMillis, scheme, density, text) { + secondsSince(activeStartedAt.orEmpty(), nowMillis) + ?.let(::formatDuration) + ?.let { + textMeasurer.measure( + it, + text.label.copy(color = colors.nodeText), + ) + } + } + // Halo and badge geometry as dp tokens (like the node layout), so they scale + // with the device rather than sitting at a raw pixel size. + val haloGapPx = with(density) { GRAPH_ACTIVE_HALO_GAP.toPx() } + val haloStrokePx = with(density) { GRAPH_ACTIVE_HALO_STROKE.toPx() } + val elapsedInsetPx = with(density) { GRAPH_ELAPSED_INSET.toPx() } + Box( modifier = modifier // Let an expand scroll the (now taller) panel back into the visible @@ -267,7 +342,7 @@ fun WorkflowGraph( userAdjusted = true // Anchor the zoom at the gesture centroid so the content under // the fingers stays put, then apply the gesture pan and keep at - // least MIN_VISIBLE of the scaled content on screen so a drag can + // least GRAPH_MIN_VISIBLE of the scaled content on screen so a drag can // never leave an empty viewport. val zoomed = zoomAbout(offset, scale, centroid, zoom, MIN_SCALE, MAX_SCALE) scale = zoomed.scale @@ -288,9 +363,26 @@ fun WorkflowGraph( }) { // Labels are drawn only after every curve so they always sit on // top of a neighbouring edge instead of being crossed by it. - drawEdgePaths(layout, colors, runState) - drawEdgeLabels(layout, colors, runState, textMeasurer) - drawNodes(layout, colors, runState, selectedStage, stageTypeByKey, textMeasurer) + drawEdgePaths(layout, colors, runState, animate, phase) + drawEdgeLabels(layout, colors, runState, textMeasurer, text) + drawNodes( + layout, + colors, + runState, + selectedStage, + stageTypeByKey, + textMeasurer, + text, + nodeCornerPx, + nodeBorderPx, + nodeBorderSelectedPx, + animate, + phase, + elapsedLayout, + haloGapPx, + haloStrokePx, + elapsedInsetPx, + ) } } // Accessibility overlay: invisible nodes carrying a click action and a @@ -326,6 +418,33 @@ fun WorkflowGraph( ) } } + // A compact one-line legend, only under a run (never the definition-only + // view): a solid, arrowed swatch means "executed", a dashed, arrowless + // one means "not executed", matching what the graph draws. It is pinned + // to the top-start (opposite the Fit/expand controls) so it stays visible + // with the top of the panel on a short/narrow window, and its surface + // background keeps it legible wherever the panned/zoomed graph sits. + if (runState != null) { + Row( + modifier = Modifier + .align(Alignment.TopStart) + .padding(4.dp) + .background(MaterialTheme.colorScheme.surface.copy(alpha = 0.85f)) + .padding(horizontal = 6.dp, vertical = 3.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(10.dp), + ) { + GRAPH_LEGEND.forEach { entry -> + Row( + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(4.dp), + ) { + LegendSwatch(entry.executed, colors) + Text(entry.label, style = MaterialTheme.typography.labelSmall) + } + } + } + } Row( modifier = Modifier.align(Alignment.TopEnd).padding(4.dp), ) { @@ -363,6 +482,42 @@ fun WorkflowGraph( } } +/** + * One legend entry: the [label] a reader sees and whether it names the executed + * state. Pure data so the legend's content is asserted in a plain JVM test. + */ +internal data class GraphLegendEntry(val label: String, val executed: Boolean) + +/** The two execution states the legend names, executed first. */ +internal val GRAPH_LEGEND: List = listOf( + GraphLegendEntry("Executed", executed = true), + GraphLegendEntry("Not executed", executed = false), +) + +/** + * A small line swatch for one legend entry, drawn with the same stroke style the + * graph uses: a solid, arrowed line when [executed], a dashed, arrowless line + * otherwise. + */ +@Composable +private fun LegendSwatch(executed: Boolean, colors: GraphColors) { + Canvas(Modifier.size(GRAPH_LEGEND_SWATCH_WIDTH, GRAPH_LEGEND_SWATCH_HEIGHT)) { + val y = size.height / 2f + val from = Offset(0f, y) + val to = Offset(size.width, y) + val color = if (executed) colors.nodeText else colors.labelText + drawLine( + color = color, + start = from, + end = to, + strokeWidth = EDGE_STROKE, + cap = StrokeCap.Round, + pathEffect = if (executed) null else INACTIVE_DASH_EFFECT, + ) + if (executed) drawArrowHead(listOf(from, to), color, ARROW_HEAD_SIZE) + } +} + internal class GraphColors( val success: Color, val error: Color, @@ -381,6 +536,80 @@ internal class GraphColors( val labelText: Color, ) +/** + * The graph's colours for [scheme], built in one place so every surface that must + * agree with the graph (the graph itself and the timeline's step-outcome chips) + * uses the same palette. The two terminal roles stay scheme roles so their + * meaning is kept; every other outcome uses the one curated, legible + * [GraphPalette] for both a stroke and its label text. + * + * Node and label surfaces are *tonal*: a raised surface tone ([scheme]'s + * `surfaceContainerHigh`/`surfaceContainerHighest`) blended with a subtle tint of + * the node's semantic colour (see [tonalFill]) rather than a flat fill, so a node + * reads as raised card, not a terminal cell. + */ +internal fun graphColors(scheme: ColorScheme): GraphColors = GraphColors( + // The two terminal roles stay scheme roles so their meaning is kept. + success = scheme.tertiary, + error = scheme.error, + // Every other outcome uses the one curated, legible palette for both its + // stroke and its label text, so a curve and its label always agree. + palette = GraphPalette.colors, + // Node fills differ by kind (see [GraphNodeKind]): model (neutral), ntfy + // (amber), other/custom (green), and the two terminals (success/error). Each + // is a tonal surface carrying a subtle tint of that kind's semantic hue. + nodeFill = tonalFill(scheme.surfaceContainerHigh, scheme.onSurfaceVariant, NEUTRAL_TINT), + nodeNtfyFill = tonalFill(scheme.surfaceContainerHigh, scheme.tertiary, KIND_TINT), + nodeCustomFill = tonalFill(scheme.surfaceContainerHigh, scheme.primary, KIND_TINT), + // A selected node inverts (light fill / dark text) plus a stronger border, so + // selection reads in either appearance and never relies on colour. + nodeFillActive = scheme.inverseSurface, + nodeTextActive = scheme.inverseOnSurface, + // The stage border is deliberately soft (a low-contrast outline variant), not + // the hard original outline; terminals carry their outcome hue instead. + nodeBorder = scheme.outlineVariant, + nodeBorderActive = scheme.primary, + nodeText = scheme.onSurface, + terminalFill = tonalFill(scheme.surfaceContainerHigh, scheme.tertiary, TERMINAL_TINT), + terminalErrorFill = tonalFill(scheme.surfaceContainerHigh, scheme.error, TERMINAL_TINT), + // Edge outcome labels sit on a tonal chip (drawn as a rounded rect) rather than + // raw text over the canvas. + labelBackground = scheme.surfaceContainerHighest, + labelText = scheme.onSurfaceVariant, +) + +/** + * [surface] blended with a [fraction] (0..1) of [accent], so a node/label fill + * carries a subtle tint of its semantic colour while staying a legible surface. + * Pure sRGB per-channel interpolation; a fraction outside `[0, 1]` is clamped so + * callers never overshoot the two colours. + */ +internal fun tonalFill(surface: Color, accent: Color, fraction: Float): Color { + val t = fraction.coerceIn(0f, 1f) + return Color( + red = surface.red + (accent.red - surface.red) * t, + green = surface.green + (accent.green - surface.green) * t, + blue = surface.blue + (accent.blue - surface.blue) * t, + alpha = surface.alpha + (accent.alpha - surface.alpha) * t, + ) +} + +/** + * The label a node shows in the graph: a stage keeps its declared key, while a + * terminal's all-caps `SUCCESS`/`FAILURE` becomes the readable `Success`/ + * `Failure` (the graph type has no unnecessary all-caps). Pure, so the display + * form is unit-tested and the shared [GraphSemantics.nodeLabel] the + * TUI-mirroring panes still use is left untouched. + */ +internal fun nodeDisplayLabel(key: String): String { + val label = GraphSemantics.nodeLabel(key) + return if (Protocol.isTerminal(key)) { + label.lowercase().replaceFirstChar { it.uppercase() } + } else { + label + } +} + /** The accessibility label for one node, naming its type when it is a stage. */ private fun nodeDescription(node: NodeLayout, type: String?): String { if (node.terminal) return "Terminal ${node.label}, tap for details" @@ -561,14 +790,14 @@ private fun forwardAdjacent(edge: GraphEdge, rank: Map): Boolean = internal fun layoutGraph(graph: Graph, density: androidx.compose.ui.unit.Density): GraphLayout { if (graph.stages.isEmpty()) return GraphLayout(emptyList(), emptyList(), 0f, 0f) - val nodeWidth = with(density) { 132.dp.toPx() } - val portSpacing = with(density) { 12.dp.toPx() } - val hGap = with(density) { 132.dp.toPx() } - val pad = with(density) { 32.dp.toPx() } - val laneSpacing = with(density) { 26.dp.toPx() } - val terminalGap = with(density) { 64.dp.toPx() } - val trackStep = with(density) { 18.dp.toPx() } - val minNodeHeight = with(density) { 56.dp.toPx() } + val nodeWidth = with(density) { GRAPH_NODE_WIDTH.toPx() } + val portSpacing = with(density) { GRAPH_NODE_PORT_SPACING.toPx() } + val hGap = with(density) { GRAPH_NODE_H_GAP.toPx() } + val pad = with(density) { GRAPH_PAD.toPx() } + val laneSpacing = with(density) { GRAPH_EDGE_LANE_SPACING.toPx() } + val terminalGap = with(density) { GRAPH_TERMINAL_ROW_GAP.toPx() } + val trackStep = with(density) { GRAPH_EDGE_TRACK_STEP.toPx() } + val minNodeHeight = with(density) { GRAPH_NODE_MIN_HEIGHT.toPx() } val ranks = rankStages(graph) val edges = graph.edges() @@ -617,7 +846,7 @@ internal fun layoutGraph(graph: Graph, density: androidx.compose.ui.unit.Density graph.stages.forEachIndexed { index, stage -> positions[stage.key] = NodeLayout( key = stage.key, - label = GraphSemantics.nodeLabel(stage.key), + label = nodeDisplayLabel(stage.key), x = stageX(index), y = pad, width = nodeWidth, @@ -654,7 +883,7 @@ internal fun layoutGraph(graph: Graph, density: androidx.compose.ui.unit.Density val successX = failureX + failureWidth + hGap positions[Protocol.FAILURE_END] = NodeLayout( key = Protocol.FAILURE_END, - label = GraphSemantics.nodeLabel(Protocol.FAILURE_END), + label = nodeDisplayLabel(Protocol.FAILURE_END), x = failureX, y = terminalY, width = failureWidth, @@ -663,7 +892,7 @@ internal fun layoutGraph(graph: Graph, density: androidx.compose.ui.unit.Density ) positions[Protocol.SUCCESS_END] = NodeLayout( key = Protocol.SUCCESS_END, - label = GraphSemantics.nodeLabel(Protocol.SUCCESS_END), + label = nodeDisplayLabel(Protocol.SUCCESS_END), x = successX, y = terminalY, width = successWidth, @@ -965,6 +1194,56 @@ internal fun arrowDirection(points: List): Offset { return Offset.Zero } +/** + * The clamped cut-back used at one bend of an axis-aligned route: the shared + * [radius], floored to half of the shorter adjacent segment ([inLength] into the + * corner, [outLength] out of it) so the two cut-backs can never meet or cross on + * a short run. It takes the lengths the caller already measured, so a bend's + * geometry is computed once. Pure, so the clamp is unit-tested without a Canvas. + */ +internal fun cornerCutRadius(inLength: Float, outLength: Float, radius: Float): Float = + minOf(radius, inLength / 2f, outLength / 2f).coerceAtLeast(0f) + +/** + * The path an axis-aligned route [points] is drawn along: each interior right + * angle is replaced by a quadratic curve with the one consistent [radius] control + * offset (clamped per corner by [cornerCutRadius]), so the tracks read as smooth + * curves. The route's own endpoints and its stored polyline are unchanged, so + * hit-testing, the arrowheads and every layout test keep using the same geometry; + * only the rendered bends soften. Each corner's segment lengths are measured once + * and reused for both the clamp and the cut points; a degenerate route falls back + * to straight segments rather than dividing by zero. + */ +private fun roundedRoutePath(points: List, radius: Float): Path { + val path = Path() + if (points.isEmpty()) return path + path.moveTo(points.first().x, points.first().y) + for (i in 1 until points.size - 1) { + val previous = points[i - 1] + val corner = points[i] + val next = points[i + 1] + val inLength = hypot(corner.x - previous.x, corner.y - previous.y) + val outLength = hypot(next.x - corner.x, next.y - corner.y) + val cut = cornerCutRadius(inLength, outLength, radius) + if (cut <= 0f) { + path.lineTo(corner.x, corner.y) + continue + } + val start = Offset( + corner.x + (previous.x - corner.x) / inLength * cut, + corner.y + (previous.y - corner.y) / inLength * cut, + ) + val end = Offset( + corner.x + (next.x - corner.x) / outLength * cut, + corner.y + (next.y - corner.y) / outLength * cut, + ) + path.lineTo(start.x, start.y) + path.quadraticTo(corner.x, corner.y, end.x, end.y) + } + path.lineTo(points.last().x, points.last().y) + return path +} + /** * Column rank for every stage in declaration order, mirroring * tui.layoutSingleRowGraph: `graph.Stages` is the source order, so stages keep @@ -982,52 +1261,154 @@ private fun DrawScope.drawEdgePaths( layout: GraphLayout, colors: GraphColors, runState: RunGraphState?, + animate: Boolean, + phase: Float, ) { for (edge in layout.edges) { - val executed = edge.isExecuted(runState) - val color = outcomeColor(edge.edge.outcome, colors) - val alpha = if (executed) 1f else 0.25f // Routing already happened once in layoutGraph; drawing only replays the // stored polyline, so there is no per-frame recompute. val points = if (edge.points.isEmpty()) routePoints(edge) else edge.points if (points.size < 2) continue - val path = Path() - path.moveTo(points.first().x, points.first().y) - for (i in 1 until points.size) { - path.lineTo(points[i].x, points[i].y) + // The stored route stays the axis-aligned polyline (the layout/tests + // contract); drawing only rounds its corners with the one shared + // [GRAPH_ROUTE_CORNER_RADIUS] control offset, so the tracks read as smooth curves + // without changing any routing. + val path = roundedRoutePath(points, GRAPH_ROUTE_CORNER_RADIUS.toPx()) + // Executed = solid full-colour stroke plus an arrowhead; not executed = + // dashed muted stroke with no arrowhead. The difference is carried by line + // style and arrowhead presence, never by opacity alone, so it survives a + // screenshot, a dim screen and a colour-blind reader. An executed + // `success`/`error` edge uses the heavier pass/fail width, a stronger + // (same-hue) stroke and a matching arrowhead, so pass/fail dominates. + val motion = edgeMotion(edge.edge, runState) + if (motion != EdgeMotion.Unvisited) { + val color = edgeStrokeColor(edge.edge, runState, colors) + val width = edgeStrokeWidth(edge.edge, runState) + drawPath( + path, + color = color, + style = Stroke(width = width, cap = StrokeCap.Round, join = StrokeJoin.Round), + ) + // Reuse the width just computed for the stroke's own head (never + // re-deriving it), so the head always matches the line it terminates. + drawArrowHead(points, color, arrowHeadSizeFor(width)) + // While the run is live, an executed route carries a dot travelling + // source -> target so its direction reads at a glance. A settled or + // off-screen graph draws no dot. + if (animate && motion == EdgeMotion.Flowing) { + drawFlowDots(points, width, colors.nodeText, phase) + } + } else { + drawPath( + path, + color = colors.labelText, + style = Stroke( + width = edgeStrokeWidth(edge.edge, runState), + cap = StrokeCap.Round, + join = StrokeJoin.Round, + pathEffect = INACTIVE_DASH_EFFECT, + ), + ) } - drawPath(path, color = color.copy(alpha = alpha), style = Stroke(width = 3f)) - drawArrowHead(points, color.copy(alpha = alpha)) } } +/** + * Draws [FLOW_DOT_COUNT] dots travelling along [points] from start to end, + * spaced evenly and advanced by [phase] (0..1), so the executed route reads its + * direction. Allocation-free: it walks the stored polyline with scalars only, so + * it is safe to call on every animation frame. The dot radius scales with the + * edge's own [strokeWidth] so it matches a pass/fail or normal route. + */ +private fun DrawScope.drawFlowDots( + points: List, + strokeWidth: Float, + color: Color, + phase: Float, +) { + var total = 0f + for (i in 1 until points.size) { + total += hypot(points[i].x - points[i - 1].x, points[i].y - points[i - 1].y) + } + if (total <= 0f) return + val radius = strokeWidth * FLOW_DOT_SCALE + for (dot in 0 until FLOW_DOT_COUNT) { + val fraction = ((phase + dot.toFloat() / FLOW_DOT_COUNT) % 1f + 1f) % 1f + val center = pointAlong(points, fraction * total) ?: continue + drawCircle(color = color, radius = radius, center = center) + } +} + +/** + * The point [distance] along the polyline [points], or null when there is no + * segment. Pure scalar interpolation with no allocation. + */ +private fun pointAlong(points: List, distance: Float): Offset? { + var remaining = distance + for (i in 1 until points.size) { + val a = points[i - 1] + val b = points[i] + val length = hypot(b.x - a.x, b.y - a.y) + if (remaining <= length) { + val t = if (length <= 0f) 0f else remaining / length + return Offset(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t) + } + remaining -= length + } + return points.lastOrNull() +} + +/** + * Draws the rounded tonal chip behind a measured label: the shared chip paddings + * and corner ([GRAPH_EDGE_CHIP_PAD_X]/[GRAPH_EDGE_CHIP_PAD_Y]/[GRAPH_EDGE_CHIP_CORNER], dp tokens so + * they scale with the device), filled with [color]. Both the edge outcome labels + * and the active stage's elapsed badge use it, so the two chip call sites keep one + * geometry instead of repeating the same rounded rect. The caller draws the + * pre-measured text at [textTopLeft] afterwards. + */ +private fun DrawScope.drawTonalChip(textTopLeft: Offset, textSize: IntSize, color: Color) { + val padX = GRAPH_EDGE_CHIP_PAD_X.toPx() + val padY = GRAPH_EDGE_CHIP_PAD_Y.toPx() + val corner = GRAPH_EDGE_CHIP_CORNER.toPx() + drawRoundRect( + color = color, + topLeft = Offset(textTopLeft.x - padX, textTopLeft.y - padY), + size = Size(textSize.width + padX * 2f, textSize.height + padY * 2f), + cornerRadius = CornerRadius(corner, corner), + ) +} + /** * Draws every outcome label in a second pass, after all curves, so a * neighbouring edge can never be drawn across a label. Each label sits on its * own edge's stored [EdgeLayout.labelPoint] (the edge's own lane/track), so - * distinct outcomes never overprint. Executed edges use a legible on-surface - * variant of their outcome colour (see [outcomeLabelColor]); dimmed edges use a - * muted colour on a near-opaque background instead of inheriting the curve's - * 0.25 alpha, which left the text unreadable. + * distinct outcomes never overprint. The label is drawn on a tonal rounded chip + * (not raw text over the canvas): the chip is the raised surface tone tinted with + * the label's own colour, so an executed edge's label keeps its legible outcome + * colour and a not-executed one stays muted but readable. The text uses the app's + * type scale ([text]'s label role), never an ad-hoc size. */ private fun DrawScope.drawEdgeLabels( layout: GraphLayout, colors: GraphColors, runState: RunGraphState?, textMeasurer: TextMeasurer, + text: PipelinesTextStyles, ) { for (edge in layout.edges) { - val executed = edge.isExecuted(runState) - val textColor = if (executed) outcomeColor(edge.edge.outcome, colors) else colors.labelText - val measured = textMeasurer.measure(edge.edge.label, TextStyle(fontSize = 11.sp, color = textColor)) + val executed = edgeIsExecuted(edge.edge, runState) + // One colour serves both the label text and its chip tint: the outcome + // hue when the edge executed, otherwise the muted not-executed label tone. + val labelColor = if (executed) outcomeColor(edge.edge.outcome, colors) else colors.labelText + val measured = textMeasurer.measure(edge.edge.label, text.label.copy(color = labelColor)) val labelTopLeft = Offset( x = edge.labelPoint.x - measured.size.width / 2f, y = edge.labelPoint.y - measured.size.height - 2f, ) - drawRect( - color = colors.labelBackground.copy(alpha = if (executed) 0.92f else 0.86f), - topLeft = Offset(labelTopLeft.x - 3f, labelTopLeft.y - 1f), - size = Size(measured.size.width + 6f, measured.size.height + 2f), + drawTonalChip( + textTopLeft = labelTopLeft, + textSize = measured.size, + color = tonalFill(colors.labelBackground, labelColor, EDGE_CHIP_TINT), ) // Draw the pre-measured layout: the string overload re-derives its width // constraints from this DrawScope and throws when a label sits outside it @@ -1040,17 +1421,18 @@ private fun DrawScope.drawEdgeLabels( } /** - * Draws an arrowhead at the tip of [points], oriented along the final segment's - * direction (see [arrowDirection]) instead of the from-to chord, so a route that - * turns a corner still gets an arrow pointing the way it actually travels. + * Draws an arrowhead of length [size] at the tip of [points], oriented along the + * final segment's direction (see [arrowDirection]) instead of the from-to chord, + * so a route that turns a corner still gets an arrow pointing the way it + * actually travels. [size] is passed by the caller from the matching named token + * (see [edgeArrowHeadSize]) rather than written here. */ -private fun DrawScope.drawArrowHead(points: List, color: Color) { +private fun DrawScope.drawArrowHead(points: List, color: Color, size: Float) { if (points.size < 2) return val to = points.last() val direction = arrowDirection(points) if (direction.x == 0f && direction.y == 0f) return val angle = kotlin.math.atan2(direction.y.toDouble(), direction.x.toDouble()) - val size = 12f val left = Offset( x = to.x - size * kotlin.math.cos(angle - 0.5).toFloat(), y = to.y - size * kotlin.math.sin(angle - 0.5).toFloat(), @@ -1075,45 +1457,90 @@ private fun DrawScope.drawNodes( selectedStage: String?, stageTypeByKey: Map, textMeasurer: TextMeasurer, + text: PipelinesTextStyles, + nodeCornerPx: Float, + nodeBorderPx: Float, + nodeBorderSelectedPx: Float, + animate: Boolean, + phase: Float, + elapsedLayout: TextLayoutResult?, + haloGapPx: Float, + haloStrokePx: Float, + elapsedInsetPx: Float, ) { for (node in layout.nodes) { - val executed = runState == null || node.key in runState.visitedStages + val motion = nodeMotion(node.key, runState) + val executed = motion != NodeMotion.Unvisited val selected = node.key == selectedStage - val alpha = if (executed) 1f else 0.3f val kind = graphNodeKind(node.terminal, node.key, stageTypeByKey[node.key]) - val fill = when { - kind == GraphNodeKind.TerminalFailure -> colors.terminalErrorFill - kind == GraphNodeKind.TerminalSuccess -> colors.terminalFill - selected -> colors.nodeFillActive - kind == GraphNodeKind.Ntfy -> colors.nodeNtfyFill - kind == GraphNodeKind.Custom -> colors.nodeCustomFill - else -> colors.nodeFill - }.copy(alpha = alpha) - val border = when (kind) { - GraphNodeKind.TerminalFailure -> colors.error - GraphNodeKind.TerminalSuccess -> colors.success - else -> if (selected) colors.nodeBorderActive else colors.nodeBorder - }.copy(alpha = alpha) - val textColor = if (!node.terminal && selected) colors.nodeTextActive else colors.nodeText val topLeft = Offset(node.x, node.y) - drawRoundRect( - color = fill, - topLeft = topLeft, - size = Size(node.width, node.height), - cornerRadius = androidx.compose.ui.geometry.CornerRadius(14f, 14f), - ) - drawRoundRect( - color = border, - topLeft = topLeft, - size = Size(node.width, node.height), - cornerRadius = androidx.compose.ui.geometry.CornerRadius(14f, 14f), - style = Stroke(width = if (selected && !node.terminal) 4f else 2f), - ) - val label = "[" + node.label + "]" - val measured = textMeasurer.measure( - label, - TextStyle(fontSize = 13.sp, fontWeight = FontWeight.Medium, color = textColor.copy(alpha = alpha)), - ) + // A stage is a rounded rectangle from the theme's shape scale; a terminal + // is a pill (fully rounded) so it is visibly not a stage. + val corner = if (node.terminal) { + CornerRadius(node.height / 2f, node.height / 2f) + } else { + CornerRadius(nodeCornerPx, nodeCornerPx) + } + val borderWidth = if (selected && !node.terminal) nodeBorderSelectedPx else nodeBorderPx + // The active stage carries a halo behind its fill: a pulse while + // animating, a fixed but clearly visible ring otherwise, so a live run's + // current stage is unmistakable with or without animation. + if (motion == NodeMotion.Active) { + drawActiveHalo(node, colors, animate, phase, corner, haloGapPx, haloStrokePx) + } + if (executed) { + // A tonal surface fill carrying a subtle tint of the node's semantic + // colour, plus a soft border (or the outcome hue for a terminal). + val fill = when { + kind == GraphNodeKind.TerminalFailure -> colors.terminalErrorFill + kind == GraphNodeKind.TerminalSuccess -> colors.terminalFill + selected -> colors.nodeFillActive + kind == GraphNodeKind.Ntfy -> colors.nodeNtfyFill + kind == GraphNodeKind.Custom -> colors.nodeCustomFill + else -> colors.nodeFill + } + val border = when (kind) { + GraphNodeKind.TerminalFailure -> colors.error + GraphNodeKind.TerminalSuccess -> colors.success + else -> if (selected) colors.nodeBorderActive else colors.nodeBorder + } + drawRoundRect( + color = fill, + topLeft = topLeft, + size = Size(node.width, node.height), + cornerRadius = corner, + ) + drawRoundRect( + color = border, + topLeft = topLeft, + size = Size(node.width, node.height), + cornerRadius = corner, + style = Stroke(width = borderWidth), + ) + } else { + // Hollow and outlined: no fill (the tonal surface shows through), a + // dashed muted border and a muted but legible label, so "not executed" + // is a shape and border-style difference rather than a faded node. A + // selected not-executed node keeps the stronger border colour. + val border = if (selected && !node.terminal) colors.nodeBorderActive else colors.labelText + drawRoundRect( + color = border, + topLeft = topLeft, + size = Size(node.width, node.height), + cornerRadius = corner, + style = Stroke(width = borderWidth, pathEffect = INACTIVE_DASH_EFFECT), + ) + } + // A terminal names its state in its own colour; a stage names itself in the + // node text colour (inverted when selected). No all-caps, no brackets. + val textColor: Color = when { + node.terminal && kind == GraphNodeKind.TerminalSuccess -> colors.success + node.terminal && kind == GraphNodeKind.TerminalFailure -> colors.error + selected && !node.terminal -> colors.nodeTextActive + executed -> colors.nodeText + else -> colors.labelText + } + val measured = textMeasurer.measure(node.label, text.cardTitle.copy(color = textColor)) // Pre-measured layout avoids the scope-relative width constraint crash and // the redundant re-measure of the string overload. drawText( @@ -1123,9 +1550,62 @@ private fun DrawScope.drawNodes( node.y + (node.height - measured.size.height) / 2f, ), ) + // The active stage's live elapsed time, drawn as a badge under its label + // from the pre-measured layout (so the draw pass adds no allocation), on + // an opaque tonal chip so it stays legible over any node fill (the + // selected active node is filled light in the dark theme). Only the + // active node has one, and only while the run is live. + if (motion == NodeMotion.Active && elapsedLayout != null) { + val badgeTopLeft = Offset( + x = node.x + (node.width - elapsedLayout.size.width) / 2f, + y = node.y + node.height - elapsedLayout.size.height - elapsedInsetPx, + ) + drawTonalChip( + textTopLeft = badgeTopLeft, + textSize = elapsedLayout.size, + color = tonalFill(colors.labelBackground, colors.nodeText, ELAPSED_CHIP_TINT), + ) + drawText(textLayoutResult = elapsedLayout, topLeft = badgeTopLeft) + } } } +/** + * The halo that makes the active stage unmistakable: a rounded-rect ring drawn a + * little outside the node, behind its fill, plus a soft glow filling the ring so + * it reads even at a small fit scale. Its strength is the smooth [pulseAlpha] + * while animating and [ACTIVE_HALO_STATIC_ALPHA] when the graph is static + * (animations disabled or paused), so the active stage is clearly marked in both + * cases. Drawing it uses only primitives, so it allocates nothing. + */ +private fun DrawScope.drawActiveHalo( + node: NodeLayout, + colors: GraphColors, + animate: Boolean, + phase: Float, + corner: CornerRadius, + gap: Float, + strokeWidth: Float, +) { + val strength = if (animate) pulseAlpha(phase) else ACTIVE_HALO_STATIC_ALPHA + val topLeft = Offset(node.x - gap, node.y - gap) + val size = Size(node.width + gap * 2f, node.height + gap * 2f) + val haloCorner = CornerRadius(corner.x + gap, corner.y + gap) + drawRoundRect( + color = colors.nodeBorderActive.copy(alpha = strength * ACTIVE_HALO_GLOW), + topLeft = topLeft, + size = size, + cornerRadius = haloCorner, + ) + drawRoundRect( + color = colors.nodeBorderActive.copy(alpha = strength), + topLeft = topLeft, + size = size, + cornerRadius = haloCorner, + style = Stroke(width = strokeWidth), + ) +} + /** * The colour for an outcome: the theme error role for `error`, a clearly * positive theme colour for `success`, and the curated [GraphPalette] entry for @@ -1140,23 +1620,93 @@ internal fun outcomeColor(outcome: String, colors: GraphColors): Color = when (o else -> colors.palette[GraphPalette.outcomeColorIndex(outcome)] } -/** True when [runState] is null (definition view) or recorded this edge's route. */ -private fun EdgeLayout.isExecuted(runState: RunGraphState?): Boolean = +/** + * True when no run is selected (the definition-only view) or [key] was visited + * by the selected run. Pure, so graph drawing and the unit tests share one + * definition of "executed". + */ +internal fun stageIsExecuted(key: String, runState: RunGraphState?): Boolean = + runState == null || key in runState.visitedStages + +/** + * True when no run is selected (the definition-only view) or the selected run + * recorded [edge]'s route. Pure, so graph drawing and the unit tests share one + * definition of "executed". + */ +internal fun edgeIsExecuted(edge: GraphEdge, runState: RunGraphState?): Boolean = runState == null || GraphRoute(edge.source, edge.outcome, edge.target) in runState.takenRoutes +/** + * True for the two decisive outcomes the graph emphasises: `success` (pass) and + * `error` (fail). These are the protocol's terminal outcomes, the only two whose + * stroke is widened. Pure, so drawing and the tests share one definition. + */ +internal fun isPassFailOutcome(outcome: String): Boolean = + outcome == "success" || outcome == "error" + +/** True for an executed pass/fail edge: the edges drawn heaviest. */ +internal fun isEmphasizedEdge(edge: GraphEdge, runState: RunGraphState?): Boolean = + isPassFailOutcome(edge.outcome) && edgeIsExecuted(edge, runState) + +/** + * The named stroke-width token for [edge]: the heavier pass/fail width for an + * executed `success`/`error`, the base width for any other executed outcome, and + * the finest width for a not-executed edge. Pure, so the widths are asserted in a + * unit test and no call site writes a stroke literal. + */ +internal fun edgeStrokeWidth(edge: GraphEdge, runState: RunGraphState?): Float = when { + !edgeIsExecuted(edge, runState) -> INACTIVE_EDGE_STROKE + isPassFailOutcome(edge.outcome) -> PASSFAIL_EDGE_STROKE + else -> EDGE_STROKE +} + +/** + * Arrowhead length for a stroke of [strokeWidth]: one [ARROW_HEAD_SCALE] multiple + * of the width. This is the single mapping both an edge and the legend share, and + * drawing passes the width it has just computed rather than re-deriving it, so a + * heavier line always carries a proportionally larger filled head. + */ +internal fun arrowHeadSizeFor(strokeWidth: Float): Float = strokeWidth * ARROW_HEAD_SCALE + +/** + * The arrowhead length for [edge]: [arrowHeadSizeFor] of its own + * [edgeStrokeWidth], so a heavier line always carries a proportionally larger + * head and the two can never disagree. The pass/fail width is the heaviest, so + * its head is the largest; a not-executed edge draws no head at all. + */ +internal fun edgeArrowHeadSize(edge: GraphEdge, runState: RunGraphState?): Float = + arrowHeadSizeFor(edgeStrokeWidth(edge, runState)) + +/** + * The stroke colour for an executed [edge]: its outcome colour, made more + * saturated when pass/fail so it is stronger without changing its hue (see + * [boostSaturation]). A not-executed edge is drawn muted elsewhere. + */ +internal fun edgeStrokeColor(edge: GraphEdge, runState: RunGraphState?, colors: GraphColors): Color = + if (isEmphasizedEdge(edge, runState)) { + boostSaturation(outcomeColor(edge.outcome, colors), PASSFAIL_SATURATION) + } else { + outcomeColor(edge.outcome, colors) + } + /** A screen-reader description so meaning is never conveyed by colour alone. */ private fun graphDescription(graph: Graph, runState: RunGraphState?): String { if (graph.stages.isEmpty()) return "Empty workflow graph" val builder = StringBuilder("Workflow graph with ${graph.stages.size} stages. ") for (stage in graph.stages) { - val executed = runState == null || stage.key in runState.visitedStages + val executed = stageIsExecuted(stage.key, runState) builder.append("Stage ${stage.key}") - if (runState != null) builder.append(if (executed) ", executed" else ", not executed") + if (runState != null) { + builder.append(if (executed) ", executed" else ", not executed") + if (runState.executing && stage.key == runState.currentStage) { + builder.append(", currently running") + } + } builder.append(". ") for (outcome in GraphSemantics.outcomes(stage)) { val target = Protocol.resolveTarget(outcome, stage.edges[outcome] ?: continue) val label = GraphSemantics.edgeLabel(stage, outcome) - builder.append("Outcome $label goes to ${GraphSemantics.nodeLabel(target)}. ") + builder.append("Outcome $label goes to ${nodeDisplayLabel(target)}. ") } } builder.append("Stages can be tapped for details.") @@ -1166,16 +1716,103 @@ private fun graphDescription(graph: Graph, runState: RunGraphState?): String { private const val MIN_SCALE = 0.3f private const val MAX_SCALE = 3f -/** Breathing room left around a fitted graph, and the least content kept visible. */ -private val FIT_PADDING = 16.dp -private val MIN_VISIBLE = 48.dp +/** + * The active-node pulse: one full cycle per [PULSE_PERIOD_MILLIS], driven by a + * linear 0..1 phase and mapped to a smooth strength by [pulseAlpha]. A slow sine + * is a halo, never a blink. Only composed while [graphShouldAnimate] is true, so + * a finished, off-screen or animations-disabled graph has no animation clock. + */ +@Composable +private fun rememberPulsePhase(animate: Boolean): Float { + if (!animate) return 0f + val transition = rememberInfiniteTransition(label = "graph-pulse") + val phase by transition.animateFloat( + initialValue = 0f, + targetValue = 1f, + animationSpec = infiniteRepeatable( + animation = tween(durationMillis = PULSE_PERIOD_MILLIS, easing = LinearEasing), + repeatMode = RepeatMode.Restart, + ), + label = "graph-pulse-phase", + ) + return phase +} + +/** One pulse (and one full pass of the edge flow) per this many milliseconds. */ +private const val PULSE_PERIOD_MILLIS = 1_600 + +/** The active stage's elapsed time ticks once a second, never per frame. */ +private const val ELAPSED_TICK_MILLIS = 1_000L + +/** How much of the pulse strength the active halo's soft glow carries. */ +private const val ACTIVE_HALO_GLOW = 0.28f + +/** Executed-edge flow: this many dots per route, sized against the edge stroke. */ +private const val FLOW_DOT_COUNT = 2 +private const val FLOW_DOT_SCALE = 1.2f + +/** + * Line-style tokens shared by the graph and its legend. Widths and the arrowhead + * size are named here so no call site writes a stroke literal. An executed route + * is solid; a not-executed route is dashed with [INACTIVE_DASH_INTERVALS] on/off + * pixels, so the two states differ by shape, not by a faded tint. + * + * The two decisive outcomes (`success`/`error`) use the heavier + * [PASSFAIL_EDGE_STROKE] with a proportionally larger arrowhead (see + * [edgeArrowHeadSize]) and a stronger [PASSFAIL_SATURATION] stroke, so pass/fail + * reads at a glance and from a distance, while every other outcome keeps the + * finer [EDGE_STROKE] and a not-executed route the finer still + * [INACTIVE_EDGE_STROKE]. + */ +private const val EDGE_STROKE = 3f + +/** Stroke width for an executed `success`/`error` edge; heavier than [EDGE_STROKE]. */ +private const val PASSFAIL_EDGE_STROKE = 7f + +/** Stroke width for a not-executed edge; finer than either executed width. */ +private const val INACTIVE_EDGE_STROKE = 2.5f + +/** + * Arrowhead length as a multiple of the edge's own stroke width, so a heavier line + * always carries a proportionally larger filled head (base `3 * 4 = 12`, + * pass/fail `7 * 4 = 28`). [ARROW_HEAD_SIZE] is the base length, used by the + * legend swatch, which names the generic executed state rather than pass/fail. + */ +private const val ARROW_HEAD_SCALE = 4f +private const val ARROW_HEAD_SIZE = EDGE_STROKE * ARROW_HEAD_SCALE + +/** + * Tonal tints: the fraction of a node's/edge's semantic colour blended into the + * raised surface for its fill or chip. Small enough to read as a tint, large + * enough to tell the node kinds and outcome labels apart. + */ +private const val NEUTRAL_TINT = 0.10f +private const val KIND_TINT = 0.22f +private const val TERMINAL_TINT = 0.30f +private const val EDGE_CHIP_TINT = 0.20f +private const val ELAPSED_CHIP_TINT = 0.14f + +/** + * How much more saturated an executed pass/fail stroke is than its outcome + * colour: hue and value are preserved (see [boostSaturation]) so the meaning of + * the colour does not change. + */ +private const val PASSFAIL_SATURATION = 1.6f + +/** The dash pattern (on/off, px) for every not-executed stroke; pure data. */ +internal val INACTIVE_DASH_INTERVALS = floatArrayOf(14f, 10f) + +/** The dashed effect for not-executed strokes, built once, never per frame. */ +private val INACTIVE_DASH_EFFECT: PathEffect by lazy { + PathEffect.dashPathEffect(INACTIVE_DASH_INTERVALS) +} /** * Collapsed graph-panel height, shared by both detail screens (one source for * the former 360.dp / 340.dp literals). ~58% of the window height so the graph * is a substantial share of the screen, floored at a height that still fits a * 4-stage layout plus its lower terminal row: pad*2 + node + terminal gap + node - * = 32*2 + 56 + 72 + 56 = 248px at density 1. + * = 40*2 + 76 + 88 + 76 = 320px at density 1. */ internal fun collapsedGraphHeight(screenHeightDp: Int): Dp = (screenHeightDp * 0.58f).dp.coerceAtLeast(GRAPH_PANEL_MIN_HEIGHT) @@ -1184,4 +1821,4 @@ internal fun collapsedGraphHeight(screenHeightDp: Int): Dp = internal fun expandedGraphHeight(screenHeightDp: Int): Dp = (screenHeightDp * 0.92f).dp /** Floor that still fits a 4-stage graph with its terminal row (see above). */ -internal val GRAPH_PANEL_MIN_HEIGHT = 260.dp +internal val GRAPH_PANEL_MIN_HEIGHT = 320.dp diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/ListFilter.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/ListFilter.kt new file mode 100644 index 00000000..29924d7b --- /dev/null +++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/ListFilter.kt @@ -0,0 +1,246 @@ +package net.awan.pipelines.ui.screens + +import java.time.LocalDate +import java.time.ZoneId +import net.awan.pipelines.data.protocol.PipelineSummary +import net.awan.pipelines.data.protocol.RunSummary +import net.awan.pipelines.ui.components.RunState +import net.awan.pipelines.ui.components.runStateOf +import net.awan.pipelines.ui.parseInstant + +/** + * The run-list time windows offered by the filter control. [storageKey] is the + * stable value persisted in SharedPreferences; [fromStorage] tolerates a stale, + * unknown or blank stored value by returning [Default] ("any time"). + */ +enum class RunTimeRange(val label: String, val storageKey: String) { + AnyTime("Any time", "any_time"), + Today("Today", "today"), + Last7Days("Last 7 days", "last_7_days"), + Last30Days("Last 30 days", "last_30_days"); + + companion object { + val Default = AnyTime + + fun fromStorage(value: String?): RunTimeRange = + entries.firstOrNull { it.storageKey == value } ?: Default + } +} + +/** + * Whether the pipeline list only shows pipelines that have (or have not) + * recorded a run, persisted like [RunTimeRange]. [Default] is no narrowing. + */ +enum class RunPresence(val label: String, val storageKey: String) { + Any("Any", "any"), + HasRuns("Has runs", "has_runs"), + NoRuns("No runs", "no_runs"); + + companion object { + val Default = Any + + fun fromStorage(value: String?): RunPresence = + entries.firstOrNull { it.storageKey == value } ?: Default + } +} + +/** + * The statuses a run filter can select. The server's own run vocabulary + * (internal/pipeline/runs.go: queued/running/succeeded/failed/canceled/ + * interrupted); the app-only `active` usage bucket and the `unknown` fallback + * are deliberately not offered, so a status filter always names a real state. + */ +internal val RUN_STATUS_FILTERS: List = listOf( + RunState.Queued, + RunState.Running, + RunState.Succeeded, + RunState.Failed, + RunState.Canceled, + RunState.Interrupted, +) + +/** Adds [state] when absent, removes it when present — the multi-select toggle. */ +internal fun Set.toggle(state: RunState): Set = + if (state in this) this - state else this + state + +/** + * The stable stored form of a status set: the states' server status words in + * ordinal order, comma-joined. [RunState.label] is that word and is unique per + * state, so the encoding round-trips and stays meaningful in the prefs file. + */ +internal fun encodeRunStates(states: Set): String = + states.sortedBy { it.ordinal }.joinToString(",") { it.label } + +/** Decodes [encodeRunStates], dropping unknown or blank tokens rather than crashing. */ +internal fun decodeRunStates(value: String?): Set = + value.orEmpty().split(',').mapNotNull { token -> + val word = token.trim() + RunState.entries.firstOrNull { it.label == word } + }.toSet() + +/** + * The runs-list filters, each defaulting to "no narrowing" so the default value + * filters nothing. [activeCount] is the number of active facets (one per + * status/pipeline/time choice), used for the control's badge. + */ +data class RunFilters( + val statuses: Set = emptySet(), + val pipelineId: Long? = null, + val timeRange: RunTimeRange = RunTimeRange.Default, +) { + val activeCount: Int + get() = (if (statuses.isNotEmpty()) 1 else 0) + + (if (pipelineId != null) 1 else 0) + + (if (timeRange != RunTimeRange.Default) 1 else 0) + + val isActive: Boolean get() = activeCount > 0 + + companion object { + val Default = RunFilters() + + fun fromStorage(statuses: String?, pipelineId: String?, timeRange: String?): RunFilters = + RunFilters( + statuses = decodeRunStates(statuses), + pipelineId = pipelineId?.trim()?.takeIf { it.isNotEmpty() }?.toLongOrNull(), + timeRange = RunTimeRange.fromStorage(timeRange), + ) + } +} + +/** + * The pipelines-list run filters: whether a pipeline has any recorded run and + * the status of its most recent one. The name search stays a separate control + * (it narrows by text, not by run facts); these two are persisted per list. + */ +data class PipelineFilters( + val presence: RunPresence = RunPresence.Default, + val lastRunStatuses: Set = emptySet(), +) { + val activeCount: Int + get() = (if (presence != RunPresence.Default) 1 else 0) + + (if (lastRunStatuses.isNotEmpty()) 1 else 0) + + val isActive: Boolean get() = activeCount > 0 + + companion object { + val Default = PipelineFilters() + + fun fromStorage(presence: String?, lastRunStatuses: String?): PipelineFilters = + PipelineFilters( + presence = RunPresence.fromStorage(presence), + lastRunStatuses = decodeRunStates(lastRunStatuses), + ) + } +} + +/** True when [run] is in [statuses]; an empty set means "any status". */ +internal fun runMatchesStatuses(run: RunSummary, statuses: Set): Boolean = + statuses.isEmpty() || runStateOf(run.status) in statuses + +/** True when [run] belongs to [pipelineId]; null means "any pipeline". */ +internal fun runMatchesPipeline(run: RunSummary, pipelineId: Long?): Boolean = + pipelineId == null || run.pipelineId == pipelineId + +/** The run's start date in [zone], or null when blank/unparseable. */ +internal fun runLocalDate(createdAt: String, zone: ZoneId): LocalDate? = + parseInstant(createdAt)?.atZoneSameInstant(zone)?.toLocalDate() + +/** + * True when [run] falls inside [range] relative to [today]. A blank/unparseable + * timestamp and a future-dated run (clock skew) never match a finite window; + * [RunTimeRange.AnyTime] matches everything. The window is inclusive calendar + * days ending today: "last 7 days" covers today and the six days before it. + */ +internal fun runMatchesTimeRange( + run: RunSummary, + range: RunTimeRange, + today: LocalDate, + zone: ZoneId, +): Boolean { + if (range == RunTimeRange.AnyTime) return true + val date = runLocalDate(run.createdAt, zone) ?: return false + if (date.isAfter(today)) return false + return when (range) { + RunTimeRange.Today -> date == today + RunTimeRange.Last7Days -> !date.isBefore(today.minusDays(6)) + RunTimeRange.Last30Days -> !date.isBefore(today.minusDays(29)) + RunTimeRange.AnyTime -> true + } +} + +/** Every run facet combined with AND. */ +internal fun runMatchesFilters( + run: RunSummary, + filters: RunFilters, + today: LocalDate, + zone: ZoneId, +): Boolean = + runMatchesStatuses(run, filters.statuses) && + runMatchesPipeline(run, filters.pipelineId) && + runMatchesTimeRange(run, filters.timeRange, today, zone) + +/** Narrows [runs] by [filters]; the default filters change nothing. */ +internal fun filterRuns( + runs: List, + filters: RunFilters, + today: LocalDate, + zone: ZoneId, +): List = + if (!filters.isActive) runs else runs.filter { runMatchesFilters(it, filters, today, zone) } + +/** True when [presence] is satisfied by whether the pipeline [hasRun]. */ +internal fun pipelineMatchesPresence(presence: RunPresence, hasRun: Boolean): Boolean = when (presence) { + RunPresence.Any -> true + RunPresence.HasRuns -> hasRun + RunPresence.NoRuns -> !hasRun +} + +/** + * True when [latestRun]'s status is in [statuses]; an empty set means "any + * status" and a pipeline with no run never matches a selected status (there is + * no last-run status to compare), so the filter genuinely narrows. + */ +internal fun pipelineMatchesLastRunStatus(latestRun: RunSummary?, statuses: Set): Boolean = + statuses.isEmpty() || (latestRun != null && runStateOf(latestRun.status) in statuses) + +/** Every pipeline run facet combined with AND. */ +internal fun pipelineMatchesFilters(filters: PipelineFilters, latestRun: RunSummary?): Boolean = + pipelineMatchesPresence(filters.presence, latestRun != null) && + pipelineMatchesLastRunStatus(latestRun, filters.lastRunStatuses) + +/** + * Narrows [pipelines] by [filters]. Both facets depend on the run history, so + * while that history is still unknown (`runsKnown == false`) the list is left + * unfiltered rather than briefly hiding every pipeline. + */ +internal fun filterPipelines( + pipelines: List, + filters: PipelineFilters, + latestRuns: Map, + runsKnown: Boolean = true, +): List { + if (!filters.isActive || !runsKnown) return pipelines + return pipelines.filter { pipelineMatchesFilters(filters, latestRuns[it.id]) } +} + +/** One selectable pipeline in the run filter, named from its runs. */ +internal data class PipelineFilterOption(val id: Long, val name: String) + +/** + * The distinct pipelines present in [runs], each named by its most recent + * non-blank run name and ordered case-insensitively by name then id, so the + * run-list pipeline filter needs no separate pipeline fetch. A blank name falls + * back to the id so the entry is never unlabelled. + */ +internal fun pipelineFilterOptions(runs: List): List { + val names = LinkedHashMap() + for (run in runs) { + val current = names[run.pipelineId] + if (current == null || current.isBlank()) names[run.pipelineId] = run.name + } + return names.map { (id, name) -> PipelineFilterOption(id, name.ifBlank { "Pipeline $id" }) } + .sortedWith( + compareBy(String.CASE_INSENSITIVE_ORDER) { it.name } + .thenBy { it.id }, + ) +} diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/ListSort.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/ListSort.kt new file mode 100644 index 00000000..62536273 --- /dev/null +++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/ListSort.kt @@ -0,0 +1,123 @@ +package net.awan.pipelines.ui.screens + +import java.time.OffsetDateTime +import net.awan.pipelines.data.protocol.PipelineSummary +import net.awan.pipelines.data.protocol.RunSummary +import net.awan.pipelines.ui.durationSeconds +import net.awan.pipelines.ui.parseInstant + +/** + * The pipeline-list orderings offered by the top-bar sort control. [storageKey] + * is the stable value persisted in SharedPreferences; [fromStorage] tolerates a + * stale, unknown or blank stored value by returning [Default] — the server's own + * order, which the default comparator preserves exactly. + */ +enum class PipelineSort(val label: String, val storageKey: String) { + ServerOrder("Server order", "server_order"), + NameAsc("Name A\u2013Z", "name_asc"), + NameDesc("Name Z\u2013A", "name_desc"), + RecentRun("Most recent run", "recent_run"), + FewestStages("Fewest stages", "fewest_stages"), + MostStages("Most stages", "most_stages"); + + companion object { + val Default = ServerOrder + + fun fromStorage(value: String?): PipelineSort = + entries.firstOrNull { it.storageKey == value } ?: Default + } +} + +/** + * The run-list orderings offered by the top-bar sort control. [storageKey] is + * persisted like [PipelineSort]'s; an unknown or stale value resolves to + * [Default] ("newest first"). + */ +enum class RunSort(val label: String, val storageKey: String) { + NewestFirst("Newest first", "newest_first"), + OldestFirst("Oldest first", "oldest_first"), + LongestDuration("Longest duration", "longest_duration"), + ShortestDuration("Shortest duration", "shortest_duration"), + PipelineName("Pipeline name", "pipeline_name"), + Status("Status", "status"); + + companion object { + val Default = NewestFirst + + fun fromStorage(value: String?): RunSort = + entries.firstOrNull { it.storageKey == value } ?: Default + } +} + +/** The identity comparator used by "server order": a stable sort then keeps the input untouched. */ +private val SERVER_ORDER = Comparator { _, _ -> 0 } + +/** + * The pure pipeline comparator for [sort]. Every case ends in an explicit + * tie-break (`id` is unique), so pipelines that compare equal on the primary key + * always order the same way rather than depending on the input order. + * + * [latestRuns] maps a pipeline id to that pipeline's most recent run + * (see [latestRunByPipeline]); only [PipelineSort.RecentRun] uses it but it is + * passed in once so the fold is never repeated per comparison. + */ +internal fun pipelineComparator( + sort: PipelineSort, + latestRuns: Map = emptyMap(), +): Comparator = when (sort) { + PipelineSort.ServerOrder -> SERVER_ORDER + PipelineSort.NameAsc -> compareBy(String.CASE_INSENSITIVE_ORDER) { it.name } + .thenBy { it.name } + .thenBy { it.id } + PipelineSort.NameDesc -> compareByDescending(String.CASE_INSENSITIVE_ORDER) { it.name } + .thenBy { it.name } + .thenBy { it.id } + PipelineSort.RecentRun -> compareBy { latestRuns[it.id] == null } + .thenByDescending { latestRuns[it.id]?.let { run -> parseInstant(run.createdAt) } ?: OffsetDateTime.MIN } + .thenByDescending { latestRuns[it.id]?.id ?: Long.MIN_VALUE } + .thenBy { it.id } + PipelineSort.FewestStages -> compareBy { it.stages } + .thenBy(String.CASE_INSENSITIVE_ORDER) { it.name } + .thenBy { it.id } + PipelineSort.MostStages -> compareByDescending { it.stages } + .thenBy(String.CASE_INSENSITIVE_ORDER) { it.name } + .thenBy { it.id } +} + +/** Orders [pipelines] by [sort], folding the run history once for the recent-run key. */ +internal fun sortPipelines( + pipelines: List, + sort: PipelineSort, + latestRuns: Map = emptyMap(), +): List = pipelines.sortedWith(pipelineComparator(sort, latestRuns)) + +/** + * The pure run comparator for [sort]. As with [pipelineComparator], every case + * ends in an explicit tie-break so equal keys always order the same way. A blank + * or unparseable timestamp, and a run with no recorded duration (still + * executing), sort last regardless of direction and never crash. + */ +internal fun runComparator(sort: RunSort): Comparator = when (sort) { + RunSort.NewestFirst -> compareByDescending { parseInstant(it.createdAt) ?: OffsetDateTime.MIN } + .thenByDescending { it.id } + RunSort.OldestFirst -> compareBy { parseInstant(it.createdAt) ?: OffsetDateTime.MAX } + .thenBy { it.id } + RunSort.LongestDuration -> compareBy { durationSeconds(it.createdAt, it.finishedAt) == null } + .thenByDescending { durationSeconds(it.createdAt, it.finishedAt) ?: Long.MIN_VALUE } + .thenByDescending { parseInstant(it.createdAt) ?: OffsetDateTime.MIN } + .thenByDescending { it.id } + RunSort.ShortestDuration -> compareBy { durationSeconds(it.createdAt, it.finishedAt) == null } + .thenBy { durationSeconds(it.createdAt, it.finishedAt) ?: Long.MAX_VALUE } + .thenByDescending { parseInstant(it.createdAt) ?: OffsetDateTime.MIN } + .thenByDescending { it.id } + RunSort.PipelineName -> compareBy(String.CASE_INSENSITIVE_ORDER) { it.name } + .thenByDescending { parseInstant(it.createdAt) ?: OffsetDateTime.MIN } + .thenByDescending { it.id } + RunSort.Status -> compareBy(String.CASE_INSENSITIVE_ORDER) { it.status } + .thenByDescending { parseInstant(it.createdAt) ?: OffsetDateTime.MIN } + .thenByDescending { it.id } +} + +/** Orders [runs] by [sort]. */ +internal fun sortRuns(runs: List, sort: RunSort): List = + runs.sortedWith(runComparator(sort)) diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineLastRun.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineLastRun.kt new file mode 100644 index 00000000..e56e15e8 --- /dev/null +++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineLastRun.kt @@ -0,0 +1,103 @@ +package net.awan.pipelines.ui.screens + +import java.time.Duration +import java.time.OffsetDateTime +import net.awan.pipelines.data.protocol.RunSummary +import net.awan.pipelines.ui.components.RunState +import net.awan.pipelines.ui.components.runStateOf +import net.awan.pipelines.ui.formatDuration +import net.awan.pipelines.ui.parseInstant + +/** Shown for a pipeline that appears in list_runs but has recorded no run. */ +const val NO_RUNS_RECORDED = "no runs recorded" + +/** + * The last-run facts one pipeline row shows: the status chip's [state], how long + * ago the run started, its recorded duration and its run id. Kept as a plain data + * class so the join and its edge cases (no runs, ties, unknown status) are + * unit-testable without composing anything. + */ +internal data class PipelineRunBadge( + val runId: Long, + val state: RunState, + val ranAgo: String?, + val duration: String?, +) + +/** + * The last-run secondary line, e.g. `2h ago · 1m 5s · run 42`. Missing fragments + * (an unparseable start, a run still executing) are omitted so no blank separator + * is ever printed; the run id is always present. + */ +internal fun PipelineRunBadge.metaLine(): String = buildList { + ranAgo?.let(::add) + duration?.let(::add) + add("run $runId") +}.joinToString(" · ") + +/** + * Joins list_runs (the whole history, delivered newest-first) onto pipelines by + * pipeline id: one badge per pipeline that has run, the most recent run winning. + * The input order never matters — recency is decided from the timestamps, with the + * higher run id breaking an exact tie — so a pipeline with no runs is simply + * absent from the result (the caller renders [NO_RUNS_RECORDED] for it). No server + * field is involved; this is a pure client-side join. + */ +internal fun pipelineRunBadges( + runs: List, + now: OffsetDateTime, +): Map = + latestRunByPipeline(runs).mapValues { (_, run) -> runBadge(run, now) } + +/** + * The most recent run of each pipeline, decided from the timestamps (the higher + * run id breaking an exact tie or a bad timestamp), independent of the input + * order. The one fold shared by the last-run badge join above and the "most + * recent run" pipeline sort, so both agree on which run is the latest. + */ +internal fun latestRunByPipeline(runs: List): Map { + val latest = HashMap() + for (run in runs) { + val current = latest[run.pipelineId] + if (current == null || isMoreRecent(run, current)) latest[run.pipelineId] = run + } + return latest +} + +/** The display facts one pipeline row shows for [run], anchored to [now]. */ +internal fun runBadge(run: RunSummary, now: OffsetDateTime): PipelineRunBadge = + PipelineRunBadge( + runId = run.id, + state = runStateOf(run.status), + ranAgo = formatRanAgo(run.createdAt, now), + duration = formatDuration(run.createdAt, run.finishedAt), + ) + +/** Timestamps decide recency; the higher run id breaks an exact tie (or a bad timestamp). */ +private fun isMoreRecent(candidate: RunSummary, current: RunSummary): Boolean { + val a = parseInstant(candidate.createdAt) + val b = parseInstant(current.createdAt) + if (a != null && b != null) { + val order = a.compareTo(b) + if (order != 0) return order > 0 + } + return candidate.id > current.id +} + +/** + * A compact "how long ago" for a run's start: `just now` under a minute, then + * `Nm ago`/`Nh ago`/`Nd ago`, the same integer rhythm as [formatDuration]. Null + * when the timestamp is blank or unparseable, so the caller omits the fragment + * instead of printing a blank. A future start (clock skew) reads as `just now`, + * never a negative age. + */ +internal fun formatRanAgo(createdAt: String, now: OffsetDateTime): String? { + val start = parseInstant(createdAt) ?: return null + val seconds = Duration.between(start, now).seconds.coerceAtLeast(0) + return when { + seconds < 60 -> "just now" + seconds < 3600 -> "${seconds / 60}m ago" + seconds < 86_400 -> "${seconds / 3600}h ago" + else -> "${seconds / 86_400}d ago" + } +} diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineListScreen.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineListScreen.kt index c12614fb..3266335b 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineListScreen.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineListScreen.kt @@ -1,7 +1,9 @@ package net.awan.pipelines.ui.screens +import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Column import androidx.compose.foundation.layout.PaddingValues +import androidx.compose.foundation.layout.Row import androidx.compose.foundation.layout.WindowInsetsSides import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.foundation.layout.fillMaxWidth @@ -14,6 +16,7 @@ import androidx.compose.material.icons.filled.AccountTree import androidx.compose.material.icons.filled.Refresh import androidx.compose.material.icons.filled.Search import androidx.compose.material3.ExperimentalMaterial3Api +import androidx.compose.material3.HorizontalDivider import androidx.compose.material3.Icon import androidx.compose.material3.IconButton import androidx.compose.material3.MaterialTheme @@ -27,18 +30,26 @@ import androidx.compose.runtime.getValue import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.compose.ui.text.style.TextOverflow import androidx.compose.ui.unit.dp import androidx.lifecycle.compose.collectAsStateWithLifecycle +import java.time.OffsetDateTime import net.awan.pipelines.data.protocol.PipelineSummary import net.awan.pipelines.ui.AppViewModel import net.awan.pipelines.ui.components.EmptyState import net.awan.pipelines.ui.components.ErrorState +import net.awan.pipelines.ui.components.FilterCheckItem +import net.awan.pipelines.ui.components.FilterMenu +import net.awan.pipelines.ui.components.FilterSectionHeader import net.awan.pipelines.ui.components.ListRow import net.awan.pipelines.ui.components.LoadPhase import net.awan.pipelines.ui.components.LoadingState import net.awan.pipelines.ui.components.PaneIdentity +import net.awan.pipelines.ui.components.RunState +import net.awan.pipelines.ui.components.RunStatusChip +import net.awan.pipelines.ui.components.SortMenu import net.awan.pipelines.ui.components.StateCrossfade import net.awan.pipelines.ui.components.animateListItem import net.awan.pipelines.ui.components.listLoadPhase @@ -55,9 +66,40 @@ fun PipelineListScreen( covered: Boolean = false, ) { val state by vm.pipelines.collectAsStateWithLifecycle() + val runsState by vm.runs.collectAsStateWithLifecycle() + val sortKey by vm.pipelineSort.collectAsStateWithLifecycle() + val sort = PipelineSort.fromStorage(sortKey) + val presenceKey by vm.pipelineFilterPresence.collectAsStateWithLifecycle() + val runStatusKey by vm.pipelineFilterRunStatuses.collectAsStateWithLifecycle() + val filters = PipelineFilters.fromStorage(presenceKey, runStatusKey) var query by remember { mutableStateOf("") } - LaunchedEffect(Unit) { vm.refreshPipelines() } + // The last-run line joins list_runs onto the pipelines client-side; runs are + // fetched here too so a pipeline list opened first still shows its history. + LaunchedEffect(Unit) { + vm.refreshPipelines() + vm.refreshRuns() + } + + // "How long ago" is anchored once per composition, not recomputed per row. + val now = remember { OffsetDateTime.now() } + // The history is folded to one latest run per pipeline once, feeding both the + // row badges and the "most recent run" ordering rather than folding twice. + val latestRuns = remember(runsState.data) { + runsState.data?.let { latestRunByPipeline(it.runs) }.orEmpty() + } + val badges = remember(latestRuns, now) { + latestRuns.mapValues { (_, run) -> runBadge(run, now) } + } + // Until the run history has loaded, a missing badge is "not known yet", never + // the explicit "no runs recorded" claim. + val runsKnown = runsState.data != null + + val onClearFilters: () -> Unit = { + vm.setPipelineFilterPresence("") + vm.setPipelineFilterRunStatuses("") + query = "" + } // A covered pane shows its compact identity only; the search field and list // must never be drawn squeezed into the peek strip. @@ -79,7 +121,26 @@ fun PipelineListScreen( title = { Text("Pipelines") }, windowInsets = paneSafeArea().only(WindowInsetsSides.Top + WindowInsetsSides.Horizontal), actions = { - IconButton(onClick = vm::refreshPipelines) { + PipelineFilterControl( + filters = filters, + onPresence = { vm.setPipelineFilterPresence(it.storageKey) }, + onRunStatuses = { vm.setPipelineFilterRunStatuses(encodeRunStates(it)) }, + onClear = onClearFilters, + ) + SortMenu( + options = PipelineSort.entries, + selected = sort, + label = { it.label }, + contentDescription = "Sort pipelines", + onSelect = { vm.setPipelineSort(it.storageKey) }, + onReset = { vm.setPipelineSort(PipelineSort.Default.storageKey) }, + ) + IconButton( + onClick = { + vm.refreshPipelines() + vm.refreshRuns() + }, + ) { Icon(Icons.Default.Refresh, contentDescription = "Refresh pipelines") } }, @@ -95,33 +156,58 @@ fun PipelineListScreen( singleLine = true, modifier = Modifier.fillMaxWidth().padding(horizontal = 16.dp, vertical = 8.dp), ) - val pipelines = (state.data ?: emptyList()) - .filter { it.name.contains(query, ignoreCase = true) } + val all = state.data ?: emptyList() + val items = remember(all, query, sort, latestRuns, filters, runsKnown) { + filterPipelines( + sortPipelines(all, sort, latestRuns), + filters, + latestRuns, + runsKnown, + ).filter { it.name.contains(query, ignoreCase = true) } + } + val queryActive = query.isNotBlank() + val filtersActive = filters.isActive && runsKnown StateCrossfade( phase = listLoadPhase( loading = state.loading, error = state.error, hasData = state.data != null, - emptyMessage = if (pipelines.isEmpty()) { - if (query.isBlank()) "No pipelines are defined on this server." - else "No pipelines match \"$query\"." + emptyMessage = if (items.isEmpty()) { + if (all.isEmpty()) { + // Nothing exists: neither the search nor the filters can + // reveal a pipeline, so there is no clear action. + "No pipelines are defined on this server." + } else if (queryActive && filtersActive) { + "No pipelines match the current search and filters." + } else if (queryActive) { + "No pipelines match \"$query\"." + } else { + "No pipelines match the current filters." + } } else { null }, + emptyActionLabel = if (items.isEmpty() && all.isNotEmpty()) "Clear filters" else null, ), ) { phase -> when (phase) { LoadPhase.Loading -> LoadingState("Loading pipelines…") is LoadPhase.Error -> ErrorState(phase.message, onRetry = vm::refreshPipelines) - is LoadPhase.Empty -> EmptyState(phase.message) + is LoadPhase.Empty -> EmptyState( + phase.message, + actionLabel = phase.actionLabel, + onAction = if (phase.actionLabel != null) onClearFilters else null, + ) LoadPhase.Content -> LazyColumn( modifier = Modifier.fillMaxSize(), contentPadding = PaddingValues(vertical = 8.dp), ) { - items(pipelines, key = { it.id }) { pipeline -> + items(items, key = { it.id }) { pipeline -> PipelineRow( pipeline = pipeline, selected = pipeline.id == selectedId, + badge = badges[pipeline.id], + runsKnown = runsKnown, onClick = { onOpen(pipeline.id, pipeline.version) }, modifier = animateListItem(), ) @@ -140,15 +226,55 @@ fun PipelineListScreen( } } +/** + * The pipelines-list run filter control: presence (has/no runs) and the + * most-recent run's status (multi-select), with the shared active-count badge + * and one Clear filters action. The name search stays a separate field. + */ +@Composable +private fun PipelineFilterControl( + filters: PipelineFilters, + onPresence: (RunPresence) -> Unit, + onRunStatuses: (Set) -> Unit, + onClear: () -> Unit, +) { + FilterMenu( + activeCount = filters.activeCount, + contentDescription = "Filter pipelines", + resetLabel = "Clear filters", + onReset = onClear, + ) { dismiss -> + FilterSectionHeader("Runs") + RunPresence.entries.forEach { presence -> + FilterCheckItem(presence.label, filters.presence == presence) { + onPresence(presence) + dismiss() + } + } + HorizontalDivider() + FilterSectionHeader("Last run status") + RUN_STATUS_FILTERS.forEach { state -> + FilterCheckItem(state.label, state in filters.lastRunStatuses) { + onRunStatuses(filters.lastRunStatuses.toggle(state)) + } + } + } +} + /** * One pipeline as a row of the shared real list: a leading workflow glyph, the - * name as the title and the id/version/stage-count as the secondary line. The - * row is selected when its pipeline is the one open in the detail pane. + * name as the title, the id/version/stage-count as the secondary line and the + * last-run facts (status chip, how long ago, duration, run id) below. The row is + * selected when its pipeline is the one open in the detail pane. Before the run + * history has loaded the last-run line is omitted; once it has, a pipeline with + * no recorded run says so explicitly. */ @Composable private fun PipelineRow( pipeline: PipelineSummary, selected: Boolean, + badge: PipelineRunBadge?, + runsKnown: Boolean, onClick: () -> Unit, modifier: Modifier = Modifier, ) { @@ -185,5 +311,29 @@ private fun PipelineRow( overflow = TextOverflow.Ellipsis, ) } + if (runsKnown) { + if (badge == null) { + Text( + NO_RUNS_RECORDED, + style = text.meta, + color = MaterialTheme.colorScheme.onSurfaceVariant, + maxLines = 1, + overflow = TextOverflow.Ellipsis, + ) + } else { + Row( + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(8.dp), + ) { + RunStatusChip(badge.state) + Text( + badge.metaLine(), + style = text.meta, + maxLines = 1, + overflow = TextOverflow.Ellipsis, + ) + } + } + } } } diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt index 1097a570..f57b82ee 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt @@ -53,6 +53,7 @@ import net.awan.pipelines.ui.AppViewModel import net.awan.pipelines.ui.ArtifactGroup import net.awan.pipelines.ui.LoadState import net.awan.pipelines.ui.components.CodeBlock +import net.awan.pipelines.ui.components.ColoredChip import net.awan.pipelines.ui.components.DetailTabBody import net.awan.pipelines.ui.components.DetailTabs import net.awan.pipelines.ui.components.ErrorState @@ -70,6 +71,7 @@ import net.awan.pipelines.ui.components.detailLoadPhase import net.awan.pipelines.ui.components.rememberPaneContent import net.awan.pipelines.ui.components.rememberSectionExpansion import net.awan.pipelines.ui.components.runDetailTabs +import net.awan.pipelines.ui.components.runStateIcon import net.awan.pipelines.ui.components.runStateOf import net.awan.pipelines.ui.displayText import net.awan.pipelines.ui.formatDuration @@ -78,6 +80,8 @@ import net.awan.pipelines.ui.graph.ArtifactGallery import net.awan.pipelines.ui.graph.ArtifactSelection import net.awan.pipelines.ui.graph.ArtifactSelectionScaffold import net.awan.pipelines.ui.graph.WorkflowGraph +import net.awan.pipelines.ui.graph.graphColors +import net.awan.pipelines.ui.graph.outcomeColor import net.awan.pipelines.ui.graph.rememberArtifactSelection import net.awan.pipelines.ui.runArtifactGroups import net.awan.pipelines.ui.theme.pipelinesText @@ -418,7 +422,11 @@ private fun RunGraphTab( onStageTap: (String, Int) -> Unit, ) { val text = pipelinesText() - val runState = remember(run.id, run.steps) { RunGraphState.from(run) } + // Keyed on the fields RunGraphState.from reads (steps, executing, current + // stage) so a run that finishes without a new step still stops animating. + val runState = remember(run.id, run.steps, run.executing, run.currentStage) { + RunGraphState.from(run) + } // Grouped once per step-list change; the sheet opened from the graph starts on // the most recent visit of the tapped stage. val timeline = remember(run.steps) { runTimeline(run.steps) } @@ -435,7 +443,7 @@ private fun RunGraphTab( Text("This server did not include the run graph.", style = text.meta) } else { Text( - "Executed stages and routes are highlighted; the rest are dimmed. Pinch to zoom, drag to pan, tap a stage for details.", + "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. Pinch to zoom, drag to pan, tap a stage for details.", style = text.meta, ) WorkflowGraph( @@ -662,6 +670,13 @@ private fun TimelineRow(entry: TimelineEntry, onClick: () -> Unit) { val text = pipelinesText() val state = runStateOf(entry.step.outcome.ifBlank { entry.step.status }) val chipLabel = entry.outcomeLabel.ifBlank { state.label } + // A visit's chip and glyph are a *stage outcome*, not the run status, so they + // take the graph's outcome palette and agree with the workflow graph instead + // of being mapped through the run-status colours (the two are different + // vocabularies). Built once per scheme, from the same factory the graph uses. + val scheme = MaterialTheme.colorScheme + val outcomeColors = remember(scheme) { graphColors(scheme) } + val outcomeTint = outcomeColor(entry.step.outcome.ifBlank { entry.step.status }, outcomeColors) Row( modifier = Modifier .fillMaxWidth() @@ -674,6 +689,7 @@ private fun TimelineRow(entry: TimelineEntry, onClick: () -> Unit) { state = state, contentDescription = "Visit ${entry.visit} ${entry.stageKey}: ${state.label}", modifier = Modifier.size(18.dp), + tint = outcomeTint, ) Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(2.dp)) { Row( @@ -687,7 +703,7 @@ private fun TimelineRow(entry: TimelineEntry, onClick: () -> Unit) { overflow = TextOverflow.Ellipsis, modifier = Modifier.weight(1f), ) - StatusChip(label = chipLabel, state = state) + ColoredChip(label = chipLabel, color = outcomeTint, icon = runStateIcon(state)) if (hasArtifacts(entry.step)) { Icon( imageVector = Icons.Default.AttachFile, diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunHistoryScreen.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunHistoryScreen.kt index f74fcce4..4646facd 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunHistoryScreen.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunHistoryScreen.kt @@ -22,6 +22,7 @@ import androidx.compose.material.icons.filled.Refresh import androidx.compose.material3.Card import androidx.compose.material3.CircularProgressIndicator import androidx.compose.material3.ExperimentalMaterial3Api +import androidx.compose.material3.HorizontalDivider import androidx.compose.material3.Icon import androidx.compose.material3.IconButton import androidx.compose.material3.MaterialTheme @@ -49,11 +50,16 @@ import net.awan.pipelines.ui.AppViewModel import net.awan.pipelines.ui.components.RunState import net.awan.pipelines.ui.components.RunStatusChip import net.awan.pipelines.ui.components.RunStatusIcon +import net.awan.pipelines.ui.components.EmptyState import net.awan.pipelines.ui.components.ErrorState +import net.awan.pipelines.ui.components.FilterCheckItem +import net.awan.pipelines.ui.components.FilterMenu +import net.awan.pipelines.ui.components.FilterSectionHeader import net.awan.pipelines.ui.components.ListRow import net.awan.pipelines.ui.components.LoadPhase import net.awan.pipelines.ui.components.LoadingState import net.awan.pipelines.ui.components.PaneIdentity +import net.awan.pipelines.ui.components.SortMenu import net.awan.pipelines.ui.components.StateCrossfade import net.awan.pipelines.ui.components.animateListItem import net.awan.pipelines.ui.components.listLoadPhase @@ -76,8 +82,25 @@ fun RunHistoryScreen( covered: Boolean = false, ) { val state by vm.runs.collectAsStateWithLifecycle() + val sortKey by vm.runSort.collectAsStateWithLifecycle() + val sort = RunSort.fromStorage(sortKey) + val statusFilterKey by vm.runFilterStatuses.collectAsStateWithLifecycle() + val pipelineFilterKey by vm.runFilterPipeline.collectAsStateWithLifecycle() + val timeRangeKey by vm.runFilterTimeRange.collectAsStateWithLifecycle() + val filters = RunFilters.fromStorage(statusFilterKey, pipelineFilterKey, timeRangeKey) LaunchedEffect(Unit) { vm.refreshRuns() } + val onClearFilters: () -> Unit = { + vm.setRunFilterStatuses("") + vm.setRunFilterPipeline("") + vm.setRunFilterTimeRange("") + } + // The pipeline filter choices come from the runs already in hand, folded once + // per history load rather than rebuilt on every recomposition. + val pipelineOptions = remember(state.data) { + pipelineFilterOptions(state.data?.runs.orEmpty()) + } + // A covered pane shows its compact identity only; the usage block, sticky day // headers and run rows must never be drawn squeezed into the peek strip. if (covered) { @@ -98,6 +121,22 @@ fun RunHistoryScreen( title = { Text(if (filterPipelineId == null) "Runs" else "Runs for this pipeline") }, windowInsets = paneSafeArea().only(WindowInsetsSides.Top + WindowInsetsSides.Horizontal), actions = { + RunFilterControl( + filters = filters, + pipelines = pipelineOptions, + onStatuses = { vm.setRunFilterStatuses(encodeRunStates(it)) }, + onPipeline = { vm.setRunFilterPipeline(it?.toString().orEmpty()) }, + onTimeRange = { vm.setRunFilterTimeRange(it.storageKey) }, + onClear = onClearFilters, + ) + SortMenu( + options = RunSort.entries, + selected = sort, + label = { it.label }, + contentDescription = "Sort runs", + onSelect = { vm.setRunSort(it.storageKey) }, + onReset = { vm.setRunSort(RunSort.Default.storageKey) }, + ) IconButton(onClick = vm::refreshRuns) { Icon(Icons.Default.Refresh, contentDescription = "Refresh runs") } @@ -129,8 +168,11 @@ fun RunHistoryScreen( runs = state.data?.runs.orEmpty(), filterPipelineId = filterPipelineId, selectedRunId = selectedRunId, + sort = sort, + filters = filters, error = state.error, onOpenRun = onOpenRun, + onClearFilters = onClearFilters, modifier = Modifier.padding(padding), ) } @@ -138,6 +180,55 @@ fun RunHistoryScreen( } } +/** + * The runs-list filter control: status (multi-select), pipeline (single-select) + * and time range, each section labelled inside one menu, with the shared + * active-count badge and one Clear filters action. + */ +@Composable +private fun RunFilterControl( + filters: RunFilters, + pipelines: List, + onStatuses: (Set) -> Unit, + onPipeline: (Long?) -> Unit, + onTimeRange: (RunTimeRange) -> Unit, + onClear: () -> Unit, +) { + FilterMenu( + activeCount = filters.activeCount, + contentDescription = "Filter runs", + resetLabel = "Clear filters", + onReset = onClear, + ) { dismiss -> + FilterSectionHeader("Status") + RUN_STATUS_FILTERS.forEach { state -> + FilterCheckItem(state.label, state in filters.statuses) { + onStatuses(filters.statuses.toggle(state)) + } + } + HorizontalDivider() + FilterSectionHeader("Pipeline") + FilterCheckItem("Any pipeline", filters.pipelineId == null) { + onPipeline(null) + dismiss() + } + pipelines.forEach { option -> + FilterCheckItem(option.name, filters.pipelineId == option.id) { + onPipeline(option.id) + dismiss() + } + } + HorizontalDivider() + FilterSectionHeader("Time range") + RunTimeRange.entries.forEach { range -> + FilterCheckItem(range.label, filters.timeRange == range) { + onTimeRange(range) + dismiss() + } + } + } +} + @OptIn(ExperimentalFoundationApi::class) @Composable private fun RunHistoryContent( @@ -145,20 +236,27 @@ private fun RunHistoryContent( runs: List, filterPipelineId: Long?, selectedRunId: Long?, + sort: RunSort, + filters: RunFilters, error: String?, onOpenRun: (Long) -> Unit, + onClearFilters: () -> Unit, modifier: Modifier = Modifier, ) { - // Day-grouping is derived once per data change (single pass, keyed on the - // stable source list), not per recomposition. - val groups = remember(runs, filterPipelineId) { - val filtered = if (filterPipelineId == null) { - runs - } else { - runs.filter { it.pipelineId == filterPipelineId } - } - val zone = ZoneId.systemDefault() - groupRunsByDay(filtered, LocalDate.now(zone), zone) + val zone = ZoneId.systemDefault() + val today = LocalDate.now(zone) + // The structural pipeline scope (a run list opened for one pipeline) and the + // user's filters both narrow, with AND semantics; the run history is folded + // once here, not per recomposition. + val scoped = remember(runs, filterPipelineId) { + if (filterPipelineId == null) runs else runs.filter { it.pipelineId == filterPipelineId } + } + val matched = remember(scoped, filters, today, zone) { filterRuns(scoped, filters, today, zone) } + // Day-grouping is derived once per data/order change (single pass, keyed on + // the stable source list), not per recomposition. The chosen comparator orders + // the runs first; the groups then follow the order their first run appears in. + val groups = remember(matched, today, zone, sort) { + groupRunsByDay(matched, today, zone, runComparator(sort)) } LazyColumn( @@ -170,13 +268,24 @@ private fun RunHistoryContent( UsageMetrics(usage, Modifier.padding(horizontal = 16.dp, vertical = 8.dp)) } } - if (groups.isEmpty()) { + if (scoped.isEmpty()) { + // Nothing exists at all: no filter could reveal a run, so there is no + // clear action. item(key = "runs-empty") { - Text( + EmptyState( "No runs have been recorded yet.", - style = pipelinesText().body, - color = MaterialTheme.colorScheme.onSurfaceVariant, - modifier = animateListItem(Modifier.padding(24.dp)), + modifier = animateListItem(), + ) + } + } else if (matched.isEmpty()) { + // Runs exist but every one is filtered out: distinguish this from the + // "nothing exists" case and offer the one clear action. + item(key = "runs-filtered-empty") { + EmptyState( + message = "No runs match the current filters.", + actionLabel = "Clear filters", + onAction = onClearFilters, + modifier = animateListItem(), ) } } else { @@ -372,24 +481,26 @@ private fun formatRunStart(createdAt: String): String? { internal data class RunDayGroup(val label: String, val runs: List) /** - * Groups runs by calendar day in the device timezone, newest first, preserving - * the order within a day. A blank/unparseable timestamp gets a safe "Unknown - * date" group instead of crashing. + * Groups runs by calendar day in the device timezone, preserving the order + * [order] puts them in (the default is newest first, so the groups come out + * newest day first), and preserving the order within a day. A blank/unparseable + * timestamp gets a safe "Unknown date" group instead of crashing. */ -internal fun groupRunsByDay(runs: List, today: LocalDate, zone: ZoneId): List { - val ordered = runs.sortedWith( - compareByDescending { runDate(it.createdAt, zone) } - .thenByDescending { it.createdAt }, - ) +internal fun groupRunsByDay( + runs: List, + today: LocalDate, + zone: ZoneId, + order: Comparator = runComparator(RunSort.NewestFirst), +): List { val groups = LinkedHashMap>() - for (run in ordered) { + for (run in runs.sortedWith(order)) { groups.getOrPut(dayLabel(run.createdAt, today, zone)) { mutableListOf() } += run } return groups.map { (label, list) -> RunDayGroup(label, list) } } internal fun dayLabel(createdAt: String, today: LocalDate, zone: ZoneId): String { - val date = runDate(createdAt, zone) ?: return "Unknown date" + val date = runLocalDate(createdAt, zone) ?: return "Unknown date" return when (date) { today -> "Today" today.minusDays(1) -> "Yesterday" @@ -397,12 +508,5 @@ internal fun dayLabel(createdAt: String, today: LocalDate, zone: ZoneId): String } } -private fun runDate(createdAt: String, zone: ZoneId): LocalDate? { - if (createdAt.isBlank()) return null - return runCatching { - OffsetDateTime.parse(createdAt).atZoneSameInstant(zone).toLocalDate() - }.getOrNull() -} - private val DAY_FORMAT: DateTimeFormatter = DateTimeFormatter.ofPattern("d MMM yyyy") private val START_FORMAT: DateTimeFormatter = DateTimeFormatter.ofPattern("d MMM HH:mm") diff --git a/android/app/src/main/java/net/awan/pipelines/ui/theme/Dimens.kt b/android/app/src/main/java/net/awan/pipelines/ui/theme/Dimens.kt index ff8b29a3..a6930347 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/theme/Dimens.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/theme/Dimens.kt @@ -81,3 +81,71 @@ internal const val WIDE_RAIL_WIDTH_DP = 200 /** Comfortable max text width for a tab body on a wide window. */ const val DETAIL_MAX_WIDTH_DP = 840 + +// ---- Workflow graph geometry (ui/graph/WorkflowGraph.kt) ------------------- +// The graph's node, edge and legend geometry. These are named here like every +// other app dimension so the graph file imports them instead of writing raw dp +// literals; the values are unchanged from the graph's own tokens. + +/** Workflow-graph node width. */ +internal val GRAPH_NODE_WIDTH = 150.dp + +/** Workflow-graph node minimum height. */ +internal val GRAPH_NODE_MIN_HEIGHT = 76.dp + +/** Workflow-graph node port spacing. */ +internal val GRAPH_NODE_PORT_SPACING = 14.dp + +/** Workflow-graph node horizontal gap. */ +internal val GRAPH_NODE_H_GAP = 168.dp + +/** Workflow-graph content padding. */ +internal val GRAPH_PAD = 40.dp + +/** Workflow-graph edge-lane spacing. */ +internal val GRAPH_EDGE_LANE_SPACING = 34.dp + +/** Workflow-graph terminal-row gap. */ +internal val GRAPH_TERMINAL_ROW_GAP = 88.dp + +/** Workflow-graph edge-track step. */ +internal val GRAPH_EDGE_TRACK_STEP = 26.dp + +/** Workflow-graph node hairline border. */ +internal val GRAPH_NODE_BORDER = 1.dp + +/** Workflow-graph selected node border. */ +internal val GRAPH_NODE_BORDER_SELECTED = 3.dp + +/** Bottom inset of the active node's elapsed-time badge. */ +internal val GRAPH_ELAPSED_INSET = 4.dp + +/** Workflow-graph orthogonal route corner radius. */ +internal val GRAPH_ROUTE_CORNER_RADIUS = 7.dp + +/** Tonal outcome-chip horizontal padding. */ +internal val GRAPH_EDGE_CHIP_PAD_X = 2.dp + +/** Tonal outcome-chip vertical padding. */ +internal val GRAPH_EDGE_CHIP_PAD_Y = 1.dp + +/** Tonal outcome-chip corner radius. */ +internal val GRAPH_EDGE_CHIP_CORNER = 2.dp + +/** Legend swatch width. */ +internal val GRAPH_LEGEND_SWATCH_WIDTH = 22.dp + +/** Legend swatch height. */ +internal val GRAPH_LEGEND_SWATCH_HEIGHT = 10.dp + +/** How far outside a node the active halo sits. */ +internal val GRAPH_ACTIVE_HALO_GAP = 6.dp + +/** How thick the active halo ring is. */ +internal val GRAPH_ACTIVE_HALO_STROKE = 4.dp + +/** Padding applied when fitting the graph to its viewport. */ +internal val GRAPH_FIT_PADDING = 16.dp + +/** Least graph span kept visible when clamping pan. */ +internal val GRAPH_MIN_VISIBLE = 48.dp diff --git a/android/app/src/test/java/net/awan/pipelines/data/protocol/GraphSemanticsTest.kt b/android/app/src/test/java/net/awan/pipelines/data/protocol/GraphSemanticsTest.kt index 0222fc6f..317e84b6 100644 --- a/android/app/src/test/java/net/awan/pipelines/data/protocol/GraphSemanticsTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/data/protocol/GraphSemanticsTest.kt @@ -2,6 +2,7 @@ package net.awan.pipelines.data.protocol import org.junit.Assert.assertEquals import org.junit.Assert.assertFalse +import org.junit.Assert.assertNull import org.junit.Assert.assertTrue import org.junit.Test @@ -77,5 +78,34 @@ class GraphSemanticsTest { assertEquals(setOf("a", "b", "#failure", "#success"), state.visitedStages) assertTrue(GraphRoute("a", "error", "#failure") in state.takenRoutes) assertEquals("b", state.currentStage) + // A finished run animates nothing: no executing flag, no live start. + assertFalse(state.executing) + assertNull(state.currentStageStartedAt) + } + + @Test + fun runGraphStateCarriesTheLiveStageAndItsStart() { + val run = RunDetail( + id = 2, + name = "demo", + status = "running", + executing = true, + currentStage = "b", + steps = listOf( + RunStep( + sequence = 1, + stage = "a", + status = "succeeded", + startedAt = "2026-10-16T07:00:00Z", + finishedAt = "2026-10-16T07:01:00Z", + ), + RunStep(sequence = 2, stage = "b", status = "running", startedAt = "2026-10-16T07:01:00Z"), + ), + ) + val state = RunGraphState.from(run) + assertTrue(state.executing) + assertEquals("b", state.currentStage) + // The timer rides on the stage the run is on, from that visit's start. + assertEquals("2026-10-16T07:01:00Z", state.currentStageStartedAt) } } diff --git a/android/app/src/test/java/net/awan/pipelines/ui/FormatTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/FormatTest.kt index dfd748f3..faa52a29 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/FormatTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/FormatTest.kt @@ -33,6 +33,19 @@ class FormatTest { assertNull(formatDuration("2026-10-15T02:05:00Z", "2026-10-15T02:00:00Z")) } + @Test + fun secondsSinceCountsFromTheStartAndIsSafe() { + // 2026-10-15T02:00:00Z in epoch millis, plus a minute and a bit. + val startMillis = parseInstant("2026-10-15T02:00:00Z")!!.toInstant().toEpochMilli() + assertEquals(0L, secondsSince("2026-10-15T02:00:00Z", startMillis)) + assertEquals(125L, secondsSince("2026-10-15T02:00:00Z", startMillis + 125_000)) + // A start in the future clamps to 0 rather than going negative. + assertEquals(0L, secondsSince("2026-10-15T02:00:00Z", startMillis - 5_000)) + // Blank or unparseable starts are "no elapsed", never a fabricated value. + assertNull(secondsSince("", startMillis)) + assertNull(secondsSince("not a timestamp", startMillis)) + } + @Test fun fileChangesSummaryOmitsBlankParts() { assertEquals("", fileChangesSummary(StageFileChanges())) diff --git a/android/app/src/test/java/net/awan/pipelines/ui/components/FilterMenuTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/components/FilterMenuTest.kt new file mode 100644 index 00000000..567c306d --- /dev/null +++ b/android/app/src/test/java/net/awan/pipelines/ui/components/FilterMenuTest.kt @@ -0,0 +1,29 @@ +package net.awan.pipelines.ui.components + +import androidx.compose.ui.unit.dp +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Test + +class FilterMenuTest { + + // --- menu height ------------------------------------------------------------ + + @Test + fun menuHeightGrowsWithTheWindowAndStaysPositive() { + assertEquals(0.85f * 700f, filterMenuMaxHeight(700).value, 0.01f) + assertTrue(filterMenuMaxHeight(360) > 0.dp) + assertTrue(filterMenuMaxHeight(700) > filterMenuMaxHeight(360)) + } + + // --- accessibility description --------------------------------------------- + + @Test + fun descriptionAnnouncesTheActiveCount() { + assertEquals("Filter runs", filterMenuDescription("Filter runs", 0)) + assertEquals("Filter runs, 1 filter active", filterMenuDescription("Filter runs", 1)) + assertEquals("Filter runs, 2 filters active", filterMenuDescription("Filter runs", 2)) + // A negative count (defensive) is treated as no filters, never "-1 filters". + assertEquals("Filter pipelines", filterMenuDescription("Filter pipelines", -1)) + } +} diff --git a/android/app/src/test/java/net/awan/pipelines/ui/components/RunStatusPaletteTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/components/RunStatusPaletteTest.kt new file mode 100644 index 00000000..831dd106 --- /dev/null +++ b/android/app/src/test/java/net/awan/pipelines/ui/components/RunStatusPaletteTest.kt @@ -0,0 +1,73 @@ +package net.awan.pipelines.ui.components + +import androidx.compose.ui.graphics.Color +import net.awan.pipelines.ui.graph.contrastRatio +import net.awan.pipelines.ui.theme.DarkError +import net.awan.pipelines.ui.theme.DarkPrimary +import net.awan.pipelines.ui.theme.DarkTertiary +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNotEquals +import org.junit.Assert.assertTrue +import org.junit.Test + +class RunStatusPaletteTest { + + /** The dark Pipelines surface every status chip/label is drawn on. */ + private val darkSurface = Color(0xFF0E1513) + + @Test + fun everyStatusColourMeetsWcagAaOnTheDarkSurface() { + RunState.entries.forEach { state -> + val ratio = contrastRatio(runStateColor(state), darkSurface) + assertTrue("$state contrast $ratio < 4.5", ratio >= 4.5) + } + } + + @Test + fun succeededIsGreenNotTheOldAmberTertiary() { + val green = runStateColor(RunState.Succeeded) + assertTrue("green must dominate: $green", green.green > green.red && green.green > green.blue) + assertNotEquals(DarkTertiary, green) + } + + @Test + fun runningAndActiveAreTheSameBlueNotTheOldMintPrimary() { + listOf(RunState.Running, RunState.Active).forEach { state -> + val blue = runStateColor(state) + assertTrue("blue must dominate: $blue", blue.blue > blue.red && blue.blue > blue.green) + assertNotEquals(DarkPrimary, blue) + } + assertEquals(runStateColor(RunState.Running), runStateColor(RunState.Active)) + } + + @Test + fun failedIsTheAppErrorRed() { + assertEquals(DarkError, runStateColor(RunState.Failed)) + } + + @Test + fun interruptedIsAmberAndDistinctFromFailure() { + val amber = runStateColor(RunState.Interrupted) + assertTrue( + "amber needs red>blue and green>blue: $amber", + amber.red > amber.blue && amber.green > amber.blue, + ) + assertNotEquals(DarkError, amber) + } + + @Test + fun queuedIsNeutralNotRunningBlue() { + val queued = runStateColor(RunState.Queued) + assertNotEquals(runStateColor(RunState.Running), queued) + val spread = maxOf(queued.red, queued.green, queued.blue) - + minOf(queued.red, queued.green, queued.blue) + assertTrue("queued should be near-grey: $queued", spread < 0.1f) + } + + @Test + fun everyEntryHasARationale() { + RunState.entries.forEach { state -> + assertTrue("$state needs a rationale", RunStatusPalette.of(state).rationale.isNotBlank()) + } + } +} diff --git a/android/app/src/test/java/net/awan/pipelines/ui/graph/GraphMotionTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/graph/GraphMotionTest.kt new file mode 100644 index 00000000..69c5f5a5 --- /dev/null +++ b/android/app/src/test/java/net/awan/pipelines/ui/graph/GraphMotionTest.kt @@ -0,0 +1,147 @@ +package net.awan.pipelines.ui.graph + +import net.awan.pipelines.data.protocol.Graph +import net.awan.pipelines.data.protocol.GraphRoute +import net.awan.pipelines.data.protocol.RunGraphState +import net.awan.pipelines.data.protocol.Stage +import net.awan.pipelines.data.protocol.edges +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Test +import kotlin.math.abs + +/** + * The graph's motion is a pure decision: which node/edge is in which visual + * state, and whether the graph animates at all, are functions of the run state + * only. These tests assert that policy directly, with no frame clock, so a + * finished run, a paused graph and the animations-off setting are all covered + * without timing a single frame. + */ +class GraphMotionTest { + + private fun stage(key: String, edges: Map) = Stage(key = key, edges = edges) + + private fun graph() = Graph( + stages = listOf( + stage("planner", mapOf("success" to "implementer", "error" to "#failure")), + stage("implementer", mapOf("success" to "reviewer", "error" to "#failure")), + stage("reviewer", mapOf("success" to "#success", "error" to "#failure")), + ), + ) + + private fun takenRoute() = graph().edges().first { it.source == "planner" && it.outcome == "success" } + + private fun untakenRoute() = graph().edges().first { it.source == "planner" && it.outcome == "error" } + + /** A live run paused on `implementer`, with a recorded start for the tick. */ + private fun liveRun(): RunGraphState { + val taken = takenRoute() + return RunGraphState( + visitedStages = setOf("planner", "implementer"), + takenRoutes = setOf(GraphRoute(taken.source, taken.outcome, taken.target)), + currentStage = "implementer", + executing = true, + currentStageStartedAt = "2026-10-16T07:36:56+01:00", + ) + } + + private fun finishedRun(): RunGraphState = + liveRun().copy(executing = false, currentStageStartedAt = null) + + @Test + fun graphAnimatesOnlyForALiveRunOnScreenWithAnimationsEnabled() { + val live = liveRun() + assertTrue(graphShouldAnimate(live, animationsEnabled = true, onScreen = true)) + // None of the three gates alone is enough. + assertFalse("finished runs never animate", graphShouldAnimate(finishedRun(), true, true)) + assertFalse("animations disabled", graphShouldAnimate(live, animationsEnabled = false, onScreen = true)) + assertFalse("off screen", graphShouldAnimate(live, animationsEnabled = true, onScreen = false)) + assertFalse("definition view", graphShouldAnimate(null, animationsEnabled = true, onScreen = true)) + } + + @Test + fun theRunningStageIsTheOnlyActiveNode() { + val live = liveRun() + assertEquals(NodeMotion.Active, nodeMotion("implementer", live)) + assertEquals(NodeMotion.Visited, nodeMotion("planner", live)) + assertEquals(NodeMotion.Unvisited, nodeMotion("reviewer", live)) + assertEquals(NodeMotion.Unvisited, nodeMotion("#success", live)) + } + + /** + * The live stage is active even before its step is recorded: [visitedStages] + * comes from the recorded steps, so a just-started stage can lag it. The halo + * must not depend on that ordering. + */ + @Test + fun theExecutingStageIsActiveEvenBeforeItsStepIsRecorded() { + val noStepsYet = RunGraphState( + visitedStages = emptySet(), + takenRoutes = emptySet(), + currentStage = "implementer", + executing = true, + currentStageStartedAt = "2026-10-16T07:36:56+01:00", + ) + assertEquals(NodeMotion.Active, nodeMotion("implementer", noStepsYet)) + } + + @Test + fun aFinishedRunHasNoActiveNode() { + val finished = finishedRun() + assertEquals(NodeMotion.Visited, nodeMotion("implementer", finished)) + assertEquals(NodeMotion.Visited, nodeMotion("planner", finished)) + assertEquals(NodeMotion.Unvisited, nodeMotion("reviewer", finished)) + } + + @Test + fun theDefinitionViewIsEntirelySettledAndStatic() { + for (key in listOf("planner", "implementer", "reviewer", "#success", "#failure")) { + assertEquals(key, NodeMotion.Visited, nodeMotion(key, null)) + } + } + + @Test + fun takenRoutesFlowOnlyWhileTheRunIsLive() { + assertEquals(EdgeMotion.Flowing, edgeMotion(takenRoute(), liveRun())) + assertEquals(EdgeMotion.Settled, edgeMotion(takenRoute(), finishedRun())) + assertEquals(EdgeMotion.Unvisited, edgeMotion(untakenRoute(), liveRun())) + assertEquals(EdgeMotion.Unvisited, edgeMotion(untakenRoute(), finishedRun())) + // Definition view: every route is executed, so settled/static (as before). + assertEquals(EdgeMotion.Settled, edgeMotion(takenRoute(), null)) + assertEquals(EdgeMotion.Settled, edgeMotion(untakenRoute(), null)) + } + + /** + * The active halo is a smooth pulse, not a blink: it stays visible, changes + * gradually between samples, both rises and falls, wraps seamlessly, and has + * a clear peak (not two alternating values). + */ + @Test + fun pulseAlphaIsABoundedSmoothNonBinaryRhythm() { + var previous = pulseAlpha(0f) + var sawIncrease = false + var sawDecrease = false + for (i in 1..100) { + val value = pulseAlpha(i / 100f) + assertTrue("in (0,1]: $value", value > 0f && value <= 1f) + assertTrue("always visible: $value", value > 0.2f) + if (value > previous) sawIncrease = true + if (value < previous) sawDecrease = true + assertTrue("continuous at $i ($value vs $previous)", abs(value - previous) < 0.1f) + previous = value + } + assertTrue("rises then falls", sawIncrease && sawDecrease) + // Periodic: the cycle wraps without a jump. + assertEquals(pulseAlpha(0f), pulseAlpha(1f), 0.0001f) + // A clear peak early in the cycle and a trough later; not a two-value blink. + assertTrue(pulseAlpha(0.25f) > pulseAlpha(0.75f)) + assertTrue(pulseAlpha(0.25f) - pulseAlpha(0.75f) > 0.2f) + } + + @Test + fun staticHaloIsClearlyVisible() { + assertTrue(ACTIVE_HALO_STATIC_ALPHA in 0.5f..1f) + assertTrue(ACTIVE_HALO_STATIC_ALPHA > 0f) + } +} diff --git a/android/app/src/test/java/net/awan/pipelines/ui/graph/GraphPaletteTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/graph/GraphPaletteTest.kt index 9d237e56..d52555ba 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/graph/GraphPaletteTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/graph/GraphPaletteTest.kt @@ -1,7 +1,10 @@ package net.awan.pipelines.ui.graph import androidx.compose.ui.graphics.Color +import net.awan.pipelines.data.protocol.GraphEdge +import net.awan.pipelines.data.protocol.GraphRoute import net.awan.pipelines.data.protocol.Protocol +import net.awan.pipelines.data.protocol.RunGraphState import org.junit.Assert.assertEquals import org.junit.Assert.assertFalse import org.junit.Assert.assertTrue @@ -98,6 +101,108 @@ class GraphPaletteTest { assertTrue(contrastRatio(errorRole, darkSurface) >= 4.5) } + /** + * The emphasis helper keeps the outcome hue and value and only raises + * saturation, so a stronger pass/fail stroke is still recognisably the same + * success/failure colour. + */ + @Test + fun boostSaturationRaisesSaturationButKeepsHueValueAndAlpha() { + val base = successRole + val boosted = boostSaturation(base, 1.6f) + assertTrue(saturationOf(boosted) > saturationOf(base)) + assertEquals(hueOf(base), hueOf(boosted), 1f) + assertEquals(valueOf(base), valueOf(boosted), 0.001f) + assertEquals(base.alpha, boosted.alpha, 0.001f) + // A second hue is left on its own hue, not shifted toward the first. + val red = errorRole + assertEquals(hueOf(red), hueOf(boostSaturation(red, 1.6f)), 1f) + } + + @Test + fun boostSaturationIsSafeAndClampedAtTheEdges() { + val base = successRole + // A no-op factor, and invalid factors, return the colour unchanged. + assertEquals(base, boostSaturation(base, 1f)) + assertEquals(base, boostSaturation(base, 0f)) + assertEquals(base, boostSaturation(base, -1f)) + assertEquals(base, boostSaturation(base, Float.NaN)) + // Achromatic colours have no saturation to raise. + assertEquals(Color.Gray, boostSaturation(Color.Gray, 2f)) + // An already fully-saturated colour clamps at 1 instead of overshooting. + assertEquals(Color.Red, boostSaturation(Color.Red, 2f)) + } + + /** + * Only an executed pass/fail edge is emphasised: its stroke is the stronger + * same-hue colour, while a non-pass/fail edge and a not-executed edge keep + * their exact outcome colour. + */ + @Test + fun onlyExecutedPassFailStrokesAreSaturatedFurther() { + val colors = colors() + val success = GraphEdge(1, "a", "success", Protocol.SUCCESS_END, "success") + val blocked = GraphEdge(2, "a", "blocked", Protocol.FAILURE_END, "blocked") + val error = GraphEdge(3, "b", "error", Protocol.FAILURE_END, "error") + val executed = RunGraphState( + visitedStages = setOf("a"), + takenRoutes = setOf(GraphRoute("a", "success", Protocol.SUCCESS_END)), + currentStage = "a", + ) + + val baseSuccess = outcomeColor("success", colors) + val strokeSuccess = edgeStrokeColor(success, executed, colors) + assertEquals(hueOf(baseSuccess), hueOf(strokeSuccess), 1f) + assertTrue(saturationOf(strokeSuccess) > saturationOf(baseSuccess)) + + // A non-pass/fail edge and a not-executed pass/fail edge are untouched. + assertEquals(outcomeColor("blocked", colors), edgeStrokeColor(blocked, executed, colors)) + assertEquals(outcomeColor("error", colors), edgeStrokeColor(error, executed, colors)) + } + + /** Hue in degrees, matching the conversion [boostSaturation] uses. */ + private fun hueOf(color: Color): Float { + val max = maxOf(color.red, color.green, color.blue) + val min = minOf(color.red, color.green, color.blue) + val delta = max - min + if (delta == 0f) return 0f + val h = when (max) { + color.red -> ((color.green - color.blue) / delta + 6f) % 6f + color.green -> (color.blue - color.red) / delta + 2f + else -> (color.red - color.green) / delta + 4f + } + return h * 60f + } + + private fun saturationOf(color: Color): Float { + val max = maxOf(color.red, color.green, color.blue) + val min = minOf(color.red, color.green, color.blue) + return if (max <= 0f) 0f else (max - min) / max + } + + private fun valueOf(color: Color): Float = maxOf(color.red, color.green, color.blue) + + /** + * [tonalFill] blends a raised surface toward the accent by the given fraction, + * so a node/label fill carries a subtle tint of its semantic colour while + * staying a surface; the fraction is clamped so a caller never overshoots. + */ + @Test + fun tonalFillBlendsTowardTheAccentAndClampsTheFraction() { + val surface = darkSurface + val accent = Color(0xFFFF0000) + // Both endpoints are reproduced exactly on the channel. + assertEquals(surface.red, tonalFill(surface, accent, 0f).red, 0.0001f) + assertEquals(accent.red, tonalFill(surface, accent, 1f).red, 0.0001f) + // A mid tint sits strictly between the two and keeps the surface's alpha. + val mid = tonalFill(surface, accent, 0.2f) + assertTrue(mid.red > surface.red && mid.red < accent.red) + assertEquals(surface.alpha, mid.alpha, 0.0001f) + // Out-of-range fractions clamp to the endpoints instead of overshooting. + assertEquals(surface.red, tonalFill(surface, accent, -1f).red, 0.0001f) + assertEquals(accent.red, tonalFill(surface, accent, 2f).red, 0.0001f) + } + @Test fun nodeKindIsDeterministicAndCoversEveryKind() { assertEquals(GraphNodeKind.Model, graphNodeKind(false, "planner", null)) diff --git a/android/app/src/test/java/net/awan/pipelines/ui/graph/WorkflowGraphTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/graph/WorkflowGraphTest.kt index f75ca759..43206f00 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/graph/WorkflowGraphTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/graph/WorkflowGraphTest.kt @@ -4,9 +4,13 @@ import androidx.compose.ui.geometry.Offset import androidx.compose.ui.geometry.Size import androidx.compose.ui.unit.Density import net.awan.pipelines.data.protocol.Graph +import net.awan.pipelines.data.protocol.GraphRoute import net.awan.pipelines.data.protocol.Protocol +import net.awan.pipelines.data.protocol.RunGraphState import net.awan.pipelines.data.protocol.Stage +import net.awan.pipelines.data.protocol.edges import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse import org.junit.Assert.assertNull import org.junit.Assert.assertTrue import org.junit.Test @@ -484,6 +488,166 @@ class WorkflowGraphTest { } } + /** + * The executed/inactive predicates are the one definition of the two states: + * the definition-only view (no run) is entirely executed, and under a run + * only the visited stages and recorded routes are. + */ + @Test + fun executedPredicatesSeparateDefinitionViewFromaRun() { + val graph = sampleGraph() + val taken = graph.edges().first { it.source == "planner" && it.outcome == "success" } + val notTaken = graph.edges().first { it.source == "planner" && it.outcome == "error" } + + // No run selected: every stage and route is executed (definition view, + // unchanged today). + assertTrue(stageIsExecuted("planner", null)) + assertTrue(stageIsExecuted("ui_reviewer", null)) + assertTrue(edgeIsExecuted(taken, null)) + + val runState = RunGraphState( + visitedStages = setOf("planner", "implementer"), + takenRoutes = setOf(GraphRoute("planner", "success", "implementer")), + currentStage = "implementer", + ) + assertTrue(stageIsExecuted("planner", runState)) + assertTrue(stageIsExecuted("implementer", runState)) + assertFalse(stageIsExecuted("reviewer", runState)) + assertFalse(stageIsExecuted("#success", runState)) + assertTrue(edgeIsExecuted(taken, runState)) + assertFalse(edgeIsExecuted(notTaken, runState)) + } + + /** + * The emphasis contract: an executed `success`/`error` edge uses the widest + * named stroke token, every other executed outcome a finer one and a + * not-executed edge the finest, with the arrowhead scaled to match. The + * definition-only view applies the same pass/fail emphasis. + */ + @Test + fun executedPassFailEdgesAreTheWidest() { + val graph = sampleGraph() + val success = graph.edges().first { it.outcome == "success" } + val error = graph.edges().first { it.outcome == "error" } + val other = graph.edges().first { it.outcome == "blocked" } + val untaken = graph.edges().first { it.outcome == "rejected" } + val runState = RunGraphState( + visitedStages = setOf("planner", "implementer", "reviewer"), + takenRoutes = setOf( + GraphRoute(success.source, success.outcome, success.target), + GraphRoute(error.source, error.outcome, error.target), + GraphRoute(other.source, other.outcome, other.target), + ), + currentStage = "reviewer", + ) + + val passFailWidth = edgeStrokeWidth(success, runState) + assertEquals(passFailWidth, edgeStrokeWidth(error, runState), 0.001f) + assertTrue(edgeStrokeWidth(other, runState) < passFailWidth) + assertTrue(edgeStrokeWidth(untaken, runState) < edgeStrokeWidth(other, runState)) + assertTrue(edgeStrokeWidth(untaken, runState) > 0f) + + // The arrowhead scales with the heavier stroke. + assertEquals(edgeArrowHeadSize(success, runState), edgeArrowHeadSize(error, runState), 0.001f) + assertTrue(edgeArrowHeadSize(success, runState) > edgeArrowHeadSize(other, runState)) + + // The definition-only view emphasises the same pass/fail edges. + assertEquals(passFailWidth, edgeStrokeWidth(success, null), 0.001f) + assertTrue(isEmphasizedEdge(success, runState)) + assertFalse(isEmphasizedEdge(other, runState)) + assertFalse(isEmphasizedEdge(untaken, runState)) + } + + /** Only `success` and `error` are the decisive, emphasised outcomes. */ + @Test + fun onlySuccessAndErrorArePassFailOutcomes() { + assertTrue(isPassFailOutcome("success")) + assertTrue(isPassFailOutcome("error")) + for (outcome in listOf("blocked", "rejected", "skipped", "exhausted", "approved", "done", "")) { + assertFalse(outcome, isPassFailOutcome(outcome)) + } + } + + /** + * The not-executed dash pattern is a real on/off rhythm, not a faded tint: a + * positive, even-length interval list so a dashed stroke reads differently + * from the solid executed one. + */ + @Test + fun inactiveDashPatternIsARealDashRhythm() { + assertTrue(INACTIVE_DASH_INTERVALS.isNotEmpty()) + assertEquals(0, INACTIVE_DASH_INTERVALS.size % 2) + assertTrue(INACTIVE_DASH_INTERVALS.all { it > 0f && it.isFinite() }) + } + + /** + * The one-line legend names both states, executed first, with exactly one + * entry flagged executed so the two swatches cannot both claim solid. + */ + @Test + fun legendNamesBothStatesWithExecutedFirst() { + assertEquals(listOf("Executed", "Not executed"), GRAPH_LEGEND.map { it.label }) + assertTrue(GRAPH_LEGEND.first().executed) + assertFalse(GRAPH_LEGEND.last().executed) + assertEquals(1, GRAPH_LEGEND.count { it.executed }) + } + + /** + * The node label the graph shows is readable: a terminal's all-caps keyword + * becomes title case (no unnecessary all-caps), while a stage keeps its + * declared key. + */ + @Test + fun nodeDisplayLabelsAreReadableAndKeepStageKeys() { + assertEquals("Success", nodeDisplayLabel(Protocol.SUCCESS_END)) + assertEquals("Failure", nodeDisplayLabel(Protocol.FAILURE_END)) + assertEquals("ui_reviewer", nodeDisplayLabel("ui_reviewer")) + assertEquals("planner", nodeDisplayLabel("planner")) + } + + /** + * A heavier line always carries a proportionally larger filled arrowhead: one + * consistent scale ties the head length to the stroke width, so the pass/fail + * head dominates exactly as its stroke does. + */ + @Test + fun arrowHeadScalesWithTheStrokeItTerminates() { + val graph = sampleGraph() + val success = graph.edges().first { it.outcome == "success" } + val other = graph.edges().first { it.outcome == "blocked" } + val runState = RunGraphState( + visitedStages = setOf(success.source, other.source), + takenRoutes = setOf( + GraphRoute(success.source, success.outcome, success.target), + GraphRoute(other.source, other.outcome, other.target), + ), + currentStage = success.source, + ) + val successRatio = edgeArrowHeadSize(success, runState) / edgeStrokeWidth(success, runState) + val otherRatio = edgeArrowHeadSize(other, runState) / edgeStrokeWidth(other, runState) + assertEquals(successRatio, otherRatio, 0.001f) + assertTrue(edgeArrowHeadSize(success, runState) > edgeArrowHeadSize(other, runState)) + } + + /** + * The rounded-corner cut at a route bend is the shared radius, floored to half + * the shorter adjacent segment so two cut-backs can never meet or cross; a + * degenerate adjacent segment yields no cut instead of dividing by zero. It + * works on the already-measured segment lengths, so a bend measures them once. + */ + @Test + fun cornerCutNeverExceedsHalfTheShorterSegment() { + val radius = 18f + // Both adjacent segments are long enough to take the full radius. + assertEquals(radius, cornerCutRadius(100f, 100f, radius), 0.001f) + // A short incoming segment halves the cut. + assertEquals(10f, cornerCutRadius(20f, 100f, radius), 0.001f) + // A short outgoing segment halves the cut. + assertEquals(15f, cornerCutRadius(100f, 30f, radius), 0.001f) + // A degenerate adjacent segment yields no cut. + assertEquals(0f, cornerCutRadius(0f, 100f, radius), 0.001f) + } + private fun assertNoSharedRuns(layout: GraphLayout) { val edges = layout.edges for (i in edges.indices) { diff --git a/android/app/src/test/java/net/awan/pipelines/ui/screens/ListFilterTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/screens/ListFilterTest.kt new file mode 100644 index 00000000..d07e6d80 --- /dev/null +++ b/android/app/src/test/java/net/awan/pipelines/ui/screens/ListFilterTest.kt @@ -0,0 +1,231 @@ +package net.awan.pipelines.ui.screens + +import java.time.LocalDate +import java.time.ZoneOffset +import net.awan.pipelines.data.protocol.PipelineSummary +import net.awan.pipelines.data.protocol.RunSummary +import net.awan.pipelines.ui.components.RunState +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Test + +class ListFilterTest { + + private val today = LocalDate.of(2026, 10, 16) + private val zone = ZoneOffset.UTC + + private fun pipeline(id: Long, name: String = "p$id") = + PipelineSummary(id = id, name = name, version = 1, stages = 1) + + private fun run( + id: Long, + pipelineId: Long = 1, + name: String = "p$pipelineId", + status: String = "succeeded", + createdAt: String = "2026-10-16T10:00:00Z", + finishedAt: String = "2026-10-16T10:00:10Z", + ) = RunSummary( + id = id, + pipelineId = pipelineId, + name = name, + status = status, + createdAt = createdAt, + finishedAt = finishedAt, + ) + + // --- stored-value tolerance ------------------------------------------------- + + @Test + fun runFiltersFromStorageParsesEveryFacetAndFallsBackForStaleValues() { + assertEquals( + RunFilters(setOf(RunState.Succeeded, RunState.Failed), 7L, RunTimeRange.Last7Days), + RunFilters.fromStorage("succeeded,failed", "7", "last_7_days"), + ) + // An unknown status token is dropped rather than crashing. + assertEquals( + setOf(RunState.Succeeded), + RunFilters.fromStorage("succeeded,bogus", null, null).statuses, + ) + // Stale/blank/unknown values fall back to the defaults. + assertEquals(RunFilters.Default, RunFilters.fromStorage(null, null, null)) + assertEquals(RunFilters.Default, RunFilters.fromStorage("", "", "")) + assertEquals(RunFilters.Default, RunFilters.fromStorage("nope", "not-a-number", "no_such_range")) + } + + @Test + fun pipelineFiltersFromStorageParsesAndFallsBack() { + assertEquals( + PipelineFilters(RunPresence.NoRuns, setOf(RunState.Failed)), + PipelineFilters.fromStorage("no_runs", "failed"), + ) + assertEquals(PipelineFilters.Default, PipelineFilters.fromStorage(null, null)) + assertEquals(PipelineFilters.Default, PipelineFilters.fromStorage("garbage", "garbage")) + } + + @Test + fun encodeDecodeRoundTripsAndToleratesGarbage() { + val states = setOf(RunState.Failed, RunState.Queued) + assertEquals(states, decodeRunStates(encodeRunStates(states))) + // Ordinal order, so the stored string is stable whatever the set order. + assertEquals("queued,failed", encodeRunStates(states)) + assertEquals(emptySet(), decodeRunStates("")) + assertEquals(emptySet(), decodeRunStates(null)) + assertEquals(setOf(RunState.Running), decodeRunStates("bogus,running,,")) + } + + // --- run status ------------------------------------------------------------- + + @Test + fun anEmptyStatusSetMatchesAnyStatus() { + assertTrue(runMatchesStatuses(run(1, status = "running"), emptySet())) + assertTrue(runMatchesStatuses(run(1, status = ""), emptySet())) + } + + @Test + fun statusFilterIsTheUnionOfTheSelectedStates() { + val statuses = setOf(RunState.Failed, RunState.Canceled) + assertTrue(runMatchesStatuses(run(1, status = "failed"), statuses)) + assertTrue(runMatchesStatuses(run(2, status = "canceled"), statuses)) + assertFalse(runMatchesStatuses(run(3, status = "succeeded"), statuses)) + // The app-only buckets are not offered, so they never match a selection. + assertFalse(runMatchesStatuses(run(4, status = "active"), statuses)) + assertFalse(runMatchesStatuses(run(5, status = "made-up"), statuses)) + } + + // --- run pipeline ----------------------------------------------------------- + + @Test + fun pipelineFilterMatchesOnlyThatPipelineAndNullMeansAny() { + assertTrue(runMatchesPipeline(run(1, pipelineId = 5), 5)) + assertFalse(runMatchesPipeline(run(1, pipelineId = 5), 6)) + assertTrue(runMatchesPipeline(run(1, pipelineId = 5), null)) + } + + // --- run time range --------------------------------------------------------- + + @Test + fun timeRangeWindowsAreInclusiveCalendarDaysEndingToday() { + fun at(date: String) = run(1, createdAt = "${date}T09:00:00Z") + // Today. + assertTrue(runMatchesTimeRange(at("2026-10-16"), RunTimeRange.Today, today, zone)) + assertFalse(runMatchesTimeRange(at("2026-10-15"), RunTimeRange.Today, today, zone)) + // Last 7 days covers today and the six days before it. + assertTrue(runMatchesTimeRange(at("2026-10-16"), RunTimeRange.Last7Days, today, zone)) + assertTrue(runMatchesTimeRange(at("2026-10-10"), RunTimeRange.Last7Days, today, zone)) + assertFalse(runMatchesTimeRange(at("2026-10-09"), RunTimeRange.Last7Days, today, zone)) + // Last 30 days covers today and the twenty-nine days before it. + assertTrue(runMatchesTimeRange(at("2026-09-17"), RunTimeRange.Last30Days, today, zone)) + assertFalse(runMatchesTimeRange(at("2026-09-16"), RunTimeRange.Last30Days, today, zone)) + // Any time matches an old run and a blank timestamp alike. + assertTrue(runMatchesTimeRange(at("2020-01-01"), RunTimeRange.AnyTime, today, zone)) + assertTrue(runMatchesTimeRange(run(1, createdAt = ""), RunTimeRange.AnyTime, today, zone)) + } + + @Test + fun blankOrFutureTimestampsNeverMatchAFiniteRange() { + assertFalse(runMatchesTimeRange(run(1, createdAt = ""), RunTimeRange.Today, today, zone)) + assertFalse(runMatchesTimeRange(run(1, createdAt = "not-a-date"), RunTimeRange.Last7Days, today, zone)) + // A future-dated run (clock skew) is outside every past window. + assertFalse(runMatchesTimeRange(run(1, createdAt = "2026-10-17T09:00:00Z"), RunTimeRange.Today, today, zone)) + assertFalse(runMatchesTimeRange(run(1, createdAt = "2026-10-17T09:00:00Z"), RunTimeRange.Last7Days, today, zone)) + } + + // --- run combination -------------------------------------------------------- + + @Test + fun defaultRunFiltersNarrowNothing() { + val runs = listOf(run(1, status = "running", createdAt = ""), run(2, status = "failed")) + assertEquals(runs, filterRuns(runs, RunFilters.Default, today, zone)) + } + + @Test + fun runFacetsCombineWithAnd() { + val filters = RunFilters( + statuses = setOf(RunState.Succeeded), + pipelineId = 2L, + timeRange = RunTimeRange.Today, + ) + val runs = listOf( + // Right status but wrong pipeline. + run(1, pipelineId = 1, status = "succeeded", createdAt = "2026-10-16T08:00:00Z"), + // Right pipeline but wrong status. + run(2, pipelineId = 2, status = "failed", createdAt = "2026-10-16T08:00:00Z"), + // Right pipeline/status but outside today. + run(3, pipelineId = 2, status = "succeeded", createdAt = "2026-10-10T08:00:00Z"), + // The one match. + run(4, pipelineId = 2, status = "succeeded", createdAt = "2026-10-16T08:00:00Z"), + ) + assertEquals(listOf(4L), filterRuns(runs, filters, today, zone).map { it.id }) + } + + // --- pipeline run facets ---------------------------------------------------- + + @Test + fun presenceSplitsPipelinesByWhetherTheyHaveARecordedRun() { + assertTrue(pipelineMatchesPresence(RunPresence.Any, hasRun = false)) + assertTrue(pipelineMatchesPresence(RunPresence.HasRuns, hasRun = true)) + assertFalse(pipelineMatchesPresence(RunPresence.HasRuns, hasRun = false)) + assertTrue(pipelineMatchesPresence(RunPresence.NoRuns, hasRun = false)) + assertFalse(pipelineMatchesPresence(RunPresence.NoRuns, hasRun = true)) + } + + @Test + fun lastRunStatusExcludesRunlessPipelinesAndEmptyMeansAny() { + val failed = setOf(RunState.Failed) + assertTrue(pipelineMatchesLastRunStatus(run(1, status = "failed"), failed)) + assertFalse(pipelineMatchesLastRunStatus(run(1, status = "succeeded"), failed)) + // No run at all: there is no last-run status, so a selection never matches. + assertFalse(pipelineMatchesLastRunStatus(null, failed)) + // An empty selection matches a runless pipeline and any status. + assertTrue(pipelineMatchesLastRunStatus(null, emptySet())) + assertTrue(pipelineMatchesLastRunStatus(run(1, status = "running"), emptySet())) + } + + @Test + fun defaultPipelineFiltersNarrowNothing() { + val pipelines = listOf(pipeline(1), pipeline(2)) + assertEquals(pipelines, filterPipelines(pipelines, PipelineFilters.Default, emptyMap())) + } + + @Test + fun pipelineFiltersCombineWithAnd() { + val filters = PipelineFilters( + presence = RunPresence.HasRuns, + lastRunStatuses = setOf(RunState.Failed), + ) + val latest = mapOf( + 1L to run(1, pipelineId = 1, status = "succeeded"), + 2L to run(2, pipelineId = 2, status = "failed"), + ) + val pipelines = listOf(pipeline(1), pipeline(2), pipeline(3)) + // No runs (3) fails presence; succeeded last run (1) fails the status. + assertEquals(listOf(2L), filterPipelines(pipelines, filters, latest).map { it.id }) + } + + @Test + fun pipelineFiltersLeaveTheListUnfilteredUntilRunsAreKnown() { + val filters = PipelineFilters(presence = RunPresence.NoRuns) + val pipelines = listOf(pipeline(1)) + // Runs not loaded yet: filtering by them would briefly hide everything. + assertEquals(pipelines, filterPipelines(pipelines, filters, emptyMap(), runsKnown = false)) + // Once known, the filter applies (pipeline 1 has no run). + assertEquals(pipelines, filterPipelines(pipelines, filters, emptyMap(), runsKnown = true)) + } + + // --- pipeline options ------------------------------------------------------- + + @Test + fun pipelineFilterOptionsAreDistinctNamedFromRunsAndSorted() { + val runs = listOf( + run(1, pipelineId = 7, name = "Zeta"), + run(2, pipelineId = 3, name = "alpha"), + run(3, pipelineId = 7, name = "Zeta"), + run(4, pipelineId = 9, name = ""), + ) + val options = pipelineFilterOptions(runs) + assertEquals(listOf(3L, 9L, 7L), options.map { it.id }) + assertEquals(listOf("alpha", "Pipeline 9", "Zeta"), options.map { it.name }) + assertEquals(3, options.size) + } +} diff --git a/android/app/src/test/java/net/awan/pipelines/ui/screens/ListSortTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/screens/ListSortTest.kt new file mode 100644 index 00000000..20779337 --- /dev/null +++ b/android/app/src/test/java/net/awan/pipelines/ui/screens/ListSortTest.kt @@ -0,0 +1,183 @@ +package net.awan.pipelines.ui.screens + +import net.awan.pipelines.data.protocol.PipelineSummary +import net.awan.pipelines.data.protocol.RunSummary +import org.junit.Assert.assertEquals +import org.junit.Test + +class ListSortTest { + + private fun pipeline( + id: Long, + name: String, + stages: Int = 1, + createdAt: String = "2026-10-01T00:00:00Z", + ) = PipelineSummary(id = id, name = name, version = 1, stages = stages, createdAt = createdAt) + + private fun run( + id: Long, + pipelineId: Long = id, + name: String = "p$id", + status: String = "succeeded", + createdAt: String = "2026-10-16T10:00:00Z", + finishedAt: String = "2026-10-16T10:00:10Z", + ) = RunSummary( + id = id, + pipelineId = pipelineId, + name = name, + status = status, + createdAt = createdAt, + finishedAt = finishedAt, + ) + + // --- stored-value tolerance ------------------------------------------------- + + @Test + fun pipelineSortFromStorageFallsBackToTheDefaultForStaleOrUnknownValues() { + assertEquals(PipelineSort.Default, PipelineSort.ServerOrder) + for (option in PipelineSort.entries) { + assertEquals(option, PipelineSort.fromStorage(option.storageKey)) + } + assertEquals(PipelineSort.ServerOrder, PipelineSort.fromStorage(null)) + assertEquals(PipelineSort.ServerOrder, PipelineSort.fromStorage("")) + assertEquals(PipelineSort.ServerOrder, PipelineSort.fromStorage("no_such_sort")) + } + + @Test + fun runSortFromStorageFallsBackToTheDefaultForStaleOrUnknownValues() { + assertEquals(RunSort.Default, RunSort.NewestFirst) + for (option in RunSort.entries) { + assertEquals(option, RunSort.fromStorage(option.storageKey)) + } + assertEquals(RunSort.NewestFirst, RunSort.fromStorage(null)) + assertEquals(RunSort.NewestFirst, RunSort.fromStorage("")) + assertEquals(RunSort.NewestFirst, RunSort.fromStorage("whatever")) + } + + // --- pipelines -------------------------------------------------------------- + + @Test + fun serverOrderKeepsTheInputUntouched() { + val input = listOf(pipeline(7, "Zeta"), pipeline(3, "alpha"), pipeline(5, "Beta")) + assertEquals(listOf(7L, 3L, 5L), sortPipelines(input, PipelineSort.ServerOrder).map { it.id }) + } + + @Test + fun nameSortsAreCaseInsensitiveAndBreakTiesByTheUniqueId() { + val input = listOf(pipeline(7, "Zebra"), pipeline(3, "apple"), pipeline(9, "APPLE")) + assertEquals(listOf(9L, 3L, 7L), sortPipelines(input, PipelineSort.NameAsc).map { it.id }) + // Descending keeps the id tie-break ascending: APPLE(9) before apple(3). + assertEquals(listOf(7L, 9L, 3L), sortPipelines(input, PipelineSort.NameDesc).map { it.id }) + } + + @Test + fun stageCountSortsBreakTiesByNameThenId() { + // Ids deliberately disagree with name/stage order so the tie-breaks show. + val input = listOf( + pipeline(7, "Alpha", stages = 2), + pipeline(3, "beta", stages = 2), + pipeline(5, "Gamma", stages = 1), + ) + assertEquals(listOf(5L, 7L, 3L), sortPipelines(input, PipelineSort.FewestStages).map { it.id }) + assertEquals(listOf(7L, 3L, 5L), sortPipelines(input, PipelineSort.MostStages).map { it.id }) + } + + @Test + fun recentRunSortPutsPipelinesWithoutRunsLastAndNewerRunsFirst() { + val runs = listOf( + run(5, pipelineId = 1, createdAt = "2026-10-16T09:00:00Z"), + run(9, pipelineId = 2, createdAt = "2026-10-16T11:00:00Z"), + ) + val latest = latestRunByPipeline(runs) + val input = listOf(pipeline(3, "NoRun"), pipeline(1, "Older"), pipeline(2, "Newer")) + assertEquals( + listOf(2L, 1L, 3L), + sortPipelines(input, PipelineSort.RecentRun, latest).map { it.id }, + ) + } + + @Test + fun recentRunSortBreaksExactTimestampTiesByTheHigherRunId() { + val runs = listOf( + run(4, pipelineId = 1, createdAt = "2026-10-16T10:00:00Z"), + run(8, pipelineId = 2, createdAt = "2026-10-16T10:00:00Z"), + ) + val latest = latestRunByPipeline(runs) + val input = listOf(pipeline(1, "A"), pipeline(2, "B")) + assertEquals( + listOf(2L, 1L), + sortPipelines(input, PipelineSort.RecentRun, latest).map { it.id }, + ) + } + + @Test + fun recentRunSortBreaksRunlessPipelinesByTheirOwnId() { + val input = listOf(pipeline(3, "C"), pipeline(1, "A"), pipeline(2, "B")) + assertEquals( + listOf(1L, 2L, 3L), + sortPipelines(input, PipelineSort.RecentRun).map { it.id }, + ) + } + + // --- runs ------------------------------------------------------------------- + + @Test + fun newestAndOldestFirstPutUnparseableTimestampsLast() { + val input = listOf( + run(3, createdAt = ""), + run(1, createdAt = "2026-10-16T10:00:00Z"), + run(2, createdAt = "2026-10-16T12:00:00Z"), + ) + assertEquals(listOf(2L, 1L, 3L), sortRuns(input, RunSort.NewestFirst).map { it.id }) + assertEquals(listOf(1L, 2L, 3L), sortRuns(input, RunSort.OldestFirst).map { it.id }) + } + + @Test + fun durationSortsPutRunsWithoutADurationLastInBothDirections() { + val input = listOf( + run(1, createdAt = "2026-10-16T10:00:00Z", finishedAt = "2026-10-16T10:00:10Z"), + run(2, createdAt = "2026-10-16T10:00:00Z", finishedAt = "2026-10-16T10:10:00Z"), + // Still executing: no finished_at, so no duration. + run(3, createdAt = "2026-10-16T10:00:00Z", finishedAt = ""), + ) + assertEquals(listOf(2L, 1L, 3L), sortRuns(input, RunSort.LongestDuration).map { it.id }) + assertEquals(listOf(1L, 2L, 3L), sortRuns(input, RunSort.ShortestDuration).map { it.id }) + } + + @Test + fun durationSortsBreakTiesByNewestStartThenId() { + val input = listOf( + run(1, createdAt = "2026-10-16T09:00:00Z", finishedAt = "2026-10-16T09:00:30Z"), + run(2, createdAt = "2026-10-16T11:00:00Z", finishedAt = "2026-10-16T11:00:30Z"), + ) + // Equal 30s durations: newer start (id 2) first. + assertEquals(listOf(2L, 1L), sortRuns(input, RunSort.LongestDuration).map { it.id }) + assertEquals(listOf(2L, 1L), sortRuns(input, RunSort.ShortestDuration).map { it.id }) + } + + @Test + fun pipelineNameAndStatusSortsAreCaseInsensitiveWithExplicitTieBreaks() { + val byName = listOf( + run(1, name = "beta", createdAt = "2026-10-16T10:00:00Z"), + run(2, name = "Alpha", createdAt = "2026-10-16T09:00:00Z"), + ) + assertEquals(listOf(2L, 1L), sortRuns(byName, RunSort.PipelineName).map { it.id }) + + val byStatus = listOf( + run(1, status = "running"), + run(2, status = "failed"), + ) + assertEquals(listOf(2L, 1L), sortRuns(byStatus, RunSort.Status).map { it.id }) + } + + @Test + fun equalKeysAlwaysOrderTheSameWay() { + // Same status and same timestamp: the id descends, so the order is fixed. + val input = listOf( + run(3, status = "succeeded", createdAt = "2026-10-16T10:00:00Z"), + run(1, status = "succeeded", createdAt = "2026-10-16T10:00:00Z"), + ) + assertEquals(listOf(3L, 1L), sortRuns(input, RunSort.Status).map { it.id }) + assertEquals(listOf(3L, 1L), sortRuns(input.reversed(), RunSort.Status).map { it.id }) + } +} diff --git a/android/app/src/test/java/net/awan/pipelines/ui/screens/PipelineLastRunTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/screens/PipelineLastRunTest.kt new file mode 100644 index 00000000..0ae593a5 --- /dev/null +++ b/android/app/src/test/java/net/awan/pipelines/ui/screens/PipelineLastRunTest.kt @@ -0,0 +1,123 @@ +package net.awan.pipelines.ui.screens + +import java.time.OffsetDateTime +import net.awan.pipelines.data.protocol.RunSummary +import net.awan.pipelines.ui.components.RunState +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Test + +class PipelineLastRunTest { + + private val now = OffsetDateTime.parse("2026-10-16T12:00:00Z") + + private fun run( + id: Long, + pipelineId: Long, + createdAt: String, + finishedAt: String = createdAt, + status: String = "succeeded", + ) = RunSummary( + id = id, + pipelineId = pipelineId, + createdAt = createdAt, + finishedAt = finishedAt, + status = status, + ) + + @Test + fun mostRecentRunWinsEvenWhenTheInputIsNotNewestFirst() { + // Deliberately unsorted: the newer start must win regardless of order. + val badges = pipelineRunBadges( + listOf( + run(7, 10, "2026-10-16T09:00:00Z"), + run(2, 10, "2026-10-16T11:00:00Z"), + run(5, 11, "2026-10-16T08:00:00Z"), + ), + now, + ) + assertEquals(2L, badges.getValue(10L).runId) + assertEquals(5L, badges.getValue(11L).runId) + } + + @Test + fun noRunsYieldsNoBadges() { + assertTrue(pipelineRunBadges(emptyList(), now).isEmpty()) + } + + @Test + fun unknownPipelineIdIsAbsentFromTheJoin() { + val badges = pipelineRunBadges(listOf(run(1, 10, "2026-10-16T10:00:00Z")), now) + assertEquals(1L, badges.getValue(10L).runId) + assertNull(badges[99L]) + } + + @Test + fun equalTimestampsBreakTheTieByTheHigherRunId() { + val badges = pipelineRunBadges( + listOf( + run(4, 10, "2026-10-16T10:00:00Z"), + run(9, 10, "2026-10-16T10:00:00Z"), + ), + now, + ) + assertEquals(9L, badges.getValue(10L).runId) + } + + @Test + fun unparseableTimestampsFallBackToRunIdWithoutCrashing() { + val badges = pipelineRunBadges( + listOf(run(3, 10, ""), run(8, 10, "not-a-date")), + now, + ) + assertEquals(8L, badges.getValue(10L).runId) + assertNull(badges.getValue(10L).ranAgo) + } + + @Test + fun unknownStatusWordYieldsAnUnknownStateNotACrash() { + val badge = pipelineRunBadges( + listOf(run(1, 10, "2026-10-16T10:00:00Z", status = "something-new")), + now, + ).getValue(10L) + assertEquals(RunState.Unknown, badge.state) + // The id still renders even when only the status word is unrecognised. + assertTrue(badge.metaLine().endsWith("run 1")) + } + + @Test + fun metaLineCarriesAgoDurationAndRunId() { + val badge = pipelineRunBadges( + listOf(run(42, 10, "2026-10-16T11:00:00Z", finishedAt = "2026-10-16T11:01:05Z")), + now, + ).getValue(10L) + assertEquals("1h ago · 1m 5s · run 42", badge.metaLine()) + } + + @Test + fun metaLineOmitsAMissingDuration() { + // A running run has no finished_at, so the duration fragment is dropped. + val badge = pipelineRunBadges( + listOf(run(42, 10, "2026-10-16T11:00:00Z", finishedAt = "", status = "running")), + now, + ).getValue(10L) + assertEquals("1h ago · run 42", badge.metaLine()) + } + + @Test + fun formatRanAgoCoversEachScaleAndRejectsBadInput() { + assertEquals("just now", formatRanAgo("2026-10-16T11:59:30Z", now)) + assertEquals("just now", formatRanAgo("2026-10-16T12:05:00Z", now)) + assertEquals("5m ago", formatRanAgo("2026-10-16T11:55:00Z", now)) + assertEquals("3h ago", formatRanAgo("2026-10-16T09:00:00Z", now)) + assertEquals("2d ago", formatRanAgo("2026-10-14T12:00:00Z", now)) + assertNull(formatRanAgo("", now)) + assertNull(formatRanAgo("not-a-date", now)) + } + + @Test + fun noRunsWordingIsTheExplicitConstant() { + assertEquals("no runs recorded", NO_RUNS_RECORDED) + } +} diff --git a/android/app/src/test/java/net/awan/pipelines/ui/screens/RunGroupingTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/screens/RunGroupingTest.kt index c735f742..487cd76e 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/screens/RunGroupingTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/screens/RunGroupingTest.kt @@ -43,4 +43,19 @@ class RunGroupingTest { val unknown = groups.first { it.label == "Unknown date" } assertEquals(setOf(1L, 2L), unknown.runs.map { it.id }.toSet()) } + + @Test + fun anExplicitOrderDrivesBothTheGroupOrderAndTheOrderWithinADay() { + val today = LocalDate.of(2026, 10, 15) + val zone = ZoneOffset.UTC + val runs = listOf( + run(3, "2026-10-14T09:00:00Z"), + run(1, "2026-10-15T10:00:00Z"), + run(2, "2026-10-15T08:00:00Z"), + ) + val groups = groupRunsByDay(runs, today, zone, runComparator(RunSort.OldestFirst)) + // Oldest day first, and within "Today" the earlier start comes first. + assertEquals(listOf("Yesterday", "Today"), groups.take(2).map { it.label }) + assertEquals(listOf(2L, 1L), groups[1].runs.map { it.id }) + } } diff --git a/android/app/src/test/java/net/awan/pipelines/ui/theme/DimensTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/theme/DimensTest.kt index d1d1ca50..7cfa3078 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/theme/DimensTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/theme/DimensTest.kt @@ -45,14 +45,11 @@ class DimensTest { "20.dp" to "List icon glyph size and code-block inner padding (20dp).", "48.dp" to "Minimum touch target and graph minimum visible span (48dp).", - // Workflow-graph pixel geometry (layout by design, not screen spacing). - "26.dp" to "Workflow-graph lane spacing (26dp).", - "64.dp" to "Workflow-graph terminal gap (64dp).", - "132.dp" to "Workflow-graph node width and horizontal gap (132dp).", - "260.dp" to "Collapsed workflow-graph panel minimum height (GRAPH_PANEL_MIN_HEIGHT).", + // Workflow-graph pixel geometry now lives in ui/theme/Dimens.kt as the + // GRAPH_* tokens, so no graph literal remains here. // Component container sizes. - "56.dp" to "Artifact thumbnail and graph minimum node height (coincides with PEEK_WIDTH_DP but is content size here).", + "56.dp" to "Artifact thumbnail size (coincides with PEEK_WIDTH_DP but is content size here).", "96.dp" to "Artifact grid preferred tile edge (ARTIFACT_TILE_DP).", "320.dp" to "Code block maximum height (CODE_BLOCK_MAX_HEIGHT).",