@@ -1,1403 +0,0 @@
1−package messages
2−
3−import (
4− "cmp"
5− "encoding/json"
6− "fmt"
7− "strings"
8− "time"
9−
10− "charm.land/lipgloss/v2"
11− "charm.land/lipgloss/v2/tree"
12− "github.com/charmbracelet/crush/internal/agent"
13− "github.com/charmbracelet/crush/internal/agent/tools"
14− "github.com/charmbracelet/crush/internal/ansiext"
15− "github.com/charmbracelet/crush/internal/fsext"
16− "github.com/charmbracelet/crush/internal/tui/components/chat/todos"
17− "github.com/charmbracelet/crush/internal/tui/components/core"
18− "github.com/charmbracelet/crush/internal/tui/highlight"
19− "github.com/charmbracelet/crush/internal/tui/styles"
20− "github.com/charmbracelet/x/ansi"
21−)
22−
23−// responseContextHeight limits the number of lines displayed in tool output
24−const responseContextHeight = 10
25−
26−// renderer defines the interface for tool-specific rendering implementations
27−type renderer interface {
28− // Render returns the complete (already styled) tool‑call view, not
29− // including the outer border.
30− Render(v *toolCallCmp) string
31−}
32−
33−// rendererFactory creates new renderer instances
34−type rendererFactory func() renderer
35−
36−// renderRegistry manages the mapping of tool names to their renderers
37−type renderRegistry map[string]rendererFactory
38−
39−// register adds a new renderer factory to the registry
40−func (rr renderRegistry) register(name string, f rendererFactory) { rr[name] = f }
41−
42−// lookup retrieves a renderer for the given tool name, falling back to generic renderer
43−func (rr renderRegistry) lookup(name string) renderer {
44− if f, ok := rr[name]; ok {
45− return f()
46− }
47− return genericRenderer{} // sensible fallback
48−}
49−
50−// registry holds all registered tool renderers
51−var registry = renderRegistry{}
52−
53−// baseRenderer provides common functionality for all tool renderers
54−type baseRenderer struct{}
55−
56−func (br baseRenderer) Render(v *toolCallCmp) string {
57− if v.result.Data != "" {
58− if strings.HasPrefix(v.result.MIMEType, "image/") {
59− return br.renderWithParams(v, v.call.Name, nil, func() string {
60− return renderImageContent(v, v.result.Data, v.result.MIMEType, v.result.Content)
61− })
62− }
63− return br.renderWithParams(v, v.call.Name, nil, func() string {
64− return renderMediaContent(v, v.result.MIMEType, v.result.Content)
65− })
66− }
67−
68− return br.renderWithParams(v, v.call.Name, nil, func() string {
69− return renderPlainContent(v, v.result.Content)
70− })
71−}
72−
73−// paramBuilder helps construct parameter lists for tool headers
74−type paramBuilder struct {
75− args []string
76−}
77−
78−// newParamBuilder creates a new parameter builder
79−func newParamBuilder() *paramBuilder {
80− return ¶mBuilder{args: make([]string, 0)}
81−}
82−
83−// addMain adds the main parameter (first argument)
84−func (pb *paramBuilder) addMain(value string) *paramBuilder {
85− if value != "" {
86− pb.args = append(pb.args, value)
87− }
88− return pb
89−}
90−
91−// addKeyValue adds a key-value pair parameter
92−func (pb *paramBuilder) addKeyValue(key, value string) *paramBuilder {
93− if value != "" {
94− pb.args = append(pb.args, key, value)
95− }
96− return pb
97−}
98−
99−// addFlag adds a boolean flag parameter
100−func (pb *paramBuilder) addFlag(key string, value bool) *paramBuilder {
101− if value {
102− pb.args = append(pb.args, key, "true")
103− }
104− return pb
105−}
106−
107−// build returns the final parameter list
108−func (pb *paramBuilder) build() []string {
109− return pb.args
110−}
111−
112−// renderWithParams provides a common rendering pattern for tools with parameters
113−func (br baseRenderer) renderWithParams(v *toolCallCmp, toolName string, args []string, contentRenderer func() string) string {
114− width := v.textWidth()
115− if v.isNested {
116− width -= 4 // Adjust for nested tool call indentation
117− }
118− header := br.makeHeader(v, toolName, width, args...)
119− if v.isNested {
120− return v.style().Render(header)
121− }
122− if res, done := earlyState(header, v); done {
123− return res
124− }
125− body := contentRenderer()
126− return joinHeaderBody(header, body)
127−}
128−
129−// unmarshalParams safely unmarshal JSON parameters
130−func (br baseRenderer) unmarshalParams(input string, target any) error {
131− return json.Unmarshal([]byte(input), target)
132−}
133−
134−// makeHeader builds the tool call header with status icon and parameters for a nested tool call.
135−func (br baseRenderer) makeNestedHeader(v *toolCallCmp, tool string, width int, params ...string) string {
136− t := styles.CurrentTheme()
137− icon := t.S().Base.Foreground(t.GreenDark).Render(styles.ToolPending)
138− if v.result.ToolCallID != "" {
139− if v.result.IsError {
140− icon = t.S().Base.Foreground(t.RedDark).Render(styles.ToolError)
141− } else {
142− icon = t.S().Base.Foreground(t.Green).Render(styles.ToolSuccess)
143− }
144− } else if v.cancelled {
145− icon = t.S().Muted.Render(styles.ToolPending)
146− }
147− tool = t.S().Base.Foreground(t.FgHalfMuted).Render(tool)
148− prefix := fmt.Sprintf("%s %s ", icon, tool)
149− return prefix + renderParamList(true, width-lipgloss.Width(prefix), params...)
150−}
151−
152−// makeHeader builds "<Tool>: param (key=value)" and truncates as needed.
153−func (br baseRenderer) makeHeader(v *toolCallCmp, tool string, width int, params ...string) string {
154− if v.isNested {
155− return br.makeNestedHeader(v, tool, width, params...)
156− }
157− t := styles.CurrentTheme()
158− icon := t.S().Base.Foreground(t.GreenDark).Render(styles.ToolPending)
159− if v.result.ToolCallID != "" {
160− if v.result.IsError {
161− icon = t.S().Base.Foreground(t.RedDark).Render(styles.ToolError)
162− } else {
163− icon = t.S().Base.Foreground(t.Green).Render(styles.ToolSuccess)
164− }
165− } else if v.cancelled {
166− icon = t.S().Muted.Render(styles.ToolPending)
167− }
168− tool = t.S().Base.Foreground(t.Blue).Render(tool)
169− prefix := fmt.Sprintf("%s %s ", icon, tool)
170− return prefix + renderParamList(false, width-lipgloss.Width(prefix), params...)
171−}
172−
173−// renderError provides consistent error rendering
174−func (br baseRenderer) renderError(v *toolCallCmp, message string) string {
175− t := styles.CurrentTheme()
176− header := br.makeHeader(v, prettifyToolName(v.call.Name), v.textWidth(), "")
177− errorTag := t.S().Base.Padding(0, 1).Background(t.Red).Foreground(t.White).Render("ERROR")
178− message = t.S().Base.Foreground(t.FgHalfMuted).Render(v.fit(message, v.textWidth()-3-lipgloss.Width(errorTag))) // -2 for padding and space
179− return joinHeaderBody(header, errorTag+" "+message)
180−}
181−
182−// Register tool renderers
183−func init() {
184− registry.register(tools.BashToolName, func() renderer { return bashRenderer{} })
185− registry.register(tools.JobOutputToolName, func() renderer { return bashOutputRenderer{} })
186− registry.register(tools.JobKillToolName, func() renderer { return bashKillRenderer{} })
187− registry.register(tools.DownloadToolName, func() renderer { return downloadRenderer{} })
188− registry.register(tools.ViewToolName, func() renderer { return viewRenderer{} })
189− registry.register(tools.EditToolName, func() renderer { return editRenderer{} })
190− registry.register(tools.MultiEditToolName, func() renderer { return multiEditRenderer{} })
191− registry.register(tools.WriteToolName, func() renderer { return writeRenderer{} })
192− registry.register(tools.FetchToolName, func() renderer { return simpleFetchRenderer{} })
193− registry.register(tools.AgenticFetchToolName, func() renderer { return agenticFetchRenderer{} })
194− registry.register(tools.WebFetchToolName, func() renderer { return webFetchRenderer{} })
195− registry.register(tools.WebSearchToolName, func() renderer { return webSearchRenderer{} })
196− registry.register(tools.GlobToolName, func() renderer { return globRenderer{} })
197− registry.register(tools.GrepToolName, func() renderer { return grepRenderer{} })
198− registry.register(tools.LSToolName, func() renderer { return lsRenderer{} })
199− registry.register(tools.SourcegraphToolName, func() renderer { return sourcegraphRenderer{} })
200− registry.register(tools.DiagnosticsToolName, func() renderer { return diagnosticsRenderer{} })
201− registry.register(tools.TodosToolName, func() renderer { return todosRenderer{} })
202− registry.register(agent.AgentToolName, func() renderer { return agentRenderer{} })
203−}
204−
205−// -----------------------------------------------------------------------------
206−// Generic renderer
207−// -----------------------------------------------------------------------------
208−
209−// genericRenderer handles unknown tool types with basic parameter display
210−type genericRenderer struct {
211− baseRenderer
212−}
213−
214−func (gr genericRenderer) Render(v *toolCallCmp) string {
215− if v.result.Data != "" {
216− if strings.HasPrefix(v.result.MIMEType, "image/") {
217− return gr.renderWithParams(v, prettifyToolName(v.call.Name), []string{v.call.Input}, func() string {
218− return renderImageContent(v, v.result.Data, v.result.MIMEType, v.result.Content)
219− })
220− }
221− return gr.renderWithParams(v, prettifyToolName(v.call.Name), []string{v.call.Input}, func() string {
222− return renderMediaContent(v, v.result.MIMEType, v.result.Content)
223− })
224− }
225−
226− return gr.renderWithParams(v, prettifyToolName(v.call.Name), []string{v.call.Input}, func() string {
227− return renderPlainContent(v, v.result.Content)
228− })
229−}
230−
231−// -----------------------------------------------------------------------------
232−// Bash renderer
233−// -----------------------------------------------------------------------------
234−
235−// bashRenderer handles bash command execution display
236−type bashRenderer struct {
237− baseRenderer
238−}
239−
240−// Render displays the bash command with sanitized newlines and plain output
241−func (br bashRenderer) Render(v *toolCallCmp) string {
242− var params tools.BashParams
243− if err := br.unmarshalParams(v.call.Input, ¶ms); err != nil {
244− return br.renderError(v, "Invalid bash parameters")
245− }
246−
247− cmd := strings.ReplaceAll(params.Command, "\n", " ")
248− cmd = strings.ReplaceAll(cmd, "\t", " ")
249− args := newParamBuilder().
250− addMain(cmd).
251− addFlag("background", params.RunInBackground).
252− build()
253− if v.call.Finished {
254− var meta tools.BashResponseMetadata
255− _ = br.unmarshalParams(v.result.Metadata, &meta)
256− if meta.Background {
257− description := cmp.Or(meta.Description, params.Command)
258− width := v.textWidth()
259− if v.isNested {
260− width -= 4 // Adjust for nested tool call indentation
261− }
262− header := makeJobHeader(v, "Start", fmt.Sprintf("PID %s", meta.ShellID), description, width)
263− if v.isNested {
264− return v.style().Render(header)
265− }
266− if res, done := earlyState(header, v); done {
267− return res
268− }
269− content := "Command: " + params.Command + "\n" + v.result.Content
270− body := renderPlainContent(v, content)
271− return joinHeaderBody(header, body)
272− }
273− }
274−
275− return br.renderWithParams(v, "Bash", args, func() string {
276− var meta tools.BashResponseMetadata
277− if err := br.unmarshalParams(v.result.Metadata, &meta); err != nil {
278− return renderPlainContent(v, v.result.Content)
279− }
280− // for backwards compatibility with older tool calls.
281− if meta.Output == "" && v.result.Content != tools.BashNoOutput {
282− meta.Output = v.result.Content
283− }
284−
285− if meta.Output == "" {
286− return ""
287− }
288− return renderPlainContent(v, meta.Output)
289− })
290−}
291−
292−// -----------------------------------------------------------------------------
293−// Bash Output renderer
294−// -----------------------------------------------------------------------------
295−
296−func makeJobHeader(v *toolCallCmp, subcommand, pid, description string, width int) string {
297− t := styles.CurrentTheme()
298− icon := t.S().Base.Foreground(t.GreenDark).Render(styles.ToolPending)
299− if v.result.ToolCallID != "" {
300− if v.result.IsError {
301− icon = t.S().Base.Foreground(t.RedDark).Render(styles.ToolError)
302− } else {
303− icon = t.S().Base.Foreground(t.Green).Render(styles.ToolSuccess)
304− }
305− } else if v.cancelled {
306− icon = t.S().Muted.Render(styles.ToolPending)
307− }
308−
309− jobPart := t.S().Base.Foreground(t.Blue).Render("Job")
310− subcommandPart := t.S().Base.Foreground(t.BlueDark).Render("(" + subcommand + ")")
311− pidPart := t.S().Muted.Render(pid)
312− descPart := ""
313− if description != "" {
314− descPart = " " + t.S().Subtle.Render(description)
315− }
316−
317− // Build the complete header
318− prefix := fmt.Sprintf("%s %s %s %s", icon, jobPart, subcommandPart, pidPart)
319− fullHeader := prefix + descPart
320−
321− // Truncate if needed
322− if lipgloss.Width(fullHeader) > width {
323− availableWidth := width - lipgloss.Width(prefix) - 1 // -1 for space
324− if availableWidth < 10 {
325− // Not enough space for description, just show prefix
326− return prefix
327− }
328− descPart = " " + t.S().Subtle.Render(ansi.Truncate(description, availableWidth, "…"))
329− fullHeader = prefix + descPart
330− }
331−
332− return fullHeader
333−}
334−
335−// bashOutputRenderer handles bash output retrieval display
336−type bashOutputRenderer struct {
337− baseRenderer
338−}
339−
340−// Render displays the shell ID and output from a background shell
341−func (bor bashOutputRenderer) Render(v *toolCallCmp) string {
342− var params tools.JobOutputParams
343− if err := bor.unmarshalParams(v.call.Input, ¶ms); err != nil {
344− return bor.renderError(v, "Invalid job_output parameters")
345− }
346−
347− var meta tools.JobOutputResponseMetadata
348− var description string
349− if v.result.Metadata != "" {
350− if err := bor.unmarshalParams(v.result.Metadata, &meta); err == nil {
351− if meta.Description != "" {
352− description = meta.Description
353− } else {
354− description = meta.Command
355− }
356− }
357− }
358−
359− width := v.textWidth()
360− if v.isNested {
361− width -= 4 // Adjust for nested tool call indentation
362− }
363− header := makeJobHeader(v, "Output", fmt.Sprintf("PID %s", params.ShellID), description, width)
364− if v.isNested {
365− return v.style().Render(header)
366− }
367− if res, done := earlyState(header, v); done {
368− return res
369− }
370− body := renderPlainContent(v, v.result.Content)
371− return joinHeaderBody(header, body)
372−}
373−
374−// -----------------------------------------------------------------------------
375−// Bash Kill renderer
376−// -----------------------------------------------------------------------------
377−
378−// bashKillRenderer handles bash process termination display
379−type bashKillRenderer struct {
380− baseRenderer
381−}
382−
383−// Render displays the shell ID being terminated
384−func (bkr bashKillRenderer) Render(v *toolCallCmp) string {
385− var params tools.JobKillParams
386− if err := bkr.unmarshalParams(v.call.Input, ¶ms); err != nil {
387− return bkr.renderError(v, "Invalid job_kill parameters")
388− }
389−
390− var meta tools.JobKillResponseMetadata
391− var description string
392− if v.result.Metadata != "" {
393− if err := bkr.unmarshalParams(v.result.Metadata, &meta); err == nil {
394− if meta.Description != "" {
395− description = meta.Description
396− } else {
397− description = meta.Command
398− }
399− }
400− }
401−
402− width := v.textWidth()
403− if v.isNested {
404− width -= 4 // Adjust for nested tool call indentation
405− }
406− header := makeJobHeader(v, "Kill", fmt.Sprintf("PID %s", params.ShellID), description, width)
407− if v.isNested {
408− return v.style().Render(header)
409− }
410− if res, done := earlyState(header, v); done {
411− return res
412− }
413− body := renderPlainContent(v, v.result.Content)
414− return joinHeaderBody(header, body)
415−}
416−
417−// -----------------------------------------------------------------------------
418−// View renderer
419−// -----------------------------------------------------------------------------
420−
421−// viewRenderer handles file viewing with syntax highlighting and line numbers
422−type viewRenderer struct {
423− baseRenderer
424−}
425−
426−// Render displays file content with optional limit and offset parameters
427−func (vr viewRenderer) Render(v *toolCallCmp) string {
428− var params tools.ViewParams
429− if err := vr.unmarshalParams(v.call.Input, ¶ms); err != nil {
430− return vr.renderError(v, "Invalid view parameters")
431− }
432−
433− file := fsext.PrettyPath(params.FilePath)
434− args := newParamBuilder().
435− addMain(file).
436− addKeyValue("limit", formatNonZero(params.Limit)).
437− addKeyValue("offset", formatNonZero(params.Offset)).
438− build()
439−
440− return vr.renderWithParams(v, "View", args, func() string {
441− if v.result.Data != "" && strings.HasPrefix(v.result.MIMEType, "image/") {
442− return renderImageContent(v, v.result.Data, v.result.MIMEType, "")
443− }
444−
445− var meta tools.ViewResponseMetadata
446− if err := vr.unmarshalParams(v.result.Metadata, &meta); err != nil {
447− return renderPlainContent(v, v.result.Content)
448− }
449− return renderCodeContent(v, meta.FilePath, meta.Content, params.Offset)
450− })
451−}
452−
453−// formatNonZero returns string representation of non-zero integers, empty string for zero
454−func formatNonZero(value int) string {
455− if value == 0 {
456− return ""
457− }
458− return fmt.Sprintf("%d", value)
459−}
460−
461−// -----------------------------------------------------------------------------
462−// Edit renderer
463−// -----------------------------------------------------------------------------
464−
465−// editRenderer handles file editing with diff visualization
466−type editRenderer struct {
467− baseRenderer
468−}
469−
470−// Render displays the edited file with a formatted diff of changes
471−func (er editRenderer) Render(v *toolCallCmp) string {
472− t := styles.CurrentTheme()
473− var params tools.EditParams
474− var args []string
475− if err := er.unmarshalParams(v.call.Input, ¶ms); err == nil {
476− file := fsext.PrettyPath(params.FilePath)
477− args = newParamBuilder().addMain(file).build()
478− }
479−
480− return er.renderWithParams(v, "Edit", args, func() string {
481− var meta tools.EditResponseMetadata
482− if err := er.unmarshalParams(v.result.Metadata, &meta); err != nil {
483− return renderPlainContent(v, v.result.Content)
484− }
485−
486− formatter := core.DiffFormatter().
487− Before(fsext.PrettyPath(params.FilePath), meta.OldContent).
488− After(fsext.PrettyPath(params.FilePath), meta.NewContent).
489− Width(v.textWidth() - 2) // -2 for padding
490− if v.textWidth() > 120 {
491− formatter = formatter.Split()
492− }
493− // add a message to the bottom if the content was truncated
494− formatted := formatter.String()
495− if lipgloss.Height(formatted) > responseContextHeight {
496− contentLines := strings.Split(formatted, "\n")
497− truncateMessage := t.S().Muted.
498− Background(t.BgBaseLighter).
499− PaddingLeft(2).
500− Width(v.textWidth() - 2).
501− Render(fmt.Sprintf("… (%d lines)", len(contentLines)-responseContextHeight))
502− formatted = strings.Join(contentLines[:responseContextHeight], "\n") + "\n" + truncateMessage
503− }
504− return formatted
505− })
506−}
507−
508−// -----------------------------------------------------------------------------
509−// Multi-Edit renderer
510−// -----------------------------------------------------------------------------
511−
512−// multiEditRenderer handles multiple file edits with diff visualization
513−type multiEditRenderer struct {
514− baseRenderer
515−}
516−
517−// Render displays the multi-edited file with a formatted diff of changes
518−func (mer multiEditRenderer) Render(v *toolCallCmp) string {
519− t := styles.CurrentTheme()
520− var params tools.MultiEditParams
521− var args []string
522− if err := mer.unmarshalParams(v.call.Input, ¶ms); err == nil {
523− file := fsext.PrettyPath(params.FilePath)
524− editsCount := len(params.Edits)
525− args = newParamBuilder().
526− addMain(file).
527− addKeyValue("edits", fmt.Sprintf("%d", editsCount)).
528− build()
529− }
530−
531− return mer.renderWithParams(v, "Multi-Edit", args, func() string {
532− var meta tools.MultiEditResponseMetadata
533− if err := mer.unmarshalParams(v.result.Metadata, &meta); err != nil {
534− return renderPlainContent(v, v.result.Content)
535− }
536−
537− formatter := core.DiffFormatter().
538− Before(fsext.PrettyPath(params.FilePath), meta.OldContent).
539− After(fsext.PrettyPath(params.FilePath), meta.NewContent).
540− Width(v.textWidth() - 2) // -2 for padding
541− if v.textWidth() > 120 {
542− formatter = formatter.Split()
543− }
544− // add a message to the bottom if the content was truncated
545− formatted := formatter.String()
546− if lipgloss.Height(formatted) > responseContextHeight {
547− contentLines := strings.Split(formatted, "\n")
548− truncateMessage := t.S().Muted.
549− Background(t.BgBaseLighter).
550− PaddingLeft(2).
551− Width(v.textWidth() - 4).
552− Render(fmt.Sprintf("… (%d lines)", len(contentLines)-responseContextHeight))
553− formatted = strings.Join(contentLines[:responseContextHeight], "\n") + "\n" + truncateMessage
554− }
555−
556− // Add failed edits warning if any exist
557− if len(meta.EditsFailed) > 0 {
558− noteTag := t.S().Base.Padding(0, 2).Background(t.Info).Foreground(t.White).Render("Note")
559− noteMsg := fmt.Sprintf("%d of %d edits succeeded", meta.EditsApplied, len(params.Edits))
560− note := t.S().Base.
561− Width(v.textWidth() - 2).
562− Render(fmt.Sprintf("%s %s", noteTag, t.S().Muted.Render(noteMsg)))
563− formatted = lipgloss.JoinVertical(lipgloss.Left, formatted, "", note)
564− }
565−
566− return formatted
567− })
568−}
569−
570−// -----------------------------------------------------------------------------
571−// Write renderer
572−// -----------------------------------------------------------------------------
573−
574−// writeRenderer handles file writing with syntax-highlighted content preview
575−type writeRenderer struct {
576− baseRenderer
577−}
578−
579−// Render displays the file being written with syntax highlighting
580−func (wr writeRenderer) Render(v *toolCallCmp) string {
581− var params tools.WriteParams
582− var args []string
583− var file string
584− if err := wr.unmarshalParams(v.call.Input, ¶ms); err == nil {
585− file = fsext.PrettyPath(params.FilePath)
586− args = newParamBuilder().addMain(file).build()
587− }
588−
589− return wr.renderWithParams(v, "Write", args, func() string {
590− return renderCodeContent(v, file, params.Content, 0)
591− })
592−}
593−
594−// -----------------------------------------------------------------------------
595−// Fetch renderer
596−// -----------------------------------------------------------------------------
597−
598−// simpleFetchRenderer handles URL fetching with format-specific content display
599−type simpleFetchRenderer struct {
600− baseRenderer
601−}
602−
603−// Render displays the fetched URL with format and timeout parameters
604−func (fr simpleFetchRenderer) Render(v *toolCallCmp) string {
605− var params tools.FetchParams
606− var args []string
607− if err := fr.unmarshalParams(v.call.Input, ¶ms); err == nil {
608− args = newParamBuilder().
609− addMain(params.URL).
610− addKeyValue("format", params.Format).
611− addKeyValue("timeout", formatTimeout(params.Timeout)).
612− build()
613− }
614−
615− return fr.renderWithParams(v, "Fetch", args, func() string {
616− file := fr.getFileExtension(params.Format)
617− return renderCodeContent(v, file, v.result.Content, 0)
618− })
619−}
620−
621−// getFileExtension returns appropriate file extension for syntax highlighting
622−func (fr simpleFetchRenderer) getFileExtension(format string) string {
623− switch format {
624− case "text":
625− return "fetch.txt"
626− case "html":
627− return "fetch.html"
628− default:
629− return "fetch.md"
630− }
631−}
632−
633−// -----------------------------------------------------------------------------
634−// Agentic fetch renderer
635−// -----------------------------------------------------------------------------
636−
637−// agenticFetchRenderer handles URL fetching with prompt parameter and nested tool calls
638−type agenticFetchRenderer struct {
639− baseRenderer
640−}
641−
642−// Render displays the fetched URL or web search with prompt parameter and nested tool calls
643−func (fr agenticFetchRenderer) Render(v *toolCallCmp) string {
644− t := styles.CurrentTheme()
645− var params tools.AgenticFetchParams
646− var args []string
647− if err := fr.unmarshalParams(v.call.Input, ¶ms); err == nil {
648− if params.URL != "" {
649− args = newParamBuilder().
650− addMain(params.URL).
651− build()
652− }
653− }
654−
655− prompt := params.Prompt
656− prompt = strings.ReplaceAll(prompt, "\n", " ")
657−
658− header := fr.makeHeader(v, "Agentic Fetch", v.textWidth(), args...)
659− if res, done := earlyState(header, v); v.cancelled && done {
660− return res
661− }
662−
663− taskTag := t.S().Base.Bold(true).Padding(0, 1).MarginLeft(2).Background(t.GreenLight).Foreground(t.Border).Render("Prompt")
664− remainingWidth := v.textWidth() - (lipgloss.Width(taskTag) + 1)
665− remainingWidth = min(remainingWidth, 120-(lipgloss.Width(taskTag)+1))
666− prompt = t.S().Base.Width(remainingWidth).Render(prompt)
667− header = lipgloss.JoinVertical(
668− lipgloss.Left,
669− header,
670− "",
671− lipgloss.JoinHorizontal(
672− lipgloss.Left,
673− taskTag,
674− " ",
675− prompt,
676− ),
677− )
678− childTools := tree.Root(header)
679−
680− for _, call := range v.nestedToolCalls {
681− call.SetSize(remainingWidth, 1)
682− childTools.Child(call.View())
683− }
684− parts := []string{
685− childTools.Enumerator(RoundedEnumeratorWithWidth(2, lipgloss.Width(taskTag)-5)).String(),
686− }
687−
688− if v.result.ToolCallID == "" {
689− v.spinning = true
690− parts = append(parts, "", v.anim.View())
691− } else {
692− v.spinning = false
693− }
694−
695− header = lipgloss.JoinVertical(
696− lipgloss.Left,
697− parts...,
698− )
699−
700− if v.result.ToolCallID == "" {
701− return header
702− }
703− body := renderMarkdownContent(v, v.result.Content)
704− return joinHeaderBody(header, body)
705−}
706−
707−// formatTimeout converts timeout seconds to duration string
708−func formatTimeout(timeout int) string {
709− if timeout == 0 {
710− return ""
711− }
712− return (time.Duration(timeout) * time.Second).String()
713−}
714−
715−// -----------------------------------------------------------------------------
716−// Web fetch renderer
717−// -----------------------------------------------------------------------------
718−
719−// webFetchRenderer handles web page fetching with simplified URL display
720−type webFetchRenderer struct {
721− baseRenderer
722−}
723−
724−// Render displays a compact view of web_fetch with just the URL in a link style
725−func (wfr webFetchRenderer) Render(v *toolCallCmp) string {
726− var params tools.WebFetchParams
727− var args []string
728− if err := wfr.unmarshalParams(v.call.Input, ¶ms); err == nil {
729− args = newParamBuilder().
730− addMain(params.URL).
731− build()
732− }
733−
734− return wfr.renderWithParams(v, "Fetch", args, func() string {
735− return renderMarkdownContent(v, v.result.Content)
736− })
737−}
738−
739−// -----------------------------------------------------------------------------
740−// Web search renderer
741−// -----------------------------------------------------------------------------
742−
743−// webSearchRenderer handles web search with query display
744−type webSearchRenderer struct {
745− baseRenderer
746−}
747−
748−// Render displays a compact view of web_search with just the query
749−func (wsr webSearchRenderer) Render(v *toolCallCmp) string {
750− var params tools.WebSearchParams
751− var args []string
752− if err := wsr.unmarshalParams(v.call.Input, ¶ms); err == nil {
753− args = newParamBuilder().
754− addMain(params.Query).
755− build()
756− }
757−
758− return wsr.renderWithParams(v, "Search", args, func() string {
759− return renderMarkdownContent(v, v.result.Content)
760− })
761−}
762−
763−// -----------------------------------------------------------------------------
764−// Download renderer
765−// -----------------------------------------------------------------------------
766−
767−// downloadRenderer handles file downloading with URL and file path display
768−type downloadRenderer struct {
769− baseRenderer
770−}
771−
772−// Render displays the download URL and destination file path with timeout parameter
773−func (dr downloadRenderer) Render(v *toolCallCmp) string {
774− var params tools.DownloadParams
775− var args []string
776− if err := dr.unmarshalParams(v.call.Input, ¶ms); err == nil {
777− args = newParamBuilder().
778− addMain(params.URL).
779− addKeyValue("file_path", fsext.PrettyPath(params.FilePath)).
780− addKeyValue("timeout", formatTimeout(params.Timeout)).
781− build()
782− }
783−
784− return dr.renderWithParams(v, "Download", args, func() string {
785− return renderPlainContent(v, v.result.Content)
786− })
787−}
788−
789−// -----------------------------------------------------------------------------
790−// Glob renderer
791−// -----------------------------------------------------------------------------
792−
793−// globRenderer handles file pattern matching with path filtering
794−type globRenderer struct {
795− baseRenderer
796−}
797−
798−// Render displays the glob pattern with optional path parameter
799−func (gr globRenderer) Render(v *toolCallCmp) string {
800− var params tools.GlobParams
801− var args []string
802− if err := gr.unmarshalParams(v.call.Input, ¶ms); err == nil {
803− args = newParamBuilder().
804− addMain(params.Pattern).
805− addKeyValue("path", params.Path).
806− build()
807− }
808−
809− return gr.renderWithParams(v, "Glob", args, func() string {
810− return renderPlainContent(v, v.result.Content)
811− })
812−}
813−
814−// -----------------------------------------------------------------------------
815−// Grep renderer
816−// -----------------------------------------------------------------------------
817−
818−// grepRenderer handles content searching with pattern matching options
819−type grepRenderer struct {
820− baseRenderer
821−}
822−
823−// Render displays the search pattern with path, include, and literal text options
824−func (gr grepRenderer) Render(v *toolCallCmp) string {
825− var params tools.GrepParams
826− var args []string
827− if err := gr.unmarshalParams(v.call.Input, ¶ms); err == nil {
828− args = newParamBuilder().
829− addMain(params.Pattern).
830− addKeyValue("path", params.Path).
831− addKeyValue("include", params.Include).
832− addFlag("literal", params.LiteralText).
833− build()
834− }
835−
836− return gr.renderWithParams(v, "Grep", args, func() string {
837− return renderPlainContent(v, v.result.Content)
838− })
839−}
840−
841−// -----------------------------------------------------------------------------
842−// LS renderer
843−// -----------------------------------------------------------------------------
844−
845−// lsRenderer handles directory listing with default path handling
846−type lsRenderer struct {
847− baseRenderer
848−}
849−
850−// Render displays the directory path, defaulting to current directory
851−func (lr lsRenderer) Render(v *toolCallCmp) string {
852− var params tools.LSParams
853− var args []string
854− if err := lr.unmarshalParams(v.call.Input, ¶ms); err == nil {
855− path := params.Path
856− if path == "" {
857− path = "."
858− }
859− path = fsext.PrettyPath(path)
860−
861− args = newParamBuilder().addMain(path).build()
862− }
863−
864− return lr.renderWithParams(v, "List", args, func() string {
865− return renderPlainContent(v, v.result.Content)
866− })
867−}
868−
869−// -----------------------------------------------------------------------------
870−// Sourcegraph renderer
871−// -----------------------------------------------------------------------------
872−
873−// sourcegraphRenderer handles code search with count and context options
874−type sourcegraphRenderer struct {
875− baseRenderer
876−}
877−
878−// Render displays the search query with optional count and context window parameters
879−func (sr sourcegraphRenderer) Render(v *toolCallCmp) string {
880− var params tools.SourcegraphParams
881− var args []string
882− if err := sr.unmarshalParams(v.call.Input, ¶ms); err == nil {
883− args = newParamBuilder().
884− addMain(params.Query).
885− addKeyValue("count", formatNonZero(params.Count)).
886− addKeyValue("context", formatNonZero(params.ContextWindow)).
887− build()
888− }
889−
890− return sr.renderWithParams(v, "Sourcegraph", args, func() string {
891− return renderPlainContent(v, v.result.Content)
892− })
893−}
894−
895−// -----------------------------------------------------------------------------
896−// Diagnostics renderer
897−// -----------------------------------------------------------------------------
898−
899−// diagnosticsRenderer handles project-wide diagnostic information
900−type diagnosticsRenderer struct {
901− baseRenderer
902−}
903−
904−// Render displays project diagnostics with plain content formatting
905−func (dr diagnosticsRenderer) Render(v *toolCallCmp) string {
906− args := newParamBuilder().addMain("project").build()
907−
908− return dr.renderWithParams(v, "Diagnostics", args, func() string {
909− return renderPlainContent(v, v.result.Content)
910− })
911−}
912−
913−// -----------------------------------------------------------------------------
914−// Task renderer
915−// -----------------------------------------------------------------------------
916−
917−// agentRenderer handles project-wide diagnostic information
918−type agentRenderer struct {
919− baseRenderer
920−}
921−
922−func RoundedEnumeratorWithWidth(lPadding, width int) tree.Enumerator {
923− if width == 0 {
924− width = 2
925− }
926− if lPadding == 0 {
927− lPadding = 1
928− }
929− return func(children tree.Children, index int) string {
930− line := strings.Repeat("─", width)
931− padding := strings.Repeat(" ", lPadding)
932− if children.Length()-1 == index {
933− return padding + "╰" + line
934− }
935− return padding + "├" + line
936− }
937−}
938−
939−// Render displays agent task parameters and result content
940−func (tr agentRenderer) Render(v *toolCallCmp) string {
941− t := styles.CurrentTheme()
942− var params agent.AgentParams
943− tr.unmarshalParams(v.call.Input, ¶ms)
944−
945− prompt := params.Prompt
946− prompt = strings.ReplaceAll(prompt, "\n", " ")
947−
948− header := tr.makeHeader(v, "Agent", v.textWidth())
949− if res, done := earlyState(header, v); v.cancelled && done {
950− return res
951− }
952− taskTag := t.S().Base.Bold(true).Padding(0, 1).MarginLeft(2).Background(t.BlueLight).Foreground(t.White).Render("Task")
953− remainingWidth := v.textWidth() - lipgloss.Width(header) - lipgloss.Width(taskTag) - 2
954− remainingWidth = min(remainingWidth, 120-lipgloss.Width(taskTag)-2)
955− prompt = t.S().Muted.Width(remainingWidth).Render(prompt)
956− header = lipgloss.JoinVertical(
957− lipgloss.Left,
958− header,
959− "",
960− lipgloss.JoinHorizontal(
961− lipgloss.Left,
962− taskTag,
963− " ",
964− prompt,
965− ),
966− )
967− childTools := tree.Root(header)
968−
969− for _, call := range v.nestedToolCalls {
970− call.SetSize(remainingWidth, 1)
971− childTools.Child(call.View())
972− }
973− parts := []string{
974− childTools.Enumerator(RoundedEnumeratorWithWidth(2, lipgloss.Width(taskTag)-5)).String(),
975− }
976−
977− if v.result.ToolCallID == "" {
978− v.spinning = true
979− parts = append(parts, "", v.anim.View())
980− } else {
981− v.spinning = false
982− }
983−
984− header = lipgloss.JoinVertical(
985− lipgloss.Left,
986− parts...,
987− )
988−
989− if v.result.ToolCallID == "" {
990− return header
991− }
992−
993− body := renderMarkdownContent(v, v.result.Content)
994− return joinHeaderBody(header, body)
995−}
996−
997−// renderParamList renders params, params[0] (params[1]=params[2] ....)
998−func renderParamList(nested bool, paramsWidth int, params ...string) string {
999− t := styles.CurrentTheme()
1000− if len(params) == 0 {
1001− return ""
1002− }
1003− mainParam := params[0]
1004− if paramsWidth >= 0 && lipgloss.Width(mainParam) > paramsWidth {
1005− mainParam = ansi.Truncate(mainParam, paramsWidth, "…")
1006− }
1007−
1008− if len(params) == 1 {
1009− return t.S().Subtle.Render(mainParam)
1010− }
1011− otherParams := params[1:]
1012− // create pairs of key/value
1013− // if odd number of params, the last one is a key without value
1014− if len(otherParams)%2 != 0 {
1015− otherParams = append(otherParams, "")
1016− }
1017− parts := make([]string, 0, len(otherParams)/2)
1018− for i := 0; i < len(otherParams); i += 2 {
1019− key := otherParams[i]
1020− value := otherParams[i+1]
1021− if value == "" {
1022− continue
1023− }
1024− parts = append(parts, fmt.Sprintf("%s=%s", key, value))
1025− }
1026−
1027− partsRendered := strings.Join(parts, ", ")
1028− remainingWidth := paramsWidth - lipgloss.Width(partsRendered) - 3 // count for " ()"
1029− if remainingWidth < 30 {
1030− // No space for the params, just show the main
1031− return t.S().Subtle.Render(mainParam)
1032− }
1033−
1034− if len(parts) > 0 {
1035− mainParam = fmt.Sprintf("%s (%s)", mainParam, strings.Join(parts, ", "))
1036− }
1037−
1038− return t.S().Subtle.Render(ansi.Truncate(mainParam, paramsWidth, "…"))
1039−}
1040−
1041−// earlyState returns immediately‑rendered error/cancelled/ongoing states.
1042−func earlyState(header string, v *toolCallCmp) (string, bool) {
1043− t := styles.CurrentTheme()
1044− message := ""
1045− switch {
1046− case v.result.IsError:
1047− message = v.renderToolError()
1048− case v.cancelled:
1049− message = t.S().Base.Foreground(t.FgSubtle).Render("Canceled.")
1050− case v.result.ToolCallID == "":
1051− if v.permissionRequested && !v.permissionGranted {
1052− message = t.S().Base.Foreground(t.FgSubtle).Render("Requesting permission...")
1053− } else {
1054− message = t.S().Base.Foreground(t.FgSubtle).Render("Waiting for tool response...")
1055− }
1056− default:
1057− return "", false
1058− }
1059−
1060− message = t.S().Base.PaddingLeft(2).Render(message)
1061− return lipgloss.JoinVertical(lipgloss.Left, header, "", message), true
1062−}
1063−
1064−func joinHeaderBody(header, body string) string {
1065− t := styles.CurrentTheme()
1066− if body == "" {
1067− return header
1068− }
1069− body = t.S().Base.PaddingLeft(2).Render(body)
1070− return lipgloss.JoinVertical(lipgloss.Left, header, "", body)
1071−}
1072−
1073−func renderPlainContent(v *toolCallCmp, content string) string {
1074− t := styles.CurrentTheme()
1075− content = strings.ReplaceAll(content, "\r\n", "\n") // Normalize line endings
1076− content = strings.ReplaceAll(content, "\t", " ") // Replace tabs with spaces
1077− content = strings.TrimSpace(content)
1078− lines := strings.Split(content, "\n")
1079−
1080− width := v.textWidth() - 2
1081− var out []string
1082− for i, ln := range lines {
1083− if i >= responseContextHeight {
1084− break
1085− }
1086− ln = ansiext.Escape(ln)
1087− ln = " " + ln
1088− if lipgloss.Width(ln) > width {
1089− ln = v.fit(ln, width)
1090− }
1091− out = append(out, t.S().Muted.
1092− Width(width).
1093− Background(t.BgBaseLighter).
1094− Render(ln))
1095− }
1096−
1097− if len(lines) > responseContextHeight {
1098− out = append(out, t.S().Muted.
1099− Background(t.BgBaseLighter).
1100− Width(width).
1101− Render(fmt.Sprintf("… (%d lines)", len(lines)-responseContextHeight)))
1102− }
1103−
1104− return strings.Join(out, "\n")
1105−}
1106−
1107−func renderMarkdownContent(v *toolCallCmp, content string) string {
1108− t := styles.CurrentTheme()
1109− content = strings.ReplaceAll(content, "\r\n", "\n")
1110− content = strings.ReplaceAll(content, "\t", " ")
1111− content = strings.TrimSpace(content)
1112−
1113− width := v.textWidth() - 2
1114− width = min(width, 120)
1115−
1116− renderer := styles.GetPlainMarkdownRenderer(width)
1117− rendered, err := renderer.Render(content)
1118− if err != nil {
1119− return renderPlainContent(v, content)
1120− }
1121−
1122− lines := strings.Split(rendered, "\n")
1123−
1124− var out []string
1125− for i, ln := range lines {
1126− if i >= responseContextHeight {
1127− break
1128− }
1129− out = append(out, ln)
1130− }
1131−
1132− style := t.S().Muted.Background(t.BgBaseLighter)
1133− if len(lines) > responseContextHeight {
1134− out = append(out, style.
1135− Width(width-2).
1136− Render(fmt.Sprintf("… (%d lines)", len(lines)-responseContextHeight)))
1137− }
1138−
1139− return style.Render(strings.Join(out, "\n"))
1140−}
1141−
1142−func getDigits(n int) int {
1143− if n == 0 {
1144− return 1
1145− }
1146− if n < 0 {
1147− n = -n
1148− }
1149−
1150− digits := 0
1151− for n > 0 {
1152− n /= 10
1153− digits++
1154− }
1155−
1156− return digits
1157−}
1158−
1159−func renderCodeContent(v *toolCallCmp, path, content string, offset int) string {
1160− t := styles.CurrentTheme()
1161− content = strings.ReplaceAll(content, "\r\n", "\n") // Normalize line endings
1162− content = strings.ReplaceAll(content, "\t", " ") // Replace tabs with spaces
1163− truncated := truncateHeight(content, responseContextHeight)
1164−
1165− lines := strings.Split(truncated, "\n")
1166− for i, ln := range lines {
1167− lines[i] = ansiext.Escape(ln)
1168− }
1169−
1170− bg := t.BgBase
1171− highlighted, _ := highlight.SyntaxHighlight(strings.Join(lines, "\n"), path, bg)
1172− lines = strings.Split(highlighted, "\n")
1173−
1174− if len(strings.Split(content, "\n")) > responseContextHeight {
1175− lines = append(lines, t.S().Muted.
1176− Background(bg).
1177− Render(fmt.Sprintf(" …(%d lines)", len(strings.Split(content, "\n"))-responseContextHeight)))
1178− }
1179−
1180− maxLineNumber := len(lines) + offset
1181− maxDigits := getDigits(maxLineNumber)
1182− numFmt := fmt.Sprintf("%%%dd", maxDigits)
1183− const numPR, numPL, codePR, codePL = 1, 1, 1, 2
1184− w := v.textWidth() - maxDigits - numPL - numPR - 2 // -2 for left padding
1185− for i, ln := range lines {
1186− num := t.S().Base.
1187− Foreground(t.FgMuted).
1188− Background(t.BgBase).
1189− PaddingRight(1).
1190− PaddingLeft(1).
1191− Render(fmt.Sprintf(numFmt, i+1+offset))
1192− lines[i] = lipgloss.JoinHorizontal(lipgloss.Left,
1193− num,
1194− t.S().Base.
1195− Width(w).
1196− Background(bg).
1197− PaddingRight(1).
1198− PaddingLeft(2).
1199− Render(v.fit(ln, w-codePL-codePR)),
1200− )
1201− }
1202−
1203− return lipgloss.JoinVertical(lipgloss.Left, lines...)
1204−}
1205−
1206−// renderImageContent renders image data with optional text content (for MCP tools).
1207−func renderImageContent(v *toolCallCmp, data, mediaType, textContent string) string {
1208− t := styles.CurrentTheme()
1209−
1210− dataSize := len(data) * 3 / 4
1211− sizeStr := formatSize(dataSize)
1212−
1213− loaded := t.S().Base.Foreground(t.Green).Render("Loaded")
1214− arrow := t.S().Base.Foreground(t.GreenDark).Render("→")
1215− typeStyled := t.S().Base.Render(mediaType)
1216− sizeStyled := t.S().Subtle.Render(sizeStr)
1217−
1218− imageDisplay := fmt.Sprintf("%s %s %s %s", loaded, arrow, typeStyled, sizeStyled)
1219− if strings.TrimSpace(textContent) != "" {
1220− textDisplay := renderPlainContent(v, textContent)
1221− return lipgloss.JoinVertical(lipgloss.Left, textDisplay, "", imageDisplay)
1222− }
1223−
1224− return imageDisplay
1225−}
1226−
1227−// renderMediaContent renders non-image media content.
1228−func renderMediaContent(v *toolCallCmp, mediaType, textContent string) string {
1229− t := styles.CurrentTheme()
1230−
1231− loaded := t.S().Base.Foreground(t.Green).Render("Loaded")
1232− arrow := t.S().Base.Foreground(t.GreenDark).Render("→")
1233− typeStyled := t.S().Base.Render(mediaType)
1234− mediaDisplay := fmt.Sprintf("%s %s %s", loaded, arrow, typeStyled)
1235−
1236− if strings.TrimSpace(textContent) != "" {
1237− textDisplay := renderPlainContent(v, textContent)
1238− return lipgloss.JoinVertical(lipgloss.Left, textDisplay, "", mediaDisplay)
1239− }
1240−
1241− return mediaDisplay
1242−}
1243−
1244−// formatSize formats byte count as human-readable size.
1245−func formatSize(bytes int) string {
1246− if bytes < 1024 {
1247− return fmt.Sprintf("%d B", bytes)
1248− }
1249− if bytes < 1024*1024 {
1250− return fmt.Sprintf("%.1f KB", float64(bytes)/1024)
1251− }
1252− return fmt.Sprintf("%.1f MB", float64(bytes)/(1024*1024))
1253−}
1254−
1255−func (v *toolCallCmp) renderToolError() string {
1256− t := styles.CurrentTheme()
1257− err := strings.ReplaceAll(v.result.Content, "\n", " ")
1258− errTag := t.S().Base.Padding(0, 1).Background(t.Red).Foreground(t.White).Render("ERROR")
1259− err = fmt.Sprintf("%s %s", errTag, t.S().Base.Foreground(t.FgHalfMuted).Render(v.fit(err, v.textWidth()-2-lipgloss.Width(errTag))))
1260− return err
1261−}
1262−
1263−func truncateHeight(s string, h int) string {
1264− lines := strings.Split(s, "\n")
1265− if len(lines) > h {
1266− return strings.Join(lines[:h], "\n")
1267− }
1268− return s
1269−}
1270−
1271−func prettifyToolName(name string) string {
1272− switch name {
1273− case agent.AgentToolName:
1274− return "Agent"
1275− case tools.BashToolName:
1276− return "Bash"
1277− case tools.JobOutputToolName:
1278− return "Job: Output"
1279− case tools.JobKillToolName:
1280− return "Job: Kill"
1281− case tools.DownloadToolName:
1282− return "Download"
1283− case tools.EditToolName:
1284− return "Edit"
1285− case tools.MultiEditToolName:
1286− return "Multi-Edit"
1287− case tools.FetchToolName:
1288− return "Fetch"
1289− case tools.AgenticFetchToolName:
1290− return "Agentic Fetch"
1291− case tools.WebFetchToolName:
1292− return "Fetch"
1293− case tools.WebSearchToolName:
1294− return "Search"
1295− case tools.GlobToolName:
1296− return "Glob"
1297− case tools.GrepToolName:
1298− return "Grep"
1299− case tools.LSToolName:
1300− return "List"
1301− case tools.SourcegraphToolName:
1302− return "Sourcegraph"
1303− case tools.TodosToolName:
1304− return "To-Do"
1305− case tools.ViewToolName:
1306− return "View"
1307− case tools.WriteToolName:
1308− return "Write"
1309− default:
1310− return name
1311− }
1312−}
1313−
1314−// -----------------------------------------------------------------------------
1315−// Todos renderer
1316−// -----------------------------------------------------------------------------
1317−
1318−type todosRenderer struct {
1319− baseRenderer
1320−}
1321−
1322−func (tr todosRenderer) Render(v *toolCallCmp) string {
1323− t := styles.CurrentTheme()
1324− var params tools.TodosParams
1325− var meta tools.TodosResponseMetadata
1326− var headerText string
1327− var body string
1328−
1329− // Parse params for pending state (before result is available).
1330− if err := tr.unmarshalParams(v.call.Input, ¶ms); err == nil {
1331− completedCount := 0
1332− inProgressTask := ""
1333− for _, todo := range params.Todos {
1334− if todo.Status == "completed" {
1335− completedCount++
1336− }
1337− if todo.Status == "in_progress" {
1338− if todo.ActiveForm != "" {
1339− inProgressTask = todo.ActiveForm
1340− } else {
1341− inProgressTask = todo.Content
1342− }
1343− }
1344− }
1345−
1346− // Default display from params (used when pending or no metadata).
1347− ratio := t.S().Base.Foreground(t.BlueDark).Render(fmt.Sprintf("%d/%d", completedCount, len(params.Todos)))
1348− headerText = ratio
1349− if inProgressTask != "" {
1350− headerText = fmt.Sprintf("%s · %s", ratio, inProgressTask)
1351− }
1352−
1353− // If we have metadata, use it for richer display.
1354− if v.result.Metadata != "" {
1355− if err := tr.unmarshalParams(v.result.Metadata, &meta); err == nil {
1356− if meta.IsNew {
1357− if meta.JustStarted != "" {
1358− headerText = fmt.Sprintf("created %d todos, starting first", meta.Total)
1359− } else {
1360− headerText = fmt.Sprintf("created %d todos", meta.Total)
1361− }
1362− body = todos.FormatTodosList(meta.Todos, styles.ArrowRightIcon, t, v.textWidth())
1363− } else {
1364− // Build header based on what changed.
1365− hasCompleted := len(meta.JustCompleted) > 0
1366− hasStarted := meta.JustStarted != ""
1367− allCompleted := meta.Completed == meta.Total
1368−
1369− ratio := t.S().Base.Foreground(t.BlueDark).Render(fmt.Sprintf("%d/%d", meta.Completed, meta.Total))
1370− if hasCompleted && hasStarted {
1371− text := t.S().Subtle.Render(fmt.Sprintf(" · completed %d, starting next", len(meta.JustCompleted)))
1372− headerText = fmt.Sprintf("%s%s", ratio, text)
1373− } else if hasCompleted {
1374− text := t.S().Subtle.Render(fmt.Sprintf(" · completed %d", len(meta.JustCompleted)))
1375− if allCompleted {
1376− text = t.S().Subtle.Render(" · completed all")
1377− }
1378− headerText = fmt.Sprintf("%s%s", ratio, text)
1379− } else if hasStarted {
1380− headerText = fmt.Sprintf("%s%s", ratio, t.S().Subtle.Render(" · starting task"))
1381− } else {
1382− headerText = ratio
1383− }
1384−
1385− // Build body with details.
1386− if allCompleted {
1387− // Show all todos when all are completed, like when created
1388− body = todos.FormatTodosList(meta.Todos, styles.ArrowRightIcon, t, v.textWidth())
1389− } else if meta.JustStarted != "" {
1390− body = t.S().Base.Foreground(t.GreenDark).Render(styles.ArrowRightIcon+" ") +
1391− t.S().Base.Foreground(t.FgBase).Render(meta.JustStarted)
1392− }
1393− }
1394− }
1395− }
1396− }
1397−
1398− args := newParamBuilder().addMain(headerText).build()
1399−
1400− return tr.renderWithParams(v, "To-Do", args, func() string {
1401− return body
1402− })
1403−}