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