1package messages
2
3import (
4 "encoding/json"
5 "fmt"
6 "strings"
7 "time"
8
9 "github.com/charmbracelet/crush/internal/agent"
10 "github.com/charmbracelet/crush/internal/agent/tools"
11 "github.com/charmbracelet/crush/internal/ansiext"
12 "github.com/charmbracelet/crush/internal/fsext"
13 "github.com/charmbracelet/crush/internal/tui/components/core"
14 "github.com/charmbracelet/crush/internal/tui/highlight"
15 "github.com/charmbracelet/crush/internal/tui/styles"
16 "github.com/charmbracelet/lipgloss/v2"
17 "github.com/charmbracelet/lipgloss/v2/tree"
18 "github.com/charmbracelet/x/ansi"
19)
20
21// responseContextHeight limits the number of lines displayed in tool output
22const responseContextHeight = 10
23
24// renderer defines the interface for tool-specific rendering implementations
25type renderer interface {
26 // Render returns the complete (already styled) tool‑call view, not
27 // including the outer border.
28 Render(v *toolCallCmp) string
29}
30
31// rendererFactory creates new renderer instances
32type rendererFactory func() renderer
33
34// renderRegistry manages the mapping of tool names to their renderers
35type renderRegistry map[string]rendererFactory
36
37// register adds a new renderer factory to the registry
38func (rr renderRegistry) register(name string, f rendererFactory) { rr[name] = f }
39
40// lookup retrieves a renderer for the given tool name, falling back to generic renderer
41func (rr renderRegistry) lookup(name string) renderer {
42 if f, ok := rr[name]; ok {
43 return f()
44 }
45 return genericRenderer{} // sensible fallback
46}
47
48// registry holds all registered tool renderers
49var registry = renderRegistry{}
50
51// baseRenderer provides common functionality for all tool renderers
52type baseRenderer struct{}
53
54// paramBuilder helps construct parameter lists for tool headers
55type paramBuilder struct {
56 args []string
57}
58
59// newParamBuilder creates a new parameter builder
60func newParamBuilder() *paramBuilder {
61 return ¶mBuilder{args: make([]string, 0)}
62}
63
64// addMain adds the main parameter (first argument)
65func (pb *paramBuilder) addMain(value string) *paramBuilder {
66 if value != "" {
67 pb.args = append(pb.args, value)
68 }
69 return pb
70}
71
72// addKeyValue adds a key-value pair parameter
73func (pb *paramBuilder) addKeyValue(key, value string) *paramBuilder {
74 if value != "" {
75 pb.args = append(pb.args, key, value)
76 }
77 return pb
78}
79
80// addFlag adds a boolean flag parameter
81func (pb *paramBuilder) addFlag(key string, value bool) *paramBuilder {
82 if value {
83 pb.args = append(pb.args, key, "true")
84 }
85 return pb
86}
87
88// build returns the final parameter list
89func (pb *paramBuilder) build() []string {
90 return pb.args
91}
92
93// renderWithParams provides a common rendering pattern for tools with parameters
94func (br baseRenderer) renderWithParams(v *toolCallCmp, toolName string, args []string, contentRenderer func() string) string {
95 width := v.textWidth()
96 if v.isNested {
97 width -= 4 // Adjust for nested tool call indentation
98 }
99 header := br.makeHeader(v, toolName, width, args...)
100 if v.isNested {
101 return v.style().Render(header)
102 }
103 if res, done := earlyState(header, v); done {
104 return res
105 }
106 body := contentRenderer()
107 return joinHeaderBody(header, body)
108}
109
110// unmarshalParams safely unmarshal JSON parameters
111func (br baseRenderer) unmarshalParams(input string, target any) error {
112 return json.Unmarshal([]byte(input), target)
113}
114
115// makeHeader builds the tool call header with status icon and parameters for a nested tool call.
116func (br baseRenderer) makeNestedHeader(v *toolCallCmp, tool string, width int, params ...string) string {
117 t := styles.CurrentTheme()
118 icon := t.S().Base.Foreground(t.GreenDark).Render(styles.ToolPending)
119 if v.result.ToolCallID != "" {
120 if v.result.IsError {
121 icon = t.S().Base.Foreground(t.RedDark).Render(styles.ToolError)
122 } else {
123 icon = t.S().Base.Foreground(t.Green).Render(styles.ToolSuccess)
124 }
125 } else if v.cancelled {
126 icon = t.S().Muted.Render(styles.ToolPending)
127 }
128 tool = t.S().Base.Foreground(t.FgHalfMuted).Render(tool)
129 prefix := fmt.Sprintf("%s %s ", icon, tool)
130 return prefix + renderParamList(true, width-lipgloss.Width(prefix), params...)
131}
132
133// makeHeader builds "<Tool>: param (key=value)" and truncates as needed.
134func (br baseRenderer) makeHeader(v *toolCallCmp, tool string, width int, params ...string) string {
135 if v.isNested {
136 return br.makeNestedHeader(v, tool, width, params...)
137 }
138 t := styles.CurrentTheme()
139 icon := t.S().Base.Foreground(t.GreenDark).Render(styles.ToolPending)
140 if v.result.ToolCallID != "" {
141 if v.result.IsError {
142 icon = t.S().Base.Foreground(t.RedDark).Render(styles.ToolError)
143 } else {
144 icon = t.S().Base.Foreground(t.Green).Render(styles.ToolSuccess)
145 }
146 } else if v.cancelled {
147 icon = t.S().Muted.Render(styles.ToolPending)
148 }
149 tool = t.S().Base.Foreground(t.Blue).Render(tool)
150 prefix := fmt.Sprintf("%s %s ", icon, tool)
151 return prefix + renderParamList(false, width-lipgloss.Width(prefix), params...)
152}
153
154// renderError provides consistent error rendering
155func (br baseRenderer) renderError(v *toolCallCmp, message string) string {
156 t := styles.CurrentTheme()
157 header := br.makeHeader(v, prettifyToolName(v.call.Name), v.textWidth(), "")
158 errorTag := t.S().Base.Padding(0, 1).Background(t.Red).Foreground(t.White).Render("ERROR")
159 message = t.S().Base.Foreground(t.FgHalfMuted).Render(v.fit(message, v.textWidth()-3-lipgloss.Width(errorTag))) // -2 for padding and space
160 return joinHeaderBody(header, errorTag+" "+message)
161}
162
163// Register tool renderers
164func init() {
165 registry.register(tools.BashToolName, func() renderer { return bashRenderer{} })
166 registry.register(tools.DownloadToolName, func() renderer { return downloadRenderer{} })
167 registry.register(tools.ViewToolName, func() renderer { return viewRenderer{} })
168 registry.register(tools.EditToolName, func() renderer { return editRenderer{} })
169 registry.register(tools.MultiEditToolName, func() renderer { return multiEditRenderer{} })
170 registry.register(tools.WriteToolName, func() renderer { return writeRenderer{} })
171 registry.register(tools.FetchToolName, func() renderer { return fetchRenderer{} })
172 registry.register(tools.GlobToolName, func() renderer { return globRenderer{} })
173 registry.register(tools.GrepToolName, func() renderer { return grepRenderer{} })
174 registry.register(tools.LSToolName, func() renderer { return lsRenderer{} })
175 registry.register(tools.SourcegraphToolName, func() renderer { return sourcegraphRenderer{} })
176 registry.register(tools.DiagnosticsToolName, func() renderer { return diagnosticsRenderer{} })
177 registry.register(agent.AgentToolName, func() renderer { return agentRenderer{} })
178}
179
180// -----------------------------------------------------------------------------
181// Generic renderer
182// -----------------------------------------------------------------------------
183
184// genericRenderer handles unknown tool types with basic parameter display
185type genericRenderer struct {
186 baseRenderer
187}
188
189// Render displays the tool call with its raw input and plain content output
190func (gr genericRenderer) Render(v *toolCallCmp) string {
191 return gr.renderWithParams(v, prettifyToolName(v.call.Name), []string{v.call.Input}, func() string {
192 return renderPlainContent(v, v.result.Content)
193 })
194}
195
196// -----------------------------------------------------------------------------
197// Bash renderer
198// -----------------------------------------------------------------------------
199
200// bashRenderer handles bash command execution display
201type bashRenderer struct {
202 baseRenderer
203}
204
205// Render displays the bash command with sanitized newlines and plain output
206func (br bashRenderer) Render(v *toolCallCmp) string {
207 var params tools.BashParams
208 if err := br.unmarshalParams(v.call.Input, ¶ms); err != nil {
209 return br.renderError(v, "Invalid bash parameters")
210 }
211
212 cmd := strings.ReplaceAll(params.Command, "\n", " ")
213 cmd = strings.ReplaceAll(cmd, "\t", " ")
214 args := newParamBuilder().addMain(cmd).build()
215
216 return br.renderWithParams(v, "Bash", args, func() string {
217 var meta tools.BashResponseMetadata
218 if err := br.unmarshalParams(v.result.Metadata, &meta); err != nil {
219 return renderPlainContent(v, v.result.Content)
220 }
221 // for backwards compatibility with older tool calls.
222 if meta.Output == "" && v.result.Content != tools.BashNoOutput {
223 meta.Output = v.result.Content
224 }
225
226 if meta.Output == "" {
227 return ""
228 }
229 return renderPlainContent(v, meta.Output)
230 })
231}
232
233// -----------------------------------------------------------------------------
234// View renderer
235// -----------------------------------------------------------------------------
236
237// viewRenderer handles file viewing with syntax highlighting and line numbers
238type viewRenderer struct {
239 baseRenderer
240}
241
242// Render displays file content with optional limit and offset parameters
243func (vr viewRenderer) Render(v *toolCallCmp) string {
244 var params tools.ViewParams
245 if err := vr.unmarshalParams(v.call.Input, ¶ms); err != nil {
246 return vr.renderError(v, "Invalid view parameters")
247 }
248
249 file := fsext.PrettyPath(params.FilePath)
250 args := newParamBuilder().
251 addMain(file).
252 addKeyValue("limit", formatNonZero(params.Limit)).
253 addKeyValue("offset", formatNonZero(params.Offset)).
254 build()
255
256 return vr.renderWithParams(v, "View", args, func() string {
257 var meta tools.ViewResponseMetadata
258 if err := vr.unmarshalParams(v.result.Metadata, &meta); err != nil {
259 return renderPlainContent(v, v.result.Content)
260 }
261 return renderCodeContent(v, meta.FilePath, meta.Content, params.Offset)
262 })
263}
264
265// formatNonZero returns string representation of non-zero integers, empty string for zero
266func formatNonZero(value int) string {
267 if value == 0 {
268 return ""
269 }
270 return fmt.Sprintf("%d", value)
271}
272
273// -----------------------------------------------------------------------------
274// Edit renderer
275// -----------------------------------------------------------------------------
276
277// editRenderer handles file editing with diff visualization
278type editRenderer struct {
279 baseRenderer
280}
281
282// Render displays the edited file with a formatted diff of changes
283func (er editRenderer) Render(v *toolCallCmp) string {
284 t := styles.CurrentTheme()
285 var params tools.EditParams
286 var args []string
287 if err := er.unmarshalParams(v.call.Input, ¶ms); err == nil {
288 file := fsext.PrettyPath(params.FilePath)
289 args = newParamBuilder().addMain(file).build()
290 }
291
292 return er.renderWithParams(v, "Edit", args, func() string {
293 var meta tools.EditResponseMetadata
294 if err := er.unmarshalParams(v.result.Metadata, &meta); err != nil {
295 return renderPlainContent(v, v.result.Content)
296 }
297
298 formatter := core.DiffFormatter().
299 Before(fsext.PrettyPath(params.FilePath), meta.OldContent).
300 After(fsext.PrettyPath(params.FilePath), meta.NewContent).
301 Width(v.textWidth() - 2) // -2 for padding
302 if v.textWidth() > 120 {
303 formatter = formatter.Split()
304 }
305 // add a message to the bottom if the content was truncated
306 formatted := formatter.String()
307 if lipgloss.Height(formatted) > responseContextHeight {
308 contentLines := strings.Split(formatted, "\n")
309 truncateMessage := t.S().Muted.
310 Background(t.BgBaseLighter).
311 PaddingLeft(2).
312 Width(v.textWidth() - 2).
313 Render(fmt.Sprintf("… (%d lines)", len(contentLines)-responseContextHeight))
314 formatted = strings.Join(contentLines[:responseContextHeight], "\n") + "\n" + truncateMessage
315 }
316 return formatted
317 })
318}
319
320// -----------------------------------------------------------------------------
321// Multi-Edit renderer
322// -----------------------------------------------------------------------------
323
324// multiEditRenderer handles multiple file edits with diff visualization
325type multiEditRenderer struct {
326 baseRenderer
327}
328
329// Render displays the multi-edited file with a formatted diff of changes
330func (mer multiEditRenderer) Render(v *toolCallCmp) string {
331 t := styles.CurrentTheme()
332 var params tools.MultiEditParams
333 var args []string
334 if err := mer.unmarshalParams(v.call.Input, ¶ms); err == nil {
335 file := fsext.PrettyPath(params.FilePath)
336 editsCount := len(params.Edits)
337 args = newParamBuilder().
338 addMain(file).
339 addKeyValue("edits", fmt.Sprintf("%d", editsCount)).
340 build()
341 }
342
343 return mer.renderWithParams(v, "Multi-Edit", args, func() string {
344 var meta tools.MultiEditResponseMetadata
345 if err := mer.unmarshalParams(v.result.Metadata, &meta); err != nil {
346 return renderPlainContent(v, v.result.Content)
347 }
348
349 formatter := core.DiffFormatter().
350 Before(fsext.PrettyPath(params.FilePath), meta.OldContent).
351 After(fsext.PrettyPath(params.FilePath), meta.NewContent).
352 Width(v.textWidth() - 2) // -2 for padding
353 if v.textWidth() > 120 {
354 formatter = formatter.Split()
355 }
356 // add a message to the bottom if the content was truncated
357 formatted := formatter.String()
358 if lipgloss.Height(formatted) > responseContextHeight {
359 contentLines := strings.Split(formatted, "\n")
360 truncateMessage := t.S().Muted.
361 Background(t.BgBaseLighter).
362 PaddingLeft(2).
363 Width(v.textWidth() - 4).
364 Render(fmt.Sprintf("… (%d lines)", len(contentLines)-responseContextHeight))
365 formatted = strings.Join(contentLines[:responseContextHeight], "\n") + "\n" + truncateMessage
366 }
367
368 // Add failed edits warning if any exist
369 if len(meta.EditsFailed) > 0 {
370 noteTag := t.S().Base.Padding(0, 2).Background(t.Info).Foreground(t.White).Render("Note")
371 noteMsg := fmt.Sprintf("%d of %d edits succeeded", meta.EditsApplied, len(params.Edits))
372 note := t.S().Base.
373 Width(v.textWidth() - 2).
374 Render(fmt.Sprintf("%s %s", noteTag, t.S().Muted.Render(noteMsg)))
375 formatted = lipgloss.JoinVertical(lipgloss.Left, formatted, "", note)
376 }
377
378 return formatted
379 })
380}
381
382// -----------------------------------------------------------------------------
383// Write renderer
384// -----------------------------------------------------------------------------
385
386// writeRenderer handles file writing with syntax-highlighted content preview
387type writeRenderer struct {
388 baseRenderer
389}
390
391// Render displays the file being written with syntax highlighting
392func (wr writeRenderer) Render(v *toolCallCmp) string {
393 var params tools.WriteParams
394 var args []string
395 var file string
396 if err := wr.unmarshalParams(v.call.Input, ¶ms); err == nil {
397 file = fsext.PrettyPath(params.FilePath)
398 args = newParamBuilder().addMain(file).build()
399 }
400
401 return wr.renderWithParams(v, "Write", args, func() string {
402 return renderCodeContent(v, file, params.Content, 0)
403 })
404}
405
406// -----------------------------------------------------------------------------
407// Fetch renderer
408// -----------------------------------------------------------------------------
409
410// fetchRenderer handles URL fetching with format-specific content display
411type fetchRenderer struct {
412 baseRenderer
413}
414
415// Render displays the fetched URL with format and timeout parameters
416func (fr fetchRenderer) Render(v *toolCallCmp) string {
417 var params tools.FetchParams
418 var args []string
419 if err := fr.unmarshalParams(v.call.Input, ¶ms); err == nil {
420 args = newParamBuilder().
421 addMain(params.URL).
422 addKeyValue("format", params.Format).
423 addKeyValue("timeout", formatTimeout(params.Timeout)).
424 build()
425 }
426
427 return fr.renderWithParams(v, "Fetch", args, func() string {
428 file := fr.getFileExtension(params.Format)
429 return renderCodeContent(v, file, v.result.Content, 0)
430 })
431}
432
433// getFileExtension returns appropriate file extension for syntax highlighting
434func (fr fetchRenderer) getFileExtension(format string) string {
435 switch format {
436 case "text":
437 return "fetch.txt"
438 case "html":
439 return "fetch.html"
440 default:
441 return "fetch.md"
442 }
443}
444
445// formatTimeout converts timeout seconds to duration string
446func formatTimeout(timeout int) string {
447 if timeout == 0 {
448 return ""
449 }
450 return (time.Duration(timeout) * time.Second).String()
451}
452
453// -----------------------------------------------------------------------------
454// Download renderer
455// -----------------------------------------------------------------------------
456
457// downloadRenderer handles file downloading with URL and file path display
458type downloadRenderer struct {
459 baseRenderer
460}
461
462// Render displays the download URL and destination file path with timeout parameter
463func (dr downloadRenderer) Render(v *toolCallCmp) string {
464 var params tools.DownloadParams
465 var args []string
466 if err := dr.unmarshalParams(v.call.Input, ¶ms); err == nil {
467 args = newParamBuilder().
468 addMain(params.URL).
469 addKeyValue("file_path", fsext.PrettyPath(params.FilePath)).
470 addKeyValue("timeout", formatTimeout(params.Timeout)).
471 build()
472 }
473
474 return dr.renderWithParams(v, "Download", args, func() string {
475 return renderPlainContent(v, v.result.Content)
476 })
477}
478
479// -----------------------------------------------------------------------------
480// Glob renderer
481// -----------------------------------------------------------------------------
482
483// globRenderer handles file pattern matching with path filtering
484type globRenderer struct {
485 baseRenderer
486}
487
488// Render displays the glob pattern with optional path parameter
489func (gr globRenderer) Render(v *toolCallCmp) string {
490 var params tools.GlobParams
491 var args []string
492 if err := gr.unmarshalParams(v.call.Input, ¶ms); err == nil {
493 args = newParamBuilder().
494 addMain(params.Pattern).
495 addKeyValue("path", params.Path).
496 build()
497 }
498
499 return gr.renderWithParams(v, "Glob", args, func() string {
500 return renderPlainContent(v, v.result.Content)
501 })
502}
503
504// -----------------------------------------------------------------------------
505// Grep renderer
506// -----------------------------------------------------------------------------
507
508// grepRenderer handles content searching with pattern matching options
509type grepRenderer struct {
510 baseRenderer
511}
512
513// Render displays the search pattern with path, include, and literal text options
514func (gr grepRenderer) Render(v *toolCallCmp) string {
515 var params tools.GrepParams
516 var args []string
517 if err := gr.unmarshalParams(v.call.Input, ¶ms); err == nil {
518 args = newParamBuilder().
519 addMain(params.Pattern).
520 addKeyValue("path", params.Path).
521 addKeyValue("include", params.Include).
522 addFlag("literal", params.LiteralText).
523 build()
524 }
525
526 return gr.renderWithParams(v, "Grep", args, func() string {
527 return renderPlainContent(v, v.result.Content)
528 })
529}
530
531// -----------------------------------------------------------------------------
532// LS renderer
533// -----------------------------------------------------------------------------
534
535// lsRenderer handles directory listing with default path handling
536type lsRenderer struct {
537 baseRenderer
538}
539
540// Render displays the directory path, defaulting to current directory
541func (lr lsRenderer) Render(v *toolCallCmp) string {
542 var params tools.LSParams
543 var args []string
544 if err := lr.unmarshalParams(v.call.Input, ¶ms); err == nil {
545 path := params.Path
546 if path == "" {
547 path = "."
548 }
549 path = fsext.PrettyPath(path)
550
551 args = newParamBuilder().addMain(path).build()
552 }
553
554 return lr.renderWithParams(v, "List", args, func() string {
555 return renderPlainContent(v, v.result.Content)
556 })
557}
558
559// -----------------------------------------------------------------------------
560// Sourcegraph renderer
561// -----------------------------------------------------------------------------
562
563// sourcegraphRenderer handles code search with count and context options
564type sourcegraphRenderer struct {
565 baseRenderer
566}
567
568// Render displays the search query with optional count and context window parameters
569func (sr sourcegraphRenderer) Render(v *toolCallCmp) string {
570 var params tools.SourcegraphParams
571 var args []string
572 if err := sr.unmarshalParams(v.call.Input, ¶ms); err == nil {
573 args = newParamBuilder().
574 addMain(params.Query).
575 addKeyValue("count", formatNonZero(params.Count)).
576 addKeyValue("context", formatNonZero(params.ContextWindow)).
577 build()
578 }
579
580 return sr.renderWithParams(v, "Sourcegraph", args, func() string {
581 return renderPlainContent(v, v.result.Content)
582 })
583}
584
585// -----------------------------------------------------------------------------
586// Diagnostics renderer
587// -----------------------------------------------------------------------------
588
589// diagnosticsRenderer handles project-wide diagnostic information
590type diagnosticsRenderer struct {
591 baseRenderer
592}
593
594// Render displays project diagnostics with plain content formatting
595func (dr diagnosticsRenderer) Render(v *toolCallCmp) string {
596 args := newParamBuilder().addMain("project").build()
597
598 return dr.renderWithParams(v, "Diagnostics", args, func() string {
599 return renderPlainContent(v, v.result.Content)
600 })
601}
602
603// -----------------------------------------------------------------------------
604// Task renderer
605// -----------------------------------------------------------------------------
606
607// agentRenderer handles project-wide diagnostic information
608type agentRenderer struct {
609 baseRenderer
610}
611
612func RoundedEnumerator(children tree.Children, index int) string {
613 if children.Length()-1 == index {
614 return " ╰──"
615 }
616 return " ├──"
617}
618
619// Render displays agent task parameters and result content
620func (tr agentRenderer) Render(v *toolCallCmp) string {
621 t := styles.CurrentTheme()
622 var params agent.AgentParams
623 tr.unmarshalParams(v.call.Input, ¶ms)
624
625 prompt := params.Prompt
626 prompt = strings.ReplaceAll(prompt, "\n", " ")
627
628 header := tr.makeHeader(v, "Agent", v.textWidth())
629 if res, done := earlyState(header, v); v.cancelled && done {
630 return res
631 }
632 taskTag := t.S().Base.Padding(0, 1).MarginLeft(1).Background(t.BlueLight).Foreground(t.White).Render("Task")
633 remainingWidth := v.textWidth() - lipgloss.Width(header) - lipgloss.Width(taskTag) - 2 // -2 for padding
634 prompt = t.S().Muted.Width(remainingWidth).Render(prompt)
635 header = lipgloss.JoinVertical(
636 lipgloss.Left,
637 header,
638 "",
639 lipgloss.JoinHorizontal(
640 lipgloss.Left,
641 taskTag,
642 " ",
643 prompt,
644 ),
645 )
646 childTools := tree.Root(header)
647
648 for _, call := range v.nestedToolCalls {
649 childTools.Child(call.View())
650 }
651 parts := []string{
652 childTools.Enumerator(RoundedEnumerator).String(),
653 }
654
655 if v.result.ToolCallID == "" {
656 v.spinning = true
657 parts = append(parts, "", v.anim.View())
658 } else {
659 v.spinning = false
660 }
661
662 header = lipgloss.JoinVertical(
663 lipgloss.Left,
664 parts...,
665 )
666
667 if v.result.ToolCallID == "" {
668 return header
669 }
670
671 body := renderPlainContent(v, v.result.Content)
672 return joinHeaderBody(header, body)
673}
674
675// renderParamList renders params, params[0] (params[1]=params[2] ....)
676func renderParamList(nested bool, paramsWidth int, params ...string) string {
677 t := styles.CurrentTheme()
678 if len(params) == 0 {
679 return ""
680 }
681 mainParam := params[0]
682 if paramsWidth >= 0 && lipgloss.Width(mainParam) > paramsWidth {
683 mainParam = ansi.Truncate(mainParam, paramsWidth, "…")
684 }
685
686 if len(params) == 1 {
687 if nested {
688 return t.S().Muted.Render(mainParam)
689 }
690 return t.S().Subtle.Render(mainParam)
691 }
692 otherParams := params[1:]
693 // create pairs of key/value
694 // if odd number of params, the last one is a key without value
695 if len(otherParams)%2 != 0 {
696 otherParams = append(otherParams, "")
697 }
698 parts := make([]string, 0, len(otherParams)/2)
699 for i := 0; i < len(otherParams); i += 2 {
700 key := otherParams[i]
701 value := otherParams[i+1]
702 if value == "" {
703 continue
704 }
705 parts = append(parts, fmt.Sprintf("%s=%s", key, value))
706 }
707
708 partsRendered := strings.Join(parts, ", ")
709 remainingWidth := paramsWidth - lipgloss.Width(partsRendered) - 3 // count for " ()"
710 if remainingWidth < 30 {
711 if nested {
712 return t.S().Muted.Render(mainParam)
713 }
714 // No space for the params, just show the main
715 return t.S().Subtle.Render(mainParam)
716 }
717
718 if len(parts) > 0 {
719 mainParam = fmt.Sprintf("%s (%s)", mainParam, strings.Join(parts, ", "))
720 }
721
722 if nested {
723 return t.S().Muted.Render(ansi.Truncate(mainParam, paramsWidth, "…"))
724 }
725 return t.S().Subtle.Render(ansi.Truncate(mainParam, paramsWidth, "…"))
726}
727
728// earlyState returns immediately‑rendered error/cancelled/ongoing states.
729func earlyState(header string, v *toolCallCmp) (string, bool) {
730 t := styles.CurrentTheme()
731 message := ""
732 switch {
733 case v.result.IsError:
734 message = v.renderToolError()
735 case v.cancelled:
736 message = t.S().Base.Foreground(t.FgSubtle).Render("Canceled.")
737 case v.result.ToolCallID == "":
738 if v.permissionRequested && !v.permissionGranted {
739 message = t.S().Base.Foreground(t.FgSubtle).Render("Requesting for permission...")
740 } else {
741 message = t.S().Base.Foreground(t.FgSubtle).Render("Waiting for tool response...")
742 }
743 default:
744 return "", false
745 }
746
747 message = t.S().Base.PaddingLeft(2).Render(message)
748 return lipgloss.JoinVertical(lipgloss.Left, header, "", message), true
749}
750
751func joinHeaderBody(header, body string) string {
752 t := styles.CurrentTheme()
753 if body == "" {
754 return header
755 }
756 body = t.S().Base.PaddingLeft(2).Render(body)
757 return lipgloss.JoinVertical(lipgloss.Left, header, "", body)
758}
759
760func renderPlainContent(v *toolCallCmp, content string) string {
761 t := styles.CurrentTheme()
762 content = strings.ReplaceAll(content, "\r\n", "\n") // Normalize line endings
763 content = strings.ReplaceAll(content, "\t", " ") // Replace tabs with spaces
764 content = strings.TrimSpace(content)
765 lines := strings.Split(content, "\n")
766
767 width := v.textWidth() - 2 // -2 for left padding
768 var out []string
769 for i, ln := range lines {
770 if i >= responseContextHeight {
771 break
772 }
773 ln = ansiext.Escape(ln)
774 ln = " " + ln // left padding
775 if len(ln) > width {
776 ln = v.fit(ln, width)
777 }
778 out = append(out, t.S().Muted.
779 Width(width).
780 Background(t.BgBaseLighter).
781 Render(ln))
782 }
783
784 if len(lines) > responseContextHeight {
785 out = append(out, t.S().Muted.
786 Background(t.BgBaseLighter).
787 Width(width).
788 Render(fmt.Sprintf("… (%d lines)", len(lines)-responseContextHeight)))
789 }
790
791 return strings.Join(out, "\n")
792}
793
794func getDigits(n int) int {
795 if n == 0 {
796 return 1
797 }
798 if n < 0 {
799 n = -n
800 }
801
802 digits := 0
803 for n > 0 {
804 n /= 10
805 digits++
806 }
807
808 return digits
809}
810
811func renderCodeContent(v *toolCallCmp, path, content string, offset int) string {
812 t := styles.CurrentTheme()
813 content = strings.ReplaceAll(content, "\r\n", "\n") // Normalize line endings
814 content = strings.ReplaceAll(content, "\t", " ") // Replace tabs with spaces
815 truncated := truncateHeight(content, responseContextHeight)
816
817 lines := strings.Split(truncated, "\n")
818 for i, ln := range lines {
819 lines[i] = ansiext.Escape(ln)
820 }
821
822 bg := t.BgBase
823 highlighted, _ := highlight.SyntaxHighlight(strings.Join(lines, "\n"), path, bg)
824 lines = strings.Split(highlighted, "\n")
825
826 if len(strings.Split(content, "\n")) > responseContextHeight {
827 lines = append(lines, t.S().Muted.
828 Background(bg).
829 Render(fmt.Sprintf(" …(%d lines)", len(strings.Split(content, "\n"))-responseContextHeight)))
830 }
831
832 maxLineNumber := len(lines) + offset
833 maxDigits := getDigits(maxLineNumber)
834 numFmt := fmt.Sprintf("%%%dd", maxDigits)
835 const numPR, numPL, codePR, codePL = 1, 1, 1, 2
836 w := v.textWidth() - maxDigits - numPL - numPR - 2 // -2 for left padding
837 for i, ln := range lines {
838 num := t.S().Base.
839 Foreground(t.FgMuted).
840 Background(t.BgBase).
841 PaddingRight(1).
842 PaddingLeft(1).
843 Render(fmt.Sprintf(numFmt, i+1+offset))
844 lines[i] = lipgloss.JoinHorizontal(lipgloss.Left,
845 num,
846 t.S().Base.
847 Width(w).
848 Background(bg).
849 PaddingRight(1).
850 PaddingLeft(2).
851 Render(v.fit(ln, w-codePL-codePR)),
852 )
853 }
854
855 return lipgloss.JoinVertical(lipgloss.Left, lines...)
856}
857
858func (v *toolCallCmp) renderToolError() string {
859 t := styles.CurrentTheme()
860 err := strings.ReplaceAll(v.result.Content, "\n", " ")
861 errTag := t.S().Base.Padding(0, 1).Background(t.Red).Foreground(t.White).Render("ERROR")
862 err = fmt.Sprintf("%s %s", errTag, t.S().Base.Foreground(t.FgHalfMuted).Render(v.fit(err, v.textWidth()-2-lipgloss.Width(errTag))))
863 return err
864}
865
866func truncateHeight(s string, h int) string {
867 lines := strings.Split(s, "\n")
868 if len(lines) > h {
869 return strings.Join(lines[:h], "\n")
870 }
871 return s
872}
873
874func prettifyToolName(name string) string {
875 switch name {
876 case agent.AgentToolName:
877 return "Agent"
878 case tools.BashToolName:
879 return "Bash"
880 case tools.DownloadToolName:
881 return "Download"
882 case tools.EditToolName:
883 return "Edit"
884 case tools.MultiEditToolName:
885 return "Multi-Edit"
886 case tools.FetchToolName:
887 return "Fetch"
888 case tools.GlobToolName:
889 return "Glob"
890 case tools.GrepToolName:
891 return "Grep"
892 case tools.LSToolName:
893 return "List"
894 case tools.SourcegraphToolName:
895 return "Sourcegraph"
896 case tools.ViewToolName:
897 return "View"
898 case tools.WriteToolName:
899 return "Write"
900 default:
901 return name
902 }
903}