package tui import ( "fmt" "sort" "strings" "time" "github.com/charmbracelet/lipgloss" "github.com/charmbracelet/x/ansi" "git.a-wan.net/alan/pipelines/internal/protocol" stageconfig "git.a-wan.net/alan/pipelines/internal/stage" ) type paneGeometry struct { graphWidth, graphHeight, stageWidth, stageHeight int } func (m Model) pipelineGeometry(height int) paneGeometry { remaining := max(0, height-len(m.pipelineToolbar())) if m.stageFocus { if remaining < 14 { return paneGeometry{stageWidth: m.width, stageHeight: remaining} } return paneGeometry{graphWidth: m.width, graphHeight: 2, stageWidth: m.width, stageHeight: remaining - 2} } if remaining < 14 { return paneGeometry{graphWidth: m.width, graphHeight: remaining} } return paneGeometry{graphWidth: m.width, graphHeight: remaining - 2, stageWidth: m.width, stageHeight: 2} } func fitBlock(lines []string, width, height int) string { if height <= 0 { return "" } rows := make([]string, height) for i := range rows { if i < len(lines) { rows[i] = ansi.Truncate(lines[i], max(1, width), "…") } rows[i] += strings.Repeat(" ", max(0, width-lipgloss.Width(rows[i]))) } return strings.Join(rows, "\n") } func panel(width, height int, headers, body []string, footer string, focused bool) string { if height <= 0 || width <= 0 { return "" } if width < 6 || height < len(headers)+3 { return fitBlock(append(append([]string{}, headers...), body...), width, height) } inner := width - 4 contentHeight := height - len(headers) - 3 lines := append([]string{}, headers...) visible := strings.Split(fitBlock(body, inner, contentHeight), "\n") if contentHeight > 0 { lines = append(lines, visible...) } lines = append(lines, lipgloss.NewStyle().Foreground(themeMuted).Render(footer)) return lipgloss.NewStyle().Background(themeSurface).Foreground(themeText). Padding(1, 2).Width(width).Render(surfaceContent(fitBlock(lines, inner, height-2), themeSurface)) } func bar(title, right string, width int, focused bool) string { left := ansi.Truncate(title, max(1, width), "…") if lipgloss.Width(left)+lipgloss.Width(right)+1 <= width { left += strings.Repeat(" ", width-lipgloss.Width(left)-lipgloss.Width(right)) + lipgloss.NewStyle().Foreground(themeMuted).Bold(false).Render(right) } left += strings.Repeat(" ", max(0, width-lipgloss.Width(left))) s := lipgloss.NewStyle().Foreground(themeText).Bold(true) if focused { s = s.Foreground(themeAccent) } return s.Render(left) } func dateLabel(value string) string { if stamp, err := time.Parse(time.RFC3339, value); err == nil { return stamp.UTC().Format("02 Jan 2006 15:04") + " UTC" } if value == "" { return "—" } return value } func (m Model) pipelineToolbar() []string { d := m.detail if d == nil { return []string{"", "", ""} } state := lipgloss.NewStyle().Foreground(themeSuccess).Bold(true).Render("LATEST") if d.Version != d.LatestVersion { state = lipgloss.NewStyle().Foreground(themeAccent).Render(fmt.Sprintf("HISTORY · latest v%d", d.LatestVersion)) } buttons := action(fmt.Sprintf("v Version %d ▾", d.Version), true) + " " + action("e Edit source", false) + " " + action("Esc Home", false) if lipgloss.Width(buttons)+lipgloss.Width(state)+1 <= m.width { buttons += strings.Repeat(" ", m.width-lipgloss.Width(buttons)-lipgloss.Width(state)) + state } meta := lipgloss.NewStyle().Foreground(themeMuted).Render("Created " + dateLabel(d.CreatedAt) + " · Updated " + dateLabel(d.UpdatedAt)) if settings := d.Graph.Settings; settings != nil { var schedules []string for _, rule := range settings.Schedules { when := "at " + strings.Join(rule.Times, ",") if rule.Every != "" { when = "every " + rule.Every } days := "everyday" if len(rule.Days) > 0 { days = strings.Join(rule.Days, ",") } zone := rule.Timezone if zone == "" { zone = "server local" } schedules = append(schedules, days+" "+when+" ("+zone+")") } meta = "Schedule: " + strings.Join(schedules, "; ") if d.Version != d.LatestVersion { meta += " · historical, inactive" } } if m.width < 80 { short := action(fmt.Sprintf("v Version %d", d.Version), true) + " " + action("e Edit", false) result := "Not run yet · no recorded results" if run := m.latestPipelineRun(d.ID, d.Version); run != nil { result = resultLabel(*run) } lines := []string{bar(short, state, m.width, false), ansi.Truncate(result, max(1, m.width), "…")} if d.Graph.Settings != nil && len(d.Graph.Settings.Schedules) > 0 { lines = append(lines, ansi.Truncate(meta, max(1, m.width), "…")) } return lines } lines := []string{buttons} lines = append(lines, m.pipelineResultLines()...) return append(lines, meta, "") } func (m Model) pipelineView(height int) string { if m.detailLoading { label := "Loading pipeline…" if m.requestedVersion > 0 { label = fmt.Sprintf("Loading version %d…", m.requestedVersion) } return fitBlock([]string{m.loading(label)}, m.width, height) } if m.detailError != "" { return fitBlock([]string{lipgloss.NewStyle().Foreground(themeError).Render("Cannot load pipeline: " + m.detailError), "Esc returns home."}, m.width, height) } if m.detail == nil { return fitBlock([]string{"No pipeline selected."}, m.width, height) } toolbar := m.pipelineToolbar() if height <= 3 { return fitBlock(toolbar, m.width, height) } g := m.pipelineGeometry(height) graph := m.graphPanel(g.graphWidth, g.graphHeight) stages := m.stagePanel(g.stageWidth, g.stageHeight) content := graph if graph != "" && stages != "" { content = graph + "\n" + stages } else if stages != "" { content = stages } return fitBlock(append(toolbar, strings.Split(content, "\n")...), m.width, height) } func (m Model) selectedStage() *protocol.Stage { if m.detail == nil || len(m.detail.Graph.Stages) == 0 { return nil } index := max(0, min(m.stageIndex, len(m.detail.Graph.Stages)-1)) return &m.detail.Graph.Stages[index] } func (m Model) graphLines() []string { if m.detail == nil { return nil } selected := m.selectedStage() if selected == nil { return renderGraph(m.detail.Graph) } return renderGraph(m.detail.Graph, selected.Key) } func (m Model) graphPanel(width, height int) string { if height <= 2 && height > 0 { return fitBlock([]string{bar("Graph", "Tab to expand", width, false)}, width, height) } label := "Graph" if !m.stageFocus { label = "▸ " + label } return graphViewport(label, m.graphLines(), width, height, m.pipelineTop, m.graphPan, !m.stageFocus, "Tab pane · r runs · * fallback error") } // Shared graph viewport for definitions and executed run paths. func graphViewport(label string, lines []string, width, height, scrollTop, pan int, focused bool, footer string) string { if width <= 0 || height <= 0 { return "" } inner := max(1, width-4) rows := max(0, height-5) top := max(0, min(scrollTop, max(0, len(lines)-rows))) end := min(len(lines), top+rows) graphWidth := 0 for _, line := range lines { graphWidth = max(graphWidth, ansi.StringWidth(line)) } pan = max(0, min(pan, max(0, graphWidth-inner))) leftPad, topPad := max(0, (inner-graphWidth)/2), max(0, (rows-len(lines))/2) body := make([]string, topPad) for _, line := range lines[top:end] { body = append(body, strings.Repeat(" ", leftPad)+ansi.Cut(line, pan, pan+inner-leftPad)) } if pan > 0 { label = "← " + label } if pan+inner < graphWidth { label += " →" } headers := []string{runPaneTitle(strings.TrimPrefix(label, "▸ "), fmt.Sprintf("%d–%d / %d", min(top+1, len(lines)), end, len(lines)), inner, focused), ""} if graphWidth > inner { footer = "←/→ pan · " + footer } return panel(width, height, headers, body, footer, focused) } func (m Model) stageTabs(width int) string { if m.selectedStage() == nil { return "No stages" } stages := m.detail.Graph.Stages index := max(0, min(m.stageIndex, len(stages)-1)) if width < 4 { return stageTab(stages[index].Key, ansi.Truncate(fmt.Sprintf("%d %s", index+1, stages[index].Key), max(1, width), "…"), true, m.detail.Graph) } start := index labelFor := func(i int) string { label := fmt.Sprintf("%d %s", i+1, stages[i].Key) if i == index && width < lipgloss.Width(label)+2 { return stages[i].Key } return label } used := min(width, lipgloss.Width(labelFor(index))+2) for start > 0 { prior := lipgloss.Width(labelFor(start-1)) + 2 marker := 0 if start > 1 { marker = 2 } if used+prior+marker > width { break } start-- used += prior } result := "" if start > 0 && used+2 <= width { result = lipgloss.NewStyle().Foreground(themeMuted).Render("‹ ") } for i := start; i < len(stages); i++ { label := labelFor(i) if i == index { label = ansi.Truncate(label, max(1, width-lipgloss.Width(result)-2), "…") } tab := stageTab(stages[i].Key, " "+label+" ", i == index, m.detail.Graph) if lipgloss.Width(result)+lipgloss.Width(tab) > width { if i > index && lipgloss.Width(result)+2 <= width { result += " ›" } break } result += tab } return ansi.Truncate(result, width, "…") } type stageField struct{ title, text string } func (m Model) stageFields() []stageField { stage := m.selectedStage() if stage == nil { return nil } keys := make([]string, 0, len(stage.Configs)) for k := range stage.Configs { keys = append(keys, k) } sort.Strings(keys) configs := make([]string, 0, len(keys)) if stage.Type != "" { configs = append(configs, lipgloss.NewStyle().Foreground(themeMuted).Render("type ")+stage.Type) } for _, k := range keys { configs = append(configs, lipgloss.NewStyle().Foreground(themeMuted).Render(k+" ")+stage.Configs[k]) } if stage.Configs["timeout"] == "" { configs = append(configs, fmt.Sprintf("timeout %s (default per attempt)", stageconfig.DefaultTimeout)) } if stage.Type == "" || stage.Type == stageconfig.ModelType { if stage.Configs["retries"] == "" { configs = append(configs, fmt.Sprintf("retries %d (default)", stageconfig.DefaultRetries)) } for _, key := range []string{"budget_usd", "budget_tokens"} { if stage.Configs[key] == "" { configs = append(configs, key+" unlimited") } } } var edges []graphEdge maxLabel := 0 for _, edge := range graphEdges(m.detail.Graph) { if edge.source != stage.Key { continue } edges = append(edges, edge) maxLabel = max(maxLabel, lipgloss.Width(outcomeLabel(edge.outcome, fmt.Sprintf("%s [%d]", edge.label, edge.id)))) } routes := make([]string, 0, len(edges)) for _, edge := range edges { label := outcomeLabel(edge.outcome, fmt.Sprintf("%s [%d]", edge.label, edge.id)) padding := strings.Repeat(" ", maxLabel-lipgloss.Width(label)) target := nodeLabel(edge.target) routes = append(routes, label+padding+" "+lipgloss.NewStyle().Foreground(themeMuted).Render("→")+" "+stageTitle(edge.target, target, false, m.detail.Graph)) } fields := []stageField{{"OUTPUT", ansi.Strip(stage.Output)}} if stage.Type == "" || stage.Type == "model" { fields = append(fields, stageField{"PROMPT", ansi.Strip(stage.Prompt)}) } fields = append(fields, stageField{"CONFIGURATION", strings.Join(configs, "\n")}, stageField{"OUTCOMES", strings.Join(routes, "\n")}) if tools, ok := stage.Blocks["tools"]; ok { if strings.TrimSpace(tools) == "" { tools = "None" } fields = append(fields, stageField{"TOOLS", ansi.Strip(tools)}) } if policy, ok := stage.Blocks["permissions"]; ok { fields = append(fields, stageField{"PERMISSIONS", ansi.Strip(policy)}) } if stage.Notify != nil { fields = append(fields, stageField{"NOTIFY", "On: " + strings.Join(stage.Notify.On, ", ") + "\nConnection: global\nArtifacts: " + strings.Join(stage.Notify.Artifacts, ", ")}) } return fields } func (m Model) stageColumns(width int) (string, []string) { header, rows, _ := m.stageColumnsWithHeaders(width) return header, rows } func (m Model) stageColumnsWithHeaders(width int) (string, []string, []string) { fields := m.stageFields() if len(fields) == 0 { return "Stages", []string{"No stages."}, []string{"Stages"} } order := map[string]int{"OUTPUT": 0, "TOOLS": 1, "OUTCOMES": 2, "NOTIFY": 3, "PROMPT": 4, "PERMISSIONS": 5, "CONFIGURATION": 6} sort.SliceStable(fields, func(i, j int) bool { return order[fields[i].title] < order[fields[j].title] }) var header string var result []string var rowHeaders []string selected := m.selectedStage() collapsedConfig := !m.stageConfigExpanded && selected != nil && (selected.Type == "" || selected.Type == stageconfig.ModelType) for i, field := range fields { title := field.title if title == "CONFIGURATION" && collapsedConfig { title = "▸ CONFIGURATION · c expand" } label := lipgloss.NewStyle().Foreground(themeAccent).Bold(true).Render(title) if i == 0 { header = label } else { result = append(result, "", label) rowHeaders = append(rowHeaders, label, label) } if field.title == "CONFIGURATION" && collapsedConfig { continue } for _, line := range strings.Split(ansi.Wrap(field.text, max(1, width), ""), "\n") { result = append(result, line) rowHeaders = append(rowHeaders, label) } } return header, result, rowHeaders } func (m Model) stageLines(width int) []string { _, rows := m.stageColumns(width) return rows } func (m Model) stagePanel(width, height int) string { if width <= 0 || height <= 0 { return "" } if width < 80 { inner := max(1, width-4) heading, lines, labels := m.stageColumnsWithHeaders(inner) page := max(0, height-4) top := max(0, min(m.stageTop, max(0, len(lines)-page))) if top < len(labels) { heading = labels[top] } rows := []string{runPaneTitle("Stages", "", width, m.stageFocus), m.stageTabs(width), heading} rows = append(rows, lines[top:min(len(lines), top+page)]...) for len(rows) < height-1 { rows = append(rows, "") } rows = append(rows, bar("c configuration", fmt.Sprintf("%d–%d / %d", top+1, min(top+page, len(lines)), len(lines)), width, false)) return fitBlock(rows, width, height) } inner := max(1, width-4) rows := max(0, height-6) columns, lines, rowHeaders := m.stageColumnsWithHeaders(inner) top := max(0, min(m.stageTop, max(0, len(lines)-rows))) if top < len(rowHeaders) { columns = rowHeaders[top] } label := "Stages" if m.stageFocus { label = "▸ " + label } headers := []string{runPaneTitle(strings.TrimPrefix(label, "▸ "), fmt.Sprintf("%d / %d · rows %d–%d/%d", m.stageIndex+1, len(m.detail.Graph.Stages), min(top+1, len(lines)), min(len(lines), top+rows), len(lines)), inner, m.stageFocus), m.stageTabs(inner), columns} return panel(width, height, headers, lines[top:min(len(lines), top+rows)], "c configuration · stage definition, not a run result", m.stageFocus) } func (m *Model) resetPipelineView() { m.pipelineTop = 0 m.graphPan = 0 m.stageIndex = 0 m.stageTop = 0 m.stageFocus = false m.revealStage() } func (m *Model) revealStage() { if m.detail == nil { return } if stage := m.selectedStage(); stage != nil { row := graphStageRow(m.detail.Graph, stage.Key) page := max(1, m.pipelineGeometry(max(0, m.height-4)).graphHeight-5) if row < m.pipelineTop { m.pipelineTop = row } else if row >= m.pipelineTop+page { m.pipelineTop = row - page + 1 } if !compactGraph(m.detail.Graph) { width := max(1, m.pipelineGeometry(max(0, m.height-4)).graphWidth-4) for _, node := range layoutGraph(m.detail.Graph).nodes { if node.key != stage.Key { continue } visible := min(page, node.height) if node.y < m.pipelineTop { m.pipelineTop = node.y } else if node.y+visible > m.pipelineTop+page { m.pipelineTop = node.y + visible - page } if node.x < m.graphPan { m.graphPan = node.x } else if node.x+node.width > m.graphPan+width { m.graphPan = node.x + node.width - width } } } } } func (m *Model) clampPipelineScroll() { if m.detail == nil { return } m.stageIndex = max(0, min(m.stageIndex, max(0, len(m.detail.Graph.Stages)-1))) g := m.pipelineGeometry(max(0, m.height-4)) m.pipelineTop = max(0, min(m.pipelineTop, max(0, len(m.graphLines())-max(1, g.graphHeight-5)))) stagePage := g.stageHeight - 6 if g.stageWidth < 80 { stagePage = g.stageHeight - 4 } m.stageTop = max(0, min(m.stageTop, max(0, len(m.stageLines(max(1, g.stageWidth-4)))-max(1, stagePage)))) width := 0 for _, line := range m.graphLines() { width = max(width, lipgloss.Width(line)) } m.graphPan = max(0, min(m.graphPan, max(0, width-max(1, g.graphWidth-4)))) }