Files
pipelines/internal/tui/dashboard.go
T
alan a6aff47117 Add a human decision stage that pauses a run for an operator's choice
A new registered stage type `human` (internal/stage/human.go) has no model,
agent, tools or configs: its required `prompt` block carries the operator
instructions and its non-error edges are the selectable options. It parses,
validates, renders, exports and imports like every other type (no parser
special-case, no config keys).

At runtime the runner parks the run instead of executing: the step and the run
persist `waiting` with self-contained {prompt, options} evidence, and the run
returns without starting later stages, capturing file diffs, scanning artifacts,
holding a goroutine/timer or applying a stage timeout. The wait is durable: a
restart leaves the waiting rows untouched (RecoverRuns excludes them) and a
rebuilt runtime over the same database still accepts the decision.

`pipelines decide <run-id> [stage] --option KEY [--feedback TEXT] [--json]` and
the TUI `c` picker resolve the decision from the pinned graph in one store
transaction, record the choice and feedback as the step's evidence and resume
along edges[KEY]. An unknown option is refused with the valid list, a stage that
is not waiting is refused, and a repeated decision for an already-decided visit
does not double-apply. Cancel and retry keep working while waiting and after a
decision; a human stage is never killed by a stage timeout or max_visits, and a
`notify` policy can fire an `on=waiting` event.

Docs: the authoring skill references (format.md, operations.md), docs/cli.md and
README describe the stage, the command and the TUI picker. Tests cover stage
validation, the parsing round-trip, the store transitions, a websocket wait/decide
integration, cancel/retry, waiting notifications and a persistence-layer rebuild
(second Open + newRunner over one database, no process restart).
2026-10-16 16:47:28 +01:00

467 lines
15 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package tui
import (
"fmt"
"strconv"
"strings"
tea "github.com/charmbracelet/bubbletea"
"github.com/charmbracelet/lipgloss"
"github.com/charmbracelet/x/ansi"
"github.com/sahilm/fuzzy"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
var commands = []string{":status", ":logs", ":new", ":drafts", ":templates", ":export", ":import", ":refresh", ":ping", ":edit", ":submit", ":versions", ":run", ":runs", ":retry", ":debug", ":pipeline", ":home", ":quit"}
var commandDescriptions = map[string]string{
":export": "Select pipelines and save their definitions in a portable ZIP in the current directory.",
":import": "Select definitions from a ZIP, resolve conflicts, then confirm publication. Schedules may activate.",
":status": "Server health and phone connection details", ":logs": "Read retained client diagnostics", ":new": "Create a retained pipeline draft", ":drafts": "Continue editing or publish a draft", ":templates": "Choose a reusable workflow starter", ":refresh": "Reload the current screen from the server", ":ping": "Check the server connection", ":edit": "Edit a retained draft of this definition", ":submit": "Publish the edited draft after confirmation", ":versions": "View an immutable published version", ":run": "Describe a task for this pipeline", ":runs": "Inspect recorded runs and their results", ":retry": "Confirm a fresh run; previous side effects may repeat", ":debug": "Open the configured harness with the pinned definition and failure evidence", ":pipeline": "View the definition used by this run", ":home": "Return to recent results and pipelines", ":quit": "Exit the client; server-owned runs continue"}
func (m Model) footerContent() string {
if footer := m.activeFooter(); footer != "" {
return footer
}
if m.width < 80 && m.runOpen {
text := "↑↓ select · Enter open · / find · Esc"
if len(m.visibleRuns()) == 0 {
text = "Esc back · / search · : commands"
}
if m.runDetail != nil {
text = "Tab graph · n/p visit · j/k read · Esc"
if m.runGraphFocus {
text = "Tab details · n/p visit · hjkl pan · Esc"
}
if m.width < 40 {
text = "Esc back · Tab pane · j/k read"
}
if m.width < 30 {
text = "Esc · Tab pane"
}
}
return lipgloss.NewStyle().Foreground(themeMuted).Render(ansi.Truncate(text, max(1, m.width), "…"))
}
if m.width < 80 && m.keys.detail {
text := "Tab stage · n/p stage · hjkl pan · Esc"
if m.stageFocus {
text = "Tab graph · n/p stage · j/k read · Esc"
}
if m.width < 40 {
text = "Esc home · Tab pane · n/p stage"
}
return lipgloss.NewStyle().Foreground(themeMuted).Render(ansi.Truncate(text, max(1, m.width), "…"))
}
label := fmt.Sprintf(" LOGS %d · :logs ", len(m.lines))
style := lipgloss.NewStyle().Foreground(themeMuted)
if m.unread > 0 {
label = fmt.Sprintf(" ● %d NEW · LOGS %d · :logs ", m.unread, len(m.lines))
if m.width < 60 {
label = fmt.Sprintf(" ● %d NEW · :logs ", m.unread)
}
style = lipgloss.NewStyle().Foreground(themeAccent).Background(themeSelection)
} else if len(m.lines) > 0 {
style = lipgloss.NewStyle().Foreground(themeAccent).Bold(true)
}
if m.homePage() {
label = strings.ReplaceAll(label, " · :logs", "")
}
label = style.Render(ansi.Truncate(label, m.width, ""))
available := m.width - lipgloss.Width(label) - 1
left := ""
if available > 0 {
keys := m.keys
keys.runInspect = m.runDetail != nil
keys.runGraph = m.runGraphFocus
keys.retryAvailable = m.selectedFailedRun() > 0
left = ansi.Truncate(m.help.View(keys), available, "…")
}
return left + strings.Repeat(" ", max(0, m.width-lipgloss.Width(left)-lipgloss.Width(label))) + label
}
func (m Model) homeLines() []string {
panelWidth := m.width
if m.width >= 120 {
panelWidth = (m.width - 2) * 3 / 5
}
runs := []string{bar("Latest runs", "Outcome & result", max(1, panelWidth-4), true), ""}
if len(m.runs) == 0 {
if !m.loaded {
runs = append(runs, m.loading("Loading recent work…"))
} else {
runs = append(runs, "No runs yet.", "Results will appear here after you run a pipeline.")
}
}
limit := 4
if m.width < 120 {
limit = 2
}
for _, r := range m.runs[:min(limit, len(m.runs))] {
runs = append(runs, bar(fmt.Sprintf("#%d %s", r.ID, r.Label()), m.progress(r.Status), max(1, panelWidth-4), false))
runs = append(runs, previewRows(resultLabel(r), max(1, panelWidth-4), 3)...)
runs = append(runs, lipgloss.NewStyle().Foreground(themeMuted).Render(fmt.Sprintf("v%d · %d completed visits · %s", r.Version, r.CompletedSteps, runDuration(r.CreatedAt, r.FinishedAt))))
if r.CurrentStage != "" && (r.Status == "running" || r.Status == "queued") {
runs = append(runs, "Working on "+r.CurrentStage)
}
if r.Status == protocol.RunStatusWaiting {
runs = append(runs, "Waiting on a person · stage "+r.CurrentStage)
}
runs = append(runs, "")
}
if len(m.runs) > limit {
runs = append(runs, lipgloss.NewStyle().Foreground(themeMuted).Render(fmt.Sprintf("%d more runs in history", len(m.runs)-limit)))
}
pipelineWidth := m.width
if m.width >= 120 {
pipelineWidth = m.width - panelWidth - 2
}
lines := []string{bar("Existing pipelines", fmt.Sprintf("%d", len(m.pipelines)), max(1, pipelineWidth-4), true), ""}
if !m.loaded {
lines = append(lines, m.loading("Waiting for pipeline data…"))
} else if len(m.pipelines) == 0 {
lines = append(lines, "No pipelines yet. Create one using commands.")
} else {
for _, p := range m.pipelines[:min(4, len(m.pipelines))] {
lines = append(lines,
lipgloss.NewStyle().Bold(true).Render(p.Name), lipgloss.NewStyle().Foreground(themeMuted).Render(fmt.Sprintf("v%d · %d stages", p.Version, p.Stages)))
if r := m.latestPipelineRun(p.ID, 0); r != nil {
lines = append(lines, fmt.Sprintf("Last run #%d · %s · v%d · %s", r.ID, r.Label(), r.Version, m.progress(r.Status)))
lines = append(lines, previewRows(resultLabel(*r), max(1, pipelineWidth-4), 2)...)
} else {
lines = append(lines, "Not run yet · no recorded results")
}
if m.usage != nil {
for _, u := range m.usage.Pipelines {
if u.PipelineID == p.ID {
lines = append(lines, fmt.Sprintf(" %d runs · %s · avg %s", u.Total, successLabel(u.RunCounts), averageLabel(u.RunCounts)))
break
}
}
}
lines = append(lines, "")
}
if len(m.pipelines) > 4 {
lines = append(lines, fmt.Sprintf("%d more pipelines", len(m.pipelines)-4))
}
}
if m.width < 8 {
return append(append(runs, ""), lines...)
}
widget := func(rows []string, width int) string {
for i := range rows {
rows[i] = ansi.Truncate(rows[i], max(1, width-4), "…")
}
content := lipgloss.NewStyle().Background(themeSurface).Foreground(themeText).
Padding(1, 2).Width(width).
Render(surfaceContent(strings.Join(rows, "\n"), themeSurface))
return content
}
panels := widget(runs, panelWidth) + "\n\n" + widget(lines, panelWidth)
if m.width >= 120 {
panels = lipgloss.JoinHorizontal(lipgloss.Top, widget(runs, panelWidth), " ", widget(lines, m.width-panelWidth-2))
}
if m.usage != nil {
panels += "\n\n" + widget(m.usageLines(), m.width)
}
return strings.Split(panels, "\n")
}
func previewRows(text string, width, limit int) []string {
rows := strings.Split(ansi.Wrap(ansi.Strip(text), max(1, width), ""), "\n")
if len(rows) > limit {
rows = rows[:limit]
rows[limit-1] = ansi.Truncate(rows[limit-1], max(1, width-1), "") + "…"
}
return rows
}
func (m Model) homePage() bool {
return !m.keys.detail && !m.runOpen && !m.templateOpen && !m.draftOpen && m.runForm == 0
}
func (m Model) pageCommands() []string {
available := []string{}
detailPage := m.keys.detail && !m.runOpen
for _, command := range commands {
switch command {
case ":debug":
if m.selectedRunID() <= 0 {
continue
}
case ":retry":
if m.selectedFailedRun() <= 0 {
continue
}
case ":pipeline":
if id, version := m.selectedRunPipeline(); id <= 0 || version <= 0 {
continue
}
case ":new", ":ping", ":templates":
if !m.homePage() {
continue
}
case ":edit", ":versions", ":run":
if !detailPage || m.detail == nil || m.detailLoading {
continue
}
case ":submit":
if !detailPage || m.pendingDraft == nil {
continue
}
case ":home":
if m.homePage() {
continue
}
}
available = append(available, command)
}
return available
}
func (m Model) matches() []string {
available := m.pageCommands()
query := strings.TrimPrefix(strings.TrimSpace(m.commandInput.Value()), ":")
if query == "" {
return available
}
result := []string{}
for _, match := range fuzzy.Find(query, available) {
result = append(result, match.Str)
}
return result
}
func (m Model) updatePalette(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
if m.searchOpen {
return m.updateSearch(msg)
}
items := m.matches()
switch msg.String() {
case "esc":
m.paletteOpen = false
m.keys.palette = false
return m, nil
case "down", "ctrl+n":
m.commandIndex = min(m.commandIndex+1, max(0, len(items)-1))
return m, nil
case "up", "ctrl+p":
m.commandIndex = max(0, m.commandIndex-1)
return m, nil
case "enter":
if len(items) == 0 {
return m, nil
}
command := items[min(m.commandIndex, len(items)-1)]
m.paletteOpen = false
m.keys.palette = false
switch command {
case ":export":
return m.transferPipelines(false)
case ":import":
return m.transferPipelines(true)
case ":status":
return m.openStatus()
case ":debug":
return m.debugRun()
case ":retry":
return m.retrySelectedRun()
case ":pipeline":
return m.openRunPipeline()
case ":drafts":
return m.openDrafts()
case ":templates":
return m.openTemplates()
case ":run":
return m.beginRun()
case ":runs":
return m.openRuns()
case ":logs":
m.logOpen = true
m.keys.logs = true
m.logTop = max(0, len(m.lines)-m.logPageSize())
m.logPan = 0
m.markVisibleLogs()
return m, nil
case ":new":
return m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'n'}})
case ":ping":
return m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'t'}})
case ":quit":
return m, tea.Quit
case ":edit":
return m.editPipeline()
case ":submit":
if m.pendingDraft != nil {
m.confirmOpen = true
m.keys.confirm = true
} else {
m.appendLine("no edited draft to create/update")
}
return m, nil
case ":versions":
return m.openVersions()
case ":home":
m.closeRuns()
return m.goHome(), nil
case ":refresh":
if m.templateOpen {
return m.openTemplates()
}
if m.runOpen {
request := protocol.Message{Type: protocol.ListRuns}
if m.requestedRunID > 0 {
request.Type = protocol.GetRun
request.RunID = m.requestedRunID
}
return m.runRequest(request)
}
if m.detail != nil && m.keys.detail {
return m.requestPipeline(m.detail.ID, m.detail.Version)
}
if m.conn == nil {
m.appendLine("not connected")
return m, nil
}
m.nextID++
return m, m.send(protocol.Message{Type: protocol.List, ID: strconv.FormatUint(m.nextID, 10)})
}
}
var cmd tea.Cmd
m.commandInput, cmd = m.commandInput.Update(msg)
m.commandIndex = 0
return m, cmd
}
// The popup reserves two lines for its border and two for title/separation.
func (m Model) logPageSize() int { return max(0, min(24, m.height-8)) }
func (m *Model) markVisibleLogs() {
for i := m.logTop; i < min(len(m.lines), m.logTop+m.logPageSize()); i++ {
if !m.logSeen[i] {
m.logSeen[i] = true
m.unread--
}
}
}
func (m Model) updateLogs(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
switch msg.String() {
case "esc", "q":
m.logOpen = false
m.keys.logs = false
return m, nil
case "j", "down":
m.logTop++
case "k", "up":
m.logTop--
case "h":
m.logTop -= max(1, m.logPageSize()/2)
case "l":
m.logTop += max(1, m.logPageSize()/2)
case "left":
m.logPan = max(0, m.logPan-8)
case "right":
m.logPan += 8
}
widest := 0
for _, line := range m.lines {
widest = max(widest, ansi.StringWidth(line))
}
m.logPan = min(m.logPan, max(0, widest-min(100, max(1, m.width-6))))
m.logTop = max(0, min(m.logTop, max(0, len(m.lines)-m.logPageSize())))
m.markVisibleLogs()
return m, nil
}
func popup(width, height, preferredWidth int, lines []string) string {
inner := min(preferredWidth, max(1, width-6))
for i := range lines {
lines[i] = ansi.Truncate(lines[i], inner, "…")
}
if len(lines) > 0 {
lines[0] = bar(lines[0], "", inner, true)
}
dialog := lipgloss.NewStyle().Background(themeElevated).Foreground(themeText).
Padding(1, 2).Width(inner + 4).
Render(surfaceContent(strings.Join(lines, "\n"), themeElevated))
if lipgloss.Width(dialog) > width || lipgloss.Height(dialog) > height {
lines = lines[:min(len(lines), height)]
for i := range lines {
lines[i] = ansi.Truncate(lines[i], width, "…")
}
dialog = strings.Join(lines, "\n")
}
return lipgloss.Place(width, height, lipgloss.Center, lipgloss.Center, dialog)
}
// Safety text wraps and scrolls independently of its pinned title and controls.
func wrappedDialog(width, height, preferredWidth int, title string, paragraphs []string, controls string, top int) string {
if width <= 0 || height <= 0 {
return ""
}
dialogWidth := min(width, preferredWidth+4)
inner := max(1, dialogWidth-4)
var rows []string
for i, text := range paragraphs {
if i > 0 {
rows = append(rows, "")
}
rows = append(rows, strings.Split(ansi.Wrap(ansi.Strip(text), inner, ""), "\n")...)
}
dialogHeight := min(height, len(rows)+4)
page := max(0, dialogHeight-4)
top = max(0, min(top, max(0, len(rows)-page)))
if page < len(rows) {
controls += " · j/k read"
}
content := panel(dialogWidth, dialogHeight, []string{bar(title, "", inner, true)}, rows[top:min(len(rows), top+page)], controls, true)
return lipgloss.Place(width, height, lipgloss.Center, lipgloss.Center, content)
}
func (m Model) logsView(height int) string {
end := min(len(m.lines), m.logTop+m.logPageSize())
lines := []string{fmt.Sprintf("Logs · %d–%d / %d", min(m.logTop+1, len(m.lines)), end, len(m.lines)), ""}
if len(m.lines) == 0 {
lines[0] = "Logs"
lines = append(lines, "No logs yet.")
} else {
width := min(100, max(1, m.width-6))
for _, line := range m.lines[m.logTop:end] {
lines = append(lines, ansi.Cut(line, m.logPan, m.logPan+width))
}
}
return popup(m.width, height, 100, lines)
}
func (m Model) paletteView(height int) string {
if m.searchOpen {
return m.searchView(height)
}
field := m.commandInput
field.Width = max(1, min(48, m.width-10))
lines := []string{"Commands", field.View(), ""}
items := m.matches()
if len(items) == 0 {
lines = append(lines, "No matching commands")
}
if len(items) > 0 {
selected := items[min(m.commandIndex, len(items)-1)]
lines = append(lines, previewRows(commandDescriptions[selected], min(50, max(1, m.width-10)), 2)...)
lines = append(lines, "")
}
start, end := selectionWindow(len(items), m.commandIndex, max(1, height-8))
for i := start; i < end; i++ {
item := items[i]
prefix := " "
if i == m.commandIndex {
prefix = "› "
}
lines = append(lines, menuOption(prefix+item, i == m.commandIndex))
}
if len(items) > 0 {
lines = append(lines, lipgloss.NewStyle().Foreground(themeMuted).Render(fmt.Sprintf("%d–%d / %d commands", start+1, end, len(items))))
}
return popup(m.width, height, 54, lines)
}