diff --git a/internal/cli/app.go b/internal/cli/app.go index a0021d81..ad18710d 100644 --- a/internal/cli/app.go +++ b/internal/cli/app.go @@ -38,9 +38,10 @@ type options struct { option, feedback string output string conflict string + kind string all bool json, source, noOpen, yes, allow, createOnly, force, wait bool - version, expected int + version, expected, limit int timeout, waitTimeout time.Duration } @@ -101,6 +102,9 @@ func (a App) flags(command string) (*flag.FlagSet, *options) { f.DurationVar(&o.waitTimeout, "wait-timeout", 0, "Client limit for --wait after the run is admitted (0 waits until terminal); separate from per-request --timeout") case "runs": f.StringVar(&o.name, "pipeline", "", "Filter by exact pipeline name or ID") + case "search": + f.StringVar(&o.kind, "type", "", "Narrow to one kind: "+strings.Join(protocol.SearchKinds, ", ")) + f.IntVar(&o.limit, "limit", 0, "Maximum results (default 50, max 200)") case "retry": f.BoolVar(&o.yes, "yes", false, "Confirm retry without an interactive prompt") f.StringVar(&o.key, "request-key", "", "Idempotency key (default: generated unique key)") @@ -729,6 +733,37 @@ func (a App) Run(ctx context.Context, args []string) error { return err case "import": return a.importBundle(ctx, o, f.Args(), call) + case "search": + query := strings.Join(pos, " ") + if strings.TrimSpace(query) == "" { + return fmt.Errorf("search requires a query; use pipelines help search") + } + r, err := call(protocol.Message{Type: protocol.Search, Search: &protocol.SearchRequest{Query: query, Kind: o.kind, Limit: o.limit}}) + if err != nil { + return err + } + if r.SearchResults == nil { + return fmt.Errorf("server did not return search results; update pipelines-server") + } + if o.json { + return a.output(r.SearchResults) + } + if len(r.SearchResults.Results) == 0 { + fmt.Fprintln(a.Out, "No matches") + } + for _, hit := range r.SearchResults.Results { + // The shared Label renders every kind; the CLI additionally shows a + // text-field hit's snippet, which the TUI marks on its own line. + label := hit.Label() + if hit.Field != nil { + label += ": " + hit.Field.Snippet + } + fmt.Fprintf(a.Out, "%s\t%s\t%d\t%s\t%s\n", hit.Kind, hit.Target, hit.Score, hit.MatchedField, label) + } + if r.SearchResults.Truncated { + fmt.Fprintf(a.Err, "Results truncated (cap %d, scan bound %d bytes)\n", r.SearchResults.Cap, r.SearchResults.ScanBoundBytes) + } + return nil case "show", "versions": value, err := one() if err != nil { diff --git a/internal/pipeline/search.go b/internal/pipeline/search.go new file mode 100644 index 00000000..c35bbb41 --- /dev/null +++ b/internal/pipeline/search.go @@ -0,0 +1,669 @@ +package pipeline + +import ( + "context" + "database/sql" + "encoding/json" + "fmt" + "sort" + "strconv" + "strings" + "time" + + "git.a-wan.net/alan/pipelines/internal/protocol" +) + +// Search answers one ranked, bounded, read-only query over the existing tables. +// It scans no artifact contents and makes no follow-up calls: each kind runs at +// most one query, field text is decoded with decodeValues over a fixed scan +// budget, and ranking/tie-breaking happens in memory over the candidate set. +func (s *Store) Search(ctx context.Context, req protocol.SearchRequest, now time.Time) (*protocol.SearchResponse, error) { + kind := strings.TrimSpace(req.Kind) + if kind != "" && searchKindIndex(kind) < 0 { + return nil, fmt.Errorf("unknown search kind %q; use one of %s", req.Kind, strings.Join(protocol.SearchKinds, ", ")) + } + response := &protocol.SearchResponse{ + Query: req.Query, + Kind: kind, + Results: []protocol.SearchResult{}, + Cap: searchLimit(req.Limit), + ScanBoundBytes: protocol.SearchMaxScanBytes, + } + // An empty query is a well-defined no-op, never a match-everything scan. + if strings.TrimSpace(req.Query) == "" { + return response, nil + } + terms := parseSearchTerms(req.Query, now) + // A bare status word or date selects runs; it is never treated as body text. + selectorOnly := terms.Text == "" + + tx, err := s.db.BeginTx(ctx, &sql.TxOptions{ReadOnly: true}) + if err != nil { + return nil, err + } + defer tx.Rollback() + + var results []protocol.SearchResult + var scan searchScan + for i, candidate := range protocol.SearchKinds { + if kind != "" && searchKindIndex(kind) != i { + continue + } + if selectorOnly && candidate != protocol.SearchKindRun { + continue + } + var hits []protocol.SearchResult + var err error + switch candidate { + case protocol.SearchKindPipeline: + hits, err = searchPipelines(ctx, tx, terms, &scan) + case protocol.SearchKindVersion: + hits, err = searchVersions(ctx, tx, terms, &scan) + case protocol.SearchKindRun: + hits, err = searchRuns(ctx, tx, terms, &scan) + case protocol.SearchKindStep: + hits, err = searchSteps(ctx, tx, terms, &scan) + case protocol.SearchKindField: + hits, err = searchFields(ctx, tx, terms, &scan) + case protocol.SearchKindArtifact: + hits, err = searchArtifacts(ctx, tx, terms, &scan) + } + if err != nil { + return nil, err + } + results = append(results, hits...) + } + if err := tx.Commit(); err != nil { + return nil, err + } + response.ScannedSteps = scan.steps + response.ScannedBytes = scan.bytes + if scan.truncated { + response.Truncated = true + } + + sortSearchResults(results) + if len(results) > response.Cap { + results = results[:response.Cap] + response.Truncated = true + } + if results == nil { + results = []protocol.SearchResult{} + } + response.Results = results + return response, nil +} + +func searchKindIndex(kind string) int { + for i, k := range protocol.SearchKinds { + if k == kind { + return i + } + } + return -1 +} + +// searchLimit clamps a requested cap. Zero, negative or over-max requests fall +// back to the default or the maximum, so the cap is always enforced server-side. +func searchLimit(limit int) int { + if limit <= 0 { + return protocol.SearchDefaultLimit + } + if limit > protocol.SearchMaxLimit { + return protocol.SearchMaxLimit + } + return limit +} + +// searchTerms is the parsed query. Text carries free text; Status and the +// From/To window carry a bare status word or a date expression that selects runs. +type searchTerms struct { + Text string + Status string + HasDate bool + From time.Time + To time.Time +} + +// parseSearchTerms recognises a lone status word and a lone date expression and +// leaves everything else as free text, so ordinary words are never misread as a +// selector. Relative dates resolve against the injected now in its own location; +// the comparison window is converted to UTC to match the stored timestamps. +func parseSearchTerms(query string, now time.Time) searchTerms { + trimmed := strings.TrimSpace(query) + lower := strings.ToLower(trimmed) + for _, status := range protocol.SearchStatuses { + if lower == status { + return searchTerms{Status: status} + } + } + location := now.Location() + day := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, location) + switch lower { + case "today": + return dateTerms(day, day.AddDate(0, 0, 1)) + case "yesterday": + return dateTerms(day.AddDate(0, 0, -1), day) + case "this week": + // Monday 00:00 local is the start of the week. + start := day.AddDate(0, 0, -((int(day.Weekday()) + 6) % 7)) + return dateTerms(start, start.AddDate(0, 0, 7)) + } + if parsed, err := time.ParseInLocation("2006-01-02", trimmed, location); err == nil { + return dateTerms(parsed, parsed.AddDate(0, 0, 1)) + } + return searchTerms{Text: trimmed} +} + +func dateTerms(from, to time.Time) searchTerms { + return searchTerms{HasDate: true, From: from.UTC(), To: to.UTC()} +} + +const searchSQLTime = "2006-01-02 15:04:05" + +// searchStepJoin is the shared run_steps/step_control source and projections the +// step and field scans build on, so those queries cannot drift apart. +const ( + searchStepJoin = `FROM run_steps s LEFT JOIN step_control c ON c.run_id=s.run_id AND c.sequence=s.sequence` + searchStepEvidence = `COALESCE(c.evidence_json,'')` + searchStepRecency = `COALESCE(strftime('%Y-%m-%dT%H:%M:%SZ',s.started_at),'')` +) + +// searchRowBudget bounds how many raw rows one non-body kind scans before it +// stops and reports Truncated, so a LIKE scan over a very large table cannot +// scale without limit. Field text uses the separate SearchMaxScanSteps budget. +const searchRowBudget = 2000 + +// searchLike builds a case-insensitive substring pattern, escaping LIKE +// metacharacters so a query can never broaden the pattern. +func searchLike(text string) string { + escaped := strings.NewReplacer(`\`, `\\`, `%`, `\%`, `_`, `\_`).Replace(strings.ToLower(text)) + return "%" + escaped + "%" +} + +// searchTier ranks a "name" match: exact beats a substring. The third tier (a +// body-text match) is assigned by the caller. +func searchTier(value, text string) (int, bool) { + if text == "" { + return 0, false + } + if strings.EqualFold(value, text) { + return 3, true + } + if strings.Contains(strings.ToLower(value), strings.ToLower(text)) { + return 2, true + } + return 0, false +} + +func searchContains(value, text string) bool { + return text != "" && strings.Contains(strings.ToLower(value), strings.ToLower(text)) +} + +func sortSearchResults(results []protocol.SearchResult) { + sort.SliceStable(results, func(i, j int) bool { + a, b := results[i], results[j] + if a.Score != b.Score { + return a.Score > b.Score + } + if a.Recency != b.Recency { + return a.Recency > b.Recency + } + if a.Kind != b.Kind { + return a.Kind < b.Kind + } + return a.Target < b.Target + }) +} + +func searchPipelines(ctx context.Context, tx *sql.Tx, terms searchTerms, scan *searchScan) ([]protocol.SearchResult, error) { + if terms.Text == "" { + return nil, nil + } + rows, err := tx.QueryContext(ctx, `SELECT p.id,p.name,v.version,json_array_length(v.graph_json,'$.stages'),COALESCE(strftime('%Y-%m-%dT%H:%M:%SZ',v.created_at),'') +FROM pipelines p JOIN pipeline_versions v ON v.pipeline_id=p.id +WHERE v.version=(SELECT MAX(version) FROM pipeline_versions WHERE pipeline_id=p.id) +AND lower(p.name) LIKE ? ESCAPE '\' +ORDER BY p.name,p.id LIMIT ?`, searchLike(terms.Text), searchRowBudget+1) + if err != nil { + return nil, err + } + defer rows.Close() + var results []protocol.SearchResult + scanned := 0 + for rows.Next() { + if scanned == searchRowBudget { + scan.truncated = true + break + } + scanned++ + var id int64 + var name, recency string + var version, stages int + if err := rows.Scan(&id, &name, &version, &stages, &recency); err != nil { + return nil, err + } + score, ok := searchTier(name, terms.Text) + if !ok { + continue + } + results = append(results, protocol.SearchResult{ + Kind: protocol.SearchKindPipeline, Target: searchPipelineTarget(id), + Score: score, MatchedField: "name", Recency: recency, + Pipeline: &protocol.SearchPipeline{ID: id, Name: name, Version: version, Stages: stages}, + }) + } + return results, rows.Err() +} + +func searchVersions(ctx context.Context, tx *sql.Tx, terms searchTerms, scan *searchScan) ([]protocol.SearchResult, error) { + if terms.Text == "" { + return nil, nil + } + query := `SELECT v.pipeline_id,v.version,v.content_hash,COALESCE(strftime('%Y-%m-%dT%H:%M:%SZ',v.created_at),''),v.source +FROM pipeline_versions v WHERE lower(v.source) LIKE ? ESCAPE '\'` + args := []any{searchLike(terms.Text)} + var wanted int64 + numeric := false + if n, err := parsePositiveInt(terms.Text); err == nil { + query += " OR v.version=?" + args = append(args, n) + wanted, numeric = n, true + } + query += " ORDER BY v.pipeline_id,v.version DESC LIMIT ?" + args = append(args, searchRowBudget+1) + rows, err := tx.QueryContext(ctx, query, args...) + if err != nil { + return nil, err + } + defer rows.Close() + var results []protocol.SearchResult + scanned := 0 + for rows.Next() { + if scanned == searchRowBudget { + scan.truncated = true + break + } + scanned++ + var pipelineID int64 + var version int + var hash, recency, source string + if err := rows.Scan(&pipelineID, &version, &hash, &recency, &source); err != nil { + return nil, err + } + score, matched := 1, "source" + if numeric && int64(version) == wanted { + score, matched = 3, "version" + } else if !searchContains(source, terms.Text) { + continue + } + results = append(results, protocol.SearchResult{ + Kind: protocol.SearchKindVersion, Target: searchVersionTarget(pipelineID, version), + Score: score, MatchedField: matched, Recency: recency, + Version: &protocol.SearchVersion{PipelineID: pipelineID, Version: version, ContentHash: hash, CreatedAt: recency}, + }) + } + return results, rows.Err() +} + +func searchRuns(ctx context.Context, tx *sql.Tx, terms searchTerms, scan *searchScan) ([]protocol.SearchResult, error) { + // Reuse runSelect's join and timestamp projection rather than restating the + // run-row SELECT; only the fields search needs are added. + base := `SELECT r.id,p.name,r.status,r.workspace,` + runStamps + `,r.diagnostic ` + runFrom + var query string + var args []any + switch { + case terms.Status != "": + query = base + " WHERE r.status=?" + args = append(args, terms.Status) + case terms.HasDate: + query = base + " WHERE r.created_at>=? AND r.created_at= protocol.SearchMaxScanSteps { + scan.truncated = true + break + } + var runID int64 + var sequence int + var input, output, transcript, evidence, recency string + if err := rows.Scan(&runID, &sequence, &input, &output, &transcript, &evidence, &recency); err != nil { + return nil, err + } + size := len(input) + len(output) + len(transcript) + len(evidence) + if scan.bytes+size > protocol.SearchMaxScanBytes { + scan.truncated = true + break + } + scan.bytes += size + scan.steps++ + for _, field := range []struct { + name string + raw string + }{ + {name: "input", raw: input}, + {name: "output", raw: output}, + {name: "evidence", raw: evidence}, + } { + if field.raw == "" { + continue + } + var values map[string]any + // A malformed retained row cannot match anything, so it is skipped + // rather than failing the whole query and hiding every other hit. + if err := decodeValues(field.raw, &values); err != nil { + continue + } + text, ok := findMatch(values, terms.Text) + if !ok { + continue + } + results = append(results, protocol.SearchResult{ + Kind: protocol.SearchKindField, Target: searchFieldTarget(runID, sequence, field.name), + Score: 1, MatchedField: field.name, Recency: recency, + Field: &protocol.SearchField{RunID: runID, Sequence: sequence, Field: field.name, Snippet: searchSnippet(text, terms.Text)}, + }) + } + if searchContains(transcript, terms.Text) { + results = append(results, protocol.SearchResult{ + Kind: protocol.SearchKindField, Target: searchFieldTarget(runID, sequence, "transcript"), + Score: 1, MatchedField: "transcript", Recency: recency, + Field: &protocol.SearchField{RunID: runID, Sequence: sequence, Field: "transcript", Snippet: searchSnippet(transcript, terms.Text)}, + }) + } + } + return results, rows.Err() +} + +func searchArtifacts(ctx context.Context, tx *sql.Tx, terms searchTerms, scan *searchScan) ([]protocol.SearchResult, error) { + if terms.Text == "" { + return nil, nil + } + pattern := searchLike(terms.Text) + rows, err := tx.QueryContext(ctx, `SELECT a.run_id,a.sequence,a.artifacts_json,COALESCE(strftime('%Y-%m-%dT%H:%M:%SZ',r.created_at),'') +FROM step_artifacts a JOIN pipeline_runs r ON r.id=a.run_id +WHERE lower(a.artifacts_json) LIKE ? ESCAPE '\' +ORDER BY a.run_id DESC,a.sequence DESC LIMIT ?`, pattern, searchRowBudget+1) + if err != nil { + return nil, err + } + defer rows.Close() + var results []protocol.SearchResult + scanned := 0 + for rows.Next() { + if scanned == searchRowBudget { + scan.truncated = true + break + } + scanned++ + var runID int64 + var sequence int + var artifacts, recency string + if err := rows.Scan(&runID, &sequence, &artifacts, &recency); err != nil { + return nil, err + } + var evidence stageArtifactsEvidence + // A malformed retained row cannot match anything, so it is skipped + // rather than failing the whole query and hiding every other hit. + if err := json.Unmarshal([]byte(artifacts), &evidence); err != nil { + continue + } + for _, file := range evidence.Files { + score, matched := 1, "content_type" + if s, ok := searchTier(file.Name, terms.Text); ok { + score, matched = s, "name" + } else if !searchContains(file.ContentType, terms.Text) { + continue + } + results = append(results, protocol.SearchResult{ + Kind: protocol.SearchKindArtifact, Target: file.URL, + Score: score, MatchedField: matched, Recency: recency, + Artifact: &protocol.SearchArtifact{RunID: runID, Sequence: sequence, Name: file.Name, ContentType: file.ContentType, SizeBytes: file.SizeBytes, URL: file.URL}, + }) + } + } + return results, rows.Err() +} + +// findMatch walks decoded JSON values in a stable key order and returns the +// first string leaf containing the query, so a hit and its snippet are +// deterministic rather than map-iteration dependent. +func findMatch(value any, text string) (string, bool) { + switch typed := value.(type) { + case string: + if searchContains(typed, text) { + return typed, true + } + case map[string]any: + keys := make([]string, 0, len(typed)) + for key := range typed { + keys = append(keys, key) + } + sort.Strings(keys) + for _, key := range keys { + if match, ok := findMatch(typed[key], text); ok { + return match, true + } + } + case []any: + for _, item := range typed { + if match, ok := findMatch(item, text); ok { + return match, true + } + } + } + return "", false +} + +// searchSnippet reduces text to a single clean line and centers a short window +// on the first case-insensitive match, folding runes so UTF-8 boundaries are +// never split and the result is always well-formed. +func searchSnippet(text, query string) string { + normalized := protocol.NormalizeText(text) + runes := []rune(normalized) + index := protocol.RuneIndexFold(runes, []rune(query)) + if index < 0 { + return truncateRunes(normalized, 80) + } + const margin = 40 + start := index - margin + if start < 0 { + start = 0 + } + end := index + len([]rune(query)) + margin + if end > len(runes) { + end = len(runes) + } + snippet := string(runes[start:end]) + if start > 0 { + snippet = "…" + snippet + } + if end < len(runes) { + snippet = snippet + "…" + } + return snippet +} + +func truncateRunes(text string, limit int) string { + runes := []rune(text) + if len(runes) <= limit { + return text + } + return string(runes[:limit]) + "…" +} + +func searchPipelineTarget(id int64) string { return fmt.Sprintf("pipeline:%d", id) } + +func searchVersionTarget(id int64, version int) string { + return fmt.Sprintf("pipeline:%d:v%d", id, version) +} + +func searchRunTarget(id int64) string { return fmt.Sprintf("run:%d", id) } + +func searchStepTarget(id int64, sequence int) string { return fmt.Sprintf("run:%d:%d", id, sequence) } + +func searchFieldTarget(id int64, sequence int, field string) string { + return fmt.Sprintf("run:%d:%d:%s", id, sequence, field) +} + +func parsePositiveInt(text string) (int64, error) { + n, err := strconv.ParseInt(strings.TrimSpace(text), 10, 64) + if err != nil || n <= 0 { + return 0, fmt.Errorf("not a positive integer") + } + return n, nil +} + +func numericEqual(text string, id int64) bool { + n, err := parsePositiveInt(text) + return err == nil && n == id +} + +func durationSeconds(created, finished string) (float64, bool) { + start, err := time.Parse(time.RFC3339, created) + if err != nil { + return 0, false + } + end, err := time.Parse(time.RFC3339, finished) + if err != nil { + return 0, false + } + if end.Before(start) { + return 0, false + } + return end.Sub(start).Seconds(), true +} diff --git a/internal/protocol/search.go b/internal/protocol/search.go new file mode 100644 index 00000000..1a5ee7da --- /dev/null +++ b/internal/protocol/search.go @@ -0,0 +1,223 @@ +package protocol + +import ( + "fmt" + "unicode" +) + +// Search brokered by the Pipelines server: one query can find a pipeline, a +// pipeline version, a run, a recorded step/visit, the text of a step field +// (input/output/evidence/transcript) or a recorded artifact. A client sends +// Message{Type: Search, ID: , Search: } and the server +// echoes the ID with a SearchResults response, matching every other exchange. +const ( + Search = "search" + SearchResults = "search_results" +) + +// Search.Kind narrowing values. They are the only narrowing mechanism and are +// enforced server-side; an empty Kind searches every kind. +const ( + SearchKindPipeline = "pipeline" + SearchKindVersion = "version" + SearchKindRun = "run" + SearchKindStep = "step" + SearchKindField = "field" + SearchKindArtifact = "artifact" +) + +// SearchKinds is the accepted Kind vocabulary in display order; the CLI help +// and notes are kept in step with it. +var SearchKinds = []string{ + SearchKindPipeline, + SearchKindVersion, + SearchKindRun, + SearchKindStep, + SearchKindField, + SearchKindArtifact, +} + +// SearchStatuses is the accepted set of bare status words a query may name to +// select runs. It mirrors the run status vocabulary; a bare word selects runs +// rather than matching as free text. +var SearchStatuses = []string{"queued", "running", "succeeded", "failed", "canceled", "interrupted"} + +// Search budget and cap constants. They are fixed, enforced server-side and +// reported on SearchResponse so a client can see the bound that applied. +const ( + // SearchDefaultLimit is the result cap when a request omits Limit (or sends 0). + SearchDefaultLimit = 50 + // SearchMaxLimit is the largest accepted result cap; larger requests clamp. + SearchMaxLimit = 200 + // SearchMaxScanSteps bounds how many recorded steps one query inspects while + // scanning input/output/transcript field text. + SearchMaxScanSteps = 2000 + // SearchMaxScanBytes bounds the total field bytes (input_json + output_json + + // evidence_json + transcript) one query decodes and searches before it stops + // and reports Truncated. + SearchMaxScanBytes = 1 << 20 +) + +// SearchRequest is the search request body. Query is the free text, a bare +// status word or a date expression; Kind optionally narrows to one SearchKind; +// Limit caps the returned results (0 = server default). +type SearchRequest struct { + Query string `json:"query"` + Kind string `json:"kind,omitempty"` + Limit int `json:"limit,omitempty"` +} + +// SearchResponse is the ranked, bounded set of matches. Results are ordered by +// score, then recency, then a stable kind/target tie-break. Truncated reports +// that either the result cap or the field-scan budget dropped matches; +// ScannedSteps/ScannedBytes and ScanBoundBytes make the body-scan bound +// observable. +type SearchResponse struct { + Query string `json:"query"` + Kind string `json:"kind,omitempty"` + Results []SearchResult `json:"results"` + Truncated bool `json:"truncated,omitempty"` + ScannedSteps int `json:"scanned_steps"` + ScannedBytes int `json:"scanned_bytes"` + Cap int `json:"cap"` + ScanBoundBytes int `json:"scan_bound_bytes"` +} + +// SearchResult is one typed, navigable match. Kind selects which payload is +// set; Target is a stable token an existing CLI command can resolve +// (pipeline:, pipeline::v, run:, run::, +// run:::, or an artifact URL). Score and MatchedField +// expose the ranking tier and why the hit matched so a client can re-rank; +// Recency is the hit's sortable UTC timestamp. +type SearchResult struct { + Kind string `json:"kind"` + Target string `json:"target"` + Score int `json:"score"` + MatchedField string `json:"matched_field"` + Recency string `json:"recency,omitempty"` + Pipeline *SearchPipeline `json:"pipeline,omitempty"` + Version *SearchVersion `json:"version,omitempty"` + Run *SearchRun `json:"run,omitempty"` + Step *SearchStep `json:"step,omitempty"` + Field *SearchField `json:"field,omitempty"` + Artifact *SearchArtifact `json:"artifact,omitempty"` +} + +// SearchPipeline is a pipeline name/identity hit: its latest version and stage count. +type SearchPipeline struct { + ID int64 `json:"id"` + Name string `json:"name"` + Version int `json:"version"` + Stages int `json:"stages"` +} + +// SearchVersion is a pipeline version/source hit. +type SearchVersion struct { + PipelineID int64 `json:"pipeline_id"` + Version int `json:"version"` + ContentHash string `json:"content_hash"` + CreatedAt string `json:"created_at"` +} + +// SearchRun is a run identity/metadata hit. FinishedAt and DurationSeconds are +// omitted for a run without a recorded finish. +type SearchRun struct { + ID int64 `json:"id"` + PipelineName string `json:"pipeline_name"` + Status string `json:"status"` + Workspace string `json:"workspace,omitempty"` + CreatedAt string `json:"created_at"` + FinishedAt string `json:"finished_at,omitempty"` + DurationSeconds float64 `json:"duration_seconds,omitempty"` +} + +// SearchStep is a recorded step/visit hit. +type SearchStep struct { + RunID int64 `json:"run_id"` + Sequence int `json:"sequence"` + Stage string `json:"stage"` + Visit int `json:"visit,omitempty"` + Outcome string `json:"outcome,omitempty"` + Target string `json:"target,omitempty"` + Diagnostic string `json:"diagnostic,omitempty"` +} + +// SearchField is a stage input/output/evidence/transcript text hit with a +// snippet around the first match. +type SearchField struct { + RunID int64 `json:"run_id"` + Sequence int `json:"sequence"` + Field string `json:"field"` + Snippet string `json:"snippet"` +} + +// SearchArtifact is a recorded artifact hit; contents are never read, only the +// recorded metadata. +type SearchArtifact struct { + RunID int64 `json:"run_id"` + Sequence int `json:"sequence"` + Name string `json:"name"` + ContentType string `json:"content_type"` + SizeBytes int64 `json:"size_bytes"` + URL string `json:"url"` +} + +// Label is the compact human description of a hit, built from the result's +// typed payload rather than its target token, so it is the single definition +// shared by the CLI and the TUI. A text-field hit's snippet is deliberately not +// part of the label: the CLI appends it and the TUI renders it on its own +// marked line, so the two surfaces show the match differently without +// duplicating the per-kind dispatch. +func (r SearchResult) Label() string { + switch r.Kind { + case SearchKindPipeline: + if r.Pipeline != nil { + return fmt.Sprintf("%s · v%d · %d stages", r.Pipeline.Name, r.Pipeline.Version, r.Pipeline.Stages) + } + case SearchKindVersion: + if r.Version != nil { + return fmt.Sprintf("pipeline %d · v%d · %s", r.Version.PipelineID, r.Version.Version, r.Version.ContentHash) + } + case SearchKindRun: + if r.Run != nil { + return fmt.Sprintf("run %d · %s · %s", r.Run.ID, r.Run.PipelineName, r.Run.Status) + } + case SearchKindStep: + if r.Step != nil { + return fmt.Sprintf("run %d · step %d · %s · %s", r.Step.RunID, r.Step.Sequence, r.Step.Stage, r.Step.Outcome) + } + case SearchKindField: + if r.Field != nil { + return fmt.Sprintf("run %d · step %d · %s", r.Field.RunID, r.Field.Sequence, r.Field.Field) + } + case SearchKindArtifact: + if r.Artifact != nil { + return fmt.Sprintf("run %d · step %d · %s · %s", r.Artifact.RunID, r.Artifact.Sequence, r.Artifact.Name, r.Artifact.ContentType) + } + } + return r.Target +} + +// RuneIndexFold returns the rune index where query first matches text +// case-insensitively, or -1 when it does not. It folds runes rather than bytes +// so a caller never splits a UTF-8 boundary, and an empty query never matches. +// It is the single definition shared by server-side snippet windowing and the +// TUI's marker placement. +func RuneIndexFold(text, query []rune) int { + if len(query) == 0 || len(query) > len(text) { + return -1 + } + for i := 0; i+len(query) <= len(text); i++ { + match := true + for j := range query { + if unicode.ToLower(text[i+j]) != unicode.ToLower(query[j]) { + match = false + break + } + } + if match { + return i + } + } + return -1 +} diff --git a/internal/protocol/search_test.go b/internal/protocol/search_test.go new file mode 100644 index 00000000..642237ef --- /dev/null +++ b/internal/protocol/search_test.go @@ -0,0 +1,125 @@ +package protocol + +import ( + "encoding/json" + "strings" + "testing" +) + +func TestSearchRequestResponseRoundTrip(t *testing.T) { + request := Message{Type: Search, ID: "req-1", Search: &SearchRequest{Query: "release", Kind: SearchKindRun, Limit: 5}} + encoded, err := json.Marshal(request) + if err != nil { + t.Fatal(err) + } + var decoded Message + if err := json.Unmarshal(encoded, &decoded); err != nil { + t.Fatal(err) + } + if decoded.Type != Search || decoded.ID != "req-1" || decoded.Search == nil { + t.Fatalf("request envelope lost: %+v", decoded) + } + if decoded.Search.Query != "release" || decoded.Search.Kind != SearchKindRun || decoded.Search.Limit != 5 { + t.Fatalf("search request lost: %+v", decoded.Search) + } + + response := Message{Type: SearchResults, ID: "req-1", SearchResults: &SearchResponse{ + Query: "release", + Results: []SearchResult{{Kind: SearchKindPipeline, Target: "pipeline:1", Score: 3, MatchedField: "name", Pipeline: &SearchPipeline{ID: 1, Name: "release", Version: 2, Stages: 3}}}, + Cap: 50, + ScanBoundBytes: SearchMaxScanBytes, + }} + encoded, err = json.Marshal(response) + if err != nil { + t.Fatal(err) + } + var echoed Message + if err := json.Unmarshal(encoded, &echoed); err != nil { + t.Fatal(err) + } + if echoed.ID != "req-1" || echoed.Type != SearchResults || echoed.SearchResults == nil { + t.Fatalf("response envelope or ID echo lost: %+v", echoed) + } + got := echoed.SearchResults + if got.Query != "release" || got.Cap != 50 || got.ScanBoundBytes != SearchMaxScanBytes || len(got.Results) != 1 { + t.Fatalf("search response lost: %+v", got) + } + hit := got.Results[0] + if hit.Pipeline == nil || hit.Pipeline.Name != "release" || hit.Pipeline.Version != 2 || hit.Pipeline.Stages != 3 || hit.Score != 3 || hit.MatchedField != "name" || hit.Target != "pipeline:1" { + t.Fatalf("pipeline payload lost: %+v", hit) + } +} + +// TestRuneIndexFold pins the shared case-insensitive matcher used by both the +// server's snippet window and the TUI's marker, so it cannot drift per package. +func TestRuneIndexFold(t *testing.T) { + cases := []struct { + text, query string + want int + }{ + {text: "prefix café résumé", query: "CAFÉ", want: 7}, + {text: "Needle in a haystack", query: "needle", want: 0}, + {text: "absent", query: "xyz", want: -1}, + {text: "abc", query: "", want: -1}, + {text: "ab", query: "abc", want: -1}, + } + for _, tc := range cases { + if got := RuneIndexFold([]rune(tc.text), []rune(tc.query)); got != tc.want { + t.Fatalf("RuneIndexFold(%q, %q) = %d, want %d", tc.text, tc.query, got, tc.want) + } + } +} + +// TestSearchLabelPerKind pins the single per-kind label shared by the CLI and +// TUI, so the six-kind dispatch lives in one place. +func TestSearchLabelPerKind(t *testing.T) { + cases := []struct { + result SearchResult + want string + }{ + {SearchResult{Kind: SearchKindPipeline, Target: "pipeline:1", Pipeline: &SearchPipeline{Name: "demo", Version: 2, Stages: 3}}, "demo · v2 · 3 stages"}, + {SearchResult{Kind: SearchKindVersion, Target: "pipeline:1:v2", Version: &SearchVersion{PipelineID: 1, Version: 2, ContentHash: "abc"}}, "pipeline 1 · v2 · abc"}, + {SearchResult{Kind: SearchKindRun, Target: "run:7", Run: &SearchRun{ID: 7, PipelineName: "demo", Status: "succeeded"}}, "run 7 · demo · succeeded"}, + {SearchResult{Kind: SearchKindStep, Target: "run:7:2", Step: &SearchStep{RunID: 7, Sequence: 2, Stage: "reviewer", Outcome: "success"}}, "run 7 · step 2 · reviewer · success"}, + {SearchResult{Kind: SearchKindField, Target: "run:7:2:output", Field: &SearchField{RunID: 7, Sequence: 2, Field: "output", Snippet: "[needle] output"}}, "run 7 · step 2 · output"}, + {SearchResult{Kind: SearchKindArtifact, Target: "/artifacts/7/2/shot.png", Artifact: &SearchArtifact{RunID: 7, Sequence: 2, Name: "shot.png", ContentType: "image/png"}}, "run 7 · step 2 · shot.png · image/png"}, + // A result missing its typed payload falls back to the navigable target. + {SearchResult{Kind: SearchKindRun, Target: "run:9"}, "run:9"}, + } + for _, tc := range cases { + if got := tc.result.Label(); got != tc.want { + t.Fatalf("Label(%s %s) = %q, want %q", tc.result.Kind, tc.result.Target, got, tc.want) + } + } +} + +func TestSearchResultOmitsAbsentPayloadsAndEmptyKind(t *testing.T) { + encoded, err := json.Marshal(SearchResult{Kind: SearchKindRun, Target: "run:1", Score: 1, MatchedField: "status"}) + if err != nil { + t.Fatal(err) + } + for _, key := range []string{"pipeline", "version", "run", "step", "field", "artifact", "recency"} { + if strings.Contains(string(encoded), `"`+key+`":`) { + t.Fatalf("absent %s payload must be omitted: %s", key, encoded) + } + } + var decoded SearchResult + if err := json.Unmarshal([]byte(`{"kind":"run","target":"run:1","score":1,"matched_field":"status"}`), &decoded); err != nil { + t.Fatal(err) + } + if decoded.Pipeline != nil || decoded.Version != nil || decoded.Run != nil || decoded.Step != nil || decoded.Field != nil || decoded.Artifact != nil { + t.Fatalf("absent payloads must decode nil: %+v", decoded) + } + + response := Message{Type: SearchResults, ID: "x", SearchResults: &SearchResponse{Query: "q", Results: []SearchResult{}}} + encoded, err = json.Marshal(response) + if err != nil { + t.Fatal(err) + } + if strings.Contains(string(encoded), `"kind"`) { + t.Fatalf("empty response kind must be omitted: %s", encoded) + } + if !strings.Contains(string(encoded), `"results":[]`) { + t.Fatalf("results must always be present: %s", encoded) + } +} diff --git a/internal/tui/pipeline.go b/internal/tui/pipeline.go index bcd18b55..5815d823 100644 --- a/internal/tui/pipeline.go +++ b/internal/tui/pipeline.go @@ -7,7 +7,7 @@ import ( tea "github.com/charmbracelet/bubbletea" "github.com/charmbracelet/lipgloss" - "github.com/sahilm/fuzzy" + "github.com/charmbracelet/x/ansi" "git.a-wan.net/alan/pipelines/internal/draft" "git.a-wan.net/alan/pipelines/internal/pipeline" @@ -19,29 +19,57 @@ func selectionWindow(count, index, capacity int) (int, int) { return start, min(count, start+capacity) } -func (m Model) searchMatches() []protocol.PipelineSummary { - query := strings.TrimPrefix(strings.TrimSpace(m.commandInput.Value()), "/") - if query == "" { - return m.pipelines +// searchNav remembers the step and section to focus once an asynchronously +// requested run arrives, so Enter on a step/artifact/field match lands exactly +// where it matched. +type searchNav struct { + runID int64 + sequence int + section int + artifact string +} + +// requestSearch asks the server for the current query. At most one request is in +// flight: a keystroke while a request is outstanding is coalesced and the latest +// text is sent when the response arrives. Stale responses are dropped by ID, so +// no keystroke triggers overlapping or unbounded scans. The server owns parsing +// (status words, dates and the optional kind filter), so the client sends the +// raw text and needs no second matcher. +func (m Model) requestSearch() (tea.Model, tea.Cmd) { + query := strings.TrimSpace(m.commandInput.Value()) + if m.conn == nil { + m.searchResults = nil + m.searchText = "" + return m, nil } - names := make([]string, len(m.pipelines)) - for i, p := range m.pipelines { - names[i] = p.Name + if m.searchInFlight { + m.searchQueued = true + return m, nil } - result := []protocol.PipelineSummary{} - for _, match := range fuzzy.Find(query, names) { - result = append(result, m.pipelines[match.Index]) - } - return result + m.nextID++ + m.searchRequest = strconv.FormatUint(m.nextID, 10) + m.searchInFlight = true + m.searchError = "" + return m, m.send(protocol.Message{Type: protocol.Search, ID: m.searchRequest, Search: &protocol.SearchRequest{Query: query}}) +} + +func (m *Model) closeSearch() { + m.paletteOpen = false + m.searchOpen = false + m.keys.palette = false + m.searchResults = nil + m.searchText = "" + m.searchRequest = "" + m.searchInFlight = false + m.searchQueued = false + m.searchError = "" } func (m Model) updateSearch(msg tea.KeyMsg) (tea.Model, tea.Cmd) { - items := m.searchMatches() + items := m.searchResults switch msg.String() { case "esc": - m.paletteOpen = false - m.searchOpen = false - m.keys.palette = false + m.closeSearch() return m, nil case "down", "ctrl+n": m.commandIndex = min(m.commandIndex+1, max(0, len(items)-1)) @@ -53,35 +81,235 @@ func (m Model) updateSearch(msg tea.KeyMsg) (tea.Model, tea.Cmd) { if len(items) == 0 { return m, nil } - selected := items[min(m.commandIndex, len(items)-1)] - m.paletteOpen = false - m.searchOpen = false - m.keys.palette = false - return m.requestPipeline(selected.ID, 0) + return m.openSearchResult(items[min(m.commandIndex, len(items)-1)]) } var cmd tea.Cmd m.commandInput, cmd = m.commandInput.Update(msg) m.commandIndex = 0 - return m, cmd + updated, send := m.requestSearch() + return updated, tea.Batch(cmd, send) +} + +// openSearchResult navigates straight to a result: a pipeline/version opens its +// detail, and a run/step/artifact/field match opens the run with that step and +// section selected once the run arrives. +func (m Model) openSearchResult(result protocol.SearchResult) (tea.Model, tea.Cmd) { + m.closeSearch() + switch result.Kind { + case protocol.SearchKindPipeline: + if result.Pipeline != nil { + return m.requestPipeline(result.Pipeline.ID, result.Pipeline.Version) + } + case protocol.SearchKindVersion: + if result.Version != nil { + return m.requestPipeline(result.Version.PipelineID, result.Version.Version) + } + } + runID, sequence, field, artifact := searchResultTarget(result) + if runID <= 0 { + return m, nil + } + m.closeRuns() + m.runOpen = true + m.keys.runs = true + m.runIndex = 0 + nav := &searchNav{runID: runID, sequence: sequence, section: runSectionNone} + switch result.Kind { + case protocol.SearchKindStep: + nav.section = runSectionProgress + case protocol.SearchKindField: + nav.section = sectionForField(field) + case protocol.SearchKindArtifact: + // Artifacts have their own grouped view; open it with the matched entry + // selected so the operator can open or copy its URL. + nav.section = runSectionNone + nav.artifact = artifact + } + m.pendingRunNav = nav + return m.runRequest(protocol.Message{Type: protocol.GetRun, RunID: runID}) +} + +// searchResultTarget returns the run, step, field and artifact a result points +// at, read from its typed payload rather than re-parsing the target token. +func searchResultTarget(result protocol.SearchResult) (runID int64, sequence int, field, artifact string) { + switch result.Kind { + case protocol.SearchKindRun: + if result.Run != nil { + runID = result.Run.ID + } + case protocol.SearchKindStep: + if result.Step != nil { + runID, sequence = result.Step.RunID, result.Step.Sequence + } + case protocol.SearchKindField: + if result.Field != nil { + runID, sequence, field = result.Field.RunID, result.Field.Sequence, result.Field.Field + } + case protocol.SearchKindArtifact: + if result.Artifact != nil { + runID, sequence, artifact = result.Artifact.RunID, result.Artifact.Sequence, result.Artifact.Name + } + } + return runID, sequence, field, artifact +} + +func sectionForField(field string) int { + switch field { + case "input": + return runSectionInput + case "output": + return runSectionResult + case "evidence", "transcript": + return runSectionEvidence + default: + return runSectionDetails + } +} + +// applyRunNav selects the matched step and scrolls to the matched section. +func (m *Model) applyRunNav(nav searchNav) { + if m.runDetail == nil { + return + } + if nav.sequence > 0 { + for i, step := range m.runDetail.Steps { + if step.Sequence == nav.sequence { + m.selectRunStep(i + 1) + break + } + } + } + if nav.section != runSectionNone { + m.runGraphFocus = false + m.runDetailFocus = true + m.focusRunSection(nav.section) + } + if nav.section == runSectionNone && nav.artifact != "" { + m.openArtifacts() + m.selectArtifactByName(nav.artifact) + } +} + +// focusRunSection opens the section and scrolls the run detail to its header, +// reusing the same shortcut markers runSectionLines renders. +func (m *Model) focusRunSection(section int) { + if m.runDetail == nil || section < 0 || section >= runSectionCount { + return + } + if m.runCollapsed == nil { + m.runCollapsed = map[string]bool{} + } + m.runCollapsed[m.runSectionKey(section)] = false + marker := "[" + runSections[section].Shortcut + "]" + for i, line := range m.runSectionLines(m.runDetailWidth()) { + if strings.HasPrefix(ansi.Strip(line), marker) { + m.runTop = i + return + } + } +} + +// searchBadge is the short type label a result shows. A pipeline version folds +// into the pipeline badge and a body-text field into the match badge, so the +// row reads the way the operator thinks about it rather than the wire kind. +func searchBadge(kind string) string { + switch kind { + case protocol.SearchKindVersion: + return "pipeline" + case protocol.SearchKindField: + return "match" + default: + return kind + } +} + +// markedSnippet brackets the first case-insensitive occurrence of query in a +// field snippet so the matched part is distinguishable without relying on +// colour, then clips the result to budget runes with the bracketed match kept +// inside the window. It tracks the exact marker span it inserts, so a snippet +// that itself contains '[' cannot make the window centre on the wrong bracket. +// The server centres the snippet on the match, so the text is present +// case-insensitively; the snippet is shown unchanged when it is not. The budget +// excludes the row's two-rune indent, since the result is clipped before the +// row is styled. +func markedSnippet(snippet, query string, budget int) string { + runes := []rune(snippet) + needle := []rune(strings.TrimSpace(query)) + if len(needle) == 0 || len(runes) == 0 { + return snippet + } + at := protocol.RuneIndexFold(runes, needle) + if at < 0 { + return snippet + } + marked := string(runes[:at]) + "[" + string(runes[at:at+len(needle)]) + "]" + string(runes[at+len(needle):]) + markedRunes := []rune(marked) + if budget <= 0 || len(markedRunes) <= budget { + return marked + } + // The inserted '[' sits at rune `at` and the ']' at at+len(needle)+1, so the + // span to keep in view is [at, at+len(needle)+2). + spanStart, spanEnd := at, at+len(needle)+2 + if spanEnd-spanStart >= budget { + return string(markedRunes[:budget]) + } + lo := max(0, spanStart-(budget-(spanEnd-spanStart))/2) + hi := min(len(markedRunes), lo+budget) + lo = max(0, hi-budget) + out := string(markedRunes[lo:hi]) + if lo > 0 { + out = "…" + out + } + if hi < len(markedRunes) { + out += "…" + } + return out +} + +// searchRowLines renders one result. A body-text match keeps its (windowed) +// snippet on its own indented line so the marker is visible at the popup width +// instead of being clipped after a long badge and label. +func searchRowLines(result protocol.SearchResult, query string, snippetBudget int) []string { + head := "[" + searchBadge(result.Kind) + "] " + result.Label() + if result.Kind == protocol.SearchKindField && result.Field != nil && result.Field.Snippet != "" { + return []string{head, " " + markedSnippet(result.Field.Snippet, query, snippetBudget)} + } + return []string{head} } func (m Model) searchView(height int) string { field := m.commandInput - field.Width = max(1, min(54, m.width-10)) - lines := []string{"Search pipelines", field.View(), ""} - items := m.searchMatches() - if len(items) == 0 { - lines = append(lines, "No matching pipelines") + field.Width = max(1, min(64, m.width-10)) + inner := min(72, max(1, m.width-6)) + snippetBudget := max(8, inner-4) + lines := []string{"Search", field.View(), ""} + items := m.searchResults + query := strings.TrimSpace(m.commandInput.Value()) + switch { + case m.searchError != "": + lines = append(lines, "Search failed: "+m.searchError) + case len(items) == 0 && m.searchInFlight: + lines = append(lines, "Searching…") + case len(items) == 0 && query != "": + lines = append(lines, "No matches for "+query) + case len(items) == 0: + lines = append(lines, "Type to search pipelines, runs, steps, text and artifacts.") } - start, end := selectionWindow(len(items), m.commandIndex, max(1, height-5)) + // A field match renders two lines, so budget the window by rendered lines. + start, end := selectionWindow(len(items), m.commandIndex, max(1, (height-4)/2)) for i := start; i < end; i++ { prefix := " " if i == m.commandIndex { prefix = "› " } - lines = append(lines, menuOption(fmt.Sprintf("%s%s · v%d · %d stages", prefix, items[i].Name, items[i].Version, items[i].Stages), i == m.commandIndex)) + for j, row := range searchRowLines(items[i], m.searchText, snippetBudget) { + if j == 0 { + row = prefix + row + } + lines = append(lines, menuOption(row, i == m.commandIndex)) + } } - return popup(m.width, height, 64, lines) + return popup(m.width, height, 72, lines) } func (m Model) requestPipeline(id int64, version int) (tea.Model, tea.Cmd) { diff --git a/internal/tui/search_live_test.go b/internal/tui/search_live_test.go new file mode 100644 index 00000000..7bd62a21 --- /dev/null +++ b/internal/tui/search_live_test.go @@ -0,0 +1,149 @@ +package tui + +import ( + "context" + "os" + "strconv" + "testing" + "time" + + tea "github.com/charmbracelet/bubbletea" + "github.com/charmbracelet/x/ansi" + + "git.a-wan.net/alan/pipelines/internal/protocol" +) + +// TestLiveOmniSearchAgainstServer is an env-gated check against a running +// server: it drives the TUI's own '/' search, renders the popup, and presses +// Enter on a live result of each kind, reporting where navigation lands. It +// skips unless PIPELINES_LIVE_SEARCH is set so CI never needs a server. +func TestLiveOmniSearchAgainstServer(t *testing.T) { + if os.Getenv("PIPELINES_LIVE_SEARCH") == "" { + t.Skip("set PIPELINES_LIVE_SEARCH=1 to query the running server") + } + url := os.Getenv("PIPELINES_URL") + if url == "" { + url = "ws://127.0.0.1:8080/connect" + } + ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second) + defer cancel() + m := New(ctx, url) + m.width, m.height = 120, 40 + connected := m.connect()().(connectedMsg) + defer connected.conn.CloseNow() + updated, _ := m.Update(connected) + m = updated.(Model) + + // Plain-text (never a type prefix) candidates per kind. The live store keeps + // changing as runs land, so a fixed query can stop matching a kind; the test + // uses the first candidate that still returns the kind it is checking. + candidates := map[string][]string{ + protocol.SearchKindPipeline: {"demo", "pipeline", "test", "a"}, + protocol.SearchKindVersion: {"1", "demo", "review", "test"}, + protocol.SearchKindRun: {"succeeded", "failed", "running", "1"}, + protocol.SearchKindStep: {"implementer", "reviewer", "planner", "success"}, + protocol.SearchKindField: {"identity", "search", "error", "the"}, + protocol.SearchKindArtifact: {"identity", "png", "log", "txt"}, + } + for _, kind := range protocol.SearchKinds { + picked, query := -1, "" + for _, candidate := range candidates[kind] { + m = resetLiveSearch(m) + m = liveType(m, tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'/'}}) + m = liveType(m, tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune(candidate)}) + m = drainLiveSearch(t, m) + query = candidate + picked = -1 + for i, result := range m.searchResults { + if result.Kind == kind { + picked = i + break + } + } + if picked >= 0 { + break + } + } + if picked < 0 { + t.Errorf("%s: no candidate query returned a %s result", kind, kind) + continue + } + m.commandIndex = picked + view := ansi.Strip(m.searchView(20)) + t.Logf("%s: query %q rendered\n%s", kind, query, view) + + updated, _ = m.Update(tea.KeyMsg{Type: tea.KeyEnter}) + m = updated.(Model) + if where := liveNavigation(m); where == "" { + t.Errorf("%s: Enter did not navigate (result %+v)", kind, m.searchResults[picked]) + } else { + t.Logf("%s: Enter navigates to %s", kind, where) + } + } +} + +// liveType delivers one key and runs any command it produced (a text-input +// update or a search request written to the socket), mirroring the real +// bubbletea loop. +func liveType(m Model, msg tea.Msg) Model { + updated, cmd := m.Update(msg) + m = updated.(Model) + if cmd == nil { + return m + } + if batch, ok := cmd().(tea.BatchMsg); ok { + for _, c := range batch { + if c != nil { + c() + } + } + } + return m +} + +// drainLiveSearch reads server frames until the outstanding search request is +// answered, so a slow or interleaved reply is still observed. +func drainLiveSearch(t *testing.T, m Model) Model { + t.Helper() + for i := 0; i < 100; i++ { + if !m.searchInFlight { + return m + } + updated, _ := m.Update(m.read()()) + m = updated.(Model) + } + t.Fatalf("timed out waiting for the search reply") + return m +} + +// resetLiveSearch returns the model to the home screen with no overlay, ready +// for the next '/' query. +func resetLiveSearch(m Model) Model { + m.closeSearch() + m.closeRuns() + m.keys.detail = false + m.detail = nil + m.detailLoading = false + m.requestedPipelineID = 0 + m.requestedVersion = 0 + m.artifactsOpen = false + return m +} + +// liveNavigation describes where the last Enter landed, read from the same +// state the views use. +func liveNavigation(m Model) string { + switch { + case m.detailLoading: + return "pipeline detail #" + strconv.FormatInt(m.requestedPipelineID, 10) + case m.runOpen && m.pendingRunNav != nil && m.pendingRunNav.artifact != "": + return "run #" + strconv.FormatInt(m.pendingRunNav.runID, 10) + " artifacts (" + m.pendingRunNav.artifact + ")" + case m.runOpen && m.pendingRunNav != nil && m.pendingRunNav.section >= 0: + return "run #" + strconv.FormatInt(m.pendingRunNav.runID, 10) + " section " + runSections[m.pendingRunNav.section].Title + case m.runOpen && m.pendingRunNav != nil: + return "run #" + strconv.FormatInt(m.pendingRunNav.runID, 10) + " detail" + case m.artifactsOpen: + return "artifacts view" + } + return "" +} diff --git a/internal/tui/search_test.go b/internal/tui/search_test.go new file mode 100644 index 00000000..bc65cef0 --- /dev/null +++ b/internal/tui/search_test.go @@ -0,0 +1,236 @@ +package tui + +import ( + "context" + "strings" + "testing" + + tea "github.com/charmbracelet/bubbletea" + "github.com/charmbracelet/x/ansi" + "github.com/coder/websocket" + + "git.a-wan.net/alan/pipelines/internal/protocol" +) + +// searchFixtureModel renders the omni popup over a fixed, mixed result set so +// the badges, labels and marked snippet are asserted without a server. +func searchFixtureModel() Model { + m := New(context.Background(), "ws://localhost/connect") + m.width, m.height = 100, 30 + m.conn = &websocket.Conn{} + m.paletteOpen = true + m.searchOpen = true + m.keys.palette = true + m.searchText = "needle" + m.searchResults = []protocol.SearchResult{ + {Kind: protocol.SearchKindPipeline, Target: "pipeline:1", Pipeline: &protocol.SearchPipeline{ID: 1, Name: "demo", Version: 2, Stages: 3}}, + {Kind: protocol.SearchKindRun, Target: "run:7", Run: &protocol.SearchRun{ID: 7, PipelineName: "demo", Status: "succeeded"}}, + {Kind: protocol.SearchKindStep, Target: "run:7:1", Step: &protocol.SearchStep{RunID: 7, Sequence: 1, Stage: "reviewer"}}, + {Kind: protocol.SearchKindArtifact, Target: "/artifacts/7/1/shot.png", Artifact: &protocol.SearchArtifact{RunID: 7, Sequence: 1, Name: "shot.png", URL: "/artifacts/7/1/shot.png"}}, + {Kind: protocol.SearchKindField, Target: "run:7:1:output", Field: &protocol.SearchField{RunID: 7, Sequence: 1, Field: "output", Snippet: "…needle output…"}}, + } + return m +} + +func TestOmniSearchShowsBadgesAndMarkedSnippet(t *testing.T) { + m := searchFixtureModel() + view := ansi.Strip(m.searchView(20)) + for _, badge := range []string{"[pipeline]", "[run]", "[step]", "[artifact]", "[match]"} { + if !strings.Contains(view, badge) { + t.Fatalf("missing badge %q in %q", badge, view) + } + } + if !strings.Contains(view, "[needle]") { + t.Fatalf("field snippet match must be marked without colour: %q", view) + } +} + +// TestOmniSearchRealSnippetMarkerVisible guards the regression where a body +// match's snippet centres the token ~60 runes in, so a single-line +// "[match] label · snippet" row was clipped and the marker was invisible at +// every realistic width. The snippet is rendered on its own windowed line. +func TestOmniSearchRealSnippetMarkerVisible(t *testing.T) { + body := strings.Repeat("backgroundcontext ", 6) + "needle output" + for _, width := range []int{80, 100} { + m := searchFixtureModel() + m.width = width + m.searchResults[4].Field.Snippet = body + view := ansi.Strip(m.View()) + if !strings.Contains(view, "[needle]") { + t.Fatalf("width %d: matched span not visible after ansi.Strip: %q", width, view) + } + } +} + +// TestOmniSearchSnippetWithOwnBracket guards the regression where the window +// located the marker by the first '[' in the marked snippet. A snippet that +// itself contains a '[' before the match (common in code/log evidence) centred +// the window on the wrong bracket and clipped the real "[match]" span, so the +// match became indistinguishable without colour. +func TestOmniSearchSnippetWithOwnBracket(t *testing.T) { + m := searchFixtureModel() + m.width = 100 + m.searchResults[4].Field.Snippet = "[x] " + strings.Repeat("word ", 30) + "needle" + view := ansi.Strip(m.View()) + if !strings.Contains(view, "[needle]") { + t.Fatalf("real bracket pair must survive a snippet that contains '[': %q", view) + } +} + +func TestOmniSearchEmptyStates(t *testing.T) { + t.Run("empty query", func(t *testing.T) { + m := searchFixtureModel() + m.searchResults = nil + if view := ansi.Strip(m.searchView(20)); !strings.Contains(view, "Type to search") { + t.Fatalf("empty query must prompt: %q", view) + } + }) + t.Run("no matches", func(t *testing.T) { + m := searchFixtureModel() + m.searchResults = nil + m.commandInput.SetValue("zzz") + view := ansi.Strip(m.searchView(20)) + if !strings.Contains(view, "No matches for zzz") || strings.Contains(view, "Type to search") { + t.Fatalf("non-empty query with no results must say so: %q", view) + } + }) + t.Run("error", func(t *testing.T) { + m := searchFixtureModel() + m.searchResults = nil + m.commandInput.SetValue("zzz") + m.searchError = "boom" + view := ansi.Strip(m.searchView(20)) + if !strings.Contains(view, "Search failed: boom") { + t.Fatalf("failed search must be distinct from no matches: %q", view) + } + }) + t.Run("in flight", func(t *testing.T) { + m := searchFixtureModel() + m.searchResults = nil + m.commandInput.SetValue("zz") + m.searchInFlight = true + if view := ansi.Strip(m.searchView(20)); !strings.Contains(view, "Searching…") { + t.Fatalf("outstanding request must show progress: %q", view) + } + }) +} + +func TestOmniSearchEscCancels(t *testing.T) { + m := searchFixtureModel() + updated, _ := m.Update(tea.KeyMsg{Type: tea.KeyEsc}) + m = updated.(Model) + if m.searchOpen || m.paletteOpen || m.searchResults != nil { + t.Fatal("Esc must cancel and clear the omni popup") + } +} + +func TestOmniSearchDropsStaleResponses(t *testing.T) { + m := searchFixtureModel() + m.searchResults = nil + m.searchRequest = "2" + updated, _ := m.Update(receivedMsg{Type: protocol.SearchResults, ID: "1", SearchResults: &protocol.SearchResponse{Results: []protocol.SearchResult{{Kind: protocol.SearchKindRun}}}}) + m = updated.(Model) + if len(m.searchResults) != 0 { + t.Fatal("stale search response replaced current results") + } + updated, _ = m.Update(receivedMsg{Type: protocol.SearchResults, ID: "2", SearchResults: &protocol.SearchResponse{Query: "demo", Results: []protocol.SearchResult{{Kind: protocol.SearchKindRun}}}}) + m = updated.(Model) + if len(m.searchResults) != 1 || m.searchText != "demo" { + t.Fatal("matching search response was dropped or its query not retained") + } +} + +func TestOmniSearchEnterNavigatesByKind(t *testing.T) { + detail := &protocol.RunDetail{ + RunSummary: protocol.RunSummary{ID: 7, Name: "demo", Status: "succeeded"}, + Steps: []protocol.RunStep{{Sequence: 1, Stage: "one"}, {Sequence: 2, Stage: "two"}}, + } + cases := []struct { + result protocol.SearchResult + section int + }{ + {protocol.SearchResult{Kind: protocol.SearchKindRun, Run: &protocol.SearchRun{ID: 7}}, -1}, + {protocol.SearchResult{Kind: protocol.SearchKindStep, Step: &protocol.SearchStep{RunID: 7, Sequence: 2}}, 0}, + {protocol.SearchResult{Kind: protocol.SearchKindField, Field: &protocol.SearchField{RunID: 7, Sequence: 2, Field: "input"}}, 1}, + {protocol.SearchResult{Kind: protocol.SearchKindArtifact, Artifact: &protocol.SearchArtifact{RunID: 7, Sequence: 2, Name: "shot.png"}}, -2}, + } + for _, tc := range cases { + m := searchFixtureModel() + m.searchResults = []protocol.SearchResult{tc.result} + updated, _ := m.Update(tea.KeyMsg{Type: tea.KeyEnter}) + m = updated.(Model) + if !m.runOpen || m.searchOpen || m.pendingRunNav == nil { + t.Fatalf("%s: Enter did not open the run: %+v", tc.result.Kind, m) + } + updated, _ = m.Update(receivedMsg{Type: protocol.Run, ID: "run", RunDetail: detail}) + m = updated.(Model) + if sequence := searchResultSequence(tc.result); sequence > 0 && m.runStepIndex != 2 { + t.Fatalf("%s: matched step not selected: %d", tc.result.Kind, m.runStepIndex) + } + if tc.result.Kind == protocol.SearchKindArtifact { + if !m.artifactsOpen { + t.Fatalf("artifact match must open the artifacts view: %+v", m) + } + continue + } + if tc.section >= 0 { + marker := "[" + runSections[tc.section].Shortcut + "]" + lines := m.runSectionLines(m.runDetailWidth()) + if m.runTop >= len(lines) || !strings.HasPrefix(ansi.Strip(lines[m.runTop]), marker) { + t.Fatalf("%s: section %d not focused: top=%d", tc.result.Kind, tc.section, m.runTop) + } + } + } +} + +func searchResultSequence(result protocol.SearchResult) int { + if result.Step != nil { + return result.Step.Sequence + } + if result.Field != nil { + return result.Field.Sequence + } + if result.Artifact != nil { + return result.Artifact.Sequence + } + return 0 +} + +func TestOmniSearchPipelineEnterOpensDetail(t *testing.T) { + m := searchFixtureModel() + m.searchResults = []protocol.SearchResult{{Kind: protocol.SearchKindPipeline, Pipeline: &protocol.SearchPipeline{ID: 3, Version: 4}}} + updated, _ := m.Update(tea.KeyMsg{Type: tea.KeyEnter}) + m = updated.(Model) + if m.searchOpen || !m.detailLoading || m.requestedPipelineID != 3 || m.requestedVersion != 4 { + t.Fatalf("pipeline Enter did not request the detail: %+v", m) + } +} + +func TestOmniSearchCoalescesInFlightRequests(t *testing.T) { + m := searchFixtureModel() + updated, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'d'}}) + m = updated.(Model) + if !m.searchInFlight { + t.Fatal("first keystroke must start a search") + } + before := m.nextID + updated, _ = m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'e'}}) + m = updated.(Model) + if m.searchInFlight == false || !m.searchQueued || m.nextID != before { + t.Fatalf("second keystroke must coalesce instead of overlapping: inFlight=%t queued=%t", m.searchInFlight, m.searchQueued) + } +} + +func TestOmniSearchLayoutStaysWithinWidth(t *testing.T) { + for _, width := range []int{100, 40, 12} { + m := searchFixtureModel() + m.width = width + m.searchResults[4].Field.Snippet = strings.Repeat("wide ", 40) + "needle" + lines := strings.Split(ansi.Strip(m.View()), "\n") + for _, line := range lines { + if len([]rune(line)) > width { + t.Fatalf("width %d: line too wide: %q", width, line) + } + } + } +}