772 lines
21 KiB
Go
772 lines
21 KiB
Go
package main
|
||
|
||
// The Board workspace: the state of the work, and what needs a person.
|
||
//
|
||
// Three panels on one page: the task tree, the summary of the chosen task, and
|
||
// the list of things waiting for a decision. Choosing a task changes what the
|
||
// other panels show, here and in every other workspace, because the choice is
|
||
// written to the project's own .harness file.
|
||
|
||
import (
|
||
"fmt"
|
||
"os"
|
||
"path/filepath"
|
||
"regexp"
|
||
"strings"
|
||
"time"
|
||
|
||
tea "github.com/charmbracelet/bubbletea"
|
||
"github.com/charmbracelet/lipgloss"
|
||
zone "github.com/lrstanley/bubblezone"
|
||
|
||
"paperclip-harness/tui/paperclip"
|
||
)
|
||
|
||
type boardDetailMsg struct {
|
||
issueID string
|
||
runs []paperclip.Run
|
||
cost paperclip.Cost
|
||
activity []paperclip.Activity
|
||
err error
|
||
}
|
||
|
||
type boardModel struct {
|
||
client *paperclip.Client
|
||
project paperclip.Project
|
||
folder string
|
||
|
||
rows []Row
|
||
cursor int
|
||
focus int // 0 tree, 1 summary, 2 needs-you
|
||
loading bool
|
||
readAt time.Time
|
||
notice string
|
||
err error
|
||
|
||
detailID string
|
||
runs []paperclip.Run
|
||
cost paperclip.Cost
|
||
activity []paperclip.Activity
|
||
needsTab int
|
||
|
||
tools bool
|
||
toolAt int
|
||
zones *zone.Manager
|
||
filter string
|
||
typing bool
|
||
showHelp bool
|
||
|
||
width, height int
|
||
}
|
||
|
||
const (
|
||
focusTree = iota
|
||
focusSummary
|
||
focusNeeds
|
||
focusCount
|
||
)
|
||
|
||
func newBoardModel(c *paperclip.Client, proj paperclip.Project, folder string) boardModel {
|
||
// One click-zone manager for the whole program, created once. Wrapping each
|
||
// panel separately drifts as soon as a pane is resized.
|
||
return boardModel{client: c, project: proj, folder: folder, loading: true, zones: zone.New()}
|
||
}
|
||
|
||
func (m boardModel) Init() tea.Cmd {
|
||
return tea.Batch(m.reload(), tickEvery(5*time.Second), tea.WindowSize())
|
||
}
|
||
|
||
func (m boardModel) reload() tea.Cmd {
|
||
c, proj, want := m.client, m.project, m.selectedID()
|
||
return func() tea.Msg {
|
||
rows, err := loadRows(c, proj)
|
||
if err != nil {
|
||
return errMsg{err}
|
||
}
|
||
_ = want
|
||
return rowsMsg(rows)
|
||
}
|
||
}
|
||
|
||
func (m boardModel) loadDetail(id string) tea.Cmd {
|
||
c := m.client
|
||
return func() tea.Msg {
|
||
if id == "" {
|
||
return boardDetailMsg{}
|
||
}
|
||
runs, err := c.Runs(id)
|
||
if err != nil {
|
||
return boardDetailMsg{issueID: id, err: err}
|
||
}
|
||
cost, _ := c.CostSummary(id)
|
||
act, _ := c.Activity(id)
|
||
return boardDetailMsg{issueID: id, runs: runs, cost: cost, activity: act}
|
||
}
|
||
}
|
||
|
||
// visible is the list after the filter. The cursor moves over this, so what is
|
||
// highlighted is always what would be acted on.
|
||
func (m boardModel) visible() []Row {
|
||
if m.filter == "" {
|
||
return m.rows
|
||
}
|
||
needle := strings.ToLower(m.filter)
|
||
var out []Row
|
||
for _, r := range m.rows {
|
||
if strings.Contains(strings.ToLower(r.Issue.Identifier), needle) ||
|
||
strings.Contains(strings.ToLower(r.Issue.Title), needle) ||
|
||
strings.Contains(strings.ToLower(r.Who), needle) {
|
||
out = append(out, r)
|
||
}
|
||
}
|
||
return out
|
||
}
|
||
|
||
func (m boardModel) selectedID() string {
|
||
vis := m.visible()
|
||
if m.cursor >= 0 && m.cursor < len(vis) {
|
||
return vis[m.cursor].Issue.ID
|
||
}
|
||
return ""
|
||
}
|
||
|
||
func (m boardModel) selectedTask() *Row {
|
||
vis := m.visible()
|
||
if m.cursor >= 0 && m.cursor < len(vis) {
|
||
return &vis[m.cursor]
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (m boardModel) 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.reload(), tickEvery(5*time.Second))
|
||
|
||
case tea.MouseMsg:
|
||
if msg.Action == tea.MouseActionPress && msg.Button == tea.MouseButtonLeft {
|
||
for i, r := range m.visible() {
|
||
if z := m.zones.Get("row-" + r.Issue.ID); z != nil && z.InBounds(msg) {
|
||
m.cursor = i
|
||
return m, m.loadDetail(r.Issue.ID)
|
||
}
|
||
}
|
||
}
|
||
return m, nil
|
||
|
||
case tea.KeyMsg:
|
||
if m.tools {
|
||
switch msg.String() {
|
||
case "esc", "q", "t":
|
||
m.tools = false
|
||
return m, nil
|
||
case "up", "k":
|
||
m.toolAt = max(0, m.toolAt-1)
|
||
return m, nil
|
||
case "down", "j":
|
||
m.toolAt = min(len(tools)-1, m.toolAt+1)
|
||
return m, nil
|
||
case "g":
|
||
m.toolAt = 0
|
||
return m, nil
|
||
case "G":
|
||
m.toolAt = len(tools) - 1
|
||
return m, nil
|
||
case "enter":
|
||
t := tools[m.toolAt]
|
||
m.tools = false
|
||
if err := openTool(m.folder, t.name); err != nil {
|
||
m.err = err
|
||
}
|
||
return m, nil
|
||
}
|
||
return m, nil
|
||
}
|
||
if m.showHelp {
|
||
m.showHelp = false
|
||
return m, nil
|
||
}
|
||
if m.typing {
|
||
switch msg.Type {
|
||
case tea.KeyEsc:
|
||
m.typing = false
|
||
m.filter = ""
|
||
return m, nil
|
||
case tea.KeyEnter, tea.KeyTab:
|
||
m.typing = false
|
||
return m, nil
|
||
case tea.KeyBackspace:
|
||
r := []rune(m.filter)
|
||
if len(r) > 0 {
|
||
m.filter = string(r[:len(r)-1])
|
||
}
|
||
return m, nil
|
||
case tea.KeySpace:
|
||
m.filter += " "
|
||
return m, nil
|
||
case tea.KeyRunes:
|
||
m.filter += string(msg.Runes)
|
||
return m, nil
|
||
}
|
||
return m, nil
|
||
}
|
||
|
||
switch msg.String() {
|
||
case "q", "ctrl+c":
|
||
return m, tea.Quit
|
||
case "?":
|
||
m.showHelp = true
|
||
return m, nil
|
||
case "t":
|
||
m.tools = true
|
||
return m, nil
|
||
case "/":
|
||
m.typing = true
|
||
return m, nil
|
||
case "u":
|
||
// A task whose blocker finished but which still says blocked is the
|
||
// one thing a person unblocks without reading anything else.
|
||
if r := m.selectedTask(); r != nil && isReadyButBlocked(*r) {
|
||
c, id := m.client, r.Issue.ID
|
||
return m, func() tea.Msg {
|
||
if _, err := c.SetStatus(id, "todo", "Unblocked: its blocker finished."); err != nil {
|
||
return errMsg{err}
|
||
}
|
||
rows, err := loadRows(c, m.project)
|
||
if err != nil {
|
||
return errMsg{err}
|
||
}
|
||
return rowsMsg(rows)
|
||
}
|
||
}
|
||
return m, nil
|
||
case "tab":
|
||
m.focus = (m.focus + 1) % focusCount
|
||
return m, nil
|
||
case "shift+tab":
|
||
m.focus = (m.focus + focusCount - 1) % focusCount
|
||
return m, nil
|
||
case "r":
|
||
m.loading = true
|
||
return m, m.reload()
|
||
case "R":
|
||
if err := startRebuild(m.folder); err != nil {
|
||
m.err = err
|
||
return m, nil
|
||
}
|
||
return m, tea.Quit
|
||
case "up", "k":
|
||
if m.cursor > 0 {
|
||
m.cursor--
|
||
return m, m.loadDetail(m.selectedID())
|
||
}
|
||
return m, nil
|
||
case "down", "j":
|
||
if m.cursor < len(m.visible())-1 {
|
||
m.cursor++
|
||
return m, m.loadDetail(m.selectedID())
|
||
}
|
||
return m, nil
|
||
case "a":
|
||
if r := m.selectedTask(); r != nil && r.Issue.AssigneeAgent == "" {
|
||
c, id, agent := m.client, r.Issue.ID, defaultAgent
|
||
return m, func() tea.Msg {
|
||
if _, err := c.Assign(id, agent); err != nil {
|
||
return errMsg{err}
|
||
}
|
||
rows, err := loadRows(c, m.project)
|
||
if err != nil {
|
||
return errMsg{err}
|
||
}
|
||
return rowsMsg(rows)
|
||
}
|
||
}
|
||
return m, nil
|
||
case "enter":
|
||
if r := m.selectedTask(); r != nil {
|
||
if err := rememberTask(m.folder, r.Issue.Identifier); err != nil {
|
||
m.err = err
|
||
return m, nil
|
||
}
|
||
m.notice = "showing " + r.Issue.Identifier + " in every workspace"
|
||
// On the needs panel, enter also takes you where the answer is.
|
||
if m.focus == focusNeeds {
|
||
if err := switchWorkspace("Reply"); err != nil {
|
||
m.err = err
|
||
}
|
||
}
|
||
}
|
||
return m, nil
|
||
case "(", "[", "h":
|
||
if m.focus == focusNeeds && m.needsTab > 0 {
|
||
m.needsTab--
|
||
}
|
||
return m, nil
|
||
case "]", "l":
|
||
if m.focus == focusNeeds && m.needsTab < 1 {
|
||
m.needsTab++
|
||
}
|
||
return m, nil
|
||
case "esc":
|
||
m.notice = ""
|
||
return m, nil
|
||
}
|
||
|
||
case rowsMsg:
|
||
m.rows = msg
|
||
m.loading = false
|
||
m.readAt = time.Now()
|
||
m.err = nil
|
||
if m.cursor >= len(m.visible()) {
|
||
m.cursor = max(0, len(m.visible())-1)
|
||
}
|
||
if id := m.selectedID(); id != "" && id != m.detailID {
|
||
return m, m.loadDetail(id)
|
||
}
|
||
return m, nil
|
||
|
||
case boardDetailMsg:
|
||
m.detailID = msg.issueID
|
||
m.runs = msg.runs
|
||
m.cost = msg.cost
|
||
m.activity = msg.activity
|
||
if msg.err != nil {
|
||
m.err = msg.err
|
||
}
|
||
return m, nil
|
||
|
||
case errMsg:
|
||
m.err = msg.err
|
||
m.loading = false
|
||
return m, nil
|
||
}
|
||
return m, nil
|
||
}
|
||
|
||
func tickEvery(d time.Duration) tea.Cmd {
|
||
return tea.Tick(d, func(t time.Time) tea.Msg { return tickMsg(t) })
|
||
}
|
||
|
||
func (m boardModel) 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.\n\nMake it larger, or use Tab and zoom.",
|
||
m.width, m.height))
|
||
}
|
||
|
||
if m.tools {
|
||
entries := make([][2]string, 0, len(tools))
|
||
for i, t := range tools {
|
||
mark := " "
|
||
if i == m.toolAt {
|
||
mark = "▸ "
|
||
}
|
||
entries = append(entries, [2]string{mark + t.name, t.about})
|
||
}
|
||
return helpOverlay("open a tool pane here", entries, m.width, m.height)
|
||
}
|
||
if m.showHelp {
|
||
return helpOverlay("keys on this panel", [][2]string{
|
||
{"↑ ↓ j k", "choose a task"},
|
||
{"enter", "show that task in every workspace"},
|
||
{"a", "assign it to the configured agent"},
|
||
{"u", "unblock it, when its blocker has finished"},
|
||
{"/", "filter the list by identifier, title or name"},
|
||
{"tab", "move to the next panel"},
|
||
{"r / R", "read again / rebuild every pane"},
|
||
{"q", "leave this panel"},
|
||
}, m.width, m.height)
|
||
}
|
||
|
||
header := m.headerLine()
|
||
footer := m.footerLine()
|
||
bodyHeight := m.height - 2
|
||
|
||
// Three ways to use the same width, chosen by what the terminal actually
|
||
// has. Wide screens get the three panels side by side; narrow ones stack.
|
||
if m.width >= 140 {
|
||
treeW := max(34, m.width*30/100)
|
||
sumW := max(38, m.width*38/100)
|
||
needsW := max(30, m.width-treeW-sumW-2)
|
||
|
||
left := panel{title: "tasks", width: treeW, height: bodyHeight, focused: m.focus == focusTree}
|
||
mid := panel{title: "the chosen task", width: sumW, height: bodyHeight, focused: m.focus == focusSummary}
|
||
rightP := panel{
|
||
title: "needs you", width: needsW, height: bodyHeight,
|
||
tabs: []string{"decisions", "activity"}, active: m.needsTab, focused: m.focus == focusNeeds,
|
||
}
|
||
body := m.needsLines(needsW-3, bodyHeight-3)
|
||
if m.needsTab == 1 {
|
||
body = m.activityLines(needsW-3, bodyHeight-3)
|
||
}
|
||
page := lipgloss.JoinHorizontal(lipgloss.Top,
|
||
left.render(m.treeLines(treeW-3)), " ",
|
||
mid.render(m.summaryLines(sumW-3)), " ",
|
||
rightP.render(body))
|
||
return m.zones.Scan(strings.Join([]string{header, page, footer}, "\n"))
|
||
}
|
||
|
||
leftWidth := max(34, m.width*40/100)
|
||
rightWidth := max(30, m.width-leftWidth-1)
|
||
|
||
// Left: the task tree.
|
||
tree := panel{title: "tasks", width: leftWidth, height: bodyHeight, focused: m.focus == focusTree}
|
||
treeLines := m.treeLines(leftWidth - 3)
|
||
left := tree.render(treeLines)
|
||
|
||
// Right, upper: the summary of the chosen task.
|
||
sumHeight := max(10, bodyHeight*58/100)
|
||
sum := panel{title: "the chosen task", width: rightWidth, height: sumHeight, focused: m.focus == focusSummary}
|
||
// Right, lower: what needs a person.
|
||
needsHeight := bodyHeight - sumHeight
|
||
needs := panel{
|
||
title: "needs you", width: rightWidth, height: needsHeight,
|
||
tabs: []string{"decisions", "activity"}, active: m.needsTab, focused: m.focus == focusNeeds,
|
||
}
|
||
needsBody := m.needsLines(rightWidth-3, needsHeight-3)
|
||
if m.needsTab == 1 {
|
||
needsBody = m.activityLines(rightWidth-3, needsHeight-3)
|
||
}
|
||
|
||
right := lipgloss.JoinVertical(lipgloss.Left,
|
||
sum.render(m.summaryLines(rightWidth-3)),
|
||
needs.render(needsBody),
|
||
)
|
||
|
||
page := lipgloss.JoinHorizontal(lipgloss.Top, left, " ", right)
|
||
return m.zones.Scan(strings.Join([]string{header, page, footer}, "\n"))
|
||
}
|
||
|
||
func (m boardModel) headerLine() string {
|
||
left := panelTitleStyle().Render("Board") + mutedStyle2().Render(" · "+m.project.Name)
|
||
state := "reading…"
|
||
if !m.readAt.IsZero() {
|
||
state = "read " + m.readAt.Format("15:04:05")
|
||
}
|
||
if m.loading {
|
||
state = "reading…"
|
||
}
|
||
if m.err != nil {
|
||
state = "last read failed"
|
||
}
|
||
right := mutedStyle2().Render(state)
|
||
gap := max(2, m.width-lipgloss.Width(left)-lipgloss.Width(right)-2)
|
||
if m.notice != "" {
|
||
right = lipgloss.NewStyle().Foreground(lipgloss.Color(active.Success)).Render(m.notice)
|
||
gap = max(2, m.width-lipgloss.Width(left)-lipgloss.Width(right)-2)
|
||
}
|
||
return left + strings.Repeat(" ", gap) + right
|
||
}
|
||
|
||
func (m boardModel) footerLine() string {
|
||
switch m.focus {
|
||
case focusTree:
|
||
return hintLine([]string{
|
||
keyHint("↑↓", "move"),
|
||
keyHint("enter", "open"),
|
||
keyHint("a", "assign"),
|
||
keyHint("u", "unblock"),
|
||
keyHint("t", "tools"),
|
||
keyHint("/", "filter"),
|
||
keyHint("?", "keys"),
|
||
keyHint("tab", "panel"),
|
||
keyHint("r", "refresh"),
|
||
keyHint("R", "rebuild"),
|
||
keyHint("q", "quit"),
|
||
}, m.width)
|
||
case focusSummary:
|
||
return hintLine([]string{
|
||
keyHint("↑↓", "move"),
|
||
keyHint("tab", "panel"),
|
||
keyHint("r", "refresh"),
|
||
keyHint("q", "quit"),
|
||
}, m.width)
|
||
default:
|
||
return hintLine([]string{
|
||
keyHint("tab", "panel"),
|
||
keyHint("( )", "tab"),
|
||
keyHint("enter", "show this task everywhere"),
|
||
keyHint("r", "refresh"),
|
||
keyHint("q", "quit"),
|
||
}, m.width)
|
||
}
|
||
}
|
||
|
||
// treeLines draws the grouped task list.
|
||
func (m boardModel) treeLines(width int) []string {
|
||
var out []string
|
||
vis := m.visible()
|
||
if len(vis) == 0 && !m.loading {
|
||
if m.filter != "" {
|
||
return []string{mutedStyle2().Render(" nothing matches " + m.filter)}
|
||
}
|
||
return []string{mutedStyle2().Render(" no tasks in this project")}
|
||
}
|
||
index := 0
|
||
for _, g := range groupOrder {
|
||
var group []Row
|
||
for _, r := range vis {
|
||
if r.Group == g {
|
||
group = append(group, r)
|
||
}
|
||
}
|
||
if len(group) == 0 {
|
||
continue
|
||
}
|
||
out = append(out, groupHeading(g, len(group), width))
|
||
for _, r := range group {
|
||
out = append(out, m.taskLine(r, index, width)...)
|
||
index++
|
||
}
|
||
out = append(out, "")
|
||
}
|
||
return out
|
||
}
|
||
|
||
// groupHeading is a label, a rule, and how many tasks are under it. The rule
|
||
// makes the groups visible at a glance without a box around every one.
|
||
func groupHeading(name string, count, width int) string {
|
||
label := lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color(active.Mauve)).Render(strings.ToUpper(name))
|
||
n := ""
|
||
if count >= 0 {
|
||
n = lipgloss.NewStyle().Foreground(lipgloss.Color(active.Muted)).Render(fmt.Sprintf(" %d ", count))
|
||
}
|
||
rule := strings.Repeat("─", max(0, width-lipgloss.Width(label)-lipgloss.Width(n)))
|
||
return label + dimStyle().Render(rule) + n
|
||
}
|
||
|
||
func (m boardModel) taskLine(r Row, index, width int) []string {
|
||
chosen := index == m.cursor
|
||
cursor := " "
|
||
firstStyle := lipgloss.NewStyle().Foreground(lipgloss.Color(active.Text))
|
||
secondStyle := mutedStyle2()
|
||
if chosen {
|
||
cursor = "▸ "
|
||
if m.focus == focusTree {
|
||
firstStyle = selectedStyle2()
|
||
secondStyle = lipgloss.NewStyle().Foreground(lipgloss.Color(active.Base))
|
||
} else {
|
||
firstStyle = lipgloss.NewStyle().Foreground(lipgloss.Color(active.Accent)).Bold(true)
|
||
secondStyle = mutedStyle2()
|
||
}
|
||
}
|
||
|
||
status, _ := shortStatus(r.Issue.Status)
|
||
who := r.Who
|
||
if who == "" || who == "—" {
|
||
who = "unassigned"
|
||
}
|
||
first := fmt.Sprintf("%s%-8s %-8s %s", cursor, r.Issue.Identifier, status, who)
|
||
second := " " + r.Issue.Title
|
||
if note := blockerNote(r); note != "" {
|
||
second += " " + note
|
||
}
|
||
|
||
if lipgloss.Width(first) > width {
|
||
first = truncateVisible(first, width)
|
||
}
|
||
if lipgloss.Width(second) > width {
|
||
second = truncateVisible(second, width)
|
||
}
|
||
if chosen {
|
||
first, second = padTo(first, width), padTo(second, width)
|
||
}
|
||
return []string{
|
||
m.zones.Mark("row-"+r.Issue.ID, firstStyle.Render(first)),
|
||
secondStyle.Render(second),
|
||
}
|
||
}
|
||
|
||
// shortStatus is the one word a row has room for.
|
||
func shortStatus(status string) (string, string) {
|
||
switch status {
|
||
case "in_progress":
|
||
return icons.Running + " running", active.Info
|
||
case "blocked":
|
||
return icons.Blocked + " blocked", active.Error
|
||
case "in_review":
|
||
return icons.Review + " review", active.Warning
|
||
case "done":
|
||
return icons.Done + " done", active.Success
|
||
case "cancelled":
|
||
return icons.Cancelled + " gone", active.Overlay
|
||
case "backlog":
|
||
return icons.Todo + " backlog", active.Muted
|
||
default:
|
||
return icons.Todo + " todo", active.Text
|
||
}
|
||
}
|
||
|
||
// isReadyButBlocked is the state that confuses people most: everything it was
|
||
// waiting for has finished, and the task still says blocked.
|
||
func isReadyButBlocked(r Row) bool {
|
||
return r.Blocker != nil &&
|
||
len(r.Blocker.BlockingIdentities) > 0 &&
|
||
r.Blocker.UnresolvedCount == 0 &&
|
||
r.Blocker.AllBlockersDone &&
|
||
r.Issue.Status == "blocked"
|
||
}
|
||
|
||
func blockerNote(r Row) string {
|
||
if r.Blocker == nil {
|
||
return ""
|
||
}
|
||
if r.Blocker.UnresolvedCount > 0 {
|
||
return dimStyle().Render("waits on " + strings.Join(r.Blocker.BlockingIdentities, ", "))
|
||
}
|
||
if r.Blocker.AllBlockersDone && r.Issue.Status == "blocked" {
|
||
return badge("ready", active.Warning)
|
||
}
|
||
return ""
|
||
}
|
||
|
||
func (m boardModel) summaryLines(width int) []string {
|
||
r := m.selectedTask()
|
||
if r == nil {
|
||
return []string{mutedStyle2().Render(" nothing chosen")}
|
||
}
|
||
var out []string
|
||
out = append(out, panelTitleStyle().Render(truncateVisible(r.Issue.Identifier+" "+r.Issue.Title, width)))
|
||
out = append(out, "")
|
||
who := r.Who
|
||
if who == "" || who == "—" {
|
||
who = "nobody yet"
|
||
}
|
||
out = append(out, " "+statusPill(r.Issue.Status)+" "+
|
||
mutedStyle2().Render("assigned to ")+lipgloss.NewStyle().Foreground(lipgloss.Color(active.Text)).Render(who))
|
||
if r.Blocker != nil && len(r.Blocker.BlockingIdentities) > 0 {
|
||
out = append(out, " "+mutedStyle2().Render("waits on ")+
|
||
lipgloss.NewStyle().Foreground(lipgloss.Color(active.Warning)).Render(strings.Join(r.Blocker.BlockingIdentities, ", ")))
|
||
} else if isReadyButBlocked(*r) {
|
||
out = append(out, " "+badge("ready to start", active.Warning)+" "+
|
||
mutedStyle2().Render("its blocker finished, but it is still marked blocked"))
|
||
}
|
||
out = append(out, "")
|
||
|
||
// The command that decides the task is finished, from the task itself.
|
||
if cmd := verifyFromDescription(r.Issue.Description); cmd != "" {
|
||
out = append(out, " "+mutedStyle2().Render("done when"))
|
||
for _, ln := range wrap(cmd, width-4) {
|
||
out = append(out, " "+lipgloss.NewStyle().Foreground(lipgloss.Color(active.Info)).Render(ln))
|
||
}
|
||
}
|
||
if len(m.runs) > 0 {
|
||
run := m.runs[0]
|
||
line := " " + mutedStyle2().Render("last run") + " " +
|
||
lipgloss.NewStyle().Foreground(lipgloss.Color(active.Text)).Render(run.Status+" · "+run.Source)
|
||
if run.StartedAt != "" {
|
||
if t, err := time.Parse(time.RFC3339, run.StartedAt); err == nil {
|
||
line += mutedStyle2().Render(" · " + t.Local().Format("15:04"))
|
||
}
|
||
}
|
||
out = append(out, line)
|
||
} else {
|
||
out = append(out, " "+mutedStyle2().Render("never run"))
|
||
}
|
||
if m.cost.RunCount > 0 {
|
||
out = append(out, " "+mutedStyle2().Render("cost")+" "+
|
||
lipgloss.NewStyle().Foreground(lipgloss.Color(active.Text)).Render(
|
||
fmt.Sprintf("%d cent(s) over %d run(s), %d tokens out", m.cost.CostCents, m.cost.RunCount, m.cost.OutputTokens)))
|
||
}
|
||
return out
|
||
}
|
||
|
||
func (m boardModel) needsLines(width, height int) []string {
|
||
var out []string
|
||
n := 0
|
||
add := func(r Row, why string) {
|
||
n++
|
||
if len(out) < height {
|
||
out = append(out, " "+badge(r.Issue.Identifier, active.Accent)+" "+lipgloss.NewStyle().
|
||
Foreground(lipgloss.Color(active.Text)).Render(truncateVisible(r.Issue.Title, width-14)))
|
||
out = append(out, " "+mutedStyle2().Render(why))
|
||
}
|
||
}
|
||
for _, r := range m.rows {
|
||
if isReadyButBlocked(r) {
|
||
add(r, "its blocker finished; it is still marked blocked")
|
||
}
|
||
}
|
||
for _, r := range m.rows {
|
||
if r.Issue.Status == "in_review" {
|
||
add(r, "waiting for a review")
|
||
}
|
||
}
|
||
for _, r := range m.rows {
|
||
if r.Issue.AssigneeUser != "" && r.Issue.Status != "done" && r.Issue.Status != "cancelled" {
|
||
add(r, "assigned to you")
|
||
}
|
||
}
|
||
if n == 0 {
|
||
return []string{" " + lipgloss.NewStyle().Foreground(lipgloss.Color(active.Success)).Render("nothing needs you")}
|
||
}
|
||
if len(out) < height {
|
||
out = append(out, "")
|
||
out = append(out, dimStyle().Render(fmt.Sprintf(" %s waiting", fmtCount(n, "thing", "things"))))
|
||
}
|
||
return out
|
||
}
|
||
|
||
func (m boardModel) activityLines(width, height int) []string {
|
||
if m.detailID == "" || len(m.activity) == 0 {
|
||
return []string{" " + mutedStyle2().Render("nothing recorded for this task yet")}
|
||
}
|
||
var out []string
|
||
for i, a := range m.activity {
|
||
if len(out) >= height-1 || i >= 10 {
|
||
break
|
||
}
|
||
when := a.CreatedAt
|
||
if t, err := time.Parse(time.RFC3339, a.CreatedAt); err == nil {
|
||
when = t.Local().Format("15:04")
|
||
}
|
||
who := a.ActorType
|
||
switch who {
|
||
case "user":
|
||
who = "you"
|
||
case "agent":
|
||
who = "agent"
|
||
case "system":
|
||
who = "system"
|
||
}
|
||
out = append(out, " "+dimStyle().Render(when)+" "+
|
||
mutedStyle2().Render(fmt.Sprintf("%-7s", who))+" "+
|
||
lipgloss.NewStyle().Foreground(lipgloss.Color(active.Text)).Render(a.Action))
|
||
}
|
||
return out
|
||
}
|
||
|
||
var verifyRE = regexp.MustCompile(`(?is)Done when this command succeeds:\s*\n+\s*(.+)`)
|
||
|
||
func verifyFromDescription(desc string) string {
|
||
if m := verifyRE.FindStringSubmatch(desc); m != nil {
|
||
return strings.TrimSpace(m[1])
|
||
}
|
||
return ""
|
||
}
|
||
|
||
// rememberTask writes the chosen task into the project's harness file, so the
|
||
// other workspaces follow without being told twice.
|
||
func rememberTask(folder, identifier string) error {
|
||
path := filepath.Join(folder, ".harness", "harness.toml")
|
||
b, err := os.ReadFile(path)
|
||
if err != nil {
|
||
return fmt.Errorf("cannot remember the choice: %w", err)
|
||
}
|
||
line := fmt.Sprintf("watching = %q", identifier)
|
||
re := regexp.MustCompile(`(?m)^watching\s*=\s*".*"`)
|
||
if re.Match(b) {
|
||
b = re.ReplaceAll(b, []byte(line))
|
||
} else {
|
||
b = append(b, []byte("\n"+line+"\n")...)
|
||
}
|
||
return os.WriteFile(path, b, 0o644)
|
||
}
|