kami
db27b3436b
The ^x fullscreen viewer (OverlayDiff) backs every tool preview — split diff for write/edit, the command card for shell, plain lines otherwise, plus any transcript tool-output — but only scrolled one line per keypress, making a long diff tedious to read. - Add paging to the viewer, matching the OUTPUT free-scroll contract: ↑↓/jk by line, PgUp/PgDn by a full body, ^u/^d by half, g/G to the ends. New scrollDiff() clamps to [0, diffMaxScroll] so paging past either edge lands exactly (no dead presses). diff_scroll_test.go (2): clamp + no-op-when-fits. - Update the modal hint to advertise paging (line / page / ends / close) and add a "diff / preview viewer (^x)" section to the ? help overlay. Also note the T3+ confirm-again behaviour in the approval-band help. Approval ergonomics re-audit (BACKLOG §E): the spec'd band still holds — single-key y/n/e for T0-T2, mandatory second-key confirm for T3+ (HighTier), navigable queue with an i/n indicator, docked band never modal-stacked; all covered green by approval_test.go. The scroll granularity above was the only gap, now closed. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
1163 lines
37 KiB
Go
1163 lines
37 KiB
Go
package app
|
||
|
||
import (
|
||
"fmt"
|
||
"sort"
|
||
"strings"
|
||
|
||
"github.com/charmbracelet/lipgloss"
|
||
"github.com/charmbracelet/x/ansi"
|
||
)
|
||
|
||
// center draws a modal centered over a *dimmed* copy of the screen behind it, so the
|
||
// transcript stays faintly visible around the modal (a transparent backdrop) rather
|
||
// than being hidden by an opaque scrim. Immediate-mode: recomputed from state every
|
||
// frame, so there is no show/restore path to desync.
|
||
//
|
||
// Idempotence guard: some modal builders call center() internally and then get centered
|
||
// again by renderOverlay. The inner call already produced a full-screen composite, so a
|
||
// second call (input already width×height) returns it unchanged instead of dimming the
|
||
// modal itself. Falls back to an opaque scrim when no base was stashed (defensive).
|
||
func (m Model) center(modal string) string {
|
||
if m.lastBase == "" {
|
||
return lipgloss.Place(m.width, m.height, lipgloss.Center, lipgloss.Center, modal,
|
||
lipgloss.WithWhitespaceBackground(m.theme.P.BgDeep),
|
||
lipgloss.WithWhitespaceForeground(m.theme.P.BgDeep))
|
||
}
|
||
if lipgloss.Height(modal) >= m.height && lipgloss.Width(modal) >= m.width {
|
||
return modal // already a full-screen composite; don't re-dim it
|
||
}
|
||
return m.compositeOverlay(m.lastBase, modal)
|
||
}
|
||
|
||
// compositeOverlay strips + dims base into a faint scrim, then splices the modal box
|
||
// over it centered. ANSI-aware so the side margins keep the (dimmed) content behind.
|
||
// base and the result are both m.width × m.height.
|
||
func (m Model) compositeOverlay(base, modal string) string {
|
||
w, h := m.width, m.height
|
||
dim := lipgloss.NewStyle().Foreground(m.theme.P.Faint).Background(m.theme.P.BgDeep)
|
||
baseLines := strings.Split(base, "\n")
|
||
scrim := make([]string, h)
|
||
for i := 0; i < h; i++ {
|
||
raw := ""
|
||
if i < len(baseLines) {
|
||
raw = ansi.Strip(baseLines[i])
|
||
}
|
||
scrim[i] = dim.Render(padRightRaw(raw, w))
|
||
}
|
||
modalLines := strings.Split(modal, "\n")
|
||
mw := lipgloss.Width(modal)
|
||
top := (h - len(modalLines)) / 2
|
||
left := (w - mw) / 2
|
||
if top < 0 {
|
||
top = 0
|
||
}
|
||
if left < 0 {
|
||
left = 0
|
||
}
|
||
for r, ml := range modalLines {
|
||
row := top + r
|
||
if row < 0 || row >= h {
|
||
continue
|
||
}
|
||
leftPart := ansi.Truncate(scrim[row], left, "")
|
||
rightPart := ansi.TruncateLeft(scrim[row], left+mw, "")
|
||
scrim[row] = leftPart + ml + rightPart
|
||
}
|
||
return strings.Join(scrim, "\n")
|
||
}
|
||
|
||
// padRightRaw pads an unstyled string with spaces to exactly w columns (or truncates).
|
||
func padRightRaw(s string, w int) string {
|
||
switch sw := ansi.StringWidth(s); {
|
||
case sw > w:
|
||
return ansi.Truncate(s, w, "")
|
||
case sw < w:
|
||
return s + strings.Repeat(" ", w-sw)
|
||
default:
|
||
return s
|
||
}
|
||
}
|
||
|
||
func (m Model) modalWidth() int {
|
||
w := m.width * 70 / 100
|
||
if m.narrow() {
|
||
w = m.width - 4 // slim terminals: give modals nearly the whole screen
|
||
}
|
||
if w > 92 {
|
||
w = 92
|
||
}
|
||
if w < 24 {
|
||
w = 24
|
||
}
|
||
return w
|
||
}
|
||
|
||
// clip truncates a (possibly ANSI-styled) line to w visible columns so modal content
|
||
// never wraps mid-word on a slim terminal. ANSI-aware — won't slice escape codes.
|
||
func clip(s string, w int) string {
|
||
if w < 1 {
|
||
w = 1
|
||
}
|
||
return ansi.Truncate(s, w, "…")
|
||
}
|
||
|
||
func (m Model) renderOverlay(base string) string {
|
||
switch m.overlay {
|
||
case OverlayPalette:
|
||
return m.center(m.paletteModal())
|
||
case OverlayEventInspector:
|
||
return m.center(m.eventInspectorModal())
|
||
case OverlayDiff:
|
||
return m.center(m.diffModal())
|
||
case OverlayToolPalette:
|
||
return m.center(m.toolPaletteModal())
|
||
case OverlayModels:
|
||
return m.center(m.modelsModal())
|
||
case OverlayArtifacts:
|
||
return m.center(m.artifactsModal())
|
||
case OverlayConfig:
|
||
return m.center(m.configModal())
|
||
case OverlayStats:
|
||
return m.center(m.statsModal())
|
||
case OverlayIdeas:
|
||
return m.center(m.ideasModal())
|
||
case OverlaySessions:
|
||
return m.center(m.sessionsModal())
|
||
case OverlayFiles:
|
||
return m.center(m.filesModal())
|
||
case OverlayStatusbar:
|
||
return m.center(m.statusbarModal())
|
||
case OverlayGrants:
|
||
return m.center(m.grantsModal())
|
||
case OverlayGrantScope:
|
||
return m.center(m.grantScopeModal())
|
||
case OverlayHelp:
|
||
return m.center(m.helpModal())
|
||
}
|
||
return base
|
||
}
|
||
|
||
func (m Model) titleLine(text string) string {
|
||
t := m.theme
|
||
return lipgloss.NewStyle().Foreground(t.P.Accent).Background(t.P.BgPanel).Bold(true).Render(text)
|
||
}
|
||
|
||
func mbg(t Theme, s string, fg lipgloss.Color) string {
|
||
return lipgloss.NewStyle().Foreground(fg).Background(t.P.BgPanel).Render(s)
|
||
}
|
||
|
||
// approvalBandHeight sizes the docked approval band to its diff, capped so it
|
||
// never crowds out the session above (longer diffs spill to the ^x fullscreen
|
||
// view). Layout: 2 borders + header + blank + diff rows + blank + action row.
|
||
func (m Model) approvalBandHeight() int {
|
||
rows, rat := 0, 0
|
||
if s := m.session(m.selectedID); s != nil && s.Pending != nil {
|
||
rows = m.approvalContentRows(s.Pending)
|
||
if n := len(s.Pending.Rationale); n > 0 {
|
||
rat = n + 1 // rationale lines + trailing blank
|
||
}
|
||
}
|
||
steer := 0
|
||
if m.steering || m.steerBuffer != "" {
|
||
steer = 1
|
||
}
|
||
h := 2 + 1 + 1 + rat + rows + 1 + steer + 1
|
||
if maxH := m.height * 55 / 100; h > maxH {
|
||
h = maxH
|
||
}
|
||
if h < 10 {
|
||
h = 10
|
||
}
|
||
if hardMax := m.height - statusH - footerH - 3; hardMax > 4 && h > hardMax {
|
||
h = hardMax
|
||
}
|
||
return h
|
||
}
|
||
|
||
// renderApprovalBand draws the approval gate as a full-width band (in place of
|
||
// the input bar): tool/tier/risk header, a two-column old|new diff, and the
|
||
// action row. It never floats over the rest of the UI.
|
||
func (m Model) renderApprovalBand(h int) string {
|
||
t := m.theme
|
||
s := m.session(m.selectedID)
|
||
if s == nil || s.Pending == nil {
|
||
return m.renderInput()
|
||
}
|
||
a := s.Pending
|
||
textW := m.width - 4 // box borders (2) + side padding (2)
|
||
|
||
riskColor := t.P.Warn
|
||
switch strings.ToUpper(a.Risk) {
|
||
case "HIGH", "CRITICAL":
|
||
riskColor = t.P.Bad
|
||
case "LOW":
|
||
riskColor = t.P.OK
|
||
}
|
||
|
||
leftHdr := lipgloss.NewStyle().Foreground(t.P.Accent).Background(t.P.Bg).Bold(true).Render("→ ") +
|
||
t.span(a.ToolName, t.P.FgStrong)
|
||
if tgt := diffTarget(a.Preview); tgt != "" {
|
||
leftHdr += t.span(" "+tgt, t.P.Dim)
|
||
}
|
||
rightHdr := t.span("tier ", t.P.Faint) + t.span(a.Tier, t.P.Accent2) +
|
||
t.span(" · risk ", t.P.Faint) +
|
||
lipgloss.NewStyle().Foreground(riskColor).Background(t.P.Bg).Bold(true).Render(strings.ToUpper(a.Risk))
|
||
// When more than one gate is queued, show "approval i/n" so the operator knows
|
||
// there are others behind this one (↑/↓ to walk them) — never stack modals.
|
||
if n := len(s.PendingQueue); n > 1 {
|
||
rightHdr = t.span("approval ", t.P.Faint) +
|
||
t.span(itoa(s.PendingIdx+1)+"/"+itoa(n), t.P.Accent) +
|
||
t.span(" · ", t.P.Faint) + rightHdr
|
||
}
|
||
|
||
innerH := h - 2
|
||
ratBlock := 0
|
||
if len(a.Rationale) > 0 {
|
||
ratBlock = len(a.Rationale) + 1 // rationale lines + trailing blank
|
||
}
|
||
steerBlock := 0
|
||
if m.steering || m.steerBuffer != "" {
|
||
steerBlock = 1
|
||
}
|
||
diffH := innerH - 4 - ratBlock - steerBlock // header, blank, blank, action row, + rationale/steer
|
||
if diffH < 1 {
|
||
diffH = 1
|
||
}
|
||
body := make([]string, 0, innerH)
|
||
body = append(body, m.justify(leftHdr, rightHdr, textW, t.P.Bg), "")
|
||
for _, r := range a.Rationale {
|
||
marker := lipgloss.NewStyle().Foreground(t.P.Warn).Background(t.P.Bg).Render("▲ ")
|
||
body = append(body, marker+t.span(truncate(r, textW-2), t.P.Dim))
|
||
}
|
||
if len(a.Rationale) > 0 {
|
||
body = append(body, "")
|
||
}
|
||
var content []string
|
||
switch {
|
||
case isCommandApproval(a):
|
||
content = m.commandCardLines(a, textW)
|
||
if len(content) > diffH {
|
||
content = content[:diffH]
|
||
}
|
||
case isUnifiedDiff(a.Preview):
|
||
content = m.renderSplitDiff(parseUnifiedDiff(a.Preview), textW, diffH, 0)
|
||
default:
|
||
content = m.renderPreviewLines(a.Preview, textW, diffH, 0)
|
||
}
|
||
diffStart := len(body)
|
||
body = append(body, content...)
|
||
for len(body) < diffStart+diffH {
|
||
body = append(body, "")
|
||
}
|
||
body = append(body, "")
|
||
if steerBlock == 1 {
|
||
body = append(body, m.steerLine())
|
||
}
|
||
body = append(body, m.approvalActions())
|
||
return t.box("permission required", body, m.width, h, true)
|
||
}
|
||
|
||
// steerLine renders the steering note inside the band: editable (with a caret)
|
||
// while the operator is typing it, or as a persistent reminder once set — so it
|
||
// stays visible after editing and it's clear it rides along with approve/reject.
|
||
func (m Model) steerLine() string {
|
||
t := m.theme
|
||
label := t.span("steer ", t.P.Faint)
|
||
caret := lipgloss.NewStyle().Foreground(t.P.Accent).Background(t.P.Bg).Render("▏")
|
||
if m.steering {
|
||
if m.steerBuffer == "" {
|
||
return label + caret + t.span(" type a note…", t.P.Faint)
|
||
}
|
||
return label + t.span(m.steerBuffer, t.P.FgStrong) + caret
|
||
}
|
||
return label + t.span(m.steerBuffer, t.P.Accent2) +
|
||
t.span(" (sent with your decision · s to edit)", t.P.Faint)
|
||
}
|
||
|
||
// approvalActions renders the action row of the approval band. While the operator
|
||
// is composing a steer note the keys are different (typing is captured), so the
|
||
// hints switch to the editing controls.
|
||
func (m Model) approvalActions() string {
|
||
t := m.theme
|
||
hint := func(k, l string) string {
|
||
return lipgloss.NewStyle().Foreground(t.P.Accent).Background(t.P.Bg).Bold(true).Render(k) +
|
||
t.span(" "+l, t.P.Faint)
|
||
}
|
||
// Tighten the inter-hint gap on a slim terminal so the action row isn't clipped —
|
||
// the approval card's decision keys must stay fully visible.
|
||
gapStr := " "
|
||
if m.narrow() {
|
||
gapStr = " "
|
||
}
|
||
gap := t.span(gapStr, t.P.Faint)
|
||
if m.steering {
|
||
return strings.Join([]string{
|
||
hint("enter", "approve + send note"), hint("esc", "keep note, decide below"),
|
||
}, gap)
|
||
}
|
||
s := m.session(m.selectedID)
|
||
// Armed T3+ approve: a single decisive line so an accidental keystroke can't slip
|
||
// a destructive action through — the confirm key must be pressed again.
|
||
if m.approvalArmed && s != nil && s.Pending != nil {
|
||
warn := lipgloss.NewStyle().Foreground(t.P.Bad).Background(t.P.Bg).Bold(true).
|
||
Render("press y again to confirm " + s.Pending.Tier + " approval")
|
||
return warn + gap + hint("any other key", "cancel")
|
||
}
|
||
parts := []string{hint("y", "approve"), hint("n", "reject"), hint("e", "steer"), hint("A", "auto")}
|
||
if s != nil && len(s.PendingQueue) > 1 {
|
||
parts = append(parts, hint("↑↓", "queue"))
|
||
}
|
||
if s != nil && s.Pending != nil &&
|
||
(isUnifiedDiff(s.Pending.Preview) || isCommandApproval(s.Pending)) {
|
||
parts = append(parts, hint("^x", "fullscreen"))
|
||
}
|
||
parts = append(parts, hint("esc", "later"))
|
||
return strings.Join(parts, gap)
|
||
}
|
||
|
||
// approvalContentRows is the number of body rows the pending approval's content
|
||
// occupies — command-card lines for a command, diff/preview rows otherwise. Drives
|
||
// band sizing so the height matches what renderApprovalBand will draw.
|
||
func (m Model) approvalContentRows(a *Approval) int {
|
||
if isCommandApproval(a) {
|
||
w := m.width - 4
|
||
if w < 8 {
|
||
w = 8
|
||
}
|
||
return len(m.commandCardLines(a, w))
|
||
}
|
||
return previewRowCount(a.Preview)
|
||
}
|
||
|
||
// diffBodyHeight is the number of diff lines visible in the diff modal body.
|
||
func (m Model) diffBodyHeight() int {
|
||
h := m.height * 70 / 100
|
||
if h < 8 {
|
||
h = 8
|
||
}
|
||
return h - 6
|
||
}
|
||
|
||
// diffMaxScroll is the largest scroll offset that still fills the body with
|
||
// diff rows, keeping the last page anchored to the bottom of the modal.
|
||
func (m Model) diffMaxScroll() int {
|
||
rows := previewRowCount(m.currentDiff())
|
||
if cmd := m.pendingCommand(); cmd != nil {
|
||
rows = len(m.commandCardLines(cmd, m.modalWidth()-6))
|
||
}
|
||
max := rows - m.diffBodyHeight()
|
||
if max < 0 {
|
||
max = 0
|
||
}
|
||
return max
|
||
}
|
||
|
||
// scrollDiff moves the diff/preview/command modal offset by delta rows, clamped to
|
||
// [0, diffMaxScroll] so paging past either end lands exactly on the edge (no dead
|
||
// presses unwinding an overshoot — same contract as the OUTPUT free-scroll).
|
||
func (m *Model) scrollDiff(delta int) {
|
||
off := m.diffScrollOffset + delta
|
||
if mx := m.diffMaxScroll(); off > mx {
|
||
off = mx
|
||
}
|
||
if off < 0 {
|
||
off = 0
|
||
}
|
||
m.diffScrollOffset = off
|
||
}
|
||
|
||
func (m Model) diffModal() string {
|
||
if cmd := m.pendingCommand(); cmd != nil {
|
||
return m.commandModal(cmd)
|
||
}
|
||
t := m.theme
|
||
w := m.modalWidth()
|
||
bodyH := m.diffBodyHeight()
|
||
diff := m.currentDiff()
|
||
isDiff := isUnifiedDiff(diff)
|
||
|
||
off := m.diffScrollOffset
|
||
if off > m.diffMaxScroll() {
|
||
off = m.diffMaxScroll()
|
||
}
|
||
if off < 0 {
|
||
off = 0
|
||
}
|
||
|
||
var b strings.Builder
|
||
title := "preview"
|
||
if isDiff {
|
||
title = "diff"
|
||
}
|
||
b.WriteString(m.titleLine(title))
|
||
if tgt := diffTarget(diff); tgt != "" {
|
||
b.WriteString(mbg(t, " "+tgt, t.P.Dim))
|
||
}
|
||
b.WriteString(mbg(t, " ("+itoa(previewRowCount(diff))+" rows)", t.P.Faint) + "\n\n")
|
||
var lines []string
|
||
if isDiff {
|
||
lines = m.renderSplitDiff(parseUnifiedDiff(diff), w-6, bodyH, off)
|
||
} else {
|
||
lines = m.renderPreviewLines(diff, w-6, bodyH, off)
|
||
}
|
||
for _, ln := range lines {
|
||
b.WriteString(ln + "\n")
|
||
}
|
||
b.WriteString("\n" + modalHints(t, [][2]string{{"↑↓", "line"}, {"PgUp/Dn", "page"}, {"g/G", "ends"}, {"^x/esc", "close"}}))
|
||
|
||
modal := t.Overlay.Width(w).Render(b.String())
|
||
return m.center(modal)
|
||
}
|
||
|
||
// commandModal is the ^x fullscreen view of a command approval: the same
|
||
// deterministic card as the band, scrollable, so a long command is fully readable
|
||
// without ever being truncated.
|
||
func (m Model) commandModal(a *Approval) string {
|
||
t := m.theme
|
||
w := m.modalWidth()
|
||
bodyH := m.diffBodyHeight()
|
||
lines := m.commandCardLines(a, w-6)
|
||
|
||
off := m.diffScrollOffset
|
||
if mx := m.diffMaxScroll(); off > mx {
|
||
off = mx
|
||
}
|
||
if off < 0 {
|
||
off = 0
|
||
}
|
||
|
||
var b strings.Builder
|
||
b.WriteString(m.titleLine("command"))
|
||
b.WriteString(mbg(t, " "+a.ToolName, t.P.Dim))
|
||
b.WriteString(mbg(t, " ("+itoa(len(lines))+" rows)", t.P.Faint) + "\n\n")
|
||
end := off + bodyH
|
||
if end > len(lines) {
|
||
end = len(lines)
|
||
}
|
||
for i := off; i < end; i++ {
|
||
b.WriteString(lines[i] + "\n")
|
||
}
|
||
b.WriteString("\n" + modalHints(t, [][2]string{{"↑↓", "line"}, {"PgUp/Dn", "page"}, {"g/G", "ends"}, {"^x/esc", "close"}}))
|
||
return m.center(t.Overlay.Width(w).Render(b.String()))
|
||
}
|
||
|
||
func (m Model) eventInspectorModal() string {
|
||
t := m.theme
|
||
w := m.modalWidth()
|
||
evs := m.currentEvents()
|
||
|
||
var b strings.Builder
|
||
b.WriteString(m.titleLine("event inspector"))
|
||
if len(evs) > 0 {
|
||
b.WriteString(mbg(t, " ("+itoa(m.overlayEventIdx+1)+"/"+itoa(len(evs))+")", t.P.Faint))
|
||
}
|
||
b.WriteString("\n\n")
|
||
// Filter line (shown while editing or when a query is set): a `/` prompt over the query.
|
||
if m.eventFilterTyping || m.eventFilter != "" {
|
||
caret := mbg(t, "", t.P.BgPanel)
|
||
if m.eventFilterTyping && m.caretVisible() {
|
||
caret = lipgloss.NewStyle().Foreground(t.P.Accent).Background(t.P.BgPanel).Render("▏")
|
||
}
|
||
prompt := lipgloss.NewStyle().Foreground(t.P.Accent).Background(t.P.BgPanel).Render("/ ")
|
||
if m.eventFilter == "" {
|
||
b.WriteString(prompt + caret + mbg(t, "type to filter events…", t.P.Faint) + "\n\n")
|
||
} else {
|
||
b.WriteString(prompt + mbg(t, m.eventFilter, t.P.FgStrong) + caret + "\n\n")
|
||
}
|
||
}
|
||
if len(evs) == 0 {
|
||
msg := "no events"
|
||
if m.eventFilter != "" {
|
||
msg = "no events match \"" + m.eventFilter + "\""
|
||
}
|
||
b.WriteString(mbg(t, msg, t.P.Faint))
|
||
return m.center(t.Overlay.Width(w).Render(b.String()))
|
||
}
|
||
// Budget the plain detail so the styled row never needs ANSI-aware truncation
|
||
// (truncating a styled string would cut through escape codes and corrupt it).
|
||
detailBudget := (w - 6) - (2 + 9 + 11 + 1 + 18 + 1)
|
||
if detailBudget < 4 {
|
||
detailBudget = 4
|
||
}
|
||
// Window the (potentially long) list to a visible height, keeping the
|
||
// selected row in view — the modal must not grow past the screen.
|
||
bodyH := m.height*70/100 - 4
|
||
if bodyH < 3 {
|
||
bodyH = 3
|
||
}
|
||
off := 0
|
||
if len(evs) > bodyH {
|
||
off = m.overlayEventIdx - bodyH/2
|
||
if off < 0 {
|
||
off = 0
|
||
}
|
||
if off > len(evs)-bodyH {
|
||
off = len(evs) - bodyH
|
||
}
|
||
}
|
||
end := off + bodyH
|
||
if end > len(evs) {
|
||
end = len(evs)
|
||
}
|
||
for i := off; i < end; i++ {
|
||
e := evs[i]
|
||
cat := inferCategory(e.Type)
|
||
marker := mbg(t, " ", t.P.BgPanel)
|
||
fg := t.P.Fg
|
||
if i == m.overlayEventIdx {
|
||
marker = lipgloss.NewStyle().Foreground(t.P.Accent).Background(t.P.BgPanel).Render("▸ ")
|
||
fg = t.P.FgStrong
|
||
}
|
||
row := marker + mbg(t, padRaw(e.Time, 8)+" ", t.P.Faint) +
|
||
lipgloss.NewStyle().Foreground(t.categoryColor(cat)).Background(t.P.BgPanel).Render(padRaw("["+cat+"]", 11)) + " " +
|
||
lipgloss.NewStyle().Foreground(fg).Background(t.P.BgPanel).Render(padRaw(e.Type, 18)) +
|
||
mbg(t, " "+truncate(e.Detail, detailBudget), t.P.Dim)
|
||
b.WriteString(row + "\n")
|
||
}
|
||
b.WriteString("\n" + modalHints(t, [][2]string{{"↑↓", "select"}, {"/", "filter"}, {"c", "clear"}, {"esc", "close"}}))
|
||
|
||
modal := t.Overlay.Width(w).Render(b.String())
|
||
return m.center(modal)
|
||
}
|
||
|
||
func (m Model) paletteModal() string {
|
||
t := m.theme
|
||
w := m.modalWidth()
|
||
cmds := m.filteredPalette()
|
||
|
||
var b strings.Builder
|
||
b.WriteString(m.titleLine("command palette") + "\n\n")
|
||
|
||
// filter input line
|
||
filter := m.paletteFilter
|
||
caret := mbg(t, " ", t.P.BgPanel)
|
||
if m.caretVisible() {
|
||
caret = lipgloss.NewStyle().Foreground(t.P.Accent).Background(t.P.BgPanel).Render("▏")
|
||
}
|
||
prompt := lipgloss.NewStyle().Foreground(t.P.Accent).Background(t.P.BgPanel).Render("› ")
|
||
if filter == "" {
|
||
b.WriteString(prompt + caret + mbg(t, "type to filter…", t.P.Faint) + "\n\n")
|
||
} else {
|
||
b.WriteString(prompt + mbg(t, filter, t.P.FgStrong) + caret + "\n\n")
|
||
}
|
||
|
||
if len(cmds) == 0 {
|
||
b.WriteString(mbg(t, " no matching commands", t.P.Faint) + "\n")
|
||
}
|
||
for i, c := range cmds {
|
||
marker := mbg(t, " ", t.P.BgPanel)
|
||
titleFg := t.P.Fg
|
||
if i == m.paletteIndex {
|
||
marker = lipgloss.NewStyle().Foreground(t.P.Accent).Background(t.P.BgPanel).Render("▌ ")
|
||
titleFg = t.P.FgStrong
|
||
}
|
||
// keybind column: the bare-key shortcut, so the palette teaches the shortcuts.
|
||
keyCell := mbg(t, padRaw("", 4), t.P.BgPanel)
|
||
if c.key != "" {
|
||
keyCell = lipgloss.NewStyle().Foreground(t.P.Accent2).Background(t.P.BgPanel).Bold(true).Render(padRaw(c.key, 4))
|
||
}
|
||
b.WriteString(marker + keyCell +
|
||
lipgloss.NewStyle().Foreground(titleFg).Background(t.P.BgPanel).Render(padRaw(c.title, 16)) +
|
||
mbg(t, " "+c.hint, t.P.Faint) + "\n")
|
||
}
|
||
b.WriteString("\n" + modalHints(t, [][2]string{{"↑↓", "select"}, {"enter", "run"}, {"esc", "close"}}))
|
||
modal := t.Overlay.Width(w).Render(b.String())
|
||
return m.center(modal)
|
||
}
|
||
|
||
// filesModal is the `@` file-reference picker: a filter line over the session workspace's
|
||
// paths, windowed around the selection; enter inserts `@path` into the chat input.
|
||
func (m Model) filesModal() string {
|
||
t := m.theme
|
||
w := m.modalWidth()
|
||
files := m.filteredFiles()
|
||
|
||
var b strings.Builder
|
||
b.WriteString(m.titleLine("@ file reference") + "\n\n")
|
||
|
||
caret := mbg(t, " ", t.P.BgPanel)
|
||
if m.caretVisible() {
|
||
caret = lipgloss.NewStyle().Foreground(t.P.Accent).Background(t.P.BgPanel).Render("▏")
|
||
}
|
||
prompt := lipgloss.NewStyle().Foreground(t.P.Accent).Background(t.P.BgPanel).Render("@ ")
|
||
if m.fileFilter == "" {
|
||
b.WriteString(prompt + caret + mbg(t, "type to filter files…", t.P.Faint) + "\n\n")
|
||
} else {
|
||
b.WriteString(prompt + mbg(t, m.fileFilter, t.P.FgStrong) + caret + "\n\n")
|
||
}
|
||
|
||
switch {
|
||
case m.filesLoading:
|
||
b.WriteString(mbg(t, " loading…", t.P.Faint) + "\n")
|
||
case len(m.files) == 0:
|
||
b.WriteString(mbg(t, " no workspace files (is a workspace bound?)", t.P.Faint) + "\n")
|
||
case len(files) == 0:
|
||
b.WriteString(mbg(t, " no matching files", t.P.Faint) + "\n")
|
||
default:
|
||
const maxRows = 12
|
||
start := 0
|
||
if m.fileIndex >= maxRows {
|
||
start = m.fileIndex - maxRows + 1
|
||
}
|
||
end := start + maxRows
|
||
if end > len(files) {
|
||
end = len(files)
|
||
}
|
||
for i := start; i < end; i++ {
|
||
marker := mbg(t, " ", t.P.BgPanel)
|
||
fg := t.P.Fg
|
||
if i == m.fileIndex {
|
||
marker = lipgloss.NewStyle().Foreground(t.P.Accent).Background(t.P.BgPanel).Render("▌ ")
|
||
fg = t.P.FgStrong
|
||
}
|
||
b.WriteString(marker +
|
||
lipgloss.NewStyle().Foreground(fg).Background(t.P.BgPanel).Render(clip(files[i], w-6)) + "\n")
|
||
}
|
||
if len(files) > maxRows {
|
||
b.WriteString(mbg(t, " "+itoa(len(files))+" matches", t.P.Faint) + "\n")
|
||
}
|
||
}
|
||
b.WriteString("\n" + modalHints(t, [][2]string{{"↑↓", "select"}, {"enter", "insert"}, {"esc", "close"}}))
|
||
modal := t.Overlay.Width(w).Render(b.String())
|
||
return m.center(modal)
|
||
}
|
||
|
||
// statusbarModal toggles which status-bar segments are shown. Choices persist to the local
|
||
// tui-prefs.json so the bar stays as configured across launches.
|
||
func (m Model) statusbarModal() string {
|
||
t := m.theme
|
||
w := m.modalWidth()
|
||
|
||
var b strings.Builder
|
||
b.WriteString(m.titleLine("status bar") + "\n\n")
|
||
b.WriteString(mbg(t, " show / hide segments (correx, connection, session name stay)", t.P.Faint) + "\n\n")
|
||
|
||
for i, seg := range statusSegments {
|
||
marker := mbg(t, " ", t.P.BgPanel)
|
||
labelFg := t.P.Fg
|
||
if i == m.sbIndex {
|
||
marker = lipgloss.NewStyle().Foreground(t.P.Accent).Background(t.P.BgPanel).Render("▌ ")
|
||
labelFg = t.P.FgStrong
|
||
}
|
||
box := lipgloss.NewStyle().Foreground(t.P.OK).Background(t.P.BgPanel).Render("[✓] ")
|
||
if !m.sbShow(seg.id) {
|
||
box = mbg(t, "[ ] ", t.P.Faint)
|
||
}
|
||
b.WriteString(marker + box +
|
||
lipgloss.NewStyle().Foreground(labelFg).Background(t.P.BgPanel).Render(seg.label) + "\n")
|
||
}
|
||
b.WriteString("\n" + modalHints(t, [][2]string{{"↑↓", "move"}, {"space", "toggle"}, {"esc", "close"}}))
|
||
modal := t.Overlay.Width(w).Render(b.String())
|
||
return m.center(modal)
|
||
}
|
||
|
||
// grantsModal lists the active standing (PROJECT/GLOBAL) grants and lets the operator revoke one.
|
||
// These are cross-session auto-approvals, so the board opens from anywhere.
|
||
func (m Model) grantsModal() string {
|
||
t := m.theme
|
||
w := m.modalWidth()
|
||
|
||
var b strings.Builder
|
||
b.WriteString(m.titleLine("standing grants") + "\n\n")
|
||
b.WriteString(mbg(t, " cross-session auto-approvals in force (tool-bound)", t.P.Faint) + "\n\n")
|
||
|
||
switch {
|
||
case m.grantsLoading:
|
||
b.WriteString(mbg(t, " loading…", t.P.Faint) + "\n")
|
||
case len(m.grants) == 0:
|
||
b.WriteString(mbg(t, " none — press A on an approval to grant project / global", t.P.Faint) + "\n")
|
||
default:
|
||
for i, g := range m.grants {
|
||
marker := mbg(t, " ", t.P.BgPanel)
|
||
fg := t.P.Fg
|
||
if i == m.grantIndex {
|
||
marker = lipgloss.NewStyle().Foreground(t.P.Accent).Background(t.P.BgPanel).Render("▌ ")
|
||
fg = t.P.FgStrong
|
||
}
|
||
scope := lipgloss.NewStyle().Foreground(t.P.Accent2).Background(t.P.BgPanel).Render(padRaw(g.Scope, 8))
|
||
tool := lipgloss.NewStyle().Foreground(fg).Background(t.P.BgPanel).Render(padRaw(g.ToolName, 16))
|
||
tiers := mbg(t, "≤"+strings.Join(g.Tiers, ","), t.P.Faint)
|
||
b.WriteString(marker + scope + tool + tiers)
|
||
if g.Scope == "PROJECT" && g.ProjectID != "" {
|
||
b.WriteString(mbg(t, " "+clip(g.ProjectID, w-52), t.P.Faint))
|
||
}
|
||
b.WriteString("\n")
|
||
}
|
||
}
|
||
b.WriteString("\n" + modalHints(t, [][2]string{{"↑↓", "select"}, {"x", "revoke"}, {"G/esc", "close"}}))
|
||
modal := t.Overlay.Width(w).Render(b.String())
|
||
return m.center(modal)
|
||
}
|
||
|
||
// grantScopeModal is the A (approve-always) breadth picker: choose how widely to stop being asked
|
||
// for the pending tool — this session, this project, or everywhere.
|
||
func (m Model) grantScopeModal() string {
|
||
t := m.theme
|
||
w := m.modalWidth()
|
||
|
||
tool := ""
|
||
if m.grantFor != nil {
|
||
tool = m.grantFor.ToolName
|
||
}
|
||
var b strings.Builder
|
||
b.WriteString(m.titleLine("approve always — choose scope") + "\n\n")
|
||
b.WriteString(mbg(t, " stop asking for ", t.P.Faint) +
|
||
lipgloss.NewStyle().Foreground(t.P.FgStrong).Background(t.P.BgPanel).Render(tool) + "\n\n")
|
||
|
||
for i, opt := range grantScopeOptions() {
|
||
marker := mbg(t, " ", t.P.BgPanel)
|
||
labelFg := t.P.Fg
|
||
if i == m.grantScopeIndex {
|
||
marker = lipgloss.NewStyle().Foreground(t.P.Accent).Background(t.P.BgPanel).Render("▌ ")
|
||
labelFg = t.P.FgStrong
|
||
}
|
||
key := lipgloss.NewStyle().Foreground(t.P.Accent2).Background(t.P.BgPanel).Render(padRaw(opt.key, 3))
|
||
title := lipgloss.NewStyle().Foreground(labelFg).Background(t.P.BgPanel).Render(padRaw(opt.title, 16))
|
||
b.WriteString(marker + key + title + mbg(t, opt.hint, t.P.Faint) + "\n")
|
||
}
|
||
b.WriteString("\n" + modalHints(t, [][2]string{{"↑↓", "move"}, {"enter", "grant"}, {"esc", "cancel"}}))
|
||
modal := t.Overlay.Width(w).Render(b.String())
|
||
return m.center(modal)
|
||
}
|
||
|
||
// helpModal is the keybinding cheat-sheet (?), grouped by context. Any key dismisses it.
|
||
func (m Model) helpModal() string {
|
||
t := m.theme
|
||
w := m.modalWidth()
|
||
|
||
type kb struct{ key, desc string }
|
||
section := func(b *strings.Builder, title string, rows []kb) {
|
||
b.WriteString(lipgloss.NewStyle().Foreground(t.P.Accent2).Background(t.P.BgPanel).Bold(true).Render(title) + "\n")
|
||
for _, r := range rows {
|
||
key := lipgloss.NewStyle().Foreground(t.P.Accent).Background(t.P.BgPanel).Render(padRaw(r.key, 16))
|
||
b.WriteString(" " + key + mbg(t, r.desc, t.P.Fg) + "\n")
|
||
}
|
||
b.WriteString("\n")
|
||
}
|
||
|
||
var b strings.Builder
|
||
b.WriteString(m.titleLine("keybindings") + "\n\n")
|
||
section(&b, "session", []kb{
|
||
{"i", "compose a message"},
|
||
{"^↑ / ^↓", "jump to your previous / next message"},
|
||
{"y", "copy the selected message (OSC52)"},
|
||
{"PgUp / PgDn", "scroll output (^u / ^d half-page)"},
|
||
{"esc", "drop selection / scroll → follow newest"},
|
||
{"^x", "open the latest diff"},
|
||
{"l", "back to the session list"},
|
||
})
|
||
section(&b, "overlays", []kb{
|
||
{"p", "command palette (shows all shortcuts)"},
|
||
{"e", "event inspector (/ to filter)"},
|
||
{"t / v", "tools / artifacts"},
|
||
{"S / R", "session stats / resume sessions"},
|
||
{"m / g", "swap model / edit config"},
|
||
{"G / I", "grants / idea board"},
|
||
})
|
||
section(&b, "approval band", []kb{
|
||
{"y / a / enter", "approve once (T3+ asks again to confirm)"},
|
||
{"n / r", "reject"},
|
||
{"e / s", "steer (add a note)"},
|
||
{"A", "approve-always — choose scope"},
|
||
{"↑ / ↓", "walk the pending queue"},
|
||
{"^x", "fullscreen the diff / command preview"},
|
||
})
|
||
section(&b, "diff / preview viewer (^x)", []kb{
|
||
{"↑ / ↓", "scroll a line"},
|
||
{"PgUp / PgDn", "scroll a page (^u / ^d half)"},
|
||
{"g / G", "jump to top / end"},
|
||
{"^x / esc", "close"},
|
||
})
|
||
b.WriteString(modalHints(t, [][2]string{{"any key", "close"}}))
|
||
modal := t.Overlay.Width(w).Render(b.String())
|
||
return m.center(modal)
|
||
}
|
||
|
||
func (m Model) toolPaletteModal() string {
|
||
t := m.theme
|
||
w := m.modalWidth()
|
||
s := m.session(m.selectedID)
|
||
|
||
var b strings.Builder
|
||
b.WriteString(m.titleLine("tool palette") + "\n\n")
|
||
if s == nil || len(s.ToolsByStage) == 0 {
|
||
b.WriteString(mbg(t, "no tool manifest for this session", t.P.Faint) + "\n")
|
||
} else {
|
||
stages := make([]string, 0, len(s.ToolsByStage))
|
||
for st := range s.ToolsByStage {
|
||
stages = append(stages, st)
|
||
}
|
||
sort.Strings(stages)
|
||
for _, st := range stages {
|
||
label := mbg(t, st, t.P.Accent2)
|
||
if st == s.CurrentStage {
|
||
label += lipgloss.NewStyle().Foreground(t.P.Accent).Background(t.P.BgPanel).Render(" ◂ current")
|
||
}
|
||
b.WriteString(label + "\n")
|
||
for _, tool := range s.ToolsByStage[st] {
|
||
tier := lipgloss.NewStyle().Foreground(tierColor(t, tool.Tier)).Background(t.P.BgPanel).Render("T" + itoa(tool.Tier))
|
||
b.WriteString(mbg(t, " "+padRaw(tool.Name, 22), t.P.Fg) + tier + "\n")
|
||
}
|
||
}
|
||
}
|
||
b.WriteString("\n" + modalHints(t, [][2]string{{"t/esc", "close"}}))
|
||
modal := t.Overlay.Width(w).Render(b.String())
|
||
return m.center(modal)
|
||
}
|
||
|
||
func (m Model) modelsModal() string {
|
||
t := m.theme
|
||
w := m.modalWidth()
|
||
|
||
var b strings.Builder
|
||
b.WriteString(m.titleLine("models") + "\n\n")
|
||
|
||
if g := m.gaugeText(); g != "" {
|
||
b.WriteString(mbg(t, g, t.P.Faint) + "\n\n")
|
||
}
|
||
|
||
if len(m.availableModels) == 0 {
|
||
b.WriteString(mbg(t, " model management not enabled", t.P.Faint) + "\n")
|
||
}
|
||
for i, id := range m.availableModels {
|
||
marker := mbg(t, " ", t.P.BgPanel)
|
||
nameFg := t.P.Fg
|
||
if i == m.modelsIndex {
|
||
marker = lipgloss.NewStyle().Foreground(t.P.Accent).Background(t.P.BgPanel).Render("▌ ")
|
||
nameFg = t.P.FgStrong
|
||
}
|
||
line := marker + lipgloss.NewStyle().Foreground(nameFg).Background(t.P.BgPanel).Render(padRaw(id, 28))
|
||
if id == m.currentModel {
|
||
line += lipgloss.NewStyle().Foreground(t.P.Accent2).Background(t.P.BgPanel).Render(" ◂ resident")
|
||
}
|
||
b.WriteString(line + "\n")
|
||
}
|
||
b.WriteString("\n" + modalHints(t, [][2]string{{"↑↓", "select"}, {"enter", "swap"}, {"c", "clear pin"}, {"esc", "close"}}))
|
||
modal := t.Overlay.Width(w).Render(b.String())
|
||
return m.center(modal)
|
||
}
|
||
|
||
// artifactListRows is the number of artifact entries shown in the list portion of
|
||
// the viewer (the rest of the modal height goes to the selected artifact's content).
|
||
func (m Model) artifactListRows() int {
|
||
n := len(m.artifacts)
|
||
if n > 6 {
|
||
n = 6
|
||
}
|
||
if n < 1 {
|
||
n = 1
|
||
}
|
||
return n
|
||
}
|
||
|
||
// artifactContentBodyH is the number of content lines visible for the selected artifact.
|
||
func (m Model) artifactContentBodyH() int {
|
||
h := m.height*70/100 - m.artifactListRows() - 7 // title, blanks, content header, hints
|
||
if h < 3 {
|
||
h = 3
|
||
}
|
||
return h
|
||
}
|
||
|
||
// artifactContentLines splits the selected artifact's content into display lines,
|
||
// wrapping each line to the specified width.
|
||
func (m Model) artifactContentLines(w int) []string {
|
||
if m.artifactsIndex < 0 || m.artifactsIndex >= len(m.artifacts) {
|
||
return nil
|
||
}
|
||
c := m.artifacts[m.artifactsIndex].Content
|
||
if c == nil {
|
||
return []string{"(no content stored)"}
|
||
}
|
||
lines := strings.Split(strings.ReplaceAll(*c, "\r\n", "\n"), "\n")
|
||
return wrapLines(lines, w)
|
||
}
|
||
|
||
// artifactContentMaxScroll keeps the last page of content anchored to the body bottom.
|
||
func (m Model) artifactContentMaxScroll(w int) int {
|
||
max := len(m.artifactContentLines(w)) - m.artifactContentBodyH()
|
||
if max < 0 {
|
||
max = 0
|
||
}
|
||
return max
|
||
}
|
||
|
||
func (m Model) artifactsModal() string {
|
||
t := m.theme
|
||
w := m.modalWidth()
|
||
|
||
var b strings.Builder
|
||
b.WriteString(m.titleLine("artifacts"))
|
||
if len(m.artifacts) > 0 {
|
||
b.WriteString(mbg(t, " ("+itoa(m.artifactsIndex+1)+"/"+itoa(len(m.artifacts))+")", t.P.Faint))
|
||
}
|
||
b.WriteString("\n\n")
|
||
|
||
if m.artifactsLoading {
|
||
b.WriteString(mbg(t, " loading…", t.P.Faint) + "\n")
|
||
b.WriteString("\n" + modalHints(t, [][2]string{{"esc", "close"}}))
|
||
return t.Overlay.Width(w).Render(b.String())
|
||
}
|
||
if len(m.artifacts) == 0 {
|
||
b.WriteString(mbg(t, " no artifacts for this session", t.P.Faint) + "\n")
|
||
b.WriteString("\n" + modalHints(t, [][2]string{{"esc", "close"}}))
|
||
return t.Overlay.Width(w).Render(b.String())
|
||
}
|
||
|
||
// Windowed artifact list, keeping the selected row in view.
|
||
rows := m.artifactListRows()
|
||
off := 0
|
||
if len(m.artifacts) > rows {
|
||
off = m.artifactsIndex - rows/2
|
||
if off < 0 {
|
||
off = 0
|
||
}
|
||
if off > len(m.artifacts)-rows {
|
||
off = len(m.artifacts) - rows
|
||
}
|
||
}
|
||
end := off + rows
|
||
if end > len(m.artifacts) {
|
||
end = len(m.artifacts)
|
||
}
|
||
for i := off; i < end; i++ {
|
||
a := m.artifacts[i]
|
||
marker := mbg(t, " ", t.P.BgPanel)
|
||
idFg := t.P.Fg
|
||
if i == m.artifactsIndex {
|
||
marker = lipgloss.NewStyle().Foreground(t.P.Accent).Background(t.P.BgPanel).Render("▸ ")
|
||
idFg = t.P.FgStrong
|
||
}
|
||
row := marker +
|
||
lipgloss.NewStyle().Foreground(idFg).Background(t.P.BgPanel).Render(padRaw(shortID(a.ArtifactID), 14)) + " " +
|
||
mbg(t, padRaw(a.StageID, 18), t.P.Accent2) + " " +
|
||
mbg(t, a.Phase, t.P.Faint)
|
||
b.WriteString(row + "\n")
|
||
}
|
||
|
||
// Selected artifact content, scrollable with PgUp/PgDn.
|
||
// Width available for content: w - 2 (left padding) - 2 (box borders) - 2 (right padding) = w - 6
|
||
contentW := w - 6
|
||
lines := m.artifactContentLines(contentW)
|
||
bodyH := m.artifactContentBodyH()
|
||
coff := m.artifactScroll
|
||
if coff > m.artifactContentMaxScroll(contentW) {
|
||
coff = m.artifactContentMaxScroll(contentW)
|
||
}
|
||
if coff < 0 {
|
||
coff = 0
|
||
}
|
||
b.WriteString(mbg(t, " ── content", t.P.Faint))
|
||
if len(lines) > bodyH {
|
||
b.WriteString(mbg(t, " ("+itoa(coff+1)+"-"+itoa(min(coff+bodyH, len(lines)))+"/"+itoa(len(lines))+")", t.P.Faint))
|
||
}
|
||
b.WriteString("\n")
|
||
cend := coff + bodyH
|
||
if cend > len(lines) {
|
||
cend = len(lines)
|
||
}
|
||
for i := coff; i < cend; i++ {
|
||
b.WriteString(mbg(t, " "+lines[i], t.P.Fg) + "\n")
|
||
}
|
||
|
||
b.WriteString("\n" + modalHints(t, [][2]string{{"↑↓", "select"}, {"PgUp/Dn", "scroll"}, {"v/esc", "close"}}))
|
||
return t.Overlay.Width(w).Render(b.String())
|
||
}
|
||
|
||
// statsBreakdownRows caps how many per-provider / per-tool / per-tier rows the pane
|
||
// shows; the server already sorts each list by descending cost, so the cap keeps the
|
||
// heaviest contributors and the modal bounded.
|
||
const statsBreakdownRows = 6
|
||
|
||
// humanDurMs renders a millisecond span as a compact "1h 2m 3s" string.
|
||
func humanDurMs(ms int64) string {
|
||
if ms <= 0 {
|
||
return "0s"
|
||
}
|
||
total := ms / 1000
|
||
h := total / 3600
|
||
mn := (total / 60) % 60
|
||
s := total % 60
|
||
out := ""
|
||
if h > 0 {
|
||
out += itoa(int(h)) + "h "
|
||
}
|
||
if h > 0 || mn > 0 {
|
||
out += itoa(int(mn)) + "m "
|
||
}
|
||
return out + itoa(int(s)) + "s"
|
||
}
|
||
|
||
func (m Model) statsModal() string {
|
||
t := m.theme
|
||
w := m.modalWidth()
|
||
|
||
var b strings.Builder
|
||
b.WriteString(m.titleLine("session stats"))
|
||
if m.selectedID != "" {
|
||
b.WriteString(mbg(t, " ("+shortID(m.selectedID)+")", t.P.Faint))
|
||
}
|
||
b.WriteString("\n\n")
|
||
|
||
if m.statsLoading || m.stats == nil || m.statsFor != m.selectedID {
|
||
msg := "loading…"
|
||
if !m.statsLoading && m.stats == nil {
|
||
msg = "no stats for this session"
|
||
}
|
||
b.WriteString(mbg(t, " "+msg, t.P.Faint) + "\n")
|
||
b.WriteString("\n" + modalHints(t, [][2]string{{"S/esc", "close"}}))
|
||
return t.Overlay.Width(w).Render(b.String())
|
||
}
|
||
|
||
s := m.stats
|
||
cw := w - 4 // modal inner content width (borders + padding)
|
||
section := func(label string) string {
|
||
return lipgloss.NewStyle().Foreground(t.P.Accent2).Background(t.P.BgPanel).Bold(true).Render(label)
|
||
}
|
||
// put clips each data line to the inner width so it never wraps on a slim modal.
|
||
put := func(styled string) { b.WriteString(clip(styled, cw) + "\n") }
|
||
line := func(s string) string { return mbg(t, s, t.P.Fg) }
|
||
faint := func(s string) string { return mbg(t, s, t.P.Faint) }
|
||
// nameW shrinks the breakdown name column on slim terminals.
|
||
nameW := 20
|
||
if cw < 52 {
|
||
nameW = 12
|
||
}
|
||
|
||
// header row: duration + event count
|
||
put(faint(" duration ") + line(humanDurMs(s.SessionDurationMs)) +
|
||
faint(" events ") + line(itoa(int(s.EventCount))))
|
||
b.WriteString("\n")
|
||
|
||
// inference
|
||
b.WriteString(section("Inference") + "\n")
|
||
put(line(fmt.Sprintf(" %d calls · %d+%d tok · %.1f tok/s",
|
||
s.InferenceCount, s.PromptTokens, s.CompletionTokens, s.TokensPerSecond)))
|
||
for i, p := range s.PerProvider {
|
||
if i >= statsBreakdownRows {
|
||
put(faint(fmt.Sprintf(" … +%d more", len(s.PerProvider)-statsBreakdownRows)))
|
||
break
|
||
}
|
||
put(faint(fmt.Sprintf(" %-*s %d× %d tok %.1f t/s",
|
||
nameW, padRaw(p.Provider, nameW), p.CompletedCount, p.PromptTokens+p.CompletionTokens, p.TokensPerSecond)))
|
||
}
|
||
b.WriteString("\n")
|
||
|
||
// tools
|
||
b.WriteString(section("Tools") + "\n")
|
||
put(line(fmt.Sprintf(" %d calls · %d ms", s.ToolCount, s.ToolMs)))
|
||
for i, tl := range s.PerTool {
|
||
if i >= statsBreakdownRows {
|
||
put(faint(fmt.Sprintf(" … +%d more", len(s.PerTool)-statsBreakdownRows)))
|
||
break
|
||
}
|
||
put(faint(fmt.Sprintf(" %-*s %d× %d ms", nameW, padRaw(tl.ToolName, nameW), tl.CompletedCount, tl.TotalDurationMs)))
|
||
}
|
||
b.WriteString("\n")
|
||
|
||
// approvals
|
||
b.WriteString(section("Approvals") + "\n")
|
||
put(line(fmt.Sprintf(" %d req · %d res · %d pending · avg %d ms",
|
||
s.ApprovalsRequested, s.ApprovalsResolved, s.ApprovalsPending, s.AvgApprovalWaitMs)))
|
||
for _, tr := range s.PerTier {
|
||
put(faint(fmt.Sprintf(" %-3s req %d res %d avg %d ms", tr.Tier, tr.RequestedCount, tr.ResolvedCount, tr.AvgWaitMs)))
|
||
}
|
||
b.WriteString("\n")
|
||
|
||
// failures
|
||
f := s.Failures
|
||
b.WriteString(section("Failures") + "\n")
|
||
put(line(fmt.Sprintf(" inf %d · t/o %d · tool %d · rej %d · stg %d · wf %d",
|
||
f.InferenceFailures, f.InferenceTimeouts, f.ToolFailures, f.ToolRejections, f.StageFailures, f.WorkflowFailures)))
|
||
b.WriteString("\n")
|
||
|
||
// time accounting
|
||
other := 100.0 - s.InferencePct - s.ToolPct - s.ApprovalWaitPct
|
||
if other < 0 {
|
||
other = 0
|
||
}
|
||
b.WriteString(section("Time") + "\n")
|
||
put(line(fmt.Sprintf(" inf %.1f%% · tools %.1f%% · wait %.1f%% · other %.1f%%",
|
||
s.InferencePct, s.ToolPct, s.ApprovalWaitPct, other)))
|
||
|
||
b.WriteString("\n" + modalHints(t, [][2]string{{"S/esc", "close"}}))
|
||
return t.Overlay.Width(w).Render(b.String())
|
||
}
|
||
|
||
// shortID trims a long artifact id for the list column while staying identifiable.
|
||
func shortID(id string) string {
|
||
if len(id) <= 14 {
|
||
return id
|
||
}
|
||
return id[:13] + "…"
|
||
}
|
||
|
||
func tierColor(t Theme, tier int) lipgloss.Color {
|
||
switch {
|
||
case tier >= 3:
|
||
return t.P.Bad
|
||
case tier == 2:
|
||
return t.P.Warn
|
||
case tier == 1:
|
||
return t.P.Accent2
|
||
default:
|
||
return t.P.OK
|
||
}
|
||
}
|
||
|
||
func modalHints(t Theme, pairs [][2]string) string {
|
||
parts := make([]string, 0, len(pairs))
|
||
for _, p := range pairs {
|
||
parts = append(parts,
|
||
lipgloss.NewStyle().Foreground(t.P.Accent).Background(t.P.BgPanel).Bold(true).Render(p[0])+
|
||
mbg(t, " "+p[1], t.P.Faint))
|
||
}
|
||
return strings.Join(parts, mbg(t, " ", t.P.Faint))
|
||
}
|
||
|
||
func truncate(s string, w int) string {
|
||
if len([]rune(s)) <= w {
|
||
return s
|
||
}
|
||
r := []rune(s)
|
||
if w < 1 {
|
||
return ""
|
||
}
|
||
return string(r[:w-1]) + "…"
|
||
}
|
||
|
||
// wrapLines wraps each line in the input slice to the specified width using hard rune-boundary wrapping.
|
||
func wrapLines(lines []string, w int) []string {
|
||
if w < 1 {
|
||
w = 1
|
||
}
|
||
var result []string
|
||
for _, line := range lines {
|
||
wrapped := wrapLine(line, w)
|
||
result = append(result, wrapped...)
|
||
}
|
||
return result
|
||
}
|
||
|
||
// wrapLine wraps a single line to the specified width using hard rune-boundary wrapping.
|
||
func wrapLine(s string, w int) []string {
|
||
if w < 1 {
|
||
w = 1
|
||
}
|
||
runes := []rune(s)
|
||
if len(runes) <= w {
|
||
return []string{s}
|
||
}
|
||
var lines []string
|
||
for len(runes) > 0 {
|
||
if len(runes) <= w {
|
||
lines = append(lines, string(runes))
|
||
break
|
||
}
|
||
lines = append(lines, string(runes[:w]))
|
||
runes = runes[w:]
|
||
}
|
||
return lines
|
||
}
|