Files
pipelines/internal/tui/results.go
T

180 lines
5.8 KiB
Go

package tui
import (
"fmt"
"maps"
"strings"
"git.a-wan.net/alan/pipelines/internal/protocol"
"github.com/charmbracelet/lipgloss"
"github.com/charmbracelet/x/ansi"
)
func resultLabel(r protocol.RunSummary) string {
preview := ansi.Strip(r.ResultPreview)
if r.Status == "succeeded" {
if preview != "" {
return "Result: " + preview
}
return "Finished · no result recorded"
}
if r.Status == protocol.RunStatusWaiting && r.ExportPendingSequence > 0 {
return "Waiting for session export · stage " + r.CurrentStage
}
if r.Diagnostic != "" {
return "Stopped: " + ansi.Strip(r.Diagnostic)
}
if preview != "" {
return "Latest output: " + preview
}
if r.Status == protocol.RunStatusWaiting {
if r.CurrentStage != "" {
return "Waiting for a person · stage " + r.CurrentStage
}
return "Waiting for a person"
}
if r.Status == "running" || r.Status == "queued" {
return "In progress · awaiting stage output"
}
return "No result recorded"
}
func (m Model) latestPipelineRun(id int64, version int) *protocol.RunSummary {
var latest *protocol.RunSummary
for i := range m.runs {
r := &m.runs[i]
if r.PipelineID == id && (version == 0 || r.Version == version) && (latest == nil || r.ID > latest.ID) {
latest = r
}
}
return latest
}
func (m Model) pipelineResultLines() []string {
if m.detail == nil {
return nil
}
r := m.latestPipelineRun(m.detail.ID, m.detail.Version)
if r == nil {
return []string{"Results · This version has not run yet. No accomplishments recorded."}
}
lines := []string{fmt.Sprintf("Results · run #%d · %s · %s · %d completed visits · %s", r.ID, r.Label(), ansi.Strip(m.runSummaryStatus(*r)), r.CompletedSteps, runDuration(r.CreatedAt, r.FinishedAt)), resultLabel(*r)}
if r.Status != "succeeded" && r.ResultPreview != "" && r.Diagnostic != "" {
lines = append(lines, "Partial output: "+ansi.Strip(r.ResultPreview))
}
return lines
}
func runResultLines(r *protocol.RunDetail) []string {
lines := []string{}
if r.Diagnostic != "" {
lines = append(lines, "Stopped: "+ansi.Strip(r.Diagnostic))
}
lines = append(lines, waitingLines(r)...)
if r.Status == "succeeded" {
if preview := protocol.OutputPreview(r.Output); preview != "" {
lines = append(lines, "Result: "+ansi.Strip(preview))
} else {
lines = append(lines, "Finished · no result recorded")
}
} else {
if r.Status == "running" || r.Status == "queued" {
lines = append(lines, "In progress · final result pending")
}
for i := len(r.Steps) - 1; i >= 0; i-- {
if r.Steps[i].Status == "completed" {
if preview := protocol.OutputPreview(r.Steps[i].Output); preview != "" {
lines = append(lines, "Latest completed output ("+r.Steps[i].Stage+"): "+ansi.Strip(preview))
}
break
}
}
}
completed := 0
failed := 0
for _, s := range r.Steps {
if s.Status == "completed" {
completed++
}
if s.Status == "failed" {
failed++
}
}
lines = append(lines, fmt.Sprintf("Progress: %d completed visits · %d failed · %d recorded", completed, failed, len(r.Steps)))
if r.CurrentStage != "" && (r.Status == "running" || r.Status == "queued") {
lines = append(lines, "Working on: "+r.CurrentStage)
}
return lines
}
// waitingLines renders a run waiting on a human stage: the banner, the operator
// instructions recorded with the wait, and the selectable options, so the choice
// is visible without opening the stage view.
func waitingLines(r *protocol.RunDetail) []string {
if r.Status != protocol.RunStatusWaiting {
return nil
}
if r.ExportPendingSequence > 0 {
return []string{fmt.Sprintf("⏸ Waiting for session export · stage %s · visit %d", r.CurrentStage, r.ExportPendingSequence), "Computed output retained; automatic export-only recovery pending."}
}
lines := []string{"⏸ Waiting for a person · stage " + r.CurrentStage}
if step, ok := lastWaitingStep(r); ok {
if prompt := strings.TrimSpace(protocol.WaitingPrompt(step.Output)); prompt != "" {
lines = append(lines, strings.Split(ansi.Strip(prompt), "\n")...)
}
if options := protocol.WaitingOptions(step.Output); len(options) > 0 {
lines = append(lines, "Options: "+strings.Join(options, ", "))
}
lines = append(lines, fmt.Sprintf("Decide: pipelines decide %d --option KEY [--feedback TEXT]", r.ID))
}
return lines
}
func completedWorkLines(r *protocol.RunDetail) []string {
var lines []string
for _, s := range r.Steps {
if s.Status != "completed" {
continue
}
line := fmt.Sprintf("%d. %s · %s", s.Sequence, s.Stage, s.Outcome)
if preview := protocol.OutputPreview(s.Output); preview != "" {
line += " — " + ansi.Strip(preview)
} else {
line += " — no output recorded"
}
lines = append(lines, line)
}
if len(lines) == 0 {
lines = append(lines, "No completed stage output yet.")
}
return append([]string{"Completed stage outputs (reported, not independently verified):"}, lines...)
}
func runOutputDocument(r *protocol.RunDetail, width int) []string {
if r.Status == protocol.RunStatusWaiting {
return waitingLines(r)
}
var notice []string
if r.Diagnostic != "" {
notice = append(notice, lipgloss.NewStyle().Foreground(themeError).Render("Stopped: "+ansi.Strip(r.Diagnostic)), "")
}
if r.Status == "succeeded" {
if len(r.Output) == 0 {
return []string{"Finished · no result recorded"}
}
return resultDocument(r.Output, width)
}
for i := len(r.Steps) - 1; i >= 0; i-- {
if r.Steps[i].Status == "completed" && len(r.Steps[i].Output) > 0 {
notice = append(notice, lipgloss.NewStyle().Foreground(themeMuted).Render("Partial result · "+r.Steps[i].Stage+" · final result not available"), "")
return append(notice, resultDocument(r.Steps[i].Output, width)...)
}
}
if len(r.Output) > 0 {
values := maps.Clone(r.Output)
delete(values, "input")
return append(notice, resultDocument(values, width)...)
}
return append(notice, "No output recorded yet.")
}