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