Rework omni search onto a typed search contract and add a TUI artifacts view

Protocol: replace the loose Query/Kind/Matches/Limit search fields with a Search request object and a SearchResults response, and have the server answer search from Store.Search over the shared run projections (runFrom/runStamps).

CLI: add the read-only 'pipelines search QUERY [--type KIND] [--limit N] [--json]' command with usage/help, and document the typed targets, ranking and bounds in docs/cli.md.

TUI: the '/' popup keeps type-to-search, up/down, Enter and Esc, renders one ranked list with kind badges and a bracketed (non-colour) match snippet, and Enter opens the matched pipeline, run, step, artifact or field; footer text updated to match.

TUI: add a dedicated run artifacts view ('A') with open/copy of recorded files, and move artifacts out of the run-detail File changes section (artifactCaptureNotes).

Tests: add Store.OpenReadOnly for read-only inspection of a live database plus pipeline/server/TUI search tests and artifacts tests, including env-gated live checks.
This commit is contained in:
2026-10-16 23:48:38 +01:00
parent fae1005962
commit 865993b200
24 changed files with 1761 additions and 68 deletions
+14 -11
View File
@@ -48,13 +48,15 @@ Search includes pipeline name, version, status, outcome, stage and diagnostic;
`#123` searches run-ID prefixes. Esc while searching clears the filter without
closing the list. The filter survives inspection/back and live list refreshes.
Home's `/` instead opens the omni popup, which searches pipelines, versions, runs,
stages/visits, artifact names, and the text of stage inputs, outputs and evidence.
A bare status word (`queued`, `running`, `succeeded`, `failed`, `canceled`,
`interrupted`) or a date (`today`, `yesterday`, `this week`, or `YYYY-MM-DD`
interpreted in UTC) selects runs, and a leading `pipeline:`/`version:`/`run:`/
`step:`/`field:`/`artifact:`/`match:` prefix narrows the result kind. Enter opens
the matched pipeline, run, stage visit, artifact or field; unrecognised words
remain text.
steps/visits, artifact names, and the text of stage inputs, outputs and evidence.
Each row carries a short type badge (`pipeline`, `run`, `step`, `artifact` or
`match`); a text match also shows a snippet with the matched part bracketed so it
is legible without colour. A bare status word (`queued`, `running`, `succeeded`,
`failed`, `canceled`, `interrupted`) or a date (`today`, `yesterday`, `this week`,
or `YYYY-MM-DD` in local time) selects runs. Enter opens the matched pipeline,
run, stage visit, artifact or field. The same query is available non-interactively
as `pipelines search QUERY [--type KIND] [--limit N] [--json]`; `--type` is the
only kind-narrowing mechanism.
Wide terminals
show runs and pipelines side by side, with stacked panels on narrow terminals.
Home run cards prioritize reported results, status, completed visits and duration;
@@ -214,7 +216,7 @@ Submitting activates included schedules, so review them before publishing.
| TUI action | Agent-capable CLI |
| --- | --- |
| Browse/search pipelines | `list --json`, `show NAME --json` |
| Browse/search pipelines | `list --json`, `show NAME --json`, `search QUERY --json` |
| Original source and history | `export NAME --version N`, `versions NAME --json` |
| Browse templates/source | `templates --json`, `template KEY --source` |
| Create or edit a definition | `new`, `edit`, `drafts` |
@@ -241,9 +243,10 @@ printf '%s' '{"type":"get_pipeline","pipeline_id":1,"version":1}' | pipelines rp
Existing protocol commands: `ping`, `list_pipelines`, `get_pipeline`,
`list_templates`, `validate`, `submit`, `run_pipeline`, `list_runs`, `get_run`,
`cancel_run`, `retry_run`, `decide_run`, `set_run_title`, `get_run_evidence`,
`get_status`, `search`. `search` takes `query` and an
optional `kind` and `limit` and returns ranked typed `matches`, each with a stable
`target` the client can open. `list_runs` also returns all-history `usage`
`get_status`, `search`. `search` takes a `search` request object (`query`, with an
optional `kind` and `limit`) and returns a `search_results` response whose ranked
`results` each carry a stable `target` the client can open plus the typed payload
and matched field. `list_runs` also returns all-history `usage`
aggregates. See `internal/protocol/message.go` for JSON envelopes. Mutating RPCs
have real effects; they are not previews. TUI-only animation, scrolling, and
transient client logs are presentation, not separate server capabilities.
+4 -1
View File
@@ -38,7 +38,7 @@ and external editor/OpenCode behavior were not assessed by that review.
| Status | Narrow cards hide addresses; scrolling does not reveal them. | Wrap card contents and scroll the actual service-card canvas. |
| Task form | Tool lists consume prompt space; wrong footer. | Larger task area, compact scope summary, correct submit/cancel controls. |
| CLI pipeline picker | Background Home controls remain visible. | Picker-specific filter/select/cancel controls. |
| Search | “Omnisearch” promises broader scope than pipeline search. | “Search pipelines” and specific open/cancel instructions. |
| Search | Home `/` now opens one omni popup that searches pipelines, versions, runs, steps/visits, artifact names and stage input/output/evidence text. | Keep the omni popup: typed badges, a non-colour marked snippet for text matches, and Enter-to-open navigation; the run-list `/` filter is unchanged. |
| Commands | No descriptions or indication of hidden entries. | Selected-command explanation and visible range/count. |
| Versions | Selected/latest markers truncate on narrow screens. | Correct view-version footer; further metadata prioritization remains a follow-up. |
| Naming/publication | Naming inherits publication shortcuts. | Input-specific name-saving/retention footer. |
@@ -61,6 +61,9 @@ repeated stages; `0` returns to the overview. `j`/`k` scrolls Details or pans Gr
depending on focus. `h`/`l` and arrow keys pan a focused graph; in Details,
left/right selects the previous/next visit. `c` centers the focused graph.
`o`, `s`, `i`, `t`, `m` disclose result, progress, input, evidence and execution details.
`A` opens the run's artifacts view: recorded files grouped by stage and visit, with
name, content type and human size in aligned columns, an `[img]` marker for images,
the URL per entry, and `Enter`/`o` to open or `y` to copy the selected entry.
Home still advertises only `/` search and `:` commands. `q` never exits the client;
use `:quit`. Consequential actions still require explicit confirmation.
+3 -1
View File
@@ -10,6 +10,7 @@ var usage = map[string]string{
"validate": "validate <draft.md> [--json]",
"submit": "submit <draft.md> [--name NAME] [--create-only] [--yes] [--json]",
"list": "list [--json]",
"search": "search QUERY [--type KIND] [--limit N] [--json]",
"show": "show <name|id> [--version N] [--json]",
"versions": "versions <name|id> [--json]",
"export": "export [name|id ...] [--output FILE.zip] [--all] [--version N]",
@@ -49,7 +50,8 @@ var notes = map[string]string{
"title": "Rename a run's operator-facing title after the fact without touching its input, steps or execution. The title is collapsed to a single bounded line and recorded as explicitly set. `pipelines runs` and `pipelines inspect` then show it.",
"decide": "Choose an option for a run waiting on a human stage. The run must be `waiting`; the option must be one of that stage's non-error edges. The stage is inferred from the run's current stage unless named. The choice and optional --feedback are recorded as the step's evidence (visible in inspect and the TUI) and the run resumes along the chosen edge. An unknown option is refused with the valid list; a repeated decision for an already-decided visit does not double-apply. Works across a server restart because the wait is persisted.",
"debug": "Open a fresh configured harness conversation to investigate a run using inspect/show/runs CLI queries. --harness opencode|pi|nvim chooses another configured harness or read-only nvim packet. Does not resume implementation or retry. --json returns the prompt without launching anything.",
"rpc": "Accepts a JSON protocol envelope; '-' reads stdin. Every TUI server operation is available here too. Mutating commands are not dry runs. The omni-search command is `search` (fields query, optional kind and limit) and answers with ranked `search_results`.",
"rpc": "Accepts a JSON protocol envelope; '-' reads stdin. Every TUI server operation is available here too. Mutating commands are not dry runs.",
"search": "One read-only query over pipelines, versions, runs, steps, field text and artifacts. QUERY is free text, a bare status word (queued, running, succeeded, failed, canceled, interrupted) selecting those runs, or a lone date expression (today, yesterday, this week [Monday 00:00 local], or YYYY-MM-DD) selecting the runs created in that window. --type is the only narrowing mechanism and takes one kind: pipeline, version, run, step, field or artifact; an unknown kind is an error. Ranking: an exact name match (3) beats a name substring (2) beats a body-text match (1); equal tiers break by recency, then a stable kind/target tie-break, and every hit reports score, matched_field and recency so a client can re-rank. Bounds: the result cap defaults to 50 and clamps to 200 (0 = default); every kind scans at most 2000 rows and field-text scanning is additionally capped at 2000 steps / 1 MiB; Truncated plus scanned_steps, scanned_bytes and scan_bound_bytes report when a bound applied. Targets are stable: pipeline:<id>, pipeline:<id>:v<version>, run:<id>, run:<id>:<sequence>, run:<id>:<sequence>:<field>, or an artifact URL.",
}
var serviceHelp = map[string]string{
+14 -7
View File
@@ -13,6 +13,7 @@ AUTHOR
BROWSE
list List registered pipelines
search QUERY Search pipelines, versions, runs, steps, field text, artifacts
show <name|id> Inspect graph, settings, source and history
versions <name|id> List immutable versions
export [name|id ...] Select/export definitions as ZIP; one name prints Markdown
@@ -54,6 +55,13 @@ restart/doctor/logs and retained-data or --purge uninstallation.
Options: --url ws://127.0.0.1:8080/connect --json --help
Use pipelines help <command> for its flags. Names with spaces must be quoted.
Stage result format:
Model and agent stages accept a line-oriented result. The first non-empty line
is the declared outcome, followed by "# " sections. "# output" is required and
short (a JSON object carrying the next stage's data); additional sections are
free-form markdown evidence. The legacy {"outcome":...,"output":...} JSON
envelope remains accepted for compatibility.
Examples:
pipelines edit "bug fix" "Add a review step"
pipelines new "release notes" "Summarize changes and notify my phone"
@@ -75,11 +83,10 @@ Nothing is published automatically.
Every submission is validated server-side. Submission activates any schedules.
JSON mode never launches an editor or picker; supply explicit arguments.
Search: the TUI '/' popup and the protocol 'search' command (via 'pipelines rpc')
find pipelines, versions, runs, stages/visits, artifact names and the text of stage
inputs, outputs and evidence. A bare status word (queued, running, succeeded,
failed, canceled, interrupted) or a date (today, yesterday, this week, or
YYYY-MM-DD interpreted in UTC) selects runs. A leading prefix pipeline:, version:,
run:, step:, field:, artifact: or match: (a field alias) narrows the result kind;
unrecognised words stay text.
Search: the 'pipelines search QUERY' command and the TUI '/' popup find pipelines,
versions, runs, steps/visits, artifact names and the text of stage inputs,
outputs and evidence. A bare status word (queued, running, succeeded, failed,
canceled, interrupted) or a date (today, yesterday, this week, or YYYY-MM-DD in
local time) selects runs. --type narrows to pipeline, version, run, step, field
or artifact; unrecognised words stay text.
`
+10 -2
View File
@@ -241,11 +241,19 @@ func (s *Store) SetRunTitle(ctx context.Context, id int64, title summarise.Title
return nil
}
// runFrom is the shared pipeline_runs/pipelines join every run-row read builds
// on, so the run projections cannot drift.
const runFrom = `FROM pipeline_runs r JOIN pipelines p ON p.id=r.pipeline_id`
// runStamps formats a run row's created/finished timestamps; reused by runSelect
// and searchRuns instead of copied per query.
const runStamps = `strftime('%Y-%m-%dT%H:%M:%SZ',r.created_at),COALESCE(strftime('%Y-%m-%dT%H:%M:%SZ',r.finished_at),'')`
const runSelect = `SELECT r.id,r.pipeline_id,p.name,r.version,v.content_hash,r.status,r.outcome,r.current_stage,
strftime('%Y-%m-%dT%H:%M:%SZ',r.created_at),COALESCE(strftime('%Y-%m-%dT%H:%M:%SZ',r.finished_at),''),r.diagnostic,
` + runStamps + `,r.diagnostic,
CASE WHEN r.status='succeeded' THEN r.output_json ELSE COALESCE((SELECT output_json FROM run_steps WHERE run_id=r.id AND status='completed' ORDER BY sequence DESC LIMIT 1),'{}') END,
(SELECT COUNT(*) FROM run_steps WHERE run_id=r.id AND status='completed'),r.workspace,r.title,r.model,r.stage_models
FROM pipeline_runs r JOIN pipelines p ON p.id=r.pipeline_id JOIN pipeline_versions v ON v.pipeline_id=r.pipeline_id AND v.version=r.version`
` + runFrom + ` JOIN pipeline_versions v ON v.pipeline_id=r.pipeline_id AND v.version=r.version`
func scanRun(row interface{ Scan(...any) error }, r *protocol.RunSummary) error {
var output, stageModels string
+119
View File
@@ -0,0 +1,119 @@
package pipeline
import (
"context"
"database/sql"
"os"
"strings"
"testing"
"time"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// TestLiveSearchRealDatabase is an env-guarded read-only check against a real
// database. It opens the file read-only (no DDL, no journal change, no writes),
// derives queries from the data itself, and reports one result of each kind it
// can observe. Run it with:
//
// PIPELINES_LIVE_SEARCH_DB=/path/to/pipelines.db go test ./internal/pipeline -run LiveSearch -v
func TestLiveSearchRealDatabase(t *testing.T) {
path := os.Getenv("PIPELINES_LIVE_SEARCH_DB")
if path == "" {
t.Skip("set PIPELINES_LIVE_SEARCH_DB to a real pipelines.db")
}
store, err := OpenReadOnly(path)
if err != nil {
t.Fatalf("open read-only: %v", err)
}
defer store.Close()
requireSearchSchema(t, store)
ctx := context.Background()
pipelines, err := store.List(ctx)
if err != nil {
t.Fatal(err)
}
if len(pipelines) == 0 {
t.Skip("database has no pipelines")
}
now := time.Now()
seen := map[string]protocol.SearchResult{}
record := func(query string) {
response, err := store.Search(ctx, protocol.SearchRequest{Query: query}, now)
if err != nil {
t.Fatalf("search %q: %v", query, err)
}
for _, hit := range response.Results {
if _, ok := seen[hit.Kind]; !ok {
seen[hit.Kind] = hit
}
}
}
queries := []string{}
for _, p := range pipelines {
queries = append(queries, p.Name)
}
// Derive stage/field/artifact queries from a bounded number of recent runs.
runs, err := store.ListRuns(ctx)
if err != nil {
t.Fatal(err)
}
for i := 0; i < len(runs) && i < 5; i++ {
detail, err := store.GetRun(ctx, runs[i].ID)
if err != nil {
continue
}
for j := 0; j < len(detail.Steps) && j < 3; j++ {
step := detail.Steps[j]
if step.Stage != "" {
queries = append(queries, step.Stage)
}
for _, artifact := range step.Artifacts {
queries = append(queries, artifact.Name)
}
for _, key := range []string{"summary", "result", "report", "message", "evidence", "reason"} {
if text, ok := step.Output[key].(string); ok {
for _, word := range strings.Fields(text) {
if len([]rune(word)) >= 6 {
queries = append(queries, word)
break
}
}
}
}
}
}
for _, query := range queries {
record(query)
}
if len(seen) == 0 {
t.Fatal("live database returned no matches for any derived query")
}
for _, kind := range protocol.SearchKinds {
if hit, ok := seen[kind]; ok {
t.Logf("kind=%s target=%s score=%d matched=%s", kind, hit.Target, hit.Score, hit.MatchedField)
} else {
t.Logf("kind=%s not observed in this database", kind)
}
}
if _, ok := seen[protocol.SearchKindRun]; !ok {
t.Fatal("live database returned no run matches")
}
}
// requireSearchSchema skips (rather than fails) when the supplied database
// predates the tables search reads, so pointing the check at a stale local file
// reports the mismatch instead of a confusing "no such table" error.
func requireSearchSchema(t *testing.T, store *Store) {
t.Helper()
for _, table := range []string{"pipelines", "pipeline_versions", "pipeline_runs", "run_steps", "step_control", "step_artifacts"} {
var name string
err := store.db.QueryRow("SELECT name FROM sqlite_master WHERE type='table' AND name=?", table).Scan(&name)
if err == sql.ErrNoRows {
t.Skipf("database lacks the current search schema (missing %q); point PIPELINES_LIVE_SEARCH_DB at a current database", table)
}
if err != nil {
t.Fatal(err)
}
}
}
+601
View File
@@ -0,0 +1,601 @@
package pipeline
import (
"context"
"path/filepath"
"strconv"
"strings"
"testing"
"time"
"unicode/utf8"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// searchFixture builds one pipeline whose name, source, run, stage, field text
// and artifact all contain "zephyr", so a single free-text query exercises
// every kind.
func searchFixture(t *testing.T) (*Store, int64) {
t.Helper()
ctx := context.Background()
store, err := Open(filepath.Join(t.TempDir(), "search.db"))
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { store.Close() })
if _, err := store.Submit(ctx, "Zephyr Build", Template([]string{"zephyr"}, true)); err != nil {
t.Fatal(err)
}
items, err := store.List(ctx)
if err != nil {
t.Fatal(err)
}
definition, err := store.Get(ctx, items[0].ID, 1)
if err != nil {
t.Fatal(err)
}
run, _, err := store.CreateRun(ctx, definition, "zephyr-key", "/work/zephyr", false, nil, map[string]any{"prompt": "zephyr task"})
if err != nil {
t.Fatal(err)
}
if err := store.BeginStep(ctx, run, 1, "zephyr", map[string]any{"prompt": "zephyr task"}); err != nil {
t.Fatal(err)
}
artifactURL := "/artifacts/" + strconv.FormatInt(run, 10) + "/1/zephyr.txt"
if err := store.FinishStep(ctx, run, protocol.RunStep{
Sequence: 1, Status: "completed", Outcome: "success", Target: protocol.SuccessEnd,
Output: map[string]any{"summary": "zephyr completed"},
Control: &protocol.ControlEvidence{Visit: 1, MaxVisits: 2, ModelTarget: "zephyr-model"},
Artifacts: []protocol.StageArtifact{{Name: "zephyr.txt", SizeBytes: 12, ContentType: "text/plain", URL: artifactURL}},
}); err != nil {
t.Fatal(err)
}
if err := store.FinishRun(ctx, run, "succeeded", "success", "", map[string]any{"summary": "zephyr completed"}); err != nil {
t.Fatal(err)
}
return store, run
}
func searchKinds(response *protocol.SearchResponse) map[string]bool {
kinds := map[string]bool{}
for _, hit := range response.Results {
kinds[hit.Kind] = true
}
return kinds
}
func TestSearchReturnsEveryKind(t *testing.T) {
store, run := searchFixture(t)
response, err := store.Search(context.Background(), protocol.SearchRequest{Query: "zephyr"}, time.Now())
if err != nil {
t.Fatal(err)
}
kinds := searchKinds(response)
for _, kind := range protocol.SearchKinds {
if !kinds[kind] {
t.Fatalf("kind %q missing from %+v", kind, response.Results)
}
}
if response.Cap != protocol.SearchDefaultLimit || response.ScanBoundBytes != protocol.SearchMaxScanBytes {
t.Fatalf("bounds not reported: %+v", response)
}
if response.Truncated {
t.Fatalf("a tiny store must not report truncation: %+v", response)
}
// Every target must point at an addressable entity an existing command resolves.
ctx := context.Background()
for _, hit := range response.Results {
switch hit.Kind {
case protocol.SearchKindPipeline:
id := targetInt(t, hit.Target, "pipeline:")
if _, err := store.Get(ctx, id, 0); err != nil {
t.Fatalf("pipeline target %q does not resolve: %v", hit.Target, err)
}
case protocol.SearchKindVersion:
parts := strings.Split(strings.TrimPrefix(hit.Target, "pipeline:"), ":v")
if len(parts) != 2 {
t.Fatalf("bad version target %q", hit.Target)
}
if _, err := store.Get(ctx, parseInt(t, parts[0]), int(parseInt(t, parts[1]))); err != nil {
t.Fatalf("version target %q does not resolve: %v", hit.Target, err)
}
case protocol.SearchKindRun:
if _, err := store.GetRun(ctx, targetInt(t, hit.Target, "run:")); err != nil {
t.Fatalf("run target %q does not resolve: %v", hit.Target, err)
}
case protocol.SearchKindStep, protocol.SearchKindField:
fields := strings.Split(strings.TrimPrefix(hit.Target, "run:"), ":")
if len(fields) < 2 {
t.Fatalf("bad step/field target %q", hit.Target)
}
detail, err := store.GetRun(ctx, parseInt(t, fields[0]))
if err != nil {
t.Fatalf("step/field target %q does not resolve: %v", hit.Target, err)
}
sequence := parseInt(t, fields[1])
found := false
for _, step := range detail.Steps {
if int64(step.Sequence) == sequence {
found = true
}
}
if !found {
t.Fatalf("step/field target %q names no recorded step", hit.Target)
}
case protocol.SearchKindArtifact:
if !strings.HasPrefix(hit.Target, "/artifacts/") {
t.Fatalf("artifact target %q is not a served URL", hit.Target)
}
}
}
if run <= 0 {
t.Fatal("fixture run missing")
}
}
func targetInt(t *testing.T, target, prefix string) int64 {
t.Helper()
if !strings.HasPrefix(target, prefix) {
t.Fatalf("target %q lacks prefix %q", target, prefix)
}
return parseInt(t, strings.TrimPrefix(target, prefix))
}
func parseInt(t *testing.T, value string) int64 {
t.Helper()
n, err := parsePositiveInt(value)
if err != nil {
t.Fatalf("bad number %q: %v", value, err)
}
return n
}
func TestSearchFieldTextCoversInputOutputEvidence(t *testing.T) {
store, _ := searchFixture(t)
response, err := store.Search(context.Background(), protocol.SearchRequest{Query: "zephyr", Kind: protocol.SearchKindField}, time.Now())
if err != nil {
t.Fatal(err)
}
fields := map[string]bool{}
for _, hit := range response.Results {
if hit.Field == nil {
t.Fatalf("field kind without a field payload: %+v", hit)
}
fields[hit.Field.Field] = true
if !strings.Contains(hit.Field.Snippet, "zephyr") {
t.Fatalf("snippet lacks the match: %+v", hit.Field)
}
}
for _, field := range []string{"input", "output", "evidence"} {
if !fields[field] {
t.Fatalf("field text search missed %q: %+v", field, response.Results)
}
}
}
func TestSearchRankingExactSubstringBodyAndRecency(t *testing.T) {
ctx := context.Background()
store, err := Open(filepath.Join(t.TempDir(), "ranking.db"))
if err != nil {
t.Fatal(err)
}
defer store.Close()
submit := func(name string) {
if _, err := store.Submit(ctx, name, Template([]string{"one"}, true)); err != nil {
t.Fatal(err)
}
}
submit("alpha")
submit("alphabet")
items, _ := store.List(ctx)
definition, _ := store.Get(ctx, items[0].ID, 1)
run, _, err := store.CreateRun(ctx, definition, "alpha-key", "/work", false, nil, map[string]any{"prompt": "body alpha match"})
if err != nil {
t.Fatal(err)
}
if err := store.BeginStep(ctx, run, 1, "one", map[string]any{"prompt": "body alpha match"}); err != nil {
t.Fatal(err)
}
if err := store.FinishStep(ctx, run, protocol.RunStep{Sequence: 1, Status: "completed", Outcome: "success", Target: protocol.SuccessEnd}); err != nil {
t.Fatal(err)
}
response, err := store.Search(ctx, protocol.SearchRequest{Query: "alpha"}, time.Now())
if err != nil {
t.Fatal(err)
}
seen := map[int]bool{}
for i, hit := range response.Results {
seen[hit.Score] = true
if i > 0 && response.Results[i-1].Score < hit.Score {
t.Fatalf("scores not descending: %+v", response.Results)
}
}
if !seen[3] || !seen[2] || !seen[1] {
t.Fatalf("expected exact/substring/body tiers: %+v", response.Results)
}
// The exact pipeline match outranks the substring pipeline match.
exactIndex, substringIndex := -1, -1
for i, hit := range response.Results {
if hit.Pipeline == nil {
continue
}
if hit.Pipeline.Name == "alpha" {
exactIndex = i
}
if hit.Pipeline.Name == "alphabet" {
substringIndex = i
}
if hit.Pipeline.Name == "alpha" && hit.Score != 3 {
t.Fatalf("exact name scored %d", hit.Score)
}
if hit.Pipeline.Name == "alphabet" && hit.Score != 2 {
t.Fatalf("substring name scored %d", hit.Score)
}
}
if exactIndex < 0 || substringIndex < 0 || exactIndex > substringIndex {
t.Fatalf("exact name must outrank a name substring: %+v", response.Results)
}
// Equal-tier ties break by recency.
older, _, err := store.CreateRun(ctx, definition, "alpha-older", "/work", false, nil, map[string]any{"prompt": "alpha"})
if err != nil {
t.Fatal(err)
}
newer, _, err := store.CreateRun(ctx, definition, "alpha-newer", "/work", false, nil, map[string]any{"prompt": "alpha"})
if err != nil {
t.Fatal(err)
}
setCreated(t, store, older, "2026-01-01 00:00:00")
setCreated(t, store, newer, "2026-06-01 00:00:00")
response, err = store.Search(ctx, protocol.SearchRequest{Query: "alpha"}, time.Now())
if err != nil {
t.Fatal(err)
}
var olderIndex, newerIndex = -1, -1
for i, hit := range response.Results {
if hit.Run == nil || hit.Run.ID == 0 {
continue
}
if hit.Run.ID == older {
olderIndex = i
}
if hit.Run.ID == newer {
newerIndex = i
}
}
if olderIndex < 0 || newerIndex < 0 || newerIndex > olderIndex {
t.Fatalf("recency tie-break lost: older=%d newer=%d", olderIndex, newerIndex)
}
}
func TestSearchStatusWordsSelectRuns(t *testing.T) {
ctx := context.Background()
store, err := Open(filepath.Join(t.TempDir(), "statuses.db"))
if err != nil {
t.Fatal(err)
}
defer store.Close()
if _, err := store.Submit(ctx, "statuses", Template([]string{"one"}, true)); err != nil {
t.Fatal(err)
}
items, _ := store.List(ctx)
definition, _ := store.Get(ctx, items[0].ID, 1)
// One run per accepted status word, each with a distinct created_at so a
// date selector can never be mistaken for the status selector.
byStatus := map[string]int64{}
for i, status := range protocol.SearchStatuses {
run, _, err := store.CreateRun(ctx, definition, "status-"+status, "/work", false, nil, nil)
if err != nil {
t.Fatal(err)
}
if _, err := store.db.Exec("UPDATE pipeline_runs SET status=?,created_at=? WHERE id=?", status, "2026-01-0"+strconv.Itoa(i+1)+" 09:00:00", run); err != nil {
t.Fatal(err)
}
byStatus[status] = run
}
now := time.Date(2026, 10, 16, 12, 0, 0, 0, time.UTC)
for _, status := range protocol.SearchStatuses {
response, err := store.Search(ctx, protocol.SearchRequest{Query: status}, now)
if err != nil {
t.Fatal(err)
}
var runs []int64
for _, hit := range response.Results {
if hit.Run == nil {
t.Fatalf("status %q returned a non-run kind %q", status, hit.Kind)
}
runs = append(runs, hit.Run.ID)
}
if len(runs) != 1 || runs[0] != byStatus[status] {
t.Fatalf("status %q selected %v, want [%d]", status, runs, byStatus[status])
}
}
}
func TestSearchStatusAndDateSelectors(t *testing.T) {
ctx := context.Background()
store, err := Open(filepath.Join(t.TempDir(), "selector.db"))
if err != nil {
t.Fatal(err)
}
defer store.Close()
if _, err := store.Submit(ctx, "selectors", Template([]string{"one"}, true)); err != nil {
t.Fatal(err)
}
items, _ := store.List(ctx)
definition, _ := store.Get(ctx, items[0].ID, 1)
yesterdayRun, _, err := store.CreateRun(ctx, definition, "yesterday", "/work", false, nil, nil)
if err != nil {
t.Fatal(err)
}
todayRun, _, err := store.CreateRun(ctx, definition, "today", "/work", false, nil, nil)
if err != nil {
t.Fatal(err)
}
if err := store.FinishRun(ctx, yesterdayRun, "failed", "error", "boom", nil); err != nil {
t.Fatal(err)
}
setCreated(t, store, yesterdayRun, "2026-10-15 09:00:00")
setCreated(t, store, todayRun, "2026-10-16 09:00:00")
now := time.Date(2026, 10, 16, 12, 0, 0, 0, time.UTC)
selects := func(query string) map[int64]bool {
t.Helper()
response, err := store.Search(ctx, protocol.SearchRequest{Query: query}, now)
if err != nil {
t.Fatal(err)
}
ids := map[int64]bool{}
for _, hit := range response.Results {
if hit.Run != nil {
ids[hit.Run.ID] = true
}
}
return ids
}
if ids := selects("failed"); !ids[yesterdayRun] || ids[todayRun] {
t.Fatalf("status selector: %+v", ids)
}
if ids := selects("today"); !ids[todayRun] || ids[yesterdayRun] {
t.Fatalf("today selector: %+v", ids)
}
if ids := selects("yesterday"); !ids[yesterdayRun] || ids[todayRun] {
t.Fatalf("yesterday selector: %+v", ids)
}
if ids := selects("2026-10-15"); !ids[yesterdayRun] || ids[todayRun] {
t.Fatalf("literal date selector: %+v", ids)
}
if ids := selects("this week"); !ids[yesterdayRun] || !ids[todayRun] {
t.Fatalf("this week selector: %+v", ids)
}
// Non-selector text stays free text.
if ids := selects("selectors"); !ids[yesterdayRun] || !ids[todayRun] {
t.Fatalf("free text was misread as a selector: %+v", ids)
}
}
func TestParseSearchTerms(t *testing.T) {
now := time.Date(2026, 10, 16, 12, 0, 0, 0, time.UTC)
cases := []struct {
query string
status string
hasDate bool
from, to string
text string
}{
{query: "failed", status: "failed"},
{query: " RUNNING ", status: "running"},
{query: "today", hasDate: true, from: "2026-10-16 00:00:00", to: "2026-10-17 00:00:00"},
{query: "yesterday", hasDate: true, from: "2026-10-15 00:00:00", to: "2026-10-16 00:00:00"},
{query: "this week", hasDate: true, from: "2026-10-12 00:00:00", to: "2026-10-19 00:00:00"},
{query: "2026-10-05", hasDate: true, from: "2026-10-05 00:00:00", to: "2026-10-06 00:00:00"},
{query: "failed to build", text: "failed to build"},
{query: "build", text: "build"},
}
for _, test := range cases {
terms := parseSearchTerms(test.query, now)
if terms.Status != test.status || terms.Text != test.text || terms.HasDate != test.hasDate {
t.Fatalf("parse %q = %+v", test.query, terms)
}
if test.hasDate {
if got := terms.From.Format(searchSQLTime); got != test.from {
t.Fatalf("parse %q from = %s, want %s", test.query, got, test.from)
}
if got := terms.To.Format(searchSQLTime); got != test.to {
t.Fatalf("parse %q to = %s, want %s", test.query, got, test.to)
}
}
}
}
func TestSearchKindFilterAndLimits(t *testing.T) {
store, _ := searchFixture(t)
ctx := context.Background()
response, err := store.Search(ctx, protocol.SearchRequest{Query: "zephyr", Kind: protocol.SearchKindRun}, time.Now())
if err != nil {
t.Fatal(err)
}
for _, hit := range response.Results {
if hit.Kind != protocol.SearchKindRun {
t.Fatalf("kind filter leaked %q", hit.Kind)
}
}
if _, err := store.Search(ctx, protocol.SearchRequest{Query: "zephyr", Kind: "bogus"}, time.Now()); err == nil {
t.Fatal("invalid kind must return a clear error")
}
for _, test := range []struct {
limit int
want int
}{{limit: 0, want: protocol.SearchDefaultLimit}, {limit: -5, want: protocol.SearchDefaultLimit}, {limit: 1, want: 1}, {limit: 500, want: protocol.SearchMaxLimit}} {
response, err := store.Search(ctx, protocol.SearchRequest{Query: "zephyr", Limit: test.limit}, time.Now())
if err != nil {
t.Fatal(err)
}
if response.Cap != test.want {
t.Fatalf("limit %d => cap %d, want %d", test.limit, response.Cap, test.want)
}
if len(response.Results) > response.Cap {
t.Fatalf("limit %d returned %d results", test.limit, len(response.Results))
}
}
// A cap below the candidate count drops matches and must report Truncated.
truncated, err := store.Search(ctx, protocol.SearchRequest{Query: "zephyr", Limit: 1}, time.Now())
if err != nil {
t.Fatal(err)
}
if len(truncated.Results) != 1 || !truncated.Truncated {
t.Fatalf("result cap must truncate: %+v", truncated)
}
}
func TestSearchEdgeCases(t *testing.T) {
store, run := searchFixture(t)
ctx := context.Background()
empty, err := store.Search(ctx, protocol.SearchRequest{Query: " "}, time.Now())
if err != nil || len(empty.Results) != 0 {
t.Fatalf("empty query: %+v %v", empty, err)
}
none, err := store.Search(ctx, protocol.SearchRequest{Query: "no-such-token-xyzzy"}, time.Now())
if err != nil || len(none.Results) != 0 {
t.Fatalf("no-match query: %+v %v", none, err)
}
if none.Results == nil {
t.Fatal("results must be an empty slice, not nil")
}
// A run without a finish reports no duration.
setFinishedNull(t, store, run)
response, err := store.Search(ctx, protocol.SearchRequest{Query: "zephyr", Kind: protocol.SearchKindRun}, time.Now())
if err != nil {
t.Fatal(err)
}
for _, hit := range response.Results {
if hit.Run != nil && hit.Run.FinishedAt != "" {
t.Fatalf("null finished_at surfaced a value: %+v", hit.Run)
}
}
}
func TestSearchSnippetBoundaries(t *testing.T) {
if got := searchSnippet("prefix café résumé naïve suffix", "naïve"); !strings.Contains(got, "naïve") || !utf8.ValidString(got) {
t.Fatalf("unicode snippet malformed: %q", got)
}
if got := searchSnippet("line one\n\tline two\r\n zephyr here", "zephyr"); strings.ContainsAny(got, "\n\r\t") || !strings.Contains(got, "zephyr") {
t.Fatalf("whitespace snippet not normalized: %q", got)
}
if got := searchSnippet(strings.Repeat("é", 200)+"needle"+strings.Repeat("é", 200), "needle"); !utf8.ValidString(got) || !strings.Contains(got, "needle") {
t.Fatalf("boundary snippet malformed: %q", got)
}
if got := searchSnippet("no match here", "absent"); got == "" || !utf8.ValidString(got) {
t.Fatalf("no-match snippet must stay a clean line: %q", got)
}
}
func TestSearchScanBoundTruncates(t *testing.T) {
ctx := context.Background()
store, err := Open(filepath.Join(t.TempDir(), "scan.db"))
if err != nil {
t.Fatal(err)
}
defer store.Close()
if _, err := store.Submit(ctx, "scan", Template([]string{"one"}, true)); err != nil {
t.Fatal(err)
}
items, _ := store.List(ctx)
definition, _ := store.Get(ctx, items[0].ID, 1)
// An older step that does match, and a newer step whose body alone exceeds
// the scan budget: the budget must stop the scan and be reported.
older, _, err := store.CreateRun(ctx, definition, "scan-older", "/work", false, nil, nil)
if err != nil {
t.Fatal(err)
}
if err := store.BeginStep(ctx, older, 1, "one", nil); err != nil {
t.Fatal(err)
}
if err := store.FinishStep(ctx, older, protocol.RunStep{Sequence: 1, Status: "completed", Outcome: "success", Target: protocol.SuccessEnd, Output: map[string]any{"summary": "needle in older step"}}); err != nil {
t.Fatal(err)
}
newer, _, err := store.CreateRun(ctx, definition, "scan-newer", "/work", false, nil, nil)
if err != nil {
t.Fatal(err)
}
if err := store.BeginStep(ctx, newer, 1, "one", nil); err != nil {
t.Fatal(err)
}
blob := strings.Repeat("x", protocol.SearchMaxScanBytes+1024)
if err := store.FinishStep(ctx, newer, protocol.RunStep{Sequence: 1, Status: "completed", Outcome: "success", Target: protocol.SuccessEnd, Output: map[string]any{"blob": blob}}); err != nil {
t.Fatal(err)
}
response, err := store.Search(ctx, protocol.SearchRequest{Query: "needle"}, time.Now())
if err != nil {
t.Fatal(err)
}
if !response.Truncated {
t.Fatalf("scan bound not reported: %+v", response)
}
for _, hit := range response.Results {
if hit.Field != nil {
t.Fatalf("scan passed the bound and matched: %+v", hit.Field)
}
}
}
// TestSearchScanBoundTruncatesByRowCount proves the step-count bound is
// observable: more recorded steps than the budget sets Truncated even though
// every body is tiny and fits the byte budget.
func TestSearchScanBoundTruncatesByRowCount(t *testing.T) {
ctx := context.Background()
store, err := Open(filepath.Join(t.TempDir(), "scanrows.db"))
if err != nil {
t.Fatal(err)
}
defer store.Close()
if _, err := store.Submit(ctx, "scanrows", Template([]string{"one"}, true)); err != nil {
t.Fatal(err)
}
items, _ := store.List(ctx)
definition, _ := store.Get(ctx, items[0].ID, 1)
run, _, err := store.CreateRun(ctx, definition, "scanrows", "/work", false, nil, nil)
if err != nil {
t.Fatal(err)
}
tx, err := store.db.Begin()
if err != nil {
t.Fatal(err)
}
for sequence := 1; sequence <= protocol.SearchMaxScanSteps+1; sequence++ {
if _, err := tx.Exec(`INSERT INTO run_steps(run_id,sequence,stage_key,input_json) VALUES(?,?,?,?)`, run, sequence, "one", "{}"); err != nil {
t.Fatal(err)
}
}
if err := tx.Commit(); err != nil {
t.Fatal(err)
}
response, err := store.Search(ctx, protocol.SearchRequest{Query: "needle"}, time.Now())
if err != nil {
t.Fatal(err)
}
if !response.Truncated {
t.Fatalf("step-count bound not reported: scanned_steps=%d total=%d", response.ScannedSteps, protocol.SearchMaxScanSteps+1)
}
if response.ScannedSteps != protocol.SearchMaxScanSteps {
t.Fatalf("scanned_steps=%d, want %d", response.ScannedSteps, protocol.SearchMaxScanSteps)
}
if response.ScannedBytes > protocol.SearchMaxScanBytes {
t.Fatalf("scanned_bytes=%d exceeds bound %d", response.ScannedBytes, protocol.SearchMaxScanBytes)
}
}
func setCreated(t *testing.T, store *Store, runID int64, timestamp string) {
t.Helper()
if _, err := store.db.Exec("UPDATE pipeline_runs SET created_at=? WHERE id=?", timestamp, runID); err != nil {
t.Fatal(err)
}
}
func setFinishedNull(t *testing.T, store *Store, runID int64) {
t.Helper()
if _, err := store.db.Exec("UPDATE pipeline_runs SET finished_at=NULL,status='running' WHERE id=?", runID); err != nil {
t.Fatal(err)
}
}
+21
View File
@@ -8,6 +8,7 @@ import (
"fmt"
"git.a-wan.net/alan/pipelines/internal/protocol"
"git.a-wan.net/alan/pipelines/internal/stage"
"os"
"path/filepath"
"strings"
"sync"
@@ -50,6 +51,26 @@ CREATE TABLE IF NOT EXISTS submissions (id INTEGER PRIMARY KEY, name TEXT NOT NU
func (s *Store) Close() error { return s.db.Close() }
// OpenReadOnly opens an existing database without running schema DDL or
// changing journal mode, so a live database can be queried read-only while its
// server keeps writing. It fails when the file does not exist. It is used by
// tests that inspect a real database and is never part of server startup.
func OpenReadOnly(path string) (*Store, error) {
if _, err := os.Stat(path); err != nil {
return nil, err
}
db, err := sql.Open("sqlite", "file:"+path+"?mode=ro")
if err != nil {
return nil, err
}
db.SetMaxOpenConns(1)
if _, err := db.Exec("PRAGMA busy_timeout=5000"); err != nil {
db.Close()
return nil, err
}
return &Store{db: db, dir: filepath.Dir(path)}, nil
}
// Directory is the resolved directory holding the database, used to place
// adjacent server state such as stage artifacts.
func (s *Store) Directory() string { return s.dir }
+10 -11
View File
@@ -102,13 +102,11 @@ type PipelineSummary struct {
UpdatedAt string `json:"updated_at"`
}
// Message is the JSON envelope shared by the server and client. It also carries
// the omni-search request/response: a client sends Type "search" with an ID, the
// Query text, an optional Kind type filter and an optional Limit, and the server
// replies with Type "search_results", the echoed ID and ranked Matches. Every
// SearchMatch carries a stable Target plus the label and per-kind evidence; all
// search fields are optional so older peers ignore them. See search.go for the
// kind constants and wire-shape detail.
// Message is the JSON envelope shared by the server and client. It also brokers
// omni search: a client sends Type "search" with an ID and a SearchRequest, and
// the server replies with Type "search_results", the echoed ID and a
// SearchResponse. Both search fields are optional so older peers ignore them.
// See search.go for the per-type payloads and the ranking/kind/bound vocabulary.
type Message struct {
DefaultHarness string `json:"default_harness,omitempty"`
Build *buildinfo.Info `json:"build,omitempty"`
@@ -130,8 +128,6 @@ type Message struct {
Source string `json:"source,omitempty"`
Title string `json:"title,omitempty"`
Version int `json:"version,omitempty"`
Query string `json:"query,omitempty"`
Kind string `json:"kind,omitempty"`
Pipelines []PipelineSummary `json:"pipelines,omitempty"`
PipelineID int64 `json:"pipeline_id,omitempty"`
Detail *PipelineDetail `json:"detail,omitempty"`
@@ -141,7 +137,6 @@ type Message struct {
Stage string `json:"stage,omitempty"`
Option string `json:"option,omitempty"`
Feedback string `json:"feedback,omitempty"`
Matches []SearchMatch `json:"matches,omitempty"`
Input map[string]any `json:"input,omitempty"`
AllowTools bool `json:"allow_tools,omitempty"`
WritePaths []string `json:"write_paths,omitempty"`
@@ -153,7 +148,11 @@ type Message struct {
// them; the same fields are echoed on the run record.
Model string `json:"model,omitempty"`
StageModels map[string]string `json:"stage_models,omitempty"`
Limit int `json:"limit,omitempty"`
// Search is the broad, read-only search traffic over pipelines, versions,
// runs, steps, field text and artifacts. See search.go for the per-type
// payloads and the ranking/kind/bound vocabulary.
Search *SearchRequest `json:"search,omitempty"`
SearchResults *SearchResponse `json:"search_results,omitempty"`
// Chat is the brokered OpenCode chat traffic (route B). See chat.go for the
// per-type payload structs and the wire shapes they mirror.
ChatSessions []ChatSession `json:"chat_sessions,omitempty"`
+105
View File
@@ -0,0 +1,105 @@
package server
import (
"bytes"
"context"
"encoding/json"
"net/http/httptest"
"path/filepath"
"strconv"
"strings"
"testing"
"git.a-wan.net/alan/pipelines/internal/cli"
"git.a-wan.net/alan/pipelines/internal/pipeline"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// TestCLISearchEndToEndEveryKind seeds a store whose pipeline, source, run,
// stage, field text and artifact all contain one token, then runs the CLI
// search command over a real Handler and asserts the server returned one match
// of every kind and rejects an unknown --type rather than ignoring it.
func TestCLISearchEndToEndEveryKind(t *testing.T) {
t.Setenv("PIPELINES_HARNESS_CONFIG", filepath.Join(t.TempDir(), "harnesses.json"))
ctx, cancel := context.WithCancel(context.Background())
store, err := pipeline.Open(filepath.Join(t.TempDir(), "search-e2e.db"))
if err != nil {
t.Fatal(err)
}
defer store.Close()
if _, err := store.Submit(ctx, "Zephyr Build", pipeline.Template([]string{"zephyr"}, true)); err != nil {
t.Fatal(err)
}
items, err := store.List(ctx)
if err != nil {
t.Fatal(err)
}
definition, err := store.Get(ctx, items[0].ID, 1)
if err != nil {
t.Fatal(err)
}
run, _, err := store.CreateRun(ctx, definition, "zephyr-key", "/work/zephyr", false, nil, map[string]any{"prompt": "zephyr task"})
if err != nil {
t.Fatal(err)
}
if err := store.BeginStep(ctx, run, 1, "zephyr", map[string]any{"prompt": "zephyr task"}); err != nil {
t.Fatal(err)
}
if err := store.FinishStep(ctx, run, protocol.RunStep{
Sequence: 1, Status: "completed", Outcome: "success", Target: protocol.SuccessEnd,
Output: map[string]any{"summary": "zephyr completed"},
Artifacts: []protocol.StageArtifact{{Name: "zephyr.txt", SizeBytes: 12, ContentType: "text/plain", URL: "/artifacts/" + strconv.FormatInt(run, 10) + "/1/zephyr.txt"}},
}); err != nil {
t.Fatal(err)
}
handler := Handler(ctx, store)
defer func() { cancel(); WaitRuns(handler) }()
http := httptest.NewServer(handler)
defer http.Close()
url := "ws" + strings.TrimPrefix(http.URL, "http") + "/connect"
runCLI := func(args ...string) (string, error) {
var out bytes.Buffer
app := cli.App{Out: &out, Err: &out, In: strings.NewReader("")}
err := app.Run(ctx, append([]string{"--url", url}, args...))
return out.String(), err
}
output, err := runCLI("search", "zephyr", "--json")
if err != nil {
t.Fatal(err)
}
var response protocol.SearchResponse
if err := json.Unmarshal([]byte(output), &response); err != nil {
t.Fatal(err, output)
}
kinds := map[string]bool{}
for _, hit := range response.Results {
kinds[hit.Kind] = true
if hit.Target == "" || hit.MatchedField == "" || hit.Score == 0 {
t.Fatalf("hit lacks ranking/navigation context: %+v", hit)
}
}
for _, kind := range protocol.SearchKinds {
if !kinds[kind] {
t.Fatalf("kind %q missing from end-to-end search: %s", kind, output)
}
}
if output, err := runCLI("search", "zephyr", "--type", "run", "--json"); err != nil {
t.Fatal(err)
} else {
var filtered protocol.SearchResponse
if err := json.Unmarshal([]byte(output), &filtered); err != nil {
t.Fatal(err)
}
for _, hit := range filtered.Results {
if hit.Kind != protocol.SearchKindRun {
t.Fatalf("kind filter leaked %q", hit.Kind)
}
}
}
if _, err := runCLI("search", "zephyr", "--type", "bogus"); err == nil || !strings.Contains(err.Error(), "unknown search kind") {
t.Fatalf("invalid kind must error, got %v", err)
}
}
+13 -6
View File
@@ -217,14 +217,21 @@ func HandlerWithOptions(ctx context.Context, options Options, stores ...*pipelin
} else {
response.Pipelines = items
}
} else if request.Type == protocol.Search && len(stores) > 0 && runs != nil {
response.Type = protocol.SearchResults
matches, err := runs.search(request)
if err != nil {
} else if request.Type == protocol.Search {
if len(stores) == 0 {
response.Type = protocol.Error
response.Error = err.Error()
response.Error = "search unavailable: no store"
} else if request.Search == nil {
response.Type = protocol.Error
response.Error = "search requires a query"
} else {
response.Matches = matches
response.Type = protocol.SearchResults
var err error
response.SearchResults, err = stores[0].Search(ctx, *request.Search, time.Now())
if err != nil {
response.Type = protocol.Error
response.Error = err.Error()
}
}
} else if runs != nil && (request.Type == protocol.RunPipeline || request.Type == protocol.RetryRun || request.Type == protocol.ListRuns || request.Type == protocol.GetRun || request.Type == protocol.CancelRun || request.Type == protocol.DecideRun || request.Type == protocol.SetRunTitle || request.Type == protocol.GetRunEvidence) {
var err error
+424
View File
@@ -0,0 +1,424 @@
package tui
import (
"fmt"
"net/url"
"os/exec"
"runtime"
"sort"
"strings"
"git.a-wan.net/alan/pipelines/internal/protocol"
"github.com/atotto/clipboard"
tea "github.com/charmbracelet/bubbletea"
"github.com/charmbracelet/lipgloss"
"github.com/charmbracelet/x/ansi"
)
// artifactVisit is one recorded stage visit and the artifacts the server
// observed for it. A visit is kept even when it recorded none, so the view can
// say plainly that nothing was captured rather than omitting it.
type artifactVisit struct {
stage string
visit int
step protocol.RunStep
artifacts []protocol.StageArtifact
}
// runArtifactVisits groups a run's recorded steps by stage and visit in the
// order the run produced them: stages in first-appearance order and each
// stage's visits by sequence. The display visit number is the recorded control
// visit when present, else the position within the stage (mirroring the app's
// runTimeline/runArtifactGroups). Pure, O(n), and it never dedupes steps, so a
// repeated stage's visits stay distinct.
func runArtifactVisits(steps []protocol.RunStep) []artifactVisit {
order := make([]string, 0)
index := map[string]int{}
byStage := make([][]protocol.RunStep, 0)
for _, step := range steps {
at, ok := index[step.Stage]
if !ok {
at = len(order)
index[step.Stage] = at
order = append(order, step.Stage)
byStage = append(byStage, nil)
}
byStage[at] = append(byStage[at], step)
}
visits := make([]artifactVisit, 0, len(steps))
for i, stage := range order {
stageSteps := byStage[i]
sort.SliceStable(stageSteps, func(a, b int) bool { return stageSteps[a].Sequence < stageSteps[b].Sequence })
for j, step := range stageSteps {
visit := j + 1
if step.Control != nil && step.Control.Visit > 0 {
visit = step.Control.Visit
}
visits = append(visits, artifactVisit{stage: stage, visit: visit, step: step, artifacts: step.Artifacts})
}
}
return visits
}
// artifactRef addresses one artifact row in the flat selection order the view
// uses (group order, then recorded order within the group).
type artifactRef struct {
visit int
artifact protocol.StageArtifact
}
func artifactRefs(visits []artifactVisit) []artifactRef {
var refs []artifactRef
for i, visit := range visits {
for _, artifact := range visit.artifacts {
refs = append(refs, artifactRef{visit: i, artifact: artifact})
}
}
return refs
}
// isImageContentType mirrors the app's isImageContentType: an image the
// terminal cannot render and therefore marks distinctly.
func isImageContentType(contentType string) bool {
return strings.HasPrefix(contentType, "image/")
}
// Column geometry for one aligned artifact row. The name and type widths are
// clamped so one very long value cannot widen every other row; the size column
// is right-aligned.
const (
artifactCursorWidth = 2
artifactMarkerWidth = 5 // "[img]" or five spaces
artifactColumnGap = 2
artifactMinName = 8
artifactMinURLWidth = 12
artifactMaxName = 40
artifactMaxType = 28
)
type artifactWidths struct{ name, typ, size int }
func artifactWidthsFor(visits []artifactVisit) artifactWidths {
widths := artifactWidths{}
for _, visit := range visits {
for _, artifact := range visit.artifacts {
widths.name = min(artifactMaxName, max(widths.name, lipgloss.Width(ansi.Strip(artifact.Name))))
widths.typ = min(artifactMaxType, max(widths.typ, lipgloss.Width(ansi.Strip(artifact.ContentType))))
widths.size = max(widths.size, lipgloss.Width(humanBytes(artifact.SizeBytes)))
}
}
return widths
}
func padRight(text string, width int) string {
if deficit := width - lipgloss.Width(text); deficit > 0 {
return text + strings.Repeat(" ", deficit)
}
return text
}
func padLeft(text string, width int) string {
if deficit := width - lipgloss.Width(text); deficit > 0 {
return strings.Repeat(" ", deficit) + text
}
return text
}
// artifactScrollTop returns the offset that keeps the selected row visible in a
// window of page rows, given the current offset and the total line count. It
// scrolls by the minimum needed, so a one-row move shifts the window by one
// rather than recentring it, and it never leaves the viewport past the end.
// Both the selection clamp and the renderer use it, so they can never disagree
// about which row is on screen.
func artifactScrollTop(from, row, page, total int) int {
if page <= 0 {
return 0
}
maxTop := max(0, total-page)
from = max(0, min(from, maxTop))
if row < from {
from = row
} else if row >= from+page {
from = row - page + 1
}
return max(0, min(from, maxTop))
}
// artifactsViewHeight is the frame body height the artifacts panel is rendered
// at, matching View: a one-line header and a one-line footer, each followed by
// a separating row.
func (m Model) artifactsViewHeight() int { return max(0, m.height-4) }
// artifactsPageSize is the number of artifact body rows the panel shows: the
// frame body less the panel's own bar and border, matching artifactsView.
func (m Model) artifactsPageSize() int { return max(0, m.artifactsViewHeight()-4) }
// artifactRowText renders one artifact as an aligned row: the image marker, the
// name, the content type and the human-readable size, with the URL appended
// when the terminal is wide enough. Optional columns drop as width shrinks and
// every cell is truncated, so the row never exceeds width.
func artifactRowText(artifact protocol.StageArtifact, widths artifactWidths, width int, selected bool) string {
prefix := strings.Repeat(" ", artifactCursorWidth)
if selected {
prefix = "› "
}
marker := strings.Repeat(" ", artifactMarkerWidth)
if isImageContentType(artifact.ContentType) {
marker = "[img]"
}
prefix += marker + " "
available := width - lipgloss.Width(prefix)
if available <= 0 {
return ansi.Truncate(prefix, max(1, width), "")
}
name := ansi.Strip(artifact.Name)
contentType := ansi.Strip(artifact.ContentType)
if strings.TrimSpace(contentType) == "" {
contentType = "unknown type"
}
size := humanBytes(artifact.SizeBytes)
gap := strings.Repeat(" ", artifactColumnGap)
nameCell := func(w int) string { return padRight(ansi.Truncate(name, max(1, w), "…"), w) }
typeCell := padRight(ansi.Truncate(contentType, max(1, widths.typ), "…"), widths.typ)
sizeCell := padLeft(size, widths.size)
switch {
case available >= widths.name+artifactColumnGap+widths.typ+artifactColumnGap+widths.size+artifactColumnGap+artifactMinURLWidth:
urlWidth := available - (widths.name + artifactColumnGap + widths.typ + artifactColumnGap + widths.size + artifactColumnGap)
return prefix + nameCell(widths.name) + gap + typeCell + gap + sizeCell + gap + ansi.Truncate(artifact.URL, max(1, urlWidth), "…")
case available >= widths.name+artifactColumnGap+widths.typ+artifactColumnGap+widths.size:
return prefix + nameCell(widths.name) + gap + typeCell + gap + sizeCell
case available >= artifactMinName+artifactColumnGap+widths.size:
nameWidth := min(widths.name, available-artifactColumnGap-widths.size)
return prefix + nameCell(nameWidth) + gap + sizeCell
default:
return prefix + ansi.Truncate(name, max(1, available), "…")
}
}
// artifactViewContent renders the grouped artifact lines for one content width
// and returns the line index of each flat artifact ref, so selection can scroll
// it into view. Group headers, the shared capture summary and the partial
// capture notes precede each visit's aligned rows.
func artifactViewContent(visits []artifactVisit, widths artifactWidths, width, selected int) ([]string, []int) {
if len(visits) == 0 {
return []string{"No recorded visits yet."}, nil
}
var lines []string
var refLines []int
ref := 0
for i, visit := range visits {
if i > 0 {
lines = append(lines, "")
}
lines = append(lines, lipgloss.NewStyle().Bold(true).Foreground(themeAccent).Render(fmt.Sprintf("%s · visit %d", ansi.Strip(visit.stage), visit.visit)))
lines = append(lines, lipgloss.NewStyle().Foreground(themePrimary).Render(artifactsSummary(visit.step)))
for _, note := range artifactCaptureNotes(visit.step) {
lines = append(lines, lipgloss.NewStyle().Foreground(themeMuted).Render(note))
}
for _, artifact := range visit.artifacts {
lines = append(lines, artifactRowText(artifact, widths, width, ref == selected))
refLines = append(refLines, len(lines)-1)
ref++
}
}
return lines, refLines
}
func (m Model) artifactViewVisits() ([]artifactVisit, []artifactRef) {
if m.runDetail == nil {
return nil, nil
}
visits := runArtifactVisits(m.runDetail.Steps)
return visits, artifactRefs(visits)
}
func (m *Model) openArtifacts() {
if m.runDetail == nil {
m.runError = "Open a run to inspect its artifacts."
return
}
m.artifactsOpen = true
m.artifactIndex = 0
m.artifactTop = 0
}
func (m *Model) selectArtifactByName(name string) {
_, refs := m.artifactViewVisits()
for i, ref := range refs {
if ref.artifact.Name == name {
m.artifactIndex = i
break
}
}
m.clampArtifactScroll()
}
// clampArtifactScroll keeps the selected artifact row inside the visible page
// after a selection move, using the same page size as the renderer.
func (m *Model) clampArtifactScroll() {
if m.runDetail == nil {
m.artifactIndex, m.artifactTop = 0, 0
return
}
visits, refs := m.artifactViewVisits()
m.artifactIndex = max(0, min(m.artifactIndex, max(0, len(refs)-1)))
if len(refs) == 0 {
m.artifactTop = 0
return
}
widths := artifactWidthsFor(visits)
inner := max(1, m.width-4)
lines, refLines := artifactViewContent(visits, widths, inner, m.artifactIndex)
if m.artifactIndex >= len(refLines) {
return
}
m.artifactTop = artifactScrollTop(m.artifactTop, refLines[m.artifactIndex], m.artifactsPageSize(), len(lines))
}
func (m Model) updateArtifacts(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
_, refs := m.artifactViewVisits()
count := len(refs)
switch msg.String() {
case "esc":
m.artifactsOpen = false
return m, nil
case "j", "down":
m.artifactIndex = min(m.artifactIndex+1, max(0, count-1))
case "k", "up":
m.artifactIndex = max(0, m.artifactIndex-1)
case "g", "home":
m.artifactIndex = 0
case "G", "end":
m.artifactIndex = max(0, count-1)
case "enter", "o":
if count == 0 {
return m, nil
}
return m, openArtifactCmd(m.url, refs[m.artifactIndex].artifact)
case "y":
if count == 0 {
return m, nil
}
return m, copyArtifactCmd(m.url, refs[m.artifactIndex].artifact)
}
m.clampArtifactScroll()
return m, nil
}
func (m Model) artifactsView(height int) string {
if m.runDetail == nil {
return fitBlock([]string{"Open a run to inspect its artifacts."}, m.width, height)
}
if height <= 0 || m.width <= 0 {
return ""
}
visits, refs := m.artifactViewVisits()
widths := artifactWidthsFor(visits)
selected := max(0, min(m.artifactIndex, max(0, len(refs)-1)))
inner := max(1, m.width-4)
lines, refLines := artifactViewContent(visits, widths, inner, selected)
page := max(0, height-4)
top := max(0, min(m.artifactTop, max(0, len(lines)-page)))
if selected < len(refLines) {
// Keep the selected row on screen even if a slightly different page
// size left the stored offset behind.
top = artifactScrollTop(top, refLines[selected], page, len(lines))
}
body := lines[top:min(len(lines), top+page)]
title := fmt.Sprintf("Artifacts · run #%d", m.runDetail.ID)
if len(visits) > 0 {
title = fmt.Sprintf("Artifacts · run #%d · %d recorded · %d visits", m.runDetail.ID, len(refs), len(visits))
}
right := ""
if len(refs) > 0 {
right = fmt.Sprintf("%d/%d", selected+1, len(refs))
}
footer := "No artifacts recorded"
if len(refs) > 0 {
// Keep the selected entry's URL available even when the row is too
// narrow to carry its own URL column.
footer = refs[selected].artifact.URL
}
return panel(m.width, height, []string{bar(title, right, inner, true)}, body, footer, true)
}
// artifactActionMsg reports the outcome of handing a URL to the opener or the
// clipboard, so a failure is surfaced instead of silently dropped.
type artifactActionMsg struct {
verb string
url string
err error
}
// openExternal and copyText are seams so tests can observe the resolved URL
// without launching a process or touching the system clipboard.
var (
openExternal = func(target string) error { return openerCommand(target).Run() }
copyText = clipboard.WriteAll
)
// openerCommand is the platform command that hands target to the system opener.
func openerCommand(target string) *exec.Cmd {
switch runtime.GOOS {
case "darwin":
return exec.Command("open", target)
case "windows":
return exec.Command("rundll32", "url.dll,FileProtocolHandler", target)
default:
return exec.Command("xdg-open", target)
}
}
// resolveArtifactURL resolves a server-relative artifact URL against the
// configured websocket server URL by mapping ws/wss to http/https and keeping
// host:port, mirroring the app's ServerUrl.resolveArtifactUrl; it never
// hardcodes a host. An already-absolute http(s) URL is returned unchanged, and
// a blank or invalid configuration fails.
func resolveArtifactURL(serverURL, artifactURL string) (string, bool) {
target := strings.TrimSpace(artifactURL)
if target == "" {
return "", false
}
if strings.HasPrefix(target, "http://") || strings.HasPrefix(target, "https://") {
return target, true
}
parsed, err := url.Parse(strings.TrimSpace(serverURL))
if err != nil || (parsed.Scheme != "ws" && parsed.Scheme != "wss") || parsed.Hostname() == "" {
return "", false
}
scheme := "http"
if parsed.Scheme == "wss" {
scheme = "https"
}
if !strings.HasPrefix(target, "/") {
target = "/" + target
}
return scheme + "://" + parsed.Host + target, true
}
func artifactURLAction(verb, serverURL string, artifact protocol.StageArtifact) tea.Cmd {
resolved, ok := resolveArtifactURL(serverURL, artifact.URL)
if !ok {
return func() tea.Msg {
return artifactActionMsg{verb: verb, err: fmt.Errorf("no server URL to resolve %q", artifact.Name)}
}
}
action := openExternal
if verb == "copy" {
action = copyText
}
return func() tea.Msg {
if err := action(resolved); err != nil {
return artifactActionMsg{verb: verb, url: resolved, err: err}
}
return artifactActionMsg{verb: verb, url: resolved}
}
}
func openArtifactCmd(serverURL string, artifact protocol.StageArtifact) tea.Cmd {
return artifactURLAction("open", serverURL, artifact)
}
func copyArtifactCmd(serverURL string, artifact protocol.StageArtifact) tea.Cmd {
return artifactURLAction("copy", serverURL, artifact)
}
+52
View File
@@ -0,0 +1,52 @@
package tui
import (
"context"
"encoding/json"
"os"
"strings"
"testing"
"git.a-wan.net/alan/pipelines/internal/protocol"
"github.com/charmbracelet/x/ansi"
)
// TestLiveArtifactsFromCapture renders the artifacts view from real
// `pipelines inspect RUN_ID --json` captures. It is env-gated and skips unless
// PIPELINES_ARTIFACT_CAPTURES names one or more capture files, so it never
// depends on a running server in CI; the operator points it at real captures to
// re-confirm that mixed artifact types, a partial capture, a running visit and
// a finished visit with none all render.
func TestLiveArtifactsFromCapture(t *testing.T) {
list := os.Getenv("PIPELINES_ARTIFACT_CAPTURES")
if strings.TrimSpace(list) == "" {
t.Skip("set PIPELINES_ARTIFACT_CAPTURES to comma-separated `pipelines inspect RUN_ID --json` files")
}
m := New(context.Background(), "ws://127.0.0.1:8080/connect")
m.width, m.height = 120, 60
var rendered strings.Builder
for _, path := range strings.Split(list, ",") {
path = strings.TrimSpace(path)
if path == "" {
continue
}
data, err := os.ReadFile(path)
if err != nil {
t.Fatal(err)
}
var detail protocol.RunDetail
if err := json.Unmarshal(data, &detail); err != nil {
t.Fatal(err)
}
m.runDetail = &detail
view := ansi.Strip(m.artifactsView(50))
t.Logf("capture %s (run #%d executing=%t):\n%s", path, detail.ID, detail.Executing, view)
rendered.WriteString(view)
}
text := rendered.String()
for _, want := range []string{"[img]", "partial capture", "capture pending", "not recorded for this visit", "image/png", "KiB"} {
if !strings.Contains(text, want) {
t.Errorf("live captures did not render %q", want)
}
}
}
+274
View File
@@ -0,0 +1,274 @@
package tui
import (
"context"
"fmt"
"strings"
"testing"
"git.a-wan.net/alan/pipelines/internal/protocol"
tea "github.com/charmbracelet/bubbletea"
"github.com/charmbracelet/x/ansi"
)
func artifactsFixtureModel() Model {
m := New(context.Background(), "ws://127.0.0.1:8080/connect")
m.width, m.height = 100, 30
m.runOpen = true
m.keys.runs = true
m.runDetailFocus = true
m.requestedRunID = 169
m.runDetail = &protocol.RunDetail{
RunSummary: protocol.RunSummary{ID: 169, Name: "demo", Version: 3, Status: "succeeded"},
Steps: []protocol.RunStep{
{Sequence: 1, Stage: "implementer", Status: "completed", Artifacts: []protocol.StageArtifact{
{Name: "build.log", SizeBytes: 2337, ContentType: "text/plain; charset=utf-8", URL: "/artifacts/169/1/build.log"},
}, ArtifactsSkipped: 1},
{Sequence: 2, Stage: "ui_reviewer", Status: "completed", Artifacts: []protocol.StageArtifact{
{Name: "01-pill.png", SizeBytes: 80544, ContentType: "image/png", URL: "/artifacts/169/2/01-pill.png"},
{Name: "morph.mp4", SizeBytes: 645782, ContentType: "video/mp4", URL: "/artifacts/169/2/morph.mp4"},
}},
{Sequence: 3, Stage: "committer", Status: "completed"},
{Sequence: 4, Stage: "reviewer", Status: "running"},
},
}
return m
}
func artifactKey(m Model, key rune) Model {
updated, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{key}})
return updated.(Model)
}
func TestRunArtifactVisitsGroupAndOrder(t *testing.T) {
steps := []protocol.RunStep{
{Sequence: 3, Stage: "build"},
{Sequence: 2, Stage: "plan"},
{Sequence: 1, Stage: "plan", Control: &protocol.ControlEvidence{Visit: 1}, Artifacts: []protocol.StageArtifact{{Name: "plan.md"}}},
}
visits := runArtifactVisits(steps)
want := []struct {
stage string
visit int
}{{"build", 1}, {"plan", 1}, {"plan", 2}}
if len(visits) != len(want) {
t.Fatalf("visits = %d, want %d", len(visits), len(want))
}
for i, w := range want {
if visits[i].stage != w.stage || visits[i].visit != w.visit {
t.Fatalf("visit %d = %s/%d, want %s/%d", i, visits[i].stage, visits[i].visit, w.stage, w.visit)
}
}
}
func TestArtifactsViewGroupsMarkersAndWording(t *testing.T) {
m := artifactsFixtureModel()
m.width = 120
view := ansi.Strip(m.artifactsView(24))
for _, want := range []string{
"implementer · visit 1",
"ui_reviewer · visit 1",
"committer · visit 1",
"reviewer · visit 1",
"Artifacts · 1 recorded · partial capture",
"1 files excluded from artifact capture.",
"Artifacts · 2 recorded",
"Artifacts · not recorded for this visit",
"Artifacts · capture pending",
"[img]",
"01-pill.png",
"morph.mp4",
"video/mp4",
"78.7 KiB",
"630.6 KiB",
"/artifacts/169/2/01-pill.png",
} {
if !strings.Contains(view, want) {
t.Fatalf("artifacts view missing %q:\n%s", want, view)
}
}
for _, line := range strings.Split(view, "\n") {
if strings.Contains(line, "morph.mp4") && strings.Contains(line, "[img]") {
t.Fatalf("non-image artifact marked as an image: %q", line)
}
}
}
func TestArtifactsViewColumnsAlign(t *testing.T) {
m := artifactsFixtureModel()
m.width = 120
lines := strings.Split(ansi.Strip(m.artifactsView(24)), "\n")
var image, video string
for _, line := range lines {
if strings.Contains(line, "01-pill.png") {
image = line
}
if strings.Contains(line, "morph.mp4") {
video = line
}
}
if image == "" || video == "" {
t.Fatalf("artifact rows not both rendered:\n%s", strings.Join(lines, "\n"))
}
name := strings.Index(image, "01-pill.png")
typeStart := strings.Index(image, "image/png")
sizeStart := strings.Index(image, "78.7 KiB")
if name != strings.Index(video, "morph.mp4") || name < 0 {
t.Fatalf("name column misaligned:\n%q\n%q", image, video)
}
if typeStart != strings.Index(video, "video/mp4") || typeStart < 0 {
t.Fatalf("type column misaligned:\n%q\n%q", image, video)
}
if sizeStart+len("78.7 KiB") != strings.Index(video, "630.6 KiB")+len("630.6 KiB") || sizeStart < 0 {
t.Fatalf("size column misaligned:\n%q\n%q", image, video)
}
}
func TestArtifactsViewNeverOverflows(t *testing.T) {
for _, width := range []int{160, 120, 80, 63, 40, 24, 12} {
m := artifactsFixtureModel()
m.width = width
for _, line := range strings.Split(m.artifactsView(24), "\n") {
if got := ansi.StringWidth(line); got > width {
t.Fatalf("width %d: line width %d: %q", width, got, line)
}
}
}
m := artifactsFixtureModel()
m.width = 40
view := ansi.Strip(m.artifactsView(24))
if !strings.Contains(view, "/artifacts/169/1/build.log") {
t.Fatalf("narrow view must keep the selected URL available:\n%s", view)
}
}
func TestArtifactsViewEmptyRun(t *testing.T) {
m := New(context.Background(), "ws://127.0.0.1:8080/connect")
m.width, m.height = 100, 24
m.runDetail = &protocol.RunDetail{RunSummary: protocol.RunSummary{ID: 5}}
view := ansi.Strip(m.artifactsView(20))
for _, want := range []string{"Artifacts · run #5", "No recorded visits yet.", "No artifacts recorded"} {
if !strings.Contains(view, want) {
t.Fatalf("empty artifacts view missing %q:\n%s", want, view)
}
}
}
func artifactsScrollFixture() (Model, []string) {
m := New(context.Background(), "ws://127.0.0.1:8080/connect")
m.width, m.height = 80, 14
m.runOpen = true
m.keys.runs = true
m.runDetailFocus = true
m.requestedRunID = 7
var steps []protocol.RunStep
names := make([]string, 0, 12)
for i := 0; i < 12; i++ {
name := fmt.Sprintf("shot-%02d.png", i)
names = append(names, name)
steps = append(steps, protocol.RunStep{Sequence: i + 1, Stage: "ui_reviewer", Status: "completed",
Artifacts: []protocol.StageArtifact{{Name: name, SizeBytes: 1024, ContentType: "image/png", URL: "/artifacts/7/" + name}}})
}
m.runDetail = &protocol.RunDetail{RunSummary: protocol.RunSummary{ID: 7}, Steps: steps}
m.artifactsOpen = true
return m, names
}
func TestArtifactsViewKeepsSelectionVisible(t *testing.T) {
m, names := artifactsScrollFixture()
for i := 0; i < len(names)-1; i++ {
m = artifactKey(m, 'j')
}
if view := ansi.Strip(m.View()); !strings.Contains(view, names[len(names)-1]) {
t.Fatalf("last artifact scrolled out of view:\n%s", view)
}
for i := 0; i < len(names)-1; i++ {
m = artifactKey(m, 'k')
}
if view := ansi.Strip(m.View()); !strings.Contains(view, names[0]) {
t.Fatalf("first artifact not visible after scrolling back:\n%s", view)
}
}
func TestArtifactsSelectByNameScrollsIntoView(t *testing.T) {
m, names := artifactsScrollFixture()
m.selectArtifactByName(names[len(names)-1])
if view := ansi.Strip(m.View()); !strings.Contains(view, names[len(names)-1]) {
t.Fatalf("selectArtifactByName did not scroll the match into view:\n%s", view)
}
}
func TestResolveArtifactURL(t *testing.T) {
cases := []struct {
server, artifact, want string
ok bool
}{
{"ws://127.0.0.1:8080/connect", "/artifacts/1/2/a.png", "http://127.0.0.1:8080/artifacts/1/2/a.png", true},
{"wss://host/connect", "/artifacts/1/2/a.png", "https://host/artifacts/1/2/a.png", true},
{"ws://host/connect", "artifacts/1/2/a.png", "http://host/artifacts/1/2/a.png", true},
{"ws://host/connect", "https://cdn.example/a.png", "https://cdn.example/a.png", true},
{"", "/artifacts/1/2/a.png", "", false},
{"http://host/connect", "/artifacts/1/2/a.png", "", false},
}
for _, tc := range cases {
got, ok := resolveArtifactURL(tc.server, tc.artifact)
if ok != tc.ok || got != tc.want {
t.Fatalf("resolveArtifactURL(%q, %q) = %q,%t want %q,%t", tc.server, tc.artifact, got, ok, tc.want, tc.ok)
}
}
}
func TestArtifactsViewOpenAndCopyKeys(t *testing.T) {
previousOpen, previousCopy := openExternal, copyText
defer func() { openExternal, copyText = previousOpen, previousCopy }()
var opened, copied string
openExternal = func(target string) error { opened = target; return nil }
copyText = func(text string) error { copied = text; return nil }
m := artifactsFixtureModel()
m = artifactKey(m, 'A')
if !m.artifactsOpen {
t.Fatal("A did not open the artifacts view")
}
if m.artifactIndex != 0 {
t.Fatalf("selection = %d, want the first artifact", m.artifactIndex)
}
updated, cmd := m.Update(tea.KeyMsg{Type: tea.KeyEnter})
m = updated.(Model)
if cmd == nil {
t.Fatal("Enter did not produce an open command")
}
updated, _ = m.Update(cmd())
m = updated.(Model)
if opened != "http://127.0.0.1:8080/artifacts/169/1/build.log" {
t.Fatalf("opened %q", opened)
}
m = artifactKey(m, 'j')
updated, cmd = m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'y'}})
m = updated.(Model)
if cmd == nil {
t.Fatal("y did not produce a copy command")
}
updated, _ = m.Update(cmd())
m = updated.(Model)
if copied != "http://127.0.0.1:8080/artifacts/169/2/01-pill.png" {
t.Fatalf("copied %q", copied)
}
if !strings.Contains(strings.Join(m.lines, "\n"), "Copied artifact URL") {
t.Fatalf("copy outcome not surfaced: %v", m.lines)
}
}
func TestArtifactsViewRenderedInRunDetail(t *testing.T) {
m := artifactsFixtureModel()
m.artifactsOpen = true
view := ansi.Strip(m.View())
if !strings.Contains(view, "Artifacts · run #169") {
t.Fatalf("run view did not render the artifacts view:\n%s", view)
}
if !strings.Contains(m.activeFooter(), "y copy URL") {
t.Fatalf("footer does not advertise the artifact controls: %q", m.activeFooter())
}
}
+6 -2
View File
@@ -15,6 +15,8 @@ func (m Model) activeFooter() string {
text = "Refreshing published state · draft retained"
case m.decisionOpen:
text = "↑/↓ choose · Tab feedback · Enter decide · Esc cancel"
case m.artifactsOpen:
text = "j/k select · Enter open · y copy URL · Esc back"
case m.actionConfirm != nil || m.mutationCommand != nil:
text = "y confirm · n/Esc cancel · j/k read"
case m.draftDeletingPath != "":
@@ -35,7 +37,7 @@ func (m Model) activeFooter() string {
case m.versionsOpen:
text = "↑/↓ choose · Enter view version · Esc back"
case m.paletteOpen && m.searchOpen:
text = "Type to search · ↑/↓ choose · Enter open · Esc cancel"
text = "Search pipelines, runs, steps, artifacts and text · ↑/↓ choose · Enter open · Esc cancel"
case m.paletteOpen:
text = "Type a command · ↑/↓ choose · Enter execute · Esc cancel"
case m.logOpen:
@@ -63,6 +65,8 @@ func (m Model) activeFooter() string {
text = "Refreshing · draft retained"
case m.decisionOpen:
text = "Esc cancel · Enter decide · ↑↓ select"
case m.artifactsOpen:
text = "Esc back · Enter open · y copy"
case m.actionConfirm != nil || m.mutationCommand != nil:
text = "Esc cancel · y confirm · j/k read"
case m.draftDeletingPath != "":
@@ -83,7 +87,7 @@ func (m Model) activeFooter() string {
case m.versionsOpen:
text = "Esc back · Enter view · ↑↓ select"
case m.paletteOpen && m.searchOpen:
text = "Esc back · Enter open · ↑↓ select"
text = "Esc cancel · Enter open · ↑↓ select"
case m.paletteOpen:
text = "Esc back · Enter run · ↑↓ select"
case m.logOpen:
+5
View File
@@ -374,6 +374,11 @@ func (m Model) updateLogs(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
return m, nil
}
// popup centres a dialog of at most preferredWidth (clamped to width-6) and
// truncates every line to that width so a modal cannot break the layout. Below
// roughly 20 columns the boxed dialog no longer fits, so popup falls back to the
// bare truncated lines without chrome; the TUI is designed for terminals at
// least 20 columns wide.
func popup(width, height, preferredWidth int, lines []string) string {
inner := min(preferredWidth, max(1, width-6))
for i := range lines {
+1 -1
View File
@@ -143,7 +143,7 @@ func TestHomeOnlyAdvertisesSearchAndCommands(t *testing.T) {
m.usage = &protocol.UsageStats{}
}
view := ansi.Strip(m.View())
for _, hint := range []string{"/ search", ": commands"} {
for _, hint := range []string{"/ omni search", ": commands"} {
if !strings.Contains(view, hint) {
t.Fatal("missing home hint", hint, view)
}
+9 -10
View File
@@ -57,23 +57,22 @@ func humanBytes(size int64) string {
return fmt.Sprintf("%.1f %ciB", float64(size)/float64(div), "KMGTPE"[exp])
}
// artifactLines lists one step's recorded artifacts (name and size) for the
// retained-evidence view, matching the file-changes style.
func artifactLines(step protocol.RunStep) []string {
// artifactCaptureNotes lists the partial-capture notes for one visit: one line
// per non-zero excluded/omitted count, and nothing when the capture was
// complete. A visit with no recorded artifacts yields no notes, mirroring the
// app's artifactCaptureNotes, so notes never accompany an empty-state summary.
func artifactCaptureNotes(step protocol.RunStep) []string {
if len(step.Artifacts) == 0 {
return nil
}
lines := []string{artifactsSummary(step)}
for _, artifact := range step.Artifacts {
lines = append(lines, fmt.Sprintf("%s · %s · %s", ansi.Strip(artifact.Name), humanBytes(artifact.SizeBytes), ansi.Strip(artifact.ContentType)))
}
var notes []string
if step.ArtifactsSkipped > 0 {
lines = append(lines, fmt.Sprintf("%d files excluded from artifact capture.", step.ArtifactsSkipped))
notes = append(notes, fmt.Sprintf("%d files excluded from artifact capture.", step.ArtifactsSkipped))
}
if step.ArtifactsTruncated > 0 {
lines = append(lines, fmt.Sprintf("%d files omitted by artifact capture limits.", step.ArtifactsTruncated))
notes = append(notes, fmt.Sprintf("%d files omitted by artifact capture limits.", step.ArtifactsTruncated))
}
return lines
return notes
}
func diffHighlight(line string) string {
+28 -4
View File
@@ -134,7 +134,8 @@ type Model struct {
commandIndex int
homeTop int
searchOpen bool
searchResults []protocol.SearchMatch
searchResults []protocol.SearchResult
searchText string
searchRequest string
searchInFlight bool
searchQueued bool
@@ -203,6 +204,9 @@ type Model struct {
decisionIndex int
decisionFeedback textinput.Model
decisionFeedbackFocus bool
artifactsOpen bool
artifactIndex int
artifactTop int
editorOpen bool
editorInput textinput.Model
editorIndex int
@@ -275,6 +279,17 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
m.appendLine("Harness debug: " + msg.err.Error())
}
return m, nil
case artifactActionMsg:
if msg.err != nil {
m.appendLine("Artifact " + msg.verb + ": " + msg.err.Error())
return m, nil
}
if msg.verb == "copy" {
m.appendLine("Copied artifact URL: " + msg.url)
} else {
m.appendLine("Opened artifact URL: " + msg.url)
}
return m, nil
case spinner.TickMsg:
var cmd tea.Cmd
m.runSpinner, cmd = m.runSpinner.Update(msg)
@@ -360,11 +375,12 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
m.statusRequest = ""
}
if msg.Type == protocol.SearchResults {
if msg.ID == m.searchRequest {
if msg.ID == m.searchRequest && msg.SearchResults != nil {
m.searchInFlight = false
m.searchResults = msg.Matches
m.searchResults = msg.SearchResults.Results
m.searchText = msg.SearchResults.Query
m.searchError = ""
m.commandIndex = min(m.commandIndex, max(0, len(msg.Matches)-1))
m.commandIndex = min(m.commandIndex, max(0, len(msg.SearchResults.Results)-1))
if m.searchQueued {
m.searchQueued = false
updated, cmd := m.requestSearch()
@@ -442,6 +458,7 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
m.searchInFlight = false
m.searchQueued = false
m.searchResults = nil
m.searchText = ""
m.searchError = msg.Error
}
} else if msg.Type == protocol.Submitted {
@@ -638,6 +655,9 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
if m.decisionOpen {
return m.updateDecision(msg)
}
if m.artifactsOpen {
return m.updateArtifacts(msg)
}
if m.runOpen && (msg.String() != ":" || m.runSearchOpen) {
return m.updateRuns(msg)
}
@@ -667,6 +687,7 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
m.commandInput = newInput()
if m.searchOpen {
m.searchResults = nil
m.searchText = ""
m.searchError = ""
m.commandInput.Placeholder = "Type to search…"
return m, m.commandInput.Focus()
@@ -845,6 +866,9 @@ func (m Model) View() string {
if m.decisionOpen {
content = m.decisionView(bodyHeight)
}
if m.artifactsOpen {
content = m.artifactsView(bodyHeight)
}
if m.mutationCommand != nil {
paragraphs := []string{"This opens a new session/editor and may modify a retained draft.", "Published definitions and previous run history are unchanged."}
if strings.Contains(m.mutationTitle, "debugging") {
+1 -1
View File
@@ -87,7 +87,7 @@ func TestLayoutResizes(t *testing.T) {
if !strings.HasPrefix(lines[0], "Pipelines ") || !strings.HasSuffix(lines[0], "127.0.0.1:8080") || lipgloss.Width(lines[0]) != size.Width {
t.Fatalf("invalid header: %q", lines[0])
}
if !strings.HasPrefix(lines[len(lines)-1], "/ search") || !strings.Contains(lines[len(lines)-1], ": commands") || !strings.Contains(lines[len(lines)-1], "● 20 NEW") {
if !strings.HasPrefix(lines[len(lines)-1], "/ omni search") || !strings.Contains(lines[len(lines)-1], ": commands") || !strings.Contains(lines[len(lines)-1], "● 20 NEW") {
t.Fatalf("invalid footer: %q", lines[len(lines)-1])
}
if strings.TrimSpace(lines[len(lines)-2]) != "" {
+25 -3
View File
@@ -17,6 +17,28 @@ import (
"git.a-wan.net/alan/pipelines/internal/server"
)
// typeSearch types into the omni popup, flushes the outgoing search request and
// reads the server response, so a test observes real server-side matches.
func typeSearch(t *testing.T, m Model, text string) Model {
t.Helper()
for _, r := range text {
updated, cmd := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{r}})
m = updated.(Model)
if cmd != nil {
if batch, ok := cmd().(tea.BatchMsg); ok {
for _, c := range batch {
if c != nil {
c()
}
}
}
}
updated, _ = m.Update(m.read()())
m = updated.(Model)
}
return m
}
func TestSearchVersionsAndEditSubmission(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
@@ -44,9 +66,9 @@ func TestSearchVersionsAndEditSubmission(t *testing.T) {
updated, read = m.Update(read())
m = updated.(Model)
m = press(m, "/")
m = press(m, "dmo")
if !m.searchOpen || !m.paletteOpen || len(m.searchMatches()) != 1 {
t.Fatal("omnisearch failed")
m = typeSearch(t, m, "demo")
if !m.searchOpen || !m.paletteOpen || len(m.searchResults) != 1 || m.searchResults[0].Kind != protocol.SearchKindPipeline {
t.Fatalf("omnisearch failed: %+v", m.searchResults)
}
updated, send := m.Update(tea.KeyMsg{Type: tea.KeyEnter})
m = updated.(Model)
+8 -3
View File
@@ -101,6 +101,9 @@ func (m *Model) closeRuns() {
m.runGraphFocus = false
m.runGraphTop = 0
m.runGraphPan = 0
m.artifactsOpen = false
m.artifactIndex = 0
m.artifactTop = 0
m.closeDecision()
}
@@ -552,7 +555,9 @@ func (m Model) runSectionLines(width int) []string {
}
var diff []string
if !m.runSectionClosed(runSectionFiles) {
diff = append(stageDiffLines(step), artifactLines(step)...)
// Artifacts have their own grouped view (A); this section is the
// observed workspace diff only.
diff = stageDiffLines(step)
}
content = append(content, diff)
for _, receipt := range step.Notifications {
@@ -646,7 +651,7 @@ func (m Model) runActions() string {
text += " · D debug"
}
if m.runDetail != nil {
text += " · a evidence"
text += " · a evidence · A artifacts"
}
if m.runDetail != nil && m.runDetail.Status == protocol.RunStatusWaiting {
text += " · c decide"
@@ -729,7 +734,7 @@ func (m Model) runsDetailsView(height int) string {
lines := m.runSectionLines(m.runDetailWidth())
page := max(0, innerHeight-5)
top := max(0, min(m.runTop, max(0, len(lines)-page)))
footerHint := "o result · d diff · s progress · i input · t evidence · m details"
footerHint := "o result · d diff · s progress · i input · t evidence · m details · A artifacts"
if r.Status == protocol.RunStatusWaiting {
footerHint += " · c decide"
}
+1 -1
View File
@@ -193,7 +193,7 @@ func TestRunningDurationAndOpenCodeEvidenceShortcut(t *testing.T) {
m := runInspectionModel()
m.runDetail.Steps[1].AgentActive = true
m = runKey(m, "a")
if m.runStepIndex != 2 || !m.runDetailFocus || m.runSectionClosed(3) || !m.runSectionClosed(0) {
if m.runStepIndex != 2 || !m.runDetailFocus || m.runSectionClosed(runSectionEvidence) || !m.runSectionClosed(runSectionProgress) {
t.Fatal("OpenCode evidence shortcut did not select active session")
}
view := ansi.Strip(strings.Join(m.runSectionLines(90), "\n"))
+13 -4
View File
@@ -322,10 +322,16 @@ func (m Model) updateRuns(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
return m.debugRun()
case "a":
return m.openOpenCodeEvidence()
case "A":
if m.runDetail != nil {
m.openArtifacts()
}
return m, nil
case "r":
return m.retrySelectedRun()
case "esc":
m.runGraphFocus = false
m.artifactsOpen = false
if m.runDetail != nil || m.requestedRunID > 0 || m.runStartRequest != "" {
m.runDetail = nil
m.requestedRunID = 0
@@ -400,18 +406,21 @@ func (m Model) updateRuns(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
}
case "s", "i", "o", "t", "m":
if m.runDetail != nil {
m.toggleRunSection(strings.Index("siotm", msg.String()))
if index, ok := runSectionForShortcut(msg.String()); ok {
m.toggleRunSection(index)
}
}
case "d":
if m.runDetail != nil {
m.runGraphFocus = false
m.runDetailFocus = true
_, focused := runFocusedSection(m.runSectionLines(m.runDetailWidth()), m.runTop)
if m.runSectionClosed(5) || focused == "File changes" {
m.toggleRunSection(5)
if m.runSectionClosed(runSectionFiles) || focused == runSections[runSectionFiles].Title {
m.toggleRunSection(runSectionFiles)
}
marker := "[" + runSections[runSectionFiles].Shortcut + "]"
for i, line := range m.runSectionLines(m.runDetailWidth()) {
if strings.HasPrefix(ansi.Strip(line), "[d]") {
if strings.HasPrefix(ansi.Strip(line), marker) {
m.runTop = i
break
}