Add omni search: ranked mixed results in the TUI and CLI
Back the TUI "/" popup with the server's search command and add a matching pipelines search CLI command. - protocol: SearchRequest/SearchResponse and per-kind SearchResult payloads, one shared Label for the six-kind badge dispatch and RuneIndexFold for case-insensitive matching. - pipeline: the read-only, ranked, bounded Store.Search implementation. - cli: search QUERY [--type KIND] [--limit N] [--json], printing the shared label plus a text-field snippet when present. - tui: type to search, up/down to choose, Enter to open and Esc to cancel over one mixed ranked list, with short type badges and a bracketed non-colour match marker; Enter navigates to the matched pipeline, run, step, field section or artifact entry. - tests: protocol and TUI coverage, including an env-gated live test against the running server.
This commit is contained in:
+36
-1
@@ -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 {
|
||||
|
||||
@@ -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<?"
|
||||
args = append(args, terms.From.Format(searchSQLTime), terms.To.Format(searchSQLTime))
|
||||
default:
|
||||
query = base + ` WHERE lower(p.name) LIKE ? ESCAPE '\' OR lower(r.workspace) LIKE ? ESCAPE '\' OR lower(r.status) LIKE ? ESCAPE '\' OR lower(r.diagnostic) LIKE ? ESCAPE '\' OR CAST(r.id AS TEXT)=?`
|
||||
pattern := searchLike(terms.Text)
|
||||
args = append(args, pattern, pattern, pattern, pattern, terms.Text)
|
||||
}
|
||||
query += " ORDER BY r.id 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 id int64
|
||||
var name, status, workspace, created, finished, diagnostic string
|
||||
if err := rows.Scan(&id, &name, &status, &workspace, &created, &finished, &diagnostic); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
score, matched := 1, "status"
|
||||
if terms.Status != "" {
|
||||
matched = "status"
|
||||
} else if terms.HasDate {
|
||||
matched = "created_at"
|
||||
} else if s, ok := searchTier(name, terms.Text); ok {
|
||||
score, matched = s, "pipeline_name"
|
||||
} else if numericEqual(terms.Text, id) {
|
||||
score, matched = 3, "id"
|
||||
} else if searchContains(workspace, terms.Text) {
|
||||
matched = "workspace"
|
||||
} else if searchContains(status, terms.Text) {
|
||||
matched = "status"
|
||||
} else if searchContains(diagnostic, terms.Text) {
|
||||
matched = "diagnostic"
|
||||
} else {
|
||||
continue
|
||||
}
|
||||
run := &protocol.SearchRun{ID: id, PipelineName: name, Status: status, Workspace: workspace, CreatedAt: created, FinishedAt: finished}
|
||||
if created != "" && finished != "" {
|
||||
if secs, ok := durationSeconds(created, finished); ok {
|
||||
run.DurationSeconds = secs
|
||||
}
|
||||
}
|
||||
results = append(results, protocol.SearchResult{
|
||||
Kind: protocol.SearchKindRun, Target: searchRunTarget(id),
|
||||
Score: score, MatchedField: matched, Recency: created, Run: run,
|
||||
})
|
||||
}
|
||||
return results, rows.Err()
|
||||
}
|
||||
|
||||
func searchSteps(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 s.run_id,s.sequence,s.stage_key,s.outcome,s.target,s.diagnostic,`+searchStepRecency+`,`+searchStepEvidence+`
|
||||
`+searchStepJoin+`
|
||||
WHERE lower(s.stage_key) LIKE ? ESCAPE '\' OR lower(s.outcome) LIKE ? ESCAPE '\' OR lower(s.target) LIKE ? ESCAPE '\' OR lower(s.diagnostic) LIKE ? ESCAPE '\'
|
||||
ORDER BY s.run_id DESC,s.sequence DESC LIMIT ?`, pattern, pattern, pattern, 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 stage, outcome, target, diagnostic, recency, control string
|
||||
if err := rows.Scan(&runID, &sequence, &stage, &outcome, &target, &diagnostic, &recency, &control); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
score, matched := 1, "diagnostic"
|
||||
if s, ok := searchTier(stage, terms.Text); ok {
|
||||
score, matched = s, "stage"
|
||||
} else if searchContains(outcome, terms.Text) {
|
||||
matched = "outcome"
|
||||
} else if searchContains(target, terms.Text) {
|
||||
matched = "target"
|
||||
} else if searchContains(diagnostic, terms.Text) {
|
||||
matched = "diagnostic"
|
||||
} else {
|
||||
continue
|
||||
}
|
||||
visit := 0
|
||||
if control != "" && control != "null" {
|
||||
var evidence protocol.ControlEvidence
|
||||
if err := json.Unmarshal([]byte(control), &evidence); err == nil {
|
||||
visit = evidence.Visit
|
||||
}
|
||||
}
|
||||
results = append(results, protocol.SearchResult{
|
||||
Kind: protocol.SearchKindStep, Target: searchStepTarget(runID, sequence),
|
||||
Score: score, MatchedField: matched, Recency: recency,
|
||||
Step: &protocol.SearchStep{RunID: runID, Sequence: sequence, Stage: stage, Visit: visit, Outcome: outcome, Target: target, Diagnostic: diagnostic},
|
||||
})
|
||||
}
|
||||
return results, rows.Err()
|
||||
}
|
||||
|
||||
// searchScan accumulates the shared bounded-scan budget so the response can
|
||||
// report how much body text was inspected and whether any bound was reached.
|
||||
type searchScan struct {
|
||||
steps int
|
||||
bytes int
|
||||
truncated bool
|
||||
}
|
||||
|
||||
func searchFields(ctx context.Context, tx *sql.Tx, terms searchTerms, scan *searchScan) ([]protocol.SearchResult, error) {
|
||||
if terms.Text == "" {
|
||||
return nil, nil
|
||||
}
|
||||
// One extra step is requested so a scan that hits the step bound can see that
|
||||
// more rows remain and report Truncated rather than ending silently.
|
||||
rows, err := tx.QueryContext(ctx, `SELECT s.run_id,s.sequence,s.input_json,s.output_json,s.transcript,`+searchStepEvidence+`,`+searchStepRecency+`
|
||||
`+searchStepJoin+`
|
||||
ORDER BY s.run_id DESC,s.sequence DESC LIMIT ?`, protocol.SearchMaxScanSteps+1)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
var results []protocol.SearchResult
|
||||
for rows.Next() {
|
||||
if scan.steps >= 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
|
||||
}
|
||||
@@ -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: <opaque>, Search: <SearchRequest>} 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:<id>, pipeline:<id>:v<version>, run:<id>, run:<id>:<sequence>,
|
||||
// run:<id>:<sequence>:<field>, 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
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
+259
-31
@@ -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) {
|
||||
|
||||
@@ -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 ""
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user