1package messages
2
3import (
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
24const responseContextHeight = 10
25
26// renderer defines the interface for tool-specific rendering implementations
27type 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
34type rendererFactory func() renderer
35
36// renderRegistry manages the mapping of tool names to their renderers
37type renderRegistry map[string]rendererFactory
38
39// register adds a new renderer factory to the registry
40func (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
43func (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
51var registry = renderRegistry{}
52
53// baseRenderer provides common functionality for all tool renderers
54type baseRenderer struct{}
55
56func (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
74type paramBuilder struct {
75 args []string
76}
77
78// newParamBuilder creates a new parameter builder
79func newParamBuilder() *paramBuilder {
80 return ¶mBuilder{args: make([]string, 0)}
81}
82
83// addMain adds the main parameter (first argument)
84func (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
92func (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
100func (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
108func (pb *paramBuilder) build() []string {
109 return pb.args
110}
111
112// renderWithParams provides a common rendering pattern for tools with parameters
113func (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
130func (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.
135func (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.
153func (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
174func (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
183func 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
210type genericRenderer struct {
211 baseRenderer
212}
213
214func (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
236type bashRenderer struct {
237 baseRenderer
238}
239
240// Render displays the bash command with sanitized newlines and plain output
241func (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
296func 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
336type bashOutputRenderer struct {
337 baseRenderer
338}
339
340// Render displays the shell ID and output from a background shell
341func (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
379type bashKillRenderer struct {
380 baseRenderer
381}
382
383// Render displays the shell ID being terminated
384func (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
422type viewRenderer struct {
423 baseRenderer
424}
425
426// Render displays file content with optional limit and offset parameters
427func (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
454func 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
466type editRenderer struct {
467 baseRenderer
468}
469
470// Render displays the edited file with a formatted diff of changes
471func (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
513type multiEditRenderer struct {
514 baseRenderer
515}
516
517// Render displays the multi-edited file with a formatted diff of changes
518func (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
575type writeRenderer struct {
576 baseRenderer
577}
578
579// Render displays the file being written with syntax highlighting
580func (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
599type simpleFetchRenderer struct {
600 baseRenderer
601}
602
603// Render displays the fetched URL with format and timeout parameters
604func (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
622func (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
638type agenticFetchRenderer struct {
639 baseRenderer
640}
641
642// Render displays the fetched URL or web search with prompt parameter and nested tool calls
643func (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
708func 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
720type webFetchRenderer struct {
721 baseRenderer
722}
723
724// Render displays a compact view of web_fetch with just the URL in a link style
725func (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
744type webSearchRenderer struct {
745 baseRenderer
746}
747
748// Render displays a compact view of web_search with just the query
749func (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
768type downloadRenderer struct {
769 baseRenderer
770}
771
772// Render displays the download URL and destination file path with timeout parameter
773func (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
794type globRenderer struct {
795 baseRenderer
796}
797
798// Render displays the glob pattern with optional path parameter
799func (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
819type grepRenderer struct {
820 baseRenderer
821}
822
823// Render displays the search pattern with path, include, and literal text options
824func (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
846type lsRenderer struct {
847 baseRenderer
848}
849
850// Render displays the directory path, defaulting to current directory
851func (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
874type sourcegraphRenderer struct {
875 baseRenderer
876}
877
878// Render displays the search query with optional count and context window parameters
879func (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
900type diagnosticsRenderer struct {
901 baseRenderer
902}
903
904// Render displays project diagnostics with plain content formatting
905func (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
918type agentRenderer struct {
919 baseRenderer
920}
921
922func 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
940func (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] ....)
998func 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.
1042func 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
1064func 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
1073func 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
1107func 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
1142func 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
1159func 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).
1207func 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.
1228func 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.
1245func 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
1255func (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
1263func 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
1271func 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
1318type todosRenderer struct {
1319 baseRenderer
1320}
1321
1322func (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}