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