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