1package messages
2
3import (
4 "encoding/json"
5 "fmt"
6 "os"
7 "strings"
8 "time"
9
10 "github.com/charmbracelet/crush/internal/config"
11 "github.com/charmbracelet/crush/internal/diff"
12 "github.com/charmbracelet/crush/internal/highlight"
13 "github.com/charmbracelet/crush/internal/llm/agent"
14 "github.com/charmbracelet/crush/internal/llm/tools"
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 "<Tool>: param (key=value)" and truncates as needed.
116func (br baseRenderer) makeHeader(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.Blue).Render(tool)
129 prefix := fmt.Sprintf("%s %s: ", icon, tool)
130 return prefix + renderParamList(width-lipgloss.Width(prefix), params...)
131}
132
133// renderError provides consistent error rendering
134func (br baseRenderer) renderError(v *toolCallCmp, message string) string {
135 t := styles.CurrentTheme()
136 header := br.makeHeader(v, prettifyToolName(v.call.Name), v.textWidth(), "")
137 message = t.S().Error.Render(v.fit(message, v.textWidth()-2)) // -2 for padding
138 return joinHeaderBody(header, message)
139}
140
141// Register tool renderers
142func init() {
143 registry.register(tools.BashToolName, func() renderer { return bashRenderer{} })
144 registry.register(tools.ViewToolName, func() renderer { return viewRenderer{} })
145 registry.register(tools.EditToolName, func() renderer { return editRenderer{} })
146 registry.register(tools.WriteToolName, func() renderer { return writeRenderer{} })
147 registry.register(tools.FetchToolName, func() renderer { return fetchRenderer{} })
148 registry.register(tools.GlobToolName, func() renderer { return globRenderer{} })
149 registry.register(tools.GrepToolName, func() renderer { return grepRenderer{} })
150 registry.register(tools.LSToolName, func() renderer { return lsRenderer{} })
151 registry.register(tools.SourcegraphToolName, func() renderer { return sourcegraphRenderer{} })
152 registry.register(tools.PatchToolName, func() renderer { return patchRenderer{} })
153 registry.register(tools.DiagnosticsToolName, func() renderer { return diagnosticsRenderer{} })
154 registry.register(agent.AgentToolName, func() renderer { return agentRenderer{} })
155}
156
157// -----------------------------------------------------------------------------
158// Generic renderer
159// -----------------------------------------------------------------------------
160
161// genericRenderer handles unknown tool types with basic parameter display
162type genericRenderer struct {
163 baseRenderer
164}
165
166// Render displays the tool call with its raw input and plain content output
167func (gr genericRenderer) Render(v *toolCallCmp) string {
168 return gr.renderWithParams(v, prettifyToolName(v.call.Name), []string{v.call.Input}, func() string {
169 return renderPlainContent(v, v.result.Content)
170 })
171}
172
173// -----------------------------------------------------------------------------
174// Bash renderer
175// -----------------------------------------------------------------------------
176
177// bashRenderer handles bash command execution display
178type bashRenderer struct {
179 baseRenderer
180}
181
182// Render displays the bash command with sanitized newlines and plain output
183func (br bashRenderer) Render(v *toolCallCmp) string {
184 var params tools.BashParams
185 if err := br.unmarshalParams(v.call.Input, ¶ms); err != nil {
186 return br.renderError(v, "Invalid bash parameters")
187 }
188
189 cmd := strings.ReplaceAll(params.Command, "\n", " ")
190 args := newParamBuilder().addMain(cmd).build()
191
192 return br.renderWithParams(v, "Bash", args, func() string {
193 return renderPlainContent(v, v.result.Content)
194 })
195}
196
197// -----------------------------------------------------------------------------
198// View renderer
199// -----------------------------------------------------------------------------
200
201// viewRenderer handles file viewing with syntax highlighting and line numbers
202type viewRenderer struct {
203 baseRenderer
204}
205
206// Render displays file content with optional limit and offset parameters
207func (vr viewRenderer) Render(v *toolCallCmp) string {
208 var params tools.ViewParams
209 if err := vr.unmarshalParams(v.call.Input, ¶ms); err != nil {
210 return vr.renderError(v, "Invalid view parameters")
211 }
212
213 file := prettyPath(params.FilePath)
214 args := newParamBuilder().
215 addMain(file).
216 addKeyValue("limit", formatNonZero(params.Limit)).
217 addKeyValue("offset", formatNonZero(params.Offset)).
218 build()
219
220 return vr.renderWithParams(v, "View", args, func() string {
221 var meta tools.ViewResponseMetadata
222 if err := vr.unmarshalParams(v.result.Metadata, &meta); err != nil {
223 return renderPlainContent(v, v.result.Content)
224 }
225 return renderCodeContent(v, meta.FilePath, meta.Content, params.Offset)
226 })
227}
228
229// formatNonZero returns string representation of non-zero integers, empty string for zero
230func formatNonZero(value int) string {
231 if value == 0 {
232 return ""
233 }
234 return fmt.Sprintf("%d", value)
235}
236
237// -----------------------------------------------------------------------------
238// Edit renderer
239// -----------------------------------------------------------------------------
240
241// editRenderer handles file editing with diff visualization
242type editRenderer struct {
243 baseRenderer
244}
245
246// Render displays the edited file with a formatted diff of changes
247func (er editRenderer) Render(v *toolCallCmp) string {
248 var params tools.EditParams
249 if err := er.unmarshalParams(v.call.Input, ¶ms); err != nil {
250 return er.renderError(v, "Invalid edit parameters")
251 }
252
253 file := prettyPath(params.FilePath)
254 args := newParamBuilder().addMain(file).build()
255
256 return er.renderWithParams(v, "Edit", args, func() string {
257 var meta tools.EditResponseMetadata
258 if err := er.unmarshalParams(v.result.Metadata, &meta); err != nil {
259 return renderPlainContent(v, v.result.Content)
260 }
261
262 trunc := truncateHeight(meta.Diff, responseContextHeight)
263 diffView, _ := diff.FormatDiff(trunc, diff.WithTotalWidth(v.textWidth()-2))
264 return diffView
265 })
266}
267
268// -----------------------------------------------------------------------------
269// Write renderer
270// -----------------------------------------------------------------------------
271
272// writeRenderer handles file writing with syntax-highlighted content preview
273type writeRenderer struct {
274 baseRenderer
275}
276
277// Render displays the file being written with syntax highlighting
278func (wr writeRenderer) Render(v *toolCallCmp) string {
279 var params tools.WriteParams
280 if err := wr.unmarshalParams(v.call.Input, ¶ms); err != nil {
281 return wr.renderError(v, "Invalid write parameters")
282 }
283
284 file := prettyPath(params.FilePath)
285 args := newParamBuilder().addMain(file).build()
286
287 return wr.renderWithParams(v, "Write", args, func() string {
288 return renderCodeContent(v, file, params.Content, 0)
289 })
290}
291
292// -----------------------------------------------------------------------------
293// Fetch renderer
294// -----------------------------------------------------------------------------
295
296// fetchRenderer handles URL fetching with format-specific content display
297type fetchRenderer struct {
298 baseRenderer
299}
300
301// Render displays the fetched URL with format and timeout parameters
302func (fr fetchRenderer) Render(v *toolCallCmp) string {
303 var params tools.FetchParams
304 if err := fr.unmarshalParams(v.call.Input, ¶ms); err != nil {
305 return fr.renderError(v, "Invalid fetch parameters")
306 }
307
308 args := newParamBuilder().
309 addMain(params.URL).
310 addKeyValue("format", params.Format).
311 addKeyValue("timeout", formatTimeout(params.Timeout)).
312 build()
313
314 return fr.renderWithParams(v, "Fetch", args, func() string {
315 file := fr.getFileExtension(params.Format)
316 return renderCodeContent(v, file, v.result.Content, 0)
317 })
318}
319
320// getFileExtension returns appropriate file extension for syntax highlighting
321func (fr fetchRenderer) getFileExtension(format string) string {
322 switch format {
323 case "text":
324 return "fetch.txt"
325 case "html":
326 return "fetch.html"
327 default:
328 return "fetch.md"
329 }
330}
331
332// formatTimeout converts timeout seconds to duration string
333func formatTimeout(timeout int) string {
334 if timeout == 0 {
335 return ""
336 }
337 return (time.Duration(timeout) * time.Second).String()
338}
339
340// -----------------------------------------------------------------------------
341// Glob renderer
342// -----------------------------------------------------------------------------
343
344// globRenderer handles file pattern matching with path filtering
345type globRenderer struct {
346 baseRenderer
347}
348
349// Render displays the glob pattern with optional path parameter
350func (gr globRenderer) Render(v *toolCallCmp) string {
351 var params tools.GlobParams
352 if err := gr.unmarshalParams(v.call.Input, ¶ms); err != nil {
353 return gr.renderError(v, "Invalid glob parameters")
354 }
355
356 args := newParamBuilder().
357 addMain(params.Pattern).
358 addKeyValue("path", params.Path).
359 build()
360
361 return gr.renderWithParams(v, "Glob", args, func() string {
362 return renderPlainContent(v, v.result.Content)
363 })
364}
365
366// -----------------------------------------------------------------------------
367// Grep renderer
368// -----------------------------------------------------------------------------
369
370// grepRenderer handles content searching with pattern matching options
371type grepRenderer struct {
372 baseRenderer
373}
374
375// Render displays the search pattern with path, include, and literal text options
376func (gr grepRenderer) Render(v *toolCallCmp) string {
377 var params tools.GrepParams
378 if err := gr.unmarshalParams(v.call.Input, ¶ms); err != nil {
379 return gr.renderError(v, "Invalid grep parameters")
380 }
381
382 args := newParamBuilder().
383 addMain(params.Pattern).
384 addKeyValue("path", params.Path).
385 addKeyValue("include", params.Include).
386 addFlag("literal", params.LiteralText).
387 build()
388
389 return gr.renderWithParams(v, "Grep", args, func() string {
390 return renderPlainContent(v, v.result.Content)
391 })
392}
393
394// -----------------------------------------------------------------------------
395// LS renderer
396// -----------------------------------------------------------------------------
397
398// lsRenderer handles directory listing with default path handling
399type lsRenderer struct {
400 baseRenderer
401}
402
403// Render displays the directory path, defaulting to current directory
404func (lr lsRenderer) Render(v *toolCallCmp) string {
405 var params tools.LSParams
406 if err := lr.unmarshalParams(v.call.Input, ¶ms); err != nil {
407 return lr.renderError(v, "Invalid ls parameters")
408 }
409
410 path := params.Path
411 if path == "" {
412 path = "."
413 }
414
415 args := newParamBuilder().addMain(path).build()
416
417 return lr.renderWithParams(v, "List", args, func() string {
418 return renderPlainContent(v, v.result.Content)
419 })
420}
421
422// -----------------------------------------------------------------------------
423// Sourcegraph renderer
424// -----------------------------------------------------------------------------
425
426// sourcegraphRenderer handles code search with count and context options
427type sourcegraphRenderer struct {
428 baseRenderer
429}
430
431// Render displays the search query with optional count and context window parameters
432func (sr sourcegraphRenderer) Render(v *toolCallCmp) string {
433 var params tools.SourcegraphParams
434 if err := sr.unmarshalParams(v.call.Input, ¶ms); err != nil {
435 return sr.renderError(v, "Invalid sourcegraph parameters")
436 }
437
438 args := newParamBuilder().
439 addMain(params.Query).
440 addKeyValue("count", formatNonZero(params.Count)).
441 addKeyValue("context", formatNonZero(params.ContextWindow)).
442 build()
443
444 return sr.renderWithParams(v, "Sourcegraph", args, func() string {
445 return renderPlainContent(v, v.result.Content)
446 })
447}
448
449// -----------------------------------------------------------------------------
450// Patch renderer
451// -----------------------------------------------------------------------------
452
453// patchRenderer handles multi-file patches with change summaries
454type patchRenderer struct {
455 baseRenderer
456}
457
458// Render displays patch summary with file count and change statistics
459func (pr patchRenderer) Render(v *toolCallCmp) string {
460 var params tools.PatchParams
461 if err := pr.unmarshalParams(v.call.Input, ¶ms); err != nil {
462 return pr.renderError(v, "Invalid patch parameters")
463 }
464
465 args := newParamBuilder().addMain("multiple files").build()
466
467 return pr.renderWithParams(v, "Patch", args, func() string {
468 var meta tools.PatchResponseMetadata
469 if err := pr.unmarshalParams(v.result.Metadata, &meta); err != nil {
470 return renderPlainContent(v, v.result.Content)
471 }
472
473 summary := fmt.Sprintf("Changed %d files (%d+ %d-)",
474 len(meta.FilesChanged), meta.Additions, meta.Removals)
475 filesList := strings.Join(meta.FilesChanged, "\n")
476
477 return renderPlainContent(v, summary+"\n\n"+filesList)
478 })
479}
480
481// -----------------------------------------------------------------------------
482// Diagnostics renderer
483// -----------------------------------------------------------------------------
484
485// diagnosticsRenderer handles project-wide diagnostic information
486type diagnosticsRenderer struct {
487 baseRenderer
488}
489
490// Render displays project diagnostics with plain content formatting
491func (dr diagnosticsRenderer) Render(v *toolCallCmp) string {
492 args := newParamBuilder().addMain("project").build()
493
494 return dr.renderWithParams(v, "Diagnostics", args, func() string {
495 return renderPlainContent(v, v.result.Content)
496 })
497}
498
499// -----------------------------------------------------------------------------
500// Task renderer
501// -----------------------------------------------------------------------------
502
503// agentRenderer handles project-wide diagnostic information
504type agentRenderer struct {
505 baseRenderer
506}
507
508// Render displays agent task parameters and result content
509func (tr agentRenderer) Render(v *toolCallCmp) string {
510 var params agent.AgentParams
511 if err := tr.unmarshalParams(v.call.Input, ¶ms); err != nil {
512 return tr.renderError(v, "Invalid task parameters")
513 }
514 prompt := params.Prompt
515 prompt = strings.ReplaceAll(prompt, "\n", " ")
516 args := newParamBuilder().addMain(prompt).build()
517
518 header := tr.makeHeader(v, "Task", v.textWidth(), args...)
519 t := tree.Root(header)
520
521 for _, call := range v.nestedToolCalls {
522 t.Child(call.View())
523 }
524
525 parts := []string{
526 t.Enumerator(tree.RoundedEnumerator).String(),
527 }
528 if v.result.ToolCallID == "" {
529 v.spinning = true
530 parts = append(parts, v.anim.View().String())
531 } else {
532 v.spinning = false
533 }
534
535 header = lipgloss.JoinVertical(
536 lipgloss.Left,
537 parts...,
538 )
539
540 if v.result.ToolCallID == "" {
541 return header
542 }
543
544 body := renderPlainContent(v, v.result.Content)
545 return joinHeaderBody(header, body)
546}
547
548// renderParamList renders params, params[0] (params[1]=params[2] ....)
549func renderParamList(paramsWidth int, params ...string) string {
550 if len(params) == 0 {
551 return ""
552 }
553 mainParam := params[0]
554 if len(mainParam) > paramsWidth {
555 mainParam = mainParam[:paramsWidth-3] + "..."
556 }
557
558 if len(params) == 1 {
559 return mainParam
560 }
561 otherParams := params[1:]
562 // create pairs of key/value
563 // if odd number of params, the last one is a key without value
564 if len(otherParams)%2 != 0 {
565 otherParams = append(otherParams, "")
566 }
567 parts := make([]string, 0, len(otherParams)/2)
568 for i := 0; i < len(otherParams); i += 2 {
569 key := otherParams[i]
570 value := otherParams[i+1]
571 if value == "" {
572 continue
573 }
574 parts = append(parts, fmt.Sprintf("%s=%s", key, value))
575 }
576
577 partsRendered := strings.Join(parts, ", ")
578 remainingWidth := paramsWidth - lipgloss.Width(partsRendered) - 3 // count for " ()"
579 if remainingWidth < 30 {
580 // No space for the params, just show the main
581 return mainParam
582 }
583
584 if len(parts) > 0 {
585 mainParam = fmt.Sprintf("%s (%s)", mainParam, strings.Join(parts, ", "))
586 }
587
588 return ansi.Truncate(mainParam, paramsWidth, "...")
589}
590
591// earlyState returns immediately‑rendered error/cancelled/ongoing states.
592func earlyState(header string, v *toolCallCmp) (string, bool) {
593 t := styles.CurrentTheme()
594 message := ""
595 switch {
596 case v.result.IsError:
597 message = v.renderToolError()
598 case v.cancelled:
599 message = "Cancelled"
600 case v.result.ToolCallID == "":
601 message = "Waiting for tool to start..."
602 default:
603 return "", false
604 }
605
606 message = t.S().Base.PaddingLeft(2).Render(message)
607 return lipgloss.JoinVertical(lipgloss.Left, header, message), true
608}
609
610func joinHeaderBody(header, body string) string {
611 t := styles.CurrentTheme()
612 body = t.S().Base.PaddingLeft(2).Render(body)
613 return lipgloss.JoinVertical(lipgloss.Left, header, body, "")
614}
615
616func renderPlainContent(v *toolCallCmp, content string) string {
617 t := styles.CurrentTheme()
618 content = strings.TrimSpace(content)
619 lines := strings.Split(content, "\n")
620
621 width := v.textWidth() - 2 // -2 for left padding
622 var out []string
623 for i, ln := range lines {
624 if i >= responseContextHeight {
625 break
626 }
627 ln = " " + ln // left padding
628 if len(ln) > width {
629 ln = v.fit(ln, width)
630 }
631 out = append(out, t.S().Muted.
632 Width(width).
633 Background(t.BgSubtle).
634 Render(ln))
635 }
636
637 if len(lines) > responseContextHeight {
638 out = append(out, t.S().Muted.
639 Background(t.BgSubtle).
640 Render(fmt.Sprintf("... (%d lines)", len(lines)-responseContextHeight)))
641 }
642 return strings.Join(out, "\n")
643}
644
645func renderCodeContent(v *toolCallCmp, path, content string, offset int) string {
646 t := styles.CurrentTheme()
647 truncated := truncateHeight(content, responseContextHeight)
648
649 highlighted, _ := highlight.SyntaxHighlight(truncated, path, t.BgSubtle)
650 lines := strings.Split(highlighted, "\n")
651
652 if len(strings.Split(content, "\n")) > responseContextHeight {
653 lines = append(lines, t.S().Muted.
654 Background(t.BgSubtle).
655 Render(fmt.Sprintf("... (%d lines)", len(strings.Split(content, "\n"))-responseContextHeight)))
656 }
657
658 for i, ln := range lines {
659 num := t.S().Muted.
660 Background(t.BgSubtle).
661 PaddingLeft(4).
662 PaddingRight(2).
663 Render(fmt.Sprintf("%d", i+1+offset))
664 w := v.textWidth() - 2 - lipgloss.Width(num) // -2 for left padding
665 lines[i] = lipgloss.JoinHorizontal(lipgloss.Left,
666 num,
667 t.S().Base.
668 Width(w).
669 Background(t.BgSubtle).
670 Render(v.fit(ln, w)))
671 }
672 return lipgloss.JoinVertical(lipgloss.Left, lines...)
673}
674
675func (v *toolCallCmp) renderToolError() string {
676 t := styles.CurrentTheme()
677 err := strings.ReplaceAll(v.result.Content, "\n", " ")
678 err = fmt.Sprintf("Error: %s", err)
679 return t.S().Base.Foreground(t.Error).Render(v.fit(err, v.textWidth()))
680}
681
682func removeWorkingDirPrefix(path string) string {
683 wd := config.WorkingDirectory()
684 return strings.TrimPrefix(path, wd)
685}
686
687func truncateHeight(s string, h int) string {
688 lines := strings.Split(s, "\n")
689 if len(lines) > h {
690 return strings.Join(lines[:h], "\n")
691 }
692 return s
693}
694
695func prettyPath(path string) string {
696 // replace home directory with ~
697 homeDir, err := os.UserHomeDir()
698 if err == nil {
699 path = strings.ReplaceAll(path, homeDir, "~")
700 }
701 return path
702}
703
704func prettifyToolName(name string) string {
705 switch name {
706 case agent.AgentToolName:
707 return "Task"
708 case tools.BashToolName:
709 return "Bash"
710 case tools.EditToolName:
711 return "Edit"
712 case tools.FetchToolName:
713 return "Fetch"
714 case tools.GlobToolName:
715 return "Glob"
716 case tools.GrepToolName:
717 return "Grep"
718 case tools.LSToolName:
719 return "List"
720 case tools.SourcegraphToolName:
721 return "Sourcegraph"
722 case tools.ViewToolName:
723 return "View"
724 case tools.WriteToolName:
725 return "Write"
726 case tools.PatchToolName:
727 return "Patch"
728 default:
729 return name
730 }
731}