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