634 lines
15 KiB
Go
634 lines
15 KiB
Go
package main
|
||
|
||
// The Agents workspace: who is working, on what, and for how much.
|
||
//
|
||
// This is the view the project was missing. Paperclip already records every
|
||
// agent, every run and every run's output; nothing here is invented, and
|
||
// nothing here is stored. Three panels in one pane, switched with tabs:
|
||
//
|
||
// roster every agent, its state, its spend and its budget
|
||
// runs every run in the company, newest first
|
||
// log the output of the chosen run — watching Pi work
|
||
//
|
||
// Pause, resume and wake are the only writes, and each one is a single call to
|
||
// Paperclip, which owns the agent.
|
||
|
||
import (
|
||
"encoding/json"
|
||
"fmt"
|
||
"strings"
|
||
"time"
|
||
|
||
tea "github.com/charmbracelet/bubbletea"
|
||
"github.com/charmbracelet/lipgloss"
|
||
|
||
"paperclip-harness/tui/paperclip"
|
||
)
|
||
|
||
type agentsMsg struct {
|
||
agents []paperclip.Agent
|
||
names map[string]string
|
||
err error
|
||
}
|
||
|
||
// runsMsg is separate from agentsMsg on purpose: the company's run list is over
|
||
// a megabyte and takes eight seconds, while the roster is small and instant.
|
||
// Reading them together made the whole screen wait for the slow one.
|
||
type runsMsg struct {
|
||
runs []paperclip.AgentRun
|
||
err error
|
||
}
|
||
|
||
type runLogMsg struct {
|
||
runID string
|
||
text string
|
||
err error
|
||
}
|
||
|
||
type agentsModel struct {
|
||
client *paperclip.Client
|
||
folder string
|
||
|
||
agents []paperclip.Agent
|
||
runs []paperclip.AgentRun
|
||
names map[string]string
|
||
logRunID string
|
||
logText string
|
||
err error
|
||
notice string
|
||
readAt time.Time
|
||
|
||
tab int
|
||
cursor int
|
||
scroll int
|
||
showHelp bool
|
||
|
||
width, height int
|
||
}
|
||
|
||
var agentTabs = []string{"roster", "runs", "log"}
|
||
|
||
func newAgentsModel(c *paperclip.Client, folder string) agentsModel {
|
||
return agentsModel{client: c, folder: folder}
|
||
}
|
||
|
||
func (m agentsModel) Init() tea.Cmd {
|
||
return tea.Batch(m.load(), tickEvery(5*time.Second))
|
||
}
|
||
|
||
func (m agentsModel) load() tea.Cmd {
|
||
c := m.client
|
||
return func() tea.Msg {
|
||
agents, err := c.Agents()
|
||
if err != nil {
|
||
return agentsMsg{err: err}
|
||
}
|
||
names := map[string]string{}
|
||
for _, a := range agents {
|
||
names[a.ID] = a.Name
|
||
}
|
||
return agentsMsg{agents: agents, names: names}
|
||
}
|
||
}
|
||
|
||
// loadRuns reads the company's runs. Called when the runs tab is opened and
|
||
// when it is asked for, never on the timer: it is a megabyte and eight seconds.
|
||
func (m agentsModel) loadRuns() tea.Cmd {
|
||
c := m.client
|
||
return func() tea.Msg {
|
||
runs, err := c.CompanyRuns()
|
||
if err != nil {
|
||
return runsMsg{err: err}
|
||
}
|
||
if len(runs) > 200 {
|
||
runs = runs[:200]
|
||
}
|
||
return runsMsg{runs: runs}
|
||
}
|
||
}
|
||
|
||
func (m agentsModel) loadLog(runID string) tea.Cmd {
|
||
c := m.client
|
||
return func() tea.Msg {
|
||
if runID == "" {
|
||
return runLogMsg{}
|
||
}
|
||
// The tail, not the whole thing: a run log here is tens of thousands of
|
||
// lines and only the end says what is happening now.
|
||
// Read the whole log: the stored form is one JSON envelope, and a
|
||
// partial read cuts the envelope in half and makes it unreadable.
|
||
text, err := c.RunLog(runID, 8<<20)
|
||
return runLogMsg{runID: runID, text: text, err: err}
|
||
}
|
||
}
|
||
|
||
func (m agentsModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
|
||
switch msg := msg.(type) {
|
||
case tea.WindowSizeMsg:
|
||
m.width, m.height = msg.Width, msg.Height
|
||
return m, nil
|
||
|
||
case tickMsg:
|
||
return m, tea.Batch(m.load(), tickEvery(5*time.Second))
|
||
|
||
case tea.KeyMsg:
|
||
if m.showHelp {
|
||
m.showHelp = false
|
||
return m, nil
|
||
}
|
||
switch msg.String() {
|
||
case "?":
|
||
m.showHelp = true
|
||
return m, nil
|
||
case "q", "ctrl+c":
|
||
return m, tea.Quit
|
||
case "r":
|
||
switch m.tab {
|
||
case 1:
|
||
return m, m.loadRuns()
|
||
case 2:
|
||
return m, m.loadLog(m.logRunID)
|
||
}
|
||
return m, m.load()
|
||
case "R":
|
||
if err := startRebuild(m.folder); err != nil {
|
||
m.err = err
|
||
return m, nil
|
||
}
|
||
return m, tea.Quit
|
||
case "[", "h":
|
||
if m.tab > 0 {
|
||
m.tab--
|
||
m.scroll = 0
|
||
}
|
||
return m, nil
|
||
case "]", "l", "tab":
|
||
if m.tab < len(agentTabs)-1 {
|
||
m.tab++
|
||
m.scroll = 0
|
||
if m.tab == 1 && len(m.runs) == 0 {
|
||
return m, m.loadRuns()
|
||
}
|
||
}
|
||
return m, nil
|
||
case "up", "k":
|
||
m.scroll--
|
||
return m, nil
|
||
case "down", "j":
|
||
m.scroll++
|
||
return m, nil
|
||
case "g":
|
||
m.scroll = 0
|
||
return m, nil
|
||
case "G":
|
||
m.scroll = 1 << 30
|
||
return m, nil
|
||
case "enter":
|
||
if m.tab == 1 {
|
||
if r := m.chosenRun(); r != nil {
|
||
m.logRunID = r.ID
|
||
m.tab = 2
|
||
m.scroll = 1 << 30
|
||
return m, m.loadLog(r.ID)
|
||
}
|
||
}
|
||
return m, nil
|
||
case "p", "P", "w":
|
||
agent := m.chosenAgent()
|
||
if agent == nil {
|
||
return m, nil
|
||
}
|
||
c := m.client
|
||
action := msg.String()
|
||
return m, func() tea.Msg {
|
||
var err error
|
||
switch action {
|
||
case "p":
|
||
err = c.PauseAgent(agent.ID)
|
||
case "P":
|
||
err = c.ResumeAgent(agent.ID)
|
||
case "w":
|
||
err = c.WakeAgent(agent.ID)
|
||
}
|
||
if err != nil {
|
||
return errMsg{err}
|
||
}
|
||
agents, err := c.Agents()
|
||
if err != nil {
|
||
return errMsg{err}
|
||
}
|
||
return agentsMsg{agents: agents}
|
||
}
|
||
case "esc":
|
||
return m, nil
|
||
}
|
||
|
||
case agentsMsg:
|
||
if msg.agents != nil {
|
||
m.agents = msg.agents
|
||
}
|
||
m.names = msg.names
|
||
if msg.err != nil {
|
||
m.err = msg.err
|
||
} else {
|
||
m.err = nil
|
||
}
|
||
m.readAt = time.Now()
|
||
return m, nil
|
||
|
||
case runsMsg:
|
||
if msg.runs != nil {
|
||
m.runs = msg.runs
|
||
m.readAt = time.Now()
|
||
}
|
||
if msg.err != nil {
|
||
m.err = msg.err
|
||
} else {
|
||
m.err = nil
|
||
}
|
||
return m, nil
|
||
|
||
case runLogMsg:
|
||
if msg.runID != "" {
|
||
m.logRunID = msg.runID
|
||
}
|
||
m.logText = msg.text
|
||
if msg.err != nil {
|
||
m.err = msg.err
|
||
}
|
||
return m, nil
|
||
|
||
case errMsg:
|
||
m.err = msg.err
|
||
return m, nil
|
||
}
|
||
return m, nil
|
||
}
|
||
|
||
// chosenRun is the run the roster cursor is on, in the runs tab.
|
||
func (m agentsModel) chosenRun() *paperclip.AgentRun {
|
||
if m.cursor >= 0 && m.cursor < len(m.runs) {
|
||
return &m.runs[m.cursor]
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// chosenAgent is the agent whose name matches the chosen run, or the first one.
|
||
func (m agentsModel) chosenAgent() *paperclip.Agent {
|
||
if r := m.chosenRun(); r != nil {
|
||
for i := range m.agents {
|
||
if m.agents[i].ID == r.AgentID {
|
||
return &m.agents[i]
|
||
}
|
||
}
|
||
}
|
||
if len(m.agents) > 0 {
|
||
return &m.agents[0]
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (m agentsModel) View() string {
|
||
if m.width == 0 || m.height == 0 {
|
||
return "reading…"
|
||
}
|
||
if m.width < 80 || m.height < 24 {
|
||
return lipgloss.NewStyle().Width(m.width).Height(m.height).Render(
|
||
fmt.Sprintf("This workspace needs 80 × 24.\nThis panel is %d × %d.", m.width, m.height))
|
||
}
|
||
|
||
if m.showHelp {
|
||
return helpOverlay("agents", [][2]string{
|
||
{"[ ] h l", "roster, runs, log"},
|
||
{"enter", "open the chosen run's log"},
|
||
{"p / P", "pause / resume the agent"},
|
||
{"w", "wake the agent now"},
|
||
{"↑ ↓ j k", "scroll"},
|
||
{"r / R", "read again / rebuild"},
|
||
{"q", "leave"},
|
||
}, m.width, m.height)
|
||
}
|
||
|
||
head := titleStyle.Render("Agents") + mutedStyle2().Render(" · who is working, on what, for how much")
|
||
state := "read " + m.readAt.Format("15:04:05")
|
||
if m.readAt.IsZero() {
|
||
state = "reading…"
|
||
}
|
||
|
||
var body []string
|
||
switch m.tab {
|
||
case 0:
|
||
body = m.rosterLines(m.width - 4)
|
||
case 1:
|
||
body = m.runLines(m.width - 4)
|
||
default:
|
||
body = m.logLines(m.width - 4)
|
||
}
|
||
|
||
p := panel{title: fmt.Sprintf("agents · %d agent(s), %d run(s)", len(m.agents), len(m.runs)),
|
||
width: m.width, height: m.height - 2, tabs: agentTabs, active: m.tab, focused: true}
|
||
visible := p.bodyHeight()
|
||
maxScroll := max(0, len(body)-visible)
|
||
if m.scroll > maxScroll {
|
||
m.scroll = maxScroll
|
||
}
|
||
if m.scroll < 0 {
|
||
m.scroll = 0
|
||
}
|
||
from := m.scroll
|
||
to := min(len(body), from+visible)
|
||
|
||
footer := hintLine([]string{
|
||
keyHint("[ ]", "roster, runs, log"),
|
||
keyHint("enter", "open a run"),
|
||
keyHint("p P w", "pause, resume, wake"),
|
||
keyHint("r", "read again"),
|
||
keyHint("?", "keys"),
|
||
}, m.width)
|
||
if m.notice != "" {
|
||
footer = lipgloss.NewStyle().Foreground(lipgloss.Color(active.Success)).Render(m.notice)
|
||
}
|
||
if m.err != nil {
|
||
footer = lipgloss.NewStyle().Foreground(lipgloss.Color(active.Error)).Render(truncateVisible("error: "+m.err.Error(), m.width))
|
||
}
|
||
|
||
gap := max(2, m.width-lipgloss.Width(head)-lipgloss.Width(state)-1)
|
||
return strings.Join([]string{
|
||
head + strings.Repeat(" ", gap) + mutedStyle2().Render(state),
|
||
p.render(body[from:to]),
|
||
footer,
|
||
}, "\n")
|
||
}
|
||
|
||
func (m agentsModel) rosterLines(width int) []string {
|
||
out := []string{"", dimStyle().Render(fmt.Sprintf(" %-16s %-10s %-18s %8s %8s", "agent", "state", "working on", "spent", "budget"))}
|
||
for _, a := range m.agents {
|
||
mark := icons.Todo
|
||
if a.Status == "idle" {
|
||
mark = icons.Done
|
||
}
|
||
working := "—"
|
||
for _, r := range m.runs {
|
||
if r.AgentID == a.ID && r.Status == "running" {
|
||
working = m.taskLabel(r)
|
||
mark = icons.Running
|
||
break
|
||
}
|
||
}
|
||
out = append(out, fmt.Sprintf(" %s %-16s %-10s %-18s %6d c %6d c",
|
||
mark, a.Name, a.Status, truncateVisible(working, 18), a.SpentCents, a.BudgetCents))
|
||
}
|
||
out = append(out, "")
|
||
out = append(out, dimStyle().Render(" c means cents. Budget is set in Paperclip; change it there, not here."))
|
||
return out
|
||
}
|
||
|
||
func (m agentsModel) taskLabel(r paperclip.AgentRun) string {
|
||
if r.Snapshot.IssueID != "" {
|
||
return short(r.Snapshot.IssueID)
|
||
}
|
||
if r.Snapshot.TaskKey != "" {
|
||
return short(r.Snapshot.TaskKey)
|
||
}
|
||
return "—"
|
||
}
|
||
|
||
func (m agentsModel) runLines(width int) []string {
|
||
if len(m.runs) == 0 {
|
||
return []string{"", mutedStyle2().Render("no runs recorded")}
|
||
}
|
||
out := []string{"", dimStyle().Render(fmt.Sprintf(" %-10s %-11s %-9s %-12s %-8s %s",
|
||
"when", "agent", "state", "woken by", "took", "task"))}
|
||
for _, r := range m.runs {
|
||
when := "-"
|
||
if t, err := time.Parse(time.RFC3339, r.StartedAt); err == nil {
|
||
when = t.Local().Format("15:04:05")
|
||
}
|
||
took := "-"
|
||
if r.FinishedAt != "" {
|
||
if s, err := time.Parse(time.RFC3339, r.StartedAt); err == nil {
|
||
if f, err := time.Parse(time.RFC3339, r.FinishedAt); err == nil {
|
||
took = f.Sub(s).Round(time.Second).String()
|
||
}
|
||
}
|
||
} else if r.Status == "running" {
|
||
took = "running"
|
||
}
|
||
colour := active.Text
|
||
switch r.Status {
|
||
case "running":
|
||
colour = active.Info
|
||
case "succeeded":
|
||
colour = active.Success
|
||
case "failed":
|
||
colour = active.Error
|
||
}
|
||
out = append(out, fmt.Sprintf(" %-10s %-11s %-9s %-12s %-8s %s",
|
||
when, truncateVisible(m.names[r.AgentID], 11),
|
||
lipgloss.NewStyle().Foreground(lipgloss.Color(colour)).Render(fmt.Sprintf("%-9s", r.Status)),
|
||
r.Source, took, m.taskLabel(r)))
|
||
}
|
||
return out
|
||
}
|
||
|
||
// logEntry is one readable line out of a run log.
|
||
type logEntry struct {
|
||
when string
|
||
stream string
|
||
line string
|
||
}
|
||
|
||
// decodeRunLog turns what Paperclip stores into something a person can read.
|
||
//
|
||
// A run log is not lines of prose: it is an envelope around newline-separated
|
||
// JSON, and most of those are token-by-token streaming events. Printed raw they
|
||
// are unreadable and they redraw the panel. So deltas are gathered back into
|
||
// paragraphs, and everything else becomes one labelled line.
|
||
func decodeRunLog(raw string) []logEntry {
|
||
var envelope struct {
|
||
Content string `json:"content"`
|
||
}
|
||
content := raw
|
||
if json.Unmarshal([]byte(raw), &envelope) == nil && envelope.Content != "" {
|
||
content = envelope.Content
|
||
}
|
||
|
||
var out []logEntry
|
||
var buf strings.Builder
|
||
bufWhen := ""
|
||
flush := func() {
|
||
text := strings.TrimSpace(cleanText(buf.String()))
|
||
buf.Reset()
|
||
if text == "" {
|
||
return
|
||
}
|
||
for _, para := range strings.Split(text, "\n") {
|
||
para = strings.TrimSpace(para)
|
||
if para != "" {
|
||
out = append(out, logEntry{when: bufWhen, stream: "thinking", line: para})
|
||
}
|
||
}
|
||
}
|
||
|
||
for _, line := range strings.Split(content, "\n") {
|
||
line = strings.TrimSpace(line)
|
||
if line == "" {
|
||
continue
|
||
}
|
||
var rec struct {
|
||
TS string `json:"ts"`
|
||
Stream string `json:"stream"`
|
||
Chunk string `json:"chunk"`
|
||
}
|
||
text := line
|
||
when := ""
|
||
if json.Unmarshal([]byte(line), &rec) == nil && rec.Chunk != "" {
|
||
text, when = rec.Chunk, shortTime(rec.TS)
|
||
}
|
||
|
||
var ev struct {
|
||
Type string `json:"type"`
|
||
Delta string `json:"delta"`
|
||
Message struct {
|
||
Role string `json:"role"`
|
||
Content []struct {
|
||
Type string `json:"type"`
|
||
Text string `json:"text"`
|
||
} `json:"content"`
|
||
} `json:"message"`
|
||
AssistantMessageEvent struct {
|
||
Type string `json:"type"`
|
||
Delta string `json:"delta"`
|
||
} `json:"assistantMessageEvent"`
|
||
}
|
||
|
||
if json.Unmarshal([]byte(text), &ev) != nil {
|
||
// Not JSON we know: show it as a line, trimmed.
|
||
if t := strings.TrimSpace(cleanText(text)); t != "" {
|
||
out = append(out, logEntry{when: when, line: t})
|
||
}
|
||
continue
|
||
}
|
||
|
||
kind := ev.AssistantMessageEvent.Type
|
||
if ev.Type == "message_update" && strings.HasSuffix(kind, "_delta") {
|
||
if bufWhen == "" {
|
||
bufWhen = when
|
||
}
|
||
buf.WriteString(ev.AssistantMessageEvent.Delta)
|
||
continue
|
||
}
|
||
|
||
// Anything else ends the paragraph that was being gathered.
|
||
flush()
|
||
bufWhen = when
|
||
|
||
switch ev.Type {
|
||
case "message_start", "message_end":
|
||
role := ev.Message.Role
|
||
if role == "" {
|
||
continue
|
||
}
|
||
for _, c := range ev.Message.Content {
|
||
t := strings.TrimSpace(cleanText(c.Text))
|
||
if t == "" {
|
||
continue
|
||
}
|
||
if i := strings.Index(t, "\n"); i > 0 {
|
||
t = t[:i]
|
||
}
|
||
out = append(out, logEntry{when: when, stream: "prompt", line: role + ": " + t})
|
||
break
|
||
}
|
||
case "tool_call", "tool_result", "tool_use":
|
||
out = append(out, logEntry{when: when, stream: "tool", line: ev.Type})
|
||
case "turn_start", "turn_end", "session", "agent_start", "agent_end":
|
||
out = append(out, logEntry{when: when, stream: "event", line: ev.Type})
|
||
default:
|
||
if kind != "" {
|
||
out = append(out, logEntry{when: when, stream: "event", line: kind})
|
||
}
|
||
}
|
||
}
|
||
flush()
|
||
|
||
if len(out) == 0 {
|
||
for _, line := range strings.Split(strings.TrimRight(content, "\n"), "\n") {
|
||
if t := strings.TrimSpace(cleanText(line)); t != "" {
|
||
out = append(out, logEntry{line: t})
|
||
}
|
||
}
|
||
}
|
||
return out
|
||
}
|
||
|
||
// shortTime is the clock time of a log line, in the reader's timezone.
|
||
func shortTime(ts string) string {
|
||
if t, err := time.Parse(time.RFC3339Nano, ts); err == nil {
|
||
return t.Local().Format("15:04:05")
|
||
}
|
||
return ""
|
||
}
|
||
|
||
// cleanText removes escape sequences and control characters, so a log cannot
|
||
// repaint the panel it is drawn in.
|
||
func cleanText(s string) string {
|
||
var b strings.Builder
|
||
skip := false
|
||
for _, r := range s {
|
||
if r == 0x1b {
|
||
skip = true
|
||
continue
|
||
}
|
||
if skip {
|
||
if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') {
|
||
skip = false
|
||
}
|
||
continue
|
||
}
|
||
if r == '\t' {
|
||
b.WriteString(" ")
|
||
continue
|
||
}
|
||
if r < 0x20 && r != '\n' {
|
||
continue
|
||
}
|
||
b.WriteRune(r)
|
||
}
|
||
return b.String()
|
||
}
|
||
|
||
func (m agentsModel) logLines(width int) []string {
|
||
if m.logRunID == "" {
|
||
return []string{"", mutedStyle2().Render("choose a run on the runs tab, then press enter")}
|
||
}
|
||
if m.logText == "" {
|
||
return []string{"", mutedStyle2().Render("no output recorded for this run")}
|
||
}
|
||
var out []string
|
||
out = append(out, "", dimStyle().Render(" run "+short(m.logRunID)))
|
||
entries := decodeRunLog(m.logText)
|
||
if len(entries) > 2000 {
|
||
entries = entries[len(entries)-2000:]
|
||
}
|
||
for _, e := range entries {
|
||
if lipgloss.Width(e.line) > width {
|
||
e.line = truncateVisible(e.line, width)
|
||
}
|
||
colour := active.Text
|
||
switch e.stream {
|
||
case "thinking":
|
||
colour = active.Muted
|
||
case "prompt":
|
||
colour = active.Info
|
||
case "tool":
|
||
colour = active.Warning
|
||
case "event":
|
||
colour = active.Overlay
|
||
}
|
||
out = append(out, " "+dimStyle().Render(e.when)+" "+
|
||
lipgloss.NewStyle().Foreground(lipgloss.Color(colour)).Render(e.line))
|
||
}
|
||
return out
|
||
}
|