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