1package messages
2
3import (
4 "encoding/json"
5 "fmt"
6 "strings"
7 "time"
8
9 "github.com/charmbracelet/crush/internal/fsext"
10 "github.com/charmbracelet/crush/internal/highlight"
11 "github.com/charmbracelet/crush/internal/llm/agent"
12 "github.com/charmbracelet/crush/internal/llm/tools"
13 "github.com/charmbracelet/crush/internal/tui/components/core"
14 "github.com/charmbracelet/crush/internal/tui/styles"
15 "github.com/charmbracelet/lipgloss/v2"
16 "github.com/charmbracelet/lipgloss/v2/tree"
17 "github.com/charmbracelet/x/ansi"
18)
19
20// responseContextHeight limits the number of lines displayed in tool output
21const responseContextHeight = 10
22
23// renderer defines the interface for tool-specific rendering implementations
24type renderer interface {
25 // Render returns the complete (already styled) tool‑call view, not
26 // including the outer border.
27 Render(v *toolCallCmp) string
28}
29
30// rendererFactory creates new renderer instances
31type rendererFactory func() renderer
32
33// renderRegistry manages the mapping of tool names to their renderers
34type renderRegistry map[string]rendererFactory
35
36// register adds a new renderer factory to the registry
37func (rr renderRegistry) register(name string, f rendererFactory) { rr[name] = f }
38
39// lookup retrieves a renderer for the given tool name, falling back to generic renderer
40func (rr renderRegistry) lookup(name string) renderer {
41 if f, ok := rr[name]; ok {
42 return f()
43 }
44 return genericRenderer{} // sensible fallback
45}
46
47// registry holds all registered tool renderers
48var registry = renderRegistry{}
49
50// baseRenderer provides common functionality for all tool renderers
51type baseRenderer struct{}
52
53// paramBuilder helps construct parameter lists for tool headers
54type paramBuilder struct {
55 args []string
56}
57
58// newParamBuilder creates a new parameter builder
59func newParamBuilder() *paramBuilder {
60 return ¶mBuilder{args: make([]string, 0)}
61}
62
63// addMain adds the main parameter (first argument)
64func (pb *paramBuilder) addMain(value string) *paramBuilder {
65 if value != "" {
66 pb.args = append(pb.args, value)
67 }
68 return pb
69}
70
71// addKeyValue adds a key-value pair parameter
72func (pb *paramBuilder) addKeyValue(key, value string) *paramBuilder {
73 if value != "" {
74 pb.args = append(pb.args, key, value)
75 }
76 return pb
77}
78
79// addFlag adds a boolean flag parameter
80func (pb *paramBuilder) addFlag(key string, value bool) *paramBuilder {
81 if value {
82 pb.args = append(pb.args, key, "true")
83 }
84 return pb
85}
86
87// build returns the final parameter list
88func (pb *paramBuilder) build() []string {
89 return pb.args
90}
91
92// renderWithParams provides a common rendering pattern for tools with parameters
93func (br baseRenderer) renderWithParams(v *toolCallCmp, toolName string, args []string, contentRenderer func() string) string {
94 width := v.textWidth()
95 if v.isNested {
96 width -= 4 // Adjust for nested tool call indentation
97 }
98 header := br.makeHeader(v, toolName, width, args...)
99 if v.isNested {
100 return v.style().Render(header)
101 }
102 if res, done := earlyState(header, v); done {
103 return res
104 }
105 body := contentRenderer()
106 return joinHeaderBody(header, body)
107}
108
109// unmarshalParams safely unmarshal JSON parameters
110func (br baseRenderer) unmarshalParams(input string, target any) error {
111 return json.Unmarshal([]byte(input), target)
112}
113
114// makeHeader builds "<Tool>: param (key=value)" and truncates as needed.
115func (br baseRenderer) makeHeader(v *toolCallCmp, tool string, width int, params ...string) string {
116 t := styles.CurrentTheme()
117 icon := t.S().Base.Foreground(t.GreenDark).Render(styles.ToolPending)
118 if v.result.ToolCallID != "" {
119 if v.result.IsError {
120 icon = t.S().Base.Foreground(t.RedDark).Render(styles.ToolError)
121 } else {
122 icon = t.S().Base.Foreground(t.Green).Render(styles.ToolSuccess)
123 }
124 } else if v.cancelled {
125 icon = t.S().Muted.Render(styles.ToolPending)
126 }
127 tool = t.S().Base.Foreground(t.Blue).Render(tool)
128 prefix := fmt.Sprintf("%s %s ", icon, tool)
129 return prefix + renderParamList(width-lipgloss.Width(prefix), params...)
130}
131
132// renderError provides consistent error rendering
133func (br baseRenderer) renderError(v *toolCallCmp, message string) string {
134 t := styles.CurrentTheme()
135 header := br.makeHeader(v, prettifyToolName(v.call.Name), v.textWidth(), "")
136 message = t.S().Error.Render(v.fit(message, v.textWidth()-2)) // -2 for padding
137 return joinHeaderBody(header, message)
138}
139
140// Register tool renderers
141func init() {
142 registry.register(tools.BashToolName, func() renderer { return bashRenderer{} })
143 registry.register(tools.ViewToolName, func() renderer { return viewRenderer{} })
144 registry.register(tools.EditToolName, func() renderer { return editRenderer{} })
145 registry.register(tools.WriteToolName, func() renderer { return writeRenderer{} })
146 registry.register(tools.FetchToolName, func() renderer { return fetchRenderer{} })
147 registry.register(tools.GlobToolName, func() renderer { return globRenderer{} })
148 registry.register(tools.GrepToolName, func() renderer { return grepRenderer{} })
149 registry.register(tools.LSToolName, func() renderer { return lsRenderer{} })
150 registry.register(tools.SourcegraphToolName, func() renderer { return sourcegraphRenderer{} })
151 registry.register(tools.DiagnosticsToolName, func() renderer { return diagnosticsRenderer{} })
152 registry.register(agent.AgentToolName, func() renderer { return agentRenderer{} })
153}
154
155// -----------------------------------------------------------------------------
156// Generic renderer
157// -----------------------------------------------------------------------------
158
159// genericRenderer handles unknown tool types with basic parameter display
160type genericRenderer struct {
161 baseRenderer
162}
163
164// Render displays the tool call with its raw input and plain content output
165func (gr genericRenderer) Render(v *toolCallCmp) string {
166 return gr.renderWithParams(v, prettifyToolName(v.call.Name), []string{v.call.Input}, func() string {
167 return renderPlainContent(v, v.result.Content)
168 })
169}
170
171// -----------------------------------------------------------------------------
172// Bash renderer
173// -----------------------------------------------------------------------------
174
175// bashRenderer handles bash command execution display
176type bashRenderer struct {
177 baseRenderer
178}
179
180// Render displays the bash command with sanitized newlines and plain output
181func (br bashRenderer) Render(v *toolCallCmp) string {
182 var params tools.BashParams
183 if err := br.unmarshalParams(v.call.Input, ¶ms); err != nil {
184 return br.renderError(v, "Invalid bash parameters")
185 }
186
187 cmd := strings.ReplaceAll(params.Command, "\n", " ")
188 args := newParamBuilder().addMain(cmd).build()
189
190 return br.renderWithParams(v, "Bash", args, func() string {
191 return renderPlainContent(v, v.result.Content)
192 })
193}
194
195// -----------------------------------------------------------------------------
196// View renderer
197// -----------------------------------------------------------------------------
198
199// viewRenderer handles file viewing with syntax highlighting and line numbers
200type viewRenderer struct {
201 baseRenderer
202}
203
204// Render displays file content with optional limit and offset parameters
205func (vr viewRenderer) Render(v *toolCallCmp) string {
206 var params tools.ViewParams
207 if err := vr.unmarshalParams(v.call.Input, ¶ms); err != nil {
208 return vr.renderError(v, "Invalid view parameters")
209 }
210
211 file := fsext.PrettyPath(params.FilePath)
212 args := newParamBuilder().
213 addMain(file).
214 addKeyValue("limit", formatNonZero(params.Limit)).
215 addKeyValue("offset", formatNonZero(params.Offset)).
216 build()
217
218 return vr.renderWithParams(v, "View", args, func() string {
219 var meta tools.ViewResponseMetadata
220 if err := vr.unmarshalParams(v.result.Metadata, &meta); err != nil {
221 return renderPlainContent(v, v.result.Content)
222 }
223 return renderCodeContent(v, meta.FilePath, meta.Content, params.Offset)
224 })
225}
226
227// formatNonZero returns string representation of non-zero integers, empty string for zero
228func formatNonZero(value int) string {
229 if value == 0 {
230 return ""
231 }
232 return fmt.Sprintf("%d", value)
233}
234
235// -----------------------------------------------------------------------------
236// Edit renderer
237// -----------------------------------------------------------------------------
238
239// editRenderer handles file editing with diff visualization
240type editRenderer struct {
241 baseRenderer
242}
243
244// Render displays the edited file with a formatted diff of changes
245func (er editRenderer) Render(v *toolCallCmp) string {
246 var params tools.EditParams
247 if err := er.unmarshalParams(v.call.Input, ¶ms); err != nil {
248 return er.renderError(v, "Invalid edit parameters")
249 }
250
251 file := fsext.PrettyPath(params.FilePath)
252 args := newParamBuilder().addMain(file).build()
253
254 return er.renderWithParams(v, "Edit", args, func() string {
255 var meta tools.EditResponseMetadata
256 if err := er.unmarshalParams(v.result.Metadata, &meta); err != nil {
257 return renderPlainContent(v, v.result.Content)
258 }
259
260 formatter := core.DiffFormatter().
261 Before(fsext.PrettyPath(params.FilePath), meta.OldContent).
262 After(fsext.PrettyPath(params.FilePath), meta.NewContent).
263 Width(v.textWidth() - 2) // -2 for padding
264 if v.textWidth() > 120 {
265 formatter = formatter.Split()
266 }
267 return formatter.String()
268 })
269}
270
271// -----------------------------------------------------------------------------
272// Write renderer
273// -----------------------------------------------------------------------------
274
275// writeRenderer handles file writing with syntax-highlighted content preview
276type writeRenderer struct {
277 baseRenderer
278}
279
280// Render displays the file being written with syntax highlighting
281func (wr writeRenderer) Render(v *toolCallCmp) string {
282 var params tools.WriteParams
283 if err := wr.unmarshalParams(v.call.Input, ¶ms); err != nil {
284 return wr.renderError(v, "Invalid write parameters")
285 }
286
287 file := fsext.PrettyPath(params.FilePath)
288 args := newParamBuilder().addMain(file).build()
289
290 return wr.renderWithParams(v, "Write", args, func() string {
291 return renderCodeContent(v, file, params.Content, 0)
292 })
293}
294
295// -----------------------------------------------------------------------------
296// Fetch renderer
297// -----------------------------------------------------------------------------
298
299// fetchRenderer handles URL fetching with format-specific content display
300type fetchRenderer struct {
301 baseRenderer
302}
303
304// Render displays the fetched URL with format and timeout parameters
305func (fr fetchRenderer) Render(v *toolCallCmp) string {
306 var params tools.FetchParams
307 if err := fr.unmarshalParams(v.call.Input, ¶ms); err != nil {
308 return fr.renderError(v, "Invalid fetch parameters")
309 }
310
311 args := newParamBuilder().
312 addMain(params.URL).
313 addKeyValue("format", params.Format).
314 addKeyValue("timeout", formatTimeout(params.Timeout)).
315 build()
316
317 return fr.renderWithParams(v, "Fetch", args, func() string {
318 file := fr.getFileExtension(params.Format)
319 return renderCodeContent(v, file, v.result.Content, 0)
320 })
321}
322
323// getFileExtension returns appropriate file extension for syntax highlighting
324func (fr fetchRenderer) getFileExtension(format string) string {
325 switch format {
326 case "text":
327 return "fetch.txt"
328 case "html":
329 return "fetch.html"
330 default:
331 return "fetch.md"
332 }
333}
334
335// formatTimeout converts timeout seconds to duration string
336func formatTimeout(timeout int) string {
337 if timeout == 0 {
338 return ""
339 }
340 return (time.Duration(timeout) * time.Second).String()
341}
342
343// -----------------------------------------------------------------------------
344// Glob renderer
345// -----------------------------------------------------------------------------
346
347// globRenderer handles file pattern matching with path filtering
348type globRenderer struct {
349 baseRenderer
350}
351
352// Render displays the glob pattern with optional path parameter
353func (gr globRenderer) Render(v *toolCallCmp) string {
354 var params tools.GlobParams
355 if err := gr.unmarshalParams(v.call.Input, ¶ms); err != nil {
356 return gr.renderError(v, "Invalid glob parameters")
357 }
358
359 args := newParamBuilder().
360 addMain(params.Pattern).
361 addKeyValue("path", params.Path).
362 build()
363
364 return gr.renderWithParams(v, "Glob", args, func() string {
365 return renderPlainContent(v, v.result.Content)
366 })
367}
368
369// -----------------------------------------------------------------------------
370// Grep renderer
371// -----------------------------------------------------------------------------
372
373// grepRenderer handles content searching with pattern matching options
374type grepRenderer struct {
375 baseRenderer
376}
377
378// Render displays the search pattern with path, include, and literal text options
379func (gr grepRenderer) Render(v *toolCallCmp) string {
380 var params tools.GrepParams
381 if err := gr.unmarshalParams(v.call.Input, ¶ms); err != nil {
382 return gr.renderError(v, "Invalid grep parameters")
383 }
384
385 args := newParamBuilder().
386 addMain(params.Pattern).
387 addKeyValue("path", params.Path).
388 addKeyValue("include", params.Include).
389 addFlag("literal", params.LiteralText).
390 build()
391
392 return gr.renderWithParams(v, "Grep", args, func() string {
393 return renderPlainContent(v, v.result.Content)
394 })
395}
396
397// -----------------------------------------------------------------------------
398// LS renderer
399// -----------------------------------------------------------------------------
400
401// lsRenderer handles directory listing with default path handling
402type lsRenderer struct {
403 baseRenderer
404}
405
406// Render displays the directory path, defaulting to current directory
407func (lr lsRenderer) Render(v *toolCallCmp) string {
408 var params tools.LSParams
409 if err := lr.unmarshalParams(v.call.Input, ¶ms); err != nil {
410 return lr.renderError(v, "Invalid ls parameters")
411 }
412
413 path := params.Path
414 if path == "" {
415 path = "."
416 }
417 path = fsext.PrettyPath(path)
418
419 args := newParamBuilder().addMain(path).build()
420
421 return lr.renderWithParams(v, "List", args, func() string {
422 return renderPlainContent(v, v.result.Content)
423 })
424}
425
426// -----------------------------------------------------------------------------
427// Sourcegraph renderer
428// -----------------------------------------------------------------------------
429
430// sourcegraphRenderer handles code search with count and context options
431type sourcegraphRenderer struct {
432 baseRenderer
433}
434
435// Render displays the search query with optional count and context window parameters
436func (sr sourcegraphRenderer) Render(v *toolCallCmp) string {
437 var params tools.SourcegraphParams
438 if err := sr.unmarshalParams(v.call.Input, ¶ms); err != nil {
439 return sr.renderError(v, "Invalid sourcegraph parameters")
440 }
441
442 args := newParamBuilder().
443 addMain(params.Query).
444 addKeyValue("count", formatNonZero(params.Count)).
445 addKeyValue("context", formatNonZero(params.ContextWindow)).
446 build()
447
448 return sr.renderWithParams(v, "Sourcegraph", args, func() string {
449 return renderPlainContent(v, v.result.Content)
450 })
451}
452
453// -----------------------------------------------------------------------------
454// Diagnostics renderer
455// -----------------------------------------------------------------------------
456
457// diagnosticsRenderer handles project-wide diagnostic information
458type diagnosticsRenderer struct {
459 baseRenderer
460}
461
462// Render displays project diagnostics with plain content formatting
463func (dr diagnosticsRenderer) Render(v *toolCallCmp) string {
464 args := newParamBuilder().addMain("project").build()
465
466 return dr.renderWithParams(v, "Diagnostics", args, func() string {
467 return renderPlainContent(v, v.result.Content)
468 })
469}
470
471// -----------------------------------------------------------------------------
472// Task renderer
473// -----------------------------------------------------------------------------
474
475// agentRenderer handles project-wide diagnostic information
476type agentRenderer struct {
477 baseRenderer
478}
479
480// Render displays agent task parameters and result content
481func (tr agentRenderer) Render(v *toolCallCmp) string {
482 var params agent.AgentParams
483 if err := tr.unmarshalParams(v.call.Input, ¶ms); err != nil {
484 return tr.renderError(v, "Invalid task parameters")
485 }
486 prompt := params.Prompt
487 prompt = strings.ReplaceAll(prompt, "\n", " ")
488 args := newParamBuilder().addMain(prompt).build()
489
490 header := tr.makeHeader(v, "Task", v.textWidth(), args...)
491 t := tree.Root(header)
492
493 for _, call := range v.nestedToolCalls {
494 t.Child(call.View())
495 }
496
497 parts := []string{
498 t.Enumerator(tree.RoundedEnumerator).String(),
499 }
500 if v.result.ToolCallID == "" {
501 v.spinning = true
502 parts = append(parts, v.anim.View().String())
503 } else {
504 v.spinning = false
505 }
506
507 header = lipgloss.JoinVertical(
508 lipgloss.Left,
509 parts...,
510 )
511
512 if v.result.ToolCallID == "" {
513 return header
514 }
515
516 body := renderPlainContent(v, v.result.Content)
517 return joinHeaderBody(header, body)
518}
519
520// renderParamList renders params, params[0] (params[1]=params[2] ....)
521func renderParamList(paramsWidth int, params ...string) string {
522 t := styles.CurrentTheme()
523 if len(params) == 0 {
524 return ""
525 }
526 mainParam := params[0]
527 if len(mainParam) > paramsWidth {
528 mainParam = mainParam[:paramsWidth-3] + "..."
529 }
530
531 if len(params) == 1 {
532 return t.S().Subtle.Render(mainParam)
533 }
534 otherParams := params[1:]
535 // create pairs of key/value
536 // if odd number of params, the last one is a key without value
537 if len(otherParams)%2 != 0 {
538 otherParams = append(otherParams, "")
539 }
540 parts := make([]string, 0, len(otherParams)/2)
541 for i := 0; i < len(otherParams); i += 2 {
542 key := otherParams[i]
543 value := otherParams[i+1]
544 if value == "" {
545 continue
546 }
547 parts = append(parts, fmt.Sprintf("%s=%s", key, value))
548 }
549
550 partsRendered := strings.Join(parts, ", ")
551 remainingWidth := paramsWidth - lipgloss.Width(partsRendered) - 3 // count for " ()"
552 if remainingWidth < 30 {
553 // No space for the params, just show the main
554 return t.S().Subtle.Render(mainParam)
555 }
556
557 if len(parts) > 0 {
558 mainParam = fmt.Sprintf("%s (%s)", mainParam, strings.Join(parts, ", "))
559 }
560
561 return t.S().Subtle.Render(ansi.Truncate(mainParam, paramsWidth, "..."))
562}
563
564// earlyState returns immediately‑rendered error/cancelled/ongoing states.
565func earlyState(header string, v *toolCallCmp) (string, bool) {
566 t := styles.CurrentTheme()
567 message := ""
568 switch {
569 case v.result.IsError:
570 message = v.renderToolError()
571 case v.cancelled:
572 message = "Cancelled"
573 case v.result.ToolCallID == "":
574 message = "Waiting for tool to start..."
575 default:
576 return "", false
577 }
578
579 message = t.S().Base.PaddingLeft(2).Render(message)
580 return lipgloss.JoinVertical(lipgloss.Left, header, message), true
581}
582
583func joinHeaderBody(header, body string) string {
584 t := styles.CurrentTheme()
585 body = t.S().Base.PaddingLeft(2).Render(body)
586 return lipgloss.JoinVertical(lipgloss.Left, header, "", body, "")
587}
588
589func renderPlainContent(v *toolCallCmp, content string) string {
590 t := styles.CurrentTheme()
591 content = strings.TrimSpace(content)
592 lines := strings.Split(content, "\n")
593
594 width := v.textWidth() - 2 // -2 for left padding
595 var out []string
596 for i, ln := range lines {
597 if i >= responseContextHeight {
598 break
599 }
600 ln = " " + ln // left padding
601 if len(ln) > width {
602 ln = v.fit(ln, width)
603 }
604 out = append(out, t.S().Muted.
605 Width(width).
606 Background(t.BgBaseLighter).
607 Render(ln))
608 }
609
610 if len(lines) > responseContextHeight {
611 out = append(out, t.S().Muted.
612 Background(t.BgBaseLighter).
613 Width(width).
614 Render(fmt.Sprintf("... (%d lines)", len(lines)-responseContextHeight)))
615 }
616 return strings.Join(out, "\n")
617}
618
619func pad(v any, width int) string {
620 s := fmt.Sprintf("%v", v)
621 w := ansi.StringWidth(s)
622 if w >= width {
623 return s
624 }
625 return strings.Repeat(" ", width-w) + s
626}
627
628func renderCodeContent(v *toolCallCmp, path, content string, offset int) string {
629 t := styles.CurrentTheme()
630 truncated := truncateHeight(content, responseContextHeight)
631
632 highlighted, _ := highlight.SyntaxHighlight(truncated, path, t.BgBase)
633 lines := strings.Split(highlighted, "\n")
634
635 if len(strings.Split(content, "\n")) > responseContextHeight {
636 lines = append(lines, t.S().Muted.
637 Background(t.BgBase).
638 Render(fmt.Sprintf(" ... (%d lines)", len(strings.Split(content, "\n"))-responseContextHeight)))
639 }
640
641 maxLineNumber := len(lines) + offset
642 padding := lipgloss.Width(fmt.Sprintf("%d", maxLineNumber))
643 for i, ln := range lines {
644 num := t.S().Base.
645 Foreground(t.FgMuted).
646 Background(t.BgBase).
647 PaddingRight(1).
648 PaddingLeft(1).
649 Render(pad(i+1+offset, padding))
650 w := v.textWidth() - 2 - lipgloss.Width(num) // -2 for left padding
651 lines[i] = lipgloss.JoinHorizontal(lipgloss.Left,
652 num,
653 t.S().Base.
654 PaddingLeft(1).
655 Width(w).
656 Render(v.fit(ln, w)))
657 }
658 return lipgloss.JoinVertical(lipgloss.Left, lines...)
659}
660
661func (v *toolCallCmp) renderToolError() string {
662 t := styles.CurrentTheme()
663 err := strings.ReplaceAll(v.result.Content, "\n", " ")
664 err = fmt.Sprintf("Error: %s", err)
665 return t.S().Base.Foreground(t.Error).Render(v.fit(err, v.textWidth()))
666}
667
668func truncateHeight(s string, h int) string {
669 lines := strings.Split(s, "\n")
670 if len(lines) > h {
671 return strings.Join(lines[:h], "\n")
672 }
673 return s
674}
675
676func prettifyToolName(name string) string {
677 switch name {
678 case agent.AgentToolName:
679 return "Task"
680 case tools.BashToolName:
681 return "Bash"
682 case tools.EditToolName:
683 return "Edit"
684 case tools.FetchToolName:
685 return "Fetch"
686 case tools.GlobToolName:
687 return "Glob"
688 case tools.GrepToolName:
689 return "Grep"
690 case tools.LSToolName:
691 return "List"
692 case tools.SourcegraphToolName:
693 return "Sourcegraph"
694 case tools.ViewToolName:
695 return "View"
696 case tools.WriteToolName:
697 return "Write"
698 default:
699 return name
700 }
701}