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.DefinitionsToolName, func() renderer { return definitionsRenderer{} })
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 formatter := core.DiffFormatter().
276 Before(fsext.PrettyPath(params.FilePath), meta.OldContent).
277 After(fsext.PrettyPath(params.FilePath), meta.NewContent).
278 Width(v.textWidth() - 2) // -2 for padding
279 if v.textWidth() > 120 {
280 formatter = formatter.Split()
281 }
282 // add a message to the bottom if the content was truncated
283 formatted := formatter.String()
284 if lipgloss.Height(formatted) > responseContextHeight {
285 contentLines := strings.Split(formatted, "\n")
286 truncateMessage := t.S().Muted.
287 Background(t.BgBaseLighter).
288 PaddingLeft(2).
289 Width(v.textWidth() - 4).
290 Render(fmt.Sprintf("… (%d lines)", len(contentLines)-responseContextHeight))
291 formatted = strings.Join(contentLines[:responseContextHeight], "\n") + "\n" + truncateMessage
292 }
293 return formatted
294 })
295}
296
297// -----------------------------------------------------------------------------
298// Write renderer
299// -----------------------------------------------------------------------------
300
301// writeRenderer handles file writing with syntax-highlighted content preview
302type writeRenderer struct {
303 baseRenderer
304}
305
306// Render displays the file being written with syntax highlighting
307func (wr writeRenderer) Render(v *toolCallCmp) string {
308 var params tools.WriteParams
309 var args []string
310 var file string
311 if err := wr.unmarshalParams(v.call.Input, ¶ms); err == nil {
312 file = fsext.PrettyPath(params.FilePath)
313 args = newParamBuilder().addMain(file).build()
314 }
315
316 return wr.renderWithParams(v, "Write", args, func() string {
317 return renderCodeContent(v, file, params.Content, 0)
318 })
319}
320
321// -----------------------------------------------------------------------------
322// Fetch renderer
323// -----------------------------------------------------------------------------
324
325// fetchRenderer handles URL fetching with format-specific content display
326type fetchRenderer struct {
327 baseRenderer
328}
329
330// Render displays the fetched URL with format and timeout parameters
331func (fr fetchRenderer) Render(v *toolCallCmp) string {
332 var params tools.FetchParams
333 var args []string
334 if err := fr.unmarshalParams(v.call.Input, ¶ms); err == nil {
335 args = newParamBuilder().
336 addMain(params.URL).
337 addKeyValue("format", params.Format).
338 addKeyValue("timeout", formatTimeout(params.Timeout)).
339 build()
340 }
341
342 return fr.renderWithParams(v, "Fetch", args, func() string {
343 file := fr.getFileExtension(params.Format)
344 return renderCodeContent(v, file, v.result.Content, 0)
345 })
346}
347
348// getFileExtension returns appropriate file extension for syntax highlighting
349func (fr fetchRenderer) getFileExtension(format string) string {
350 switch format {
351 case "text":
352 return "fetch.txt"
353 case "html":
354 return "fetch.html"
355 default:
356 return "fetch.md"
357 }
358}
359
360// formatTimeout converts timeout seconds to duration string
361func formatTimeout(timeout int) string {
362 if timeout == 0 {
363 return ""
364 }
365 return (time.Duration(timeout) * time.Second).String()
366}
367
368// -----------------------------------------------------------------------------
369// Glob renderer
370// -----------------------------------------------------------------------------
371
372// globRenderer handles file pattern matching with path filtering
373type globRenderer struct {
374 baseRenderer
375}
376
377// Render displays the glob pattern with optional path parameter
378func (gr globRenderer) Render(v *toolCallCmp) string {
379 var params tools.GlobParams
380 var args []string
381 if err := gr.unmarshalParams(v.call.Input, ¶ms); err == nil {
382 args = newParamBuilder().
383 addMain(params.Pattern).
384 addKeyValue("path", params.Path).
385 build()
386 }
387
388 return gr.renderWithParams(v, "Glob", args, func() string {
389 return renderPlainContent(v, v.result.Content)
390 })
391}
392
393// -----------------------------------------------------------------------------
394// Grep renderer
395// -----------------------------------------------------------------------------
396
397// grepRenderer handles content searching with pattern matching options
398type grepRenderer struct {
399 baseRenderer
400}
401
402// Render displays the search pattern with path, include, and literal text options
403func (gr grepRenderer) Render(v *toolCallCmp) string {
404 var params tools.GrepParams
405 var args []string
406 if err := gr.unmarshalParams(v.call.Input, ¶ms); err == nil {
407 args = newParamBuilder().
408 addMain(params.Pattern).
409 addKeyValue("path", params.Path).
410 addKeyValue("include", params.Include).
411 addFlag("literal", params.LiteralText).
412 build()
413 }
414
415 return gr.renderWithParams(v, "Grep", args, func() string {
416 return renderPlainContent(v, v.result.Content)
417 })
418}
419
420// -----------------------------------------------------------------------------
421// LS renderer
422// -----------------------------------------------------------------------------
423
424// lsRenderer handles directory listing with default path handling
425type lsRenderer struct {
426 baseRenderer
427}
428
429// Render displays the directory path, defaulting to current directory
430func (lr lsRenderer) Render(v *toolCallCmp) string {
431 var params tools.LSParams
432 var args []string
433 if err := lr.unmarshalParams(v.call.Input, ¶ms); err == nil {
434 path := params.Path
435 if path == "" {
436 path = "."
437 }
438 path = fsext.PrettyPath(path)
439
440 args = newParamBuilder().addMain(path).build()
441 }
442
443 return lr.renderWithParams(v, "List", args, func() string {
444 return renderPlainContent(v, v.result.Content)
445 })
446}
447
448// -----------------------------------------------------------------------------
449// Sourcegraph renderer
450// -----------------------------------------------------------------------------
451
452// sourcegraphRenderer handles code search with count and context options
453type sourcegraphRenderer struct {
454 baseRenderer
455}
456
457// Render displays the search query with optional count and context window parameters
458func (sr sourcegraphRenderer) Render(v *toolCallCmp) string {
459 var params tools.SourcegraphParams
460 var args []string
461 if err := sr.unmarshalParams(v.call.Input, ¶ms); err == nil {
462 args = newParamBuilder().
463 addMain(params.Query).
464 addKeyValue("count", formatNonZero(params.Count)).
465 addKeyValue("context", formatNonZero(params.ContextWindow)).
466 build()
467 }
468
469 return sr.renderWithParams(v, "Sourcegraph", args, func() string {
470 return renderPlainContent(v, v.result.Content)
471 })
472}
473
474// -----------------------------------------------------------------------------
475// Diagnostics renderer
476// -----------------------------------------------------------------------------
477
478// diagnosticsRenderer handles project-wide diagnostic information
479type diagnosticsRenderer struct {
480 baseRenderer
481}
482
483// Render displays project diagnostics with plain content formatting
484func (dr diagnosticsRenderer) Render(v *toolCallCmp) string {
485 args := newParamBuilder().addMain("project").build()
486
487 return dr.renderWithParams(v, "Diagnostics", args, func() string {
488 return renderPlainContent(v, v.result.Content)
489 })
490}
491
492// -----------------------------------------------------------------------------
493// Definitions renderer
494// -----------------------------------------------------------------------------
495
496// definitionsRenderer handles file symbol definitions display
497type definitionsRenderer struct {
498 baseRenderer
499}
500
501// Render displays file definitions with enhanced formatting for symbol structure
502func (dr definitionsRenderer) Render(v *toolCallCmp) string {
503 var params tools.DefinitionsParams
504 var args []string
505 if err := dr.unmarshalParams(v.call.Input, ¶ms); err == nil {
506 file := fsext.PrettyPath(params.FilePath)
507 args = newParamBuilder().addMain(file).build()
508 }
509
510 return dr.renderWithParams(v, "Definitions", args, func() string {
511 // The definitions tool outputs well-structured markdown content
512 // We'll render it as markdown to preserve the formatting and hierarchy
513 return renderCodeContent(v, "definitions.md", v.result.Content, 0)
514 })
515}
516
517// -----------------------------------------------------------------------------
518// Task renderer
519// -----------------------------------------------------------------------------
520
521// agentRenderer handles project-wide diagnostic information
522type agentRenderer struct {
523 baseRenderer
524}
525
526func RoundedEnumerator(children tree.Children, index int) string {
527 if children.Length()-1 == index {
528 return " ╰──"
529 }
530 return " ├──"
531}
532
533// Render displays agent task parameters and result content
534func (tr agentRenderer) Render(v *toolCallCmp) string {
535 t := styles.CurrentTheme()
536 var params agent.AgentParams
537 tr.unmarshalParams(v.call.Input, ¶ms)
538
539 prompt := params.Prompt
540 prompt = strings.ReplaceAll(prompt, "\n", " ")
541
542 header := tr.makeHeader(v, "Agent", v.textWidth())
543 if res, done := earlyState(header, v); v.cancelled && done {
544 return res
545 }
546 taskTag := t.S().Base.Padding(0, 1).MarginLeft(1).Background(t.BlueLight).Foreground(t.White).Render("Task")
547 remainingWidth := v.textWidth() - lipgloss.Width(header) - lipgloss.Width(taskTag) - 2 // -2 for padding
548 prompt = t.S().Muted.Width(remainingWidth).Render(prompt)
549 header = lipgloss.JoinVertical(
550 lipgloss.Left,
551 header,
552 "",
553 lipgloss.JoinHorizontal(
554 lipgloss.Left,
555 taskTag,
556 " ",
557 prompt,
558 ),
559 )
560 childTools := tree.Root(header)
561
562 for _, call := range v.nestedToolCalls {
563 childTools.Child(call.View())
564 }
565 parts := []string{
566 childTools.Enumerator(RoundedEnumerator).String(),
567 }
568
569 if v.result.ToolCallID == "" {
570 v.spinning = true
571 parts = append(parts, v.anim.View().String())
572 } else {
573 v.spinning = false
574 }
575
576 header = lipgloss.JoinVertical(
577 lipgloss.Left,
578 parts...,
579 )
580
581 if v.result.ToolCallID == "" {
582 return header
583 }
584
585 body := renderPlainContent(v, v.result.Content)
586 return joinHeaderBody(header, body)
587}
588
589// renderParamList renders params, params[0] (params[1]=params[2] ....)
590func renderParamList(nested bool, paramsWidth int, params ...string) string {
591 t := styles.CurrentTheme()
592 if len(params) == 0 {
593 return ""
594 }
595 mainParam := params[0]
596 if len(mainParam) > paramsWidth {
597 mainParam = mainParam[:paramsWidth-3] + "…"
598 }
599
600 if len(params) == 1 {
601 if nested {
602 return t.S().Muted.Render(mainParam)
603 }
604 return t.S().Subtle.Render(mainParam)
605 }
606 otherParams := params[1:]
607 // create pairs of key/value
608 // if odd number of params, the last one is a key without value
609 if len(otherParams)%2 != 0 {
610 otherParams = append(otherParams, "")
611 }
612 parts := make([]string, 0, len(otherParams)/2)
613 for i := 0; i < len(otherParams); i += 2 {
614 key := otherParams[i]
615 value := otherParams[i+1]
616 if value == "" {
617 continue
618 }
619 parts = append(parts, fmt.Sprintf("%s=%s", key, value))
620 }
621
622 partsRendered := strings.Join(parts, ", ")
623 remainingWidth := paramsWidth - lipgloss.Width(partsRendered) - 3 // count for " ()"
624 if remainingWidth < 30 {
625 if nested {
626 return t.S().Muted.Render(mainParam)
627 }
628 // No space for the params, just show the main
629 return t.S().Subtle.Render(mainParam)
630 }
631
632 if len(parts) > 0 {
633 mainParam = fmt.Sprintf("%s (%s)", mainParam, strings.Join(parts, ", "))
634 }
635
636 if nested {
637 return t.S().Muted.Render(ansi.Truncate(mainParam, paramsWidth, "…"))
638 }
639 return t.S().Subtle.Render(ansi.Truncate(mainParam, paramsWidth, "…"))
640}
641
642// earlyState returns immediately‑rendered error/cancelled/ongoing states.
643func earlyState(header string, v *toolCallCmp) (string, bool) {
644 t := styles.CurrentTheme()
645 message := ""
646 switch {
647 case v.result.IsError:
648 message = v.renderToolError()
649 case v.cancelled:
650 message = t.S().Base.Padding(0, 1).Background(t.Border).Render("Cancelled")
651 case v.result.ToolCallID == "":
652 message = t.S().Base.Padding(0, 1).Background(t.Accent).Foreground(t.FgSubtle).Render("Waiting for tool to start...")
653 default:
654 return "", false
655 }
656
657 message = t.S().Base.PaddingLeft(2).Render(message)
658 return lipgloss.JoinVertical(lipgloss.Left, header, "", message), true
659}
660
661func joinHeaderBody(header, body string) string {
662 t := styles.CurrentTheme()
663 body = t.S().Base.PaddingLeft(2).Render(body)
664 return lipgloss.JoinVertical(lipgloss.Left, header, "", body, "")
665}
666
667func renderPlainContent(v *toolCallCmp, content string) string {
668 t := styles.CurrentTheme()
669 content = strings.TrimSpace(content)
670 lines := strings.Split(content, "\n")
671
672 width := v.textWidth() - 2 // -2 for left padding
673 var out []string
674 for i, ln := range lines {
675 if i >= responseContextHeight {
676 break
677 }
678 ln = " " + ln // left padding
679 if len(ln) > width {
680 ln = v.fit(ln, width)
681 }
682 out = append(out, t.S().Muted.
683 Width(width).
684 Background(t.BgBaseLighter).
685 Render(ln))
686 }
687
688 if len(lines) > responseContextHeight {
689 out = append(out, t.S().Muted.
690 Background(t.BgBaseLighter).
691 Width(width).
692 Render(fmt.Sprintf("… (%d lines)", len(lines)-responseContextHeight)))
693 }
694 return strings.Join(out, "\n")
695}
696
697func pad(v any, width int) string {
698 s := fmt.Sprintf("%v", v)
699 w := ansi.StringWidth(s)
700 if w >= width {
701 return s
702 }
703 return strings.Repeat(" ", width-w) + s
704}
705
706func renderCodeContent(v *toolCallCmp, path, content string, offset int) string {
707 t := styles.CurrentTheme()
708 truncated := truncateHeight(content, responseContextHeight)
709
710 highlighted, _ := highlight.SyntaxHighlight(truncated, path, t.BgBase)
711 lines := strings.Split(highlighted, "\n")
712
713 if len(strings.Split(content, "\n")) > responseContextHeight {
714 lines = append(lines, t.S().Muted.
715 Background(t.BgBase).
716 Render(fmt.Sprintf(" …(%d lines)", len(strings.Split(content, "\n"))-responseContextHeight)))
717 }
718
719 maxLineNumber := len(lines) + offset
720 padding := lipgloss.Width(fmt.Sprintf("%d", maxLineNumber))
721 for i, ln := range lines {
722 num := t.S().Base.
723 Foreground(t.FgMuted).
724 Background(t.BgBase).
725 PaddingRight(1).
726 PaddingLeft(1).
727 Render(pad(i+1+offset, padding))
728 w := v.textWidth() - 10 - lipgloss.Width(num) // -4 for left padding
729 lines[i] = lipgloss.JoinHorizontal(lipgloss.Left,
730 num,
731 t.S().Base.
732 PaddingLeft(1).
733 Render(v.fit(ln, w-1)))
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 case tools.DiagnosticsToolName:
777 return "Diagnostics"
778 case tools.DefinitionsToolName:
779 return "Definitions"
780 default:
781 return name
782 }
783}