1package chat
2
3import (
4 "encoding/json"
5 "fmt"
6 "strings"
7
8 "github.com/charmbracelet/crush/internal/agent/tools"
9 "github.com/charmbracelet/crush/internal/fsext"
10 "github.com/charmbracelet/crush/internal/message"
11 "github.com/charmbracelet/crush/internal/ui/styles"
12)
13
14// -----------------------------------------------------------------------------
15// View Tool
16// -----------------------------------------------------------------------------
17
18// ViewToolMessageItem is a message item that represents a view tool call.
19type ViewToolMessageItem struct {
20 *baseToolMessageItem
21}
22
23var _ ToolMessageItem = (*ViewToolMessageItem)(nil)
24
25// NewViewToolMessageItem creates a new [ViewToolMessageItem].
26func NewViewToolMessageItem(
27 sty *styles.Styles,
28 toolCall message.ToolCall,
29 result *message.ToolResult,
30 canceled bool,
31) ToolMessageItem {
32 return newBaseToolMessageItem(sty, toolCall, result, &ViewToolRenderContext{}, canceled)
33}
34
35// ViewToolRenderContext renders view tool messages.
36type ViewToolRenderContext struct{}
37
38// RenderTool implements the [ToolRenderer] interface.
39func (v *ViewToolRenderContext) RenderTool(sty *styles.Styles, width int, opts *ToolRenderOpts) string {
40 cappedWidth := cappedMessageWidth(width)
41 if opts.IsPending() {
42 return pendingTool(sty, "View", opts.Anim)
43 }
44
45 var params tools.ViewParams
46 if err := json.Unmarshal([]byte(opts.ToolCall.Input), ¶ms); err != nil {
47 return toolErrorContent(sty, &message.ToolResult{Content: "Invalid parameters"}, cappedWidth)
48 }
49
50 file := fsext.PrettyPath(params.FilePath)
51 toolParams := []string{file}
52 if params.Limit != 0 {
53 toolParams = append(toolParams, "limit", fmt.Sprintf("%d", params.Limit))
54 }
55 if params.Offset != 0 {
56 toolParams = append(toolParams, "offset", fmt.Sprintf("%d", params.Offset))
57 }
58
59 header := toolHeader(sty, opts.Status, "View", cappedWidth, opts.Compact, toolParams...)
60 if opts.Compact {
61 return header
62 }
63
64 if earlyState, ok := toolEarlyStateContent(sty, opts, cappedWidth); ok {
65 return joinToolParts(header, earlyState)
66 }
67
68 if !opts.HasResult() {
69 return header
70 }
71
72 // Handle image content.
73 if opts.Result.Data != "" && strings.HasPrefix(opts.Result.MIMEType, "image/") {
74 body := toolOutputImageContent(sty, opts.Result.Data, opts.Result.MIMEType)
75 return joinToolParts(header, body)
76 }
77
78 // Try to get content from metadata first (contains actual file content).
79 var meta tools.ViewResponseMetadata
80 content := opts.Result.Content
81 if err := json.Unmarshal([]byte(opts.Result.Metadata), &meta); err == nil && meta.Content != "" {
82 content = meta.Content
83 }
84
85 // Handle skill content.
86 if meta.ResourceType == tools.ViewResourceSkill {
87 body := toolOutputSkillContent(sty, meta.ResourceName, meta.ResourceDescription)
88 return joinToolParts(header, body)
89 }
90
91 if content == "" {
92 return header
93 }
94
95 // Render code content with syntax highlighting.
96 body := toolOutputCodeContent(sty, params.FilePath, content, params.Offset, cappedWidth, opts.ExpandedContent)
97 return joinToolParts(header, body)
98}
99
100// -----------------------------------------------------------------------------
101// Write Tool
102// -----------------------------------------------------------------------------
103
104// WriteToolMessageItem is a message item that represents a write tool call.
105type WriteToolMessageItem struct {
106 *baseToolMessageItem
107}
108
109var _ ToolMessageItem = (*WriteToolMessageItem)(nil)
110
111// NewWriteToolMessageItem creates a new [WriteToolMessageItem].
112func NewWriteToolMessageItem(
113 sty *styles.Styles,
114 toolCall message.ToolCall,
115 result *message.ToolResult,
116 canceled bool,
117) ToolMessageItem {
118 return newBaseToolMessageItem(sty, toolCall, result, &WriteToolRenderContext{}, canceled)
119}
120
121// WriteToolRenderContext renders write tool messages.
122type WriteToolRenderContext struct{}
123
124// RenderTool implements the [ToolRenderer] interface.
125func (w *WriteToolRenderContext) RenderTool(sty *styles.Styles, width int, opts *ToolRenderOpts) string {
126 cappedWidth := cappedMessageWidth(width)
127 if opts.IsPending() {
128 return pendingTool(sty, "Write", opts.Anim)
129 }
130
131 var params tools.WriteParams
132 if err := json.Unmarshal([]byte(opts.ToolCall.Input), ¶ms); err != nil {
133 return toolErrorContent(sty, &message.ToolResult{Content: "Invalid parameters"}, cappedWidth)
134 }
135
136 file := fsext.PrettyPath(params.FilePath)
137 header := toolHeader(sty, opts.Status, "Write", cappedWidth, opts.Compact, file)
138 if opts.Compact {
139 return header
140 }
141
142 if earlyState, ok := toolEarlyStateContent(sty, opts, cappedWidth); ok {
143 return joinToolParts(header, earlyState)
144 }
145
146 if params.Content == "" {
147 return header
148 }
149
150 // Render code content with syntax highlighting.
151 body := toolOutputCodeContent(sty, params.FilePath, params.Content, 0, cappedWidth, opts.ExpandedContent)
152 return joinToolParts(header, body)
153}
154
155// -----------------------------------------------------------------------------
156// Edit Tool
157// -----------------------------------------------------------------------------
158
159// EditToolMessageItem is a message item that represents an edit tool call.
160type EditToolMessageItem struct {
161 *baseToolMessageItem
162}
163
164var _ ToolMessageItem = (*EditToolMessageItem)(nil)
165
166// NewEditToolMessageItem creates a new [EditToolMessageItem].
167func NewEditToolMessageItem(
168 sty *styles.Styles,
169 toolCall message.ToolCall,
170 result *message.ToolResult,
171 canceled bool,
172) ToolMessageItem {
173 return newBaseToolMessageItem(sty, toolCall, result, &EditToolRenderContext{}, canceled)
174}
175
176// EditToolRenderContext renders edit tool messages.
177type EditToolRenderContext struct{}
178
179// RenderTool implements the [ToolRenderer] interface.
180func (e *EditToolRenderContext) RenderTool(sty *styles.Styles, width int, opts *ToolRenderOpts) string {
181 // Edit tool uses full width for diffs.
182 if opts.IsPending() {
183 return pendingTool(sty, "Edit", opts.Anim)
184 }
185
186 var params tools.EditParams
187 if err := json.Unmarshal([]byte(opts.ToolCall.Input), ¶ms); err != nil {
188 return toolErrorContent(sty, &message.ToolResult{Content: "Invalid parameters"}, width)
189 }
190
191 file := fsext.PrettyPath(params.FilePath)
192 header := toolHeader(sty, opts.Status, "Edit", width, opts.Compact, file)
193 if opts.Compact {
194 return header
195 }
196
197 if earlyState, ok := toolEarlyStateContent(sty, opts, width); ok {
198 return joinToolParts(header, earlyState)
199 }
200
201 if !opts.HasResult() {
202 return header
203 }
204
205 // Get diff content from metadata.
206 var meta tools.EditResponseMetadata
207 if err := json.Unmarshal([]byte(opts.Result.Metadata), &meta); err != nil {
208 bodyWidth := width - toolBodyLeftPaddingTotal
209 body := sty.Tool.Body.Render(toolOutputPlainContent(sty, opts.Result.Content, bodyWidth, opts.ExpandedContent))
210 return joinToolParts(header, body)
211 }
212
213 // Render diff.
214 body := toolOutputDiffContent(sty, file, meta.OldContent, meta.NewContent, width, opts.ExpandedContent)
215 return joinToolParts(header, body)
216}
217
218// -----------------------------------------------------------------------------
219// MultiEdit Tool
220// -----------------------------------------------------------------------------
221
222// MultiEditToolMessageItem is a message item that represents a multi-edit tool call.
223type MultiEditToolMessageItem struct {
224 *baseToolMessageItem
225}
226
227var _ ToolMessageItem = (*MultiEditToolMessageItem)(nil)
228
229// NewMultiEditToolMessageItem creates a new [MultiEditToolMessageItem].
230func NewMultiEditToolMessageItem(
231 sty *styles.Styles,
232 toolCall message.ToolCall,
233 result *message.ToolResult,
234 canceled bool,
235) ToolMessageItem {
236 return newBaseToolMessageItem(sty, toolCall, result, &MultiEditToolRenderContext{}, canceled)
237}
238
239// MultiEditToolRenderContext renders multi-edit tool messages.
240type MultiEditToolRenderContext struct{}
241
242// RenderTool implements the [ToolRenderer] interface.
243func (m *MultiEditToolRenderContext) RenderTool(sty *styles.Styles, width int, opts *ToolRenderOpts) string {
244 // MultiEdit tool uses full width for diffs.
245 if opts.IsPending() {
246 return pendingTool(sty, "Multi-Edit", opts.Anim)
247 }
248
249 var params tools.MultiEditParams
250 if err := json.Unmarshal([]byte(opts.ToolCall.Input), ¶ms); err != nil {
251 return toolErrorContent(sty, &message.ToolResult{Content: "Invalid parameters"}, width)
252 }
253
254 file := fsext.PrettyPath(params.FilePath)
255 toolParams := []string{file}
256 if len(params.Edits) > 0 {
257 toolParams = append(toolParams, "edits", fmt.Sprintf("%d", len(params.Edits)))
258 }
259
260 header := toolHeader(sty, opts.Status, "Multi-Edit", width, opts.Compact, toolParams...)
261 if opts.Compact {
262 return header
263 }
264
265 if earlyState, ok := toolEarlyStateContent(sty, opts, width); ok {
266 return joinToolParts(header, earlyState)
267 }
268
269 if !opts.HasResult() {
270 return header
271 }
272
273 // Get diff content from metadata.
274 var meta tools.MultiEditResponseMetadata
275 if err := json.Unmarshal([]byte(opts.Result.Metadata), &meta); err != nil {
276 bodyWidth := width - toolBodyLeftPaddingTotal
277 body := sty.Tool.Body.Render(toolOutputPlainContent(sty, opts.Result.Content, bodyWidth, opts.ExpandedContent))
278 return joinToolParts(header, body)
279 }
280
281 // Render diff with optional failed edits note.
282 body := toolOutputMultiEditDiffContent(sty, file, meta, len(params.Edits), width, opts.ExpandedContent)
283 return joinToolParts(header, body)
284}
285
286// -----------------------------------------------------------------------------
287// Download Tool
288// -----------------------------------------------------------------------------
289
290// DownloadToolMessageItem is a message item that represents a download tool call.
291type DownloadToolMessageItem struct {
292 *baseToolMessageItem
293}
294
295var _ ToolMessageItem = (*DownloadToolMessageItem)(nil)
296
297// NewDownloadToolMessageItem creates a new [DownloadToolMessageItem].
298func NewDownloadToolMessageItem(
299 sty *styles.Styles,
300 toolCall message.ToolCall,
301 result *message.ToolResult,
302 canceled bool,
303) ToolMessageItem {
304 return newBaseToolMessageItem(sty, toolCall, result, &DownloadToolRenderContext{}, canceled)
305}
306
307// DownloadToolRenderContext renders download tool messages.
308type DownloadToolRenderContext struct{}
309
310// RenderTool implements the [ToolRenderer] interface.
311func (d *DownloadToolRenderContext) RenderTool(sty *styles.Styles, width int, opts *ToolRenderOpts) string {
312 cappedWidth := cappedMessageWidth(width)
313 if opts.IsPending() {
314 return pendingTool(sty, "Download", opts.Anim)
315 }
316
317 var params tools.DownloadParams
318 if err := json.Unmarshal([]byte(opts.ToolCall.Input), ¶ms); err != nil {
319 return toolErrorContent(sty, &message.ToolResult{Content: "Invalid parameters"}, cappedWidth)
320 }
321
322 toolParams := []string{params.URL}
323 if params.FilePath != "" {
324 toolParams = append(toolParams, "file_path", fsext.PrettyPath(params.FilePath))
325 }
326 if params.Timeout != 0 {
327 toolParams = append(toolParams, "timeout", formatTimeout(params.Timeout))
328 }
329
330 header := toolHeader(sty, opts.Status, "Download", cappedWidth, opts.Compact, toolParams...)
331 if opts.Compact {
332 return header
333 }
334
335 if earlyState, ok := toolEarlyStateContent(sty, opts, cappedWidth); ok {
336 return joinToolParts(header, earlyState)
337 }
338
339 if opts.HasEmptyResult() {
340 return header
341 }
342
343 bodyWidth := cappedWidth - toolBodyLeftPaddingTotal
344 body := sty.Tool.Body.Render(toolOutputPlainContent(sty, opts.Result.Content, bodyWidth, opts.ExpandedContent))
345 return joinToolParts(header, body)
346}