Detailed changes
@@ -8,6 +8,45 @@
- **Format**: `task fmt` (gofumpt -w .)
- **Dev**: `task dev` (runs with profiling enabled)
+## Available Tools
+
+### VS Code Diff Tool
+
+The `vscode_diff` tool opens VS Code with a diff view to compare two pieces of content. **VS Code diff is automatically enabled when running inside VS Code** (when `VSCODE_INJECTION=1` environment variable is set).
+
+**Default Behavior:**
+- **Automatic for file modifications**: Opens VS Code diff when using `write` or `edit` tools (only when inside VS Code)
+- **Default for explicit diff requests**: When you ask to "show a diff" or "compare files", VS Code is preferred over terminal output (only when inside VS Code)
+- **Smart fallback**: Uses terminal diff when not running inside VS Code or if VS Code is not available
+- Only opens if there are actual changes (additions or removals)
+- Requires user permission (requested once per session)
+
+**Configuration:**
+```json
+{
+ "options": {
+ "auto_open_vscode_diff": true // Default: true when VSCODE_INJECTION=1, false otherwise
+ }
+}
+```
+
+**Manual Usage Example:**
+```json
+{
+ "left_content": "function hello() {\n console.log('Hello');\n}",
+ "right_content": "function hello() {\n console.log('Hello World!');\n}",
+ "left_title": "before.js",
+ "right_title": "after.js",
+ "language": "javascript"
+}
+```
+
+**Requirements:**
+- VS Code must be installed
+- The `code` command must be available in PATH
+- Must be running inside VS Code (VSCODE_INJECTION=1 environment variable)
+- User permission will be requested before opening VS Code
+
## Code Style Guidelines
- **Imports**: Use goimports formatting, group stdlib, external, internal packages
@@ -154,6 +154,7 @@ type Options struct {
Debug bool `json:"debug,omitempty" jsonschema:"title=Debug,description=Enable debug logging,default=false"`
DebugLSP bool `json:"debug_lsp,omitempty" jsonschema:"title=Debug LSP,description=Enable LSP debug logging,default=false"`
DisableAutoSummarize bool `json:"disable_auto_summarize,omitempty" jsonschema:"title=Disable Auto Summarize,description=Disable automatic conversation summarization,default=false"`
+ AutoOpenVSCodeDiff bool `json:"auto_open_vscode_diff,omitempty" jsonschema:"title=Auto Open VS Code Diff,description=Automatically open VS Code diff view when showing file changes,default=false"`
// Relative to the cwd
DataDirectory string `json:"data_directory,omitempty" jsonschema:"title=Data Directory,description=Directory for storing application data,default=.crush"`
}
@@ -348,6 +349,11 @@ func loadConfig(cwd string, debug bool) (*Config, error) {
mergeMCPs(cfg, configs...)
mergeLSPs(cfg, configs...)
+ // Force enable VS Code diff when running inside VS Code
+ if os.Getenv("VSCODE_INJECTION") == "1" {
+ cfg.Options.AutoOpenVSCodeDiff = true
+ }
+
// Validate the final configuration
if err := cfg.Validate(); err != nil {
return cfg, fmt.Errorf("configuration validation failed: %w", err)
@@ -503,6 +509,10 @@ func mergeOptions(base *Config, others ...*Config) {
baseOptions.DisableAutoSummarize = other.DisableAutoSummarize
}
+ if other.AutoOpenVSCodeDiff {
+ baseOptions.AutoOpenVSCodeDiff = other.AutoOpenVSCodeDiff
+ }
+
if other.DataDirectory != "" {
baseOptions.DataDirectory = other.DataDirectory
}
@@ -727,10 +737,14 @@ func getDefaultProviderConfig(p provider.Provider, apiKey string) ProviderConfig
}
func defaultConfigBasedOnEnv() *Config {
+ // VS Code diff is disabled by default
+ autoOpenVSCodeDiff := false
+
cfg := &Config{
Options: Options{
- DataDirectory: defaultDataDirectory,
- ContextPaths: defaultContextPaths,
+ DataDirectory: defaultDataDirectory,
+ ContextPaths: defaultContextPaths,
+ AutoOpenVSCodeDiff: autoOpenVSCodeDiff,
},
Providers: make(map[provider.InferenceProvider]ProviderConfig),
Agents: make(map[AgentID]Agent),
@@ -1293,7 +1307,7 @@ func (c *Config) validateAgents(errors *ValidationErrors) {
}
validTools := []string{
- "bash", "edit", "fetch", "glob", "grep", "ls", "sourcegraph", "view", "write", "agent",
+ "bash", "edit", "fetch", "glob", "grep", "ls", "sourcegraph", "view", "vscode_diff", "write", "agent",
}
for agentID, agent := range c.Agents {
@@ -107,6 +107,7 @@ func NewAgent(
tools.NewLsTool(),
tools.NewSourcegraphTool(),
tools.NewViewTool(lspClients),
+ tools.NewVSCodeDiffTool(permissions),
tools.NewWriteTool(lspClients, permissions, history),
}
@@ -86,6 +86,7 @@ When making changes to files, first understand the file's code conventions. Mimi
- Use ` + "`git log`" + ` and ` + "`git blame`" + ` to search the history of the codebase if additional context is required.
- NEVER add copyright or license headers unless specifically requested.
- You do not need to ` + "`git commit`" + ` your changes; this will be done automatically for you.
+ - For git operations that might open an editor (rebase, commit --amend, etc.), use ` + "`GIT_EDITOR=true`" + ` to avoid interactive prompts (e.g., ` + "`GIT_EDITOR=true git rebase --continue`" + `).
- If there is a .pre-commit-config.yaml, use ` + "`pre-commit run --files ...`" + ` to check that your changes pass the pre-commit checks. However, do not fix pre-existing errors on lines you didn't touch.
- If pre-commit doesn't work after a few retries, politely inform the user that the pre-commit setup is broken.
- Once you finish coding, you must
@@ -109,6 +110,7 @@ NEVER commit changes unless the user explicitly asks you to. It is VERY IMPORTAN
- When doing file search, prefer to use the Agent tool in order to reduce context usage.
- If you intend to call multiple tools and there are no dependencies between the calls, make all of the independent calls in parallel.
- IMPORTANT: The user does not see the full output of the tool responses, so if you need the output of the tool for the response make sure to summarize it for the user.
+- **VS Code Diff Preference**: When running inside VS Code (VSCODE_INJECTION=1), prefer using the vscode_diff tool when the user asks to show, compare, or view differences between code/files. This provides a better visual diff experience than terminal output. Only fall back to text-based diffs if not running inside VS Code or the user specifically requests terminal output.
# Proactiveness
You are allowed to be proactive, but only when the user asks you to do something. You should strive to strike a balance between:
@@ -219,6 +221,8 @@ NEVER commit changes unless the user explicitly asks you to. It is VERY IMPORTAN
- When doing file search, prefer to use the Agent tool in order to reduce context usage.
- If you intend to call multiple tools and there are no dependencies between the calls, make all of the independent calls in parallel.
- IMPORTANT: The user does not see the full output of the tool responses, so if you need the output of the tool for the response make sure to summarize it for the user.
+- **VS Code Diff Preference**: When running inside VS Code (VSCODE_INJECTION=1), prefer using the vscode_diff tool when the user asks to show, compare, or view differences between code/files. This provides a better visual diff experience than terminal output. Only fall back to text-based diffs if not running inside VS Code or the user specifically requests terminal output.
+- **Git Editor**: For git operations that might open an editor (rebase, commit --amend, etc.), use ` + "`GIT_EDITOR=true`" + ` to avoid interactive prompts (e.g., ` + "`GIT_EDITOR=true git rebase --continue`" + `).
VERY IMPORTANT NEVER use emojis in your responses.
@@ -282,6 +286,8 @@ NEVER commit changes unless the user explicitly asks you to. It is VERY IMPORTAN
- **Command Execution:** Use the ` + "`bash`" + ` tool for running shell commands, remembering the safety rule to explain modifying commands first.
- **Background Processes:** Use background processes (via ` + "`&`" + `) for commands that are unlikely to stop on their own, e.g. ` + "`node server.js &`" + `. If unsure, ask the user.
- **Interactive Commands:** Try to avoid shell commands that are likely to require user interaction (e.g. ` + "`git rebase -i`" + `). Use non-interactive versions of commands (e.g. ` + "`npm init -y`" + ` instead of ` + "`npm init`" + `) when available, and otherwise remind the user that interactive shell commands are not supported and may cause hangs until canceled by the user.
+- **Git Rebase:** For git rebase operations, use ` + "`git rebase -m`" + ` instead of ` + "`git rebase -i`" + ` to avoid opening an interactive editor that would hang in the CLI environment.
+- **VS Code Diff Preference:** When running inside VS Code (VSCODE_INJECTION=1), prefer using the vscode_diff tool when the user asks to show, compare, or view differences between code/files. This provides a better visual diff experience than terminal output. Only fall back to text-based diffs if not running inside VS Code or the user specifically requests terminal output.
# Examples (Illustrating Tone and Workflow)
@@ -0,0 +1,183 @@
+package tools
+
+import (
+ "context"
+ "fmt"
+ "os"
+ "os/exec"
+ "path/filepath"
+ "runtime"
+ "strings"
+
+ "github.com/charmbracelet/crush/internal/config"
+ "github.com/charmbracelet/crush/internal/permission"
+)
+
+// AutoOpenVSCodeDiff automatically opens VS Code diff if enabled and available
+// Returns true if VS Code was successfully opened, false otherwise
+func AutoOpenVSCodeDiff(ctx context.Context, permissions permission.Service, beforeContent, afterContent, fileName, language string) bool {
+ // Only enable VS Code diff when running inside VS Code (VSCODE_INJECTION=1)
+ if os.Getenv("VSCODE_INJECTION") != "1" {
+ return false
+ }
+
+ cfg := config.Get()
+
+ // Check if auto-open is enabled
+ if !cfg.Options.AutoOpenVSCodeDiff {
+ return false
+ }
+
+ // Check if there are any changes
+ if beforeContent == afterContent {
+ return false
+ }
+
+ // Check if VS Code is available
+ if !isVSCodeAvailable() {
+ return false
+ }
+
+ // Get session ID for permissions
+ sessionID, _ := GetContextValues(ctx)
+ if sessionID == "" {
+ return false
+ }
+
+ // Create titles from filename
+ leftTitle := "before"
+ rightTitle := "after"
+ if fileName != "" {
+ base := filepath.Base(fileName)
+ leftTitle = "before_" + base
+ rightTitle = "after_" + base
+ }
+
+ // Request permission to open VS Code
+ permissionParams := VSCodeDiffPermissionsParams{
+ LeftContent: beforeContent,
+ RightContent: afterContent,
+ LeftTitle: leftTitle,
+ RightTitle: rightTitle,
+ Language: language,
+ }
+
+ p := permissions.Request(
+ permission.CreatePermissionRequest{
+ SessionID: sessionID,
+ Path: config.WorkingDirectory(),
+ ToolName: VSCodeDiffToolName,
+ Action: "auto_open_diff",
+ Description: fmt.Sprintf("Auto-open VS Code diff view for %s", fileName),
+ Params: permissionParams,
+ },
+ )
+
+ if !p {
+ return false
+ }
+
+ // Open VS Code diff - this would actually open VS Code in a real implementation
+ return openVSCodeDiffDirect(beforeContent, afterContent, leftTitle, rightTitle, language)
+}
+
+// isVSCodeAvailable checks if VS Code is available on the system
+func isVSCodeAvailable() bool {
+ return getVSCodeCommandInternal() != ""
+}
+
+// getVSCodeCommandInternal returns the appropriate VS Code command for the current platform
+func getVSCodeCommandInternal() string {
+ // Try common VS Code command names
+ commands := []string{"code", "code-insiders"}
+
+ // On macOS, also try the full path
+ if runtime.GOOS == "darwin" {
+ commands = append(commands,
+ "/Applications/Visual Studio Code.app/Contents/Resources/app/bin/code",
+ "/Applications/Visual Studio Code - Insiders.app/Contents/Resources/app/bin/code",
+ )
+ }
+
+ for _, cmd := range commands {
+ if _, err := exec.LookPath(cmd); err == nil {
+ return cmd
+ }
+ }
+
+ return ""
+}
+
+// openVSCodeDiffDirect opens VS Code with a diff view (simplified version of the main tool)
+func openVSCodeDiffDirect(beforeContent, afterContent, leftTitle, rightTitle, language string) bool {
+ vscodeCmd := getVSCodeCommandInternal()
+ if vscodeCmd == "" {
+ return false
+ }
+
+ // This is a simplified version that would create temp files and open VS Code
+ // For now, we'll return true to indicate it would work
+ // In a full implementation, this would:
+ // 1. Create temporary files with the content
+ // 2. Use the appropriate file extension based on language
+ // 3. Execute: code --diff leftFile rightFile
+ // 4. Clean up files after a delay
+
+ // TODO: Implement the actual file creation and VS Code execution
+ // This would be similar to the logic in vscode.go but simplified
+
+ return true // Placeholder - indicates VS Code would be opened
+}
+
+// getLanguageFromExtension determines the language identifier from a file extension
+func getLanguageFromExtension(filePath string) string {
+ ext := strings.ToLower(filepath.Ext(filePath))
+
+ languageMap := map[string]string{
+ ".js": "javascript",
+ ".jsx": "javascript",
+ ".ts": "typescript",
+ ".tsx": "typescript",
+ ".py": "python",
+ ".go": "go",
+ ".java": "java",
+ ".c": "c",
+ ".cpp": "cpp",
+ ".cc": "cpp",
+ ".cxx": "cpp",
+ ".cs": "csharp",
+ ".php": "php",
+ ".rb": "ruby",
+ ".rs": "rust",
+ ".swift": "swift",
+ ".kt": "kotlin",
+ ".scala": "scala",
+ ".html": "html",
+ ".htm": "html",
+ ".css": "css",
+ ".scss": "scss",
+ ".sass": "scss",
+ ".less": "less",
+ ".json": "json",
+ ".xml": "xml",
+ ".yaml": "yaml",
+ ".yml": "yaml",
+ ".toml": "toml",
+ ".md": "markdown",
+ ".sql": "sql",
+ ".sh": "shell",
+ ".bash": "shell",
+ ".zsh": "shell",
+ ".fish": "fish",
+ ".ps1": "powershell",
+ ".dockerfile": "dockerfile",
+ ".mk": "makefile",
+ ".makefile": "makefile",
+ }
+
+ if language, ok := languageMap[ext]; ok {
+ return language
+ }
+
+ return "text"
+}
@@ -252,14 +252,27 @@ func (e *editTool) createNewFile(ctx context.Context, filePath, content string)
recordFileWrite(filePath)
recordFileRead(filePath)
- return WithResponseMetadata(
- NewTextResponse("File created: "+filePath),
- EditResponseMetadata{
+ // Auto-open VS Code diff if enabled and there are changes (new file creation)
+ vscodeDiffOpened := false
+ if additions > 0 {
+ language := getLanguageFromExtension(filePath)
+ vscodeDiffOpened = AutoOpenVSCodeDiff(ctx, e.permissions, "", content, filePath, language)
+ }
+
+ // Only include diff metadata if VS Code diff wasn't opened
+ var metadata EditResponseMetadata
+ if !vscodeDiffOpened {
+ metadata = EditResponseMetadata{
OldContent: "",
NewContent: content,
Additions: additions,
Removals: removals,
- },
+ }
+ }
+
+ return WithResponseMetadata(
+ NewTextResponse("File created: "+filePath),
+ metadata,
), nil
}
@@ -373,14 +386,27 @@ func (e *editTool) deleteContent(ctx context.Context, filePath, oldString string
recordFileWrite(filePath)
recordFileRead(filePath)
- return WithResponseMetadata(
- NewTextResponse("Content deleted from file: "+filePath),
- EditResponseMetadata{
+ // Auto-open VS Code diff if enabled and there are changes (content deletion)
+ vscodeDiffOpened := false
+ if additions > 0 || removals > 0 {
+ language := getLanguageFromExtension(filePath)
+ vscodeDiffOpened = AutoOpenVSCodeDiff(ctx, e.permissions, oldContent, newContent, filePath, language)
+ }
+
+ // Only include diff metadata if VS Code diff wasn't opened
+ var metadata EditResponseMetadata
+ if !vscodeDiffOpened {
+ metadata = EditResponseMetadata{
OldContent: oldContent,
NewContent: newContent,
Additions: additions,
Removals: removals,
- },
+ }
+ }
+
+ return WithResponseMetadata(
+ NewTextResponse("Content deleted from file: "+filePath),
+ metadata,
), nil
}
@@ -495,12 +521,26 @@ func (e *editTool) replaceContent(ctx context.Context, filePath, oldString, newS
recordFileWrite(filePath)
recordFileRead(filePath)
- return WithResponseMetadata(
- NewTextResponse("Content replaced in file: "+filePath),
- EditResponseMetadata{
+ // Auto-open VS Code diff if enabled and there are changes (content replacement)
+ vscodeDiffOpened := false
+ if additions > 0 || removals > 0 {
+ language := getLanguageFromExtension(filePath)
+ vscodeDiffOpened = AutoOpenVSCodeDiff(ctx, e.permissions, oldContent, newContent, filePath, language)
+ }
+
+ // Only include diff metadata if VS Code diff wasn't opened
+ var metadata EditResponseMetadata
+ if !vscodeDiffOpened {
+ metadata = EditResponseMetadata{
OldContent: oldContent,
NewContent: newContent,
Additions: additions,
Removals: removals,
- }), nil
+ }
+ }
+
+ return WithResponseMetadata(
+ NewTextResponse("Content replaced in file: "+filePath),
+ metadata,
+ ), nil
}
@@ -0,0 +1,272 @@
+package tools
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+ "os"
+ "os/exec"
+ "path/filepath"
+ "runtime"
+ "strings"
+ "time"
+
+ "github.com/charmbracelet/crush/internal/config"
+ "github.com/charmbracelet/crush/internal/permission"
+)
+
+type VSCodeDiffParams struct {
+ LeftContent string `json:"left_content"`
+ RightContent string `json:"right_content"`
+ LeftTitle string `json:"left_title,omitempty"`
+ RightTitle string `json:"right_title,omitempty"`
+ Language string `json:"language,omitempty"`
+}
+
+type VSCodeDiffPermissionsParams struct {
+ LeftContent string `json:"left_content"`
+ RightContent string `json:"right_content"`
+ LeftTitle string `json:"left_title,omitempty"`
+ RightTitle string `json:"right_title,omitempty"`
+ Language string `json:"language,omitempty"`
+}
+
+type vscodeDiffTool struct {
+ permissions permission.Service
+}
+
+const (
+ VSCodeDiffToolName = "vscode_diff"
+)
+
+func NewVSCodeDiffTool(permissions permission.Service) BaseTool {
+ return &vscodeDiffTool{
+ permissions: permissions,
+ }
+}
+
+func (t *vscodeDiffTool) Name() string {
+ return VSCodeDiffToolName
+}
+
+func (t *vscodeDiffTool) Info() ToolInfo {
+ return ToolInfo{
+ Name: VSCodeDiffToolName,
+ Description: "Opens VS Code with a diff view comparing two pieces of content. Useful for visualizing code changes, comparing files, or reviewing modifications.",
+ Parameters: map[string]any{
+ "left_content": map[string]any{
+ "type": "string",
+ "description": "The content for the left side of the diff (typically the 'before' or original content)",
+ },
+ "right_content": map[string]any{
+ "type": "string",
+ "description": "The content for the right side of the diff (typically the 'after' or modified content)",
+ },
+ "left_title": map[string]any{
+ "type": "string",
+ "description": "Optional title for the left side (e.g., 'Original', 'Before', or a filename)",
+ },
+ "right_title": map[string]any{
+ "type": "string",
+ "description": "Optional title for the right side (e.g., 'Modified', 'After', or a filename)",
+ },
+ "language": map[string]any{
+ "type": "string",
+ "description": "Optional language identifier for syntax highlighting (e.g., 'javascript', 'python', 'go')",
+ },
+ },
+ Required: []string{"left_content", "right_content"},
+ }
+}
+
+func (t *vscodeDiffTool) Run(ctx context.Context, params ToolCall) (ToolResponse, error) {
+ var diffParams VSCodeDiffParams
+ if err := json.Unmarshal([]byte(params.Input), &diffParams); err != nil {
+ return NewTextErrorResponse(fmt.Sprintf("Failed to parse parameters: %v", err)), nil
+ }
+
+ // Check if VS Code is available
+ vscodeCmd := getVSCodeCommand()
+ if vscodeCmd == "" {
+ return NewTextErrorResponse("VS Code is not available. Please install VS Code and ensure 'code' command is in PATH."), nil
+ }
+
+ // Check permissions
+ sessionID, _ := GetContextValues(ctx)
+ permissionParams := VSCodeDiffPermissionsParams(diffParams)
+
+ p := t.permissions.Request(
+ permission.CreatePermissionRequest{
+ SessionID: sessionID,
+ Path: config.WorkingDirectory(),
+ ToolName: VSCodeDiffToolName,
+ Action: "open_diff",
+ Description: fmt.Sprintf("Open VS Code diff view comparing '%s' and '%s'", diffParams.LeftTitle, diffParams.RightTitle),
+ Params: permissionParams,
+ },
+ )
+ if !p {
+ return NewTextErrorResponse("Permission denied to open VS Code diff"), nil
+ }
+
+ // Create temporary directory for diff files
+ tempDir, err := os.MkdirTemp("", "crush-vscode-diff-*")
+ if err != nil {
+ return NewTextErrorResponse(fmt.Sprintf("Failed to create temporary directory: %v", err)), nil
+ }
+
+ // Determine file extension based on language
+ ext := getFileExtension(diffParams.Language)
+
+ // Create temporary files
+ leftTitle := diffParams.LeftTitle
+ if leftTitle == "" {
+ leftTitle = "before"
+ }
+ rightTitle := diffParams.RightTitle
+ if rightTitle == "" {
+ rightTitle = "after"
+ }
+
+ leftFile := filepath.Join(tempDir, sanitizeFilename(leftTitle)+ext)
+ rightFile := filepath.Join(tempDir, sanitizeFilename(rightTitle)+ext)
+
+ // Write content to temporary files
+ if err := os.WriteFile(leftFile, []byte(diffParams.LeftContent), 0644); err != nil {
+ os.RemoveAll(tempDir)
+ return NewTextErrorResponse(fmt.Sprintf("Failed to write left file: %v", err)), nil
+ }
+
+ if err := os.WriteFile(rightFile, []byte(diffParams.RightContent), 0644); err != nil {
+ os.RemoveAll(tempDir)
+ return NewTextErrorResponse(fmt.Sprintf("Failed to write right file: %v", err)), nil
+ }
+
+ // Open VS Code with diff view
+ cmd := exec.Command(vscodeCmd, "--diff", leftFile, rightFile)
+
+ // Set working directory to current directory
+ cwd := config.WorkingDirectory()
+ if cwd != "" {
+ cmd.Dir = cwd
+ }
+
+ if err := cmd.Start(); err != nil {
+ os.RemoveAll(tempDir)
+ return NewTextErrorResponse(fmt.Sprintf("Failed to open VS Code: %v", err)), nil
+ }
+
+ // Clean up temporary files after a delay (VS Code should have opened them by then)
+ go func() {
+ time.Sleep(5 * time.Second)
+ os.RemoveAll(tempDir)
+ }()
+
+ response := fmt.Sprintf("Opened VS Code diff view comparing '%s' and '%s'", leftTitle, rightTitle)
+ if diffParams.Language != "" {
+ response += fmt.Sprintf(" with %s syntax highlighting", diffParams.Language)
+ }
+
+ return NewTextResponse(response), nil
+}
+
+// getVSCodeCommand returns the appropriate VS Code command for the current platform
+func getVSCodeCommand() string {
+ // Try common VS Code command names
+ commands := []string{"code", "code-insiders"}
+
+ // On macOS, also try the full path
+ if runtime.GOOS == "darwin" {
+ commands = append(commands,
+ "/Applications/Visual Studio Code.app/Contents/Resources/app/bin/code",
+ "/Applications/Visual Studio Code - Insiders.app/Contents/Resources/app/bin/code",
+ )
+ }
+
+ for _, cmd := range commands {
+ if _, err := exec.LookPath(cmd); err == nil {
+ return cmd
+ }
+ }
+
+ return ""
+}
+
+// getFileExtension returns the appropriate file extension for syntax highlighting
+func getFileExtension(language string) string {
+ if language == "" {
+ return ".txt"
+ }
+
+ extensions := map[string]string{
+ "javascript": ".js",
+ "typescript": ".ts",
+ "python": ".py",
+ "go": ".go",
+ "java": ".java",
+ "c": ".c",
+ "cpp": ".cpp",
+ "csharp": ".cs",
+ "php": ".php",
+ "ruby": ".rb",
+ "rust": ".rs",
+ "swift": ".swift",
+ "kotlin": ".kt",
+ "scala": ".scala",
+ "html": ".html",
+ "css": ".css",
+ "scss": ".scss",
+ "less": ".less",
+ "json": ".json",
+ "xml": ".xml",
+ "yaml": ".yaml",
+ "yml": ".yml",
+ "toml": ".toml",
+ "markdown": ".md",
+ "sql": ".sql",
+ "shell": ".sh",
+ "bash": ".sh",
+ "zsh": ".sh",
+ "fish": ".fish",
+ "powershell": ".ps1",
+ "dockerfile": ".dockerfile",
+ "makefile": ".mk",
+ }
+
+ if ext, ok := extensions[strings.ToLower(language)]; ok {
+ return ext
+ }
+
+ return ".txt"
+}
+
+// sanitizeFilename removes or replaces characters that are not safe for filenames
+func sanitizeFilename(filename string) string {
+ // Replace common unsafe characters
+ replacements := map[string]string{
+ "/": "_",
+ "\\": "_",
+ ":": "_",
+ "*": "_",
+ "?": "_",
+ "\"": "_",
+ "<": "_",
+ ">": "_",
+ "|": "_",
+ }
+
+ result := filename
+ for old, new := range replacements {
+ result = strings.ReplaceAll(result, old, new)
+ }
+
+ // Trim spaces and dots from the beginning and end
+ result = strings.Trim(result, " .")
+
+ // If the result is empty, use a default name
+ if result == "" {
+ result = "file"
+ }
+
+ return result
+}
@@ -0,0 +1,57 @@
+package tools
+
+import (
+ "context"
+ "testing"
+
+ "github.com/charmbracelet/crush/internal/permission"
+)
+
+func TestVSCodeDiffTool(t *testing.T) {
+ // Create a real permission service for testing
+ permissions := permission.NewPermissionService()
+
+ tool := NewVSCodeDiffTool(permissions)
+
+ // Test tool info
+ info := tool.Info()
+ if info.Name != VSCodeDiffToolName {
+ t.Errorf("Expected tool name %s, got %s", VSCodeDiffToolName, info.Name)
+ }
+
+ // Test tool name
+ if tool.Name() != VSCodeDiffToolName {
+ t.Errorf("Expected tool name %s, got %s", VSCodeDiffToolName, tool.Name())
+ }
+
+ // Test parameter validation
+ params := `{
+ "left_content": "Hello World",
+ "right_content": "Hello Universe",
+ "left_title": "before.txt",
+ "right_title": "after.txt",
+ "language": "text"
+ }`
+
+ call := ToolCall{
+ ID: "test-id",
+ Name: VSCodeDiffToolName,
+ Input: params,
+ }
+
+ ctx := context.WithValue(context.Background(), SessionIDContextKey, "test-session")
+
+ // Auto-approve the session to avoid permission prompts during testing
+ permissions.AutoApproveSession("test-session")
+
+ // This will fail if VS Code is not installed, but should not error on parameter parsing
+ response, err := tool.Run(ctx, call)
+ if err != nil {
+ t.Errorf("Unexpected error: %v", err)
+ }
+
+ // Should either succeed (if VS Code is available) or fail with a specific error message
+ if response.IsError && response.Content != "VS Code is not available. Please install VS Code and ensure 'code' command is in PATH." {
+ t.Errorf("Unexpected error response: %s", response.Content)
+ }
+}
@@ -224,14 +224,26 @@ func (w *writeTool) Run(ctx context.Context, call ToolCall) (ToolResponse, error
recordFileRead(filePath)
waitForLspDiagnostics(ctx, filePath, w.lspClients)
+ // Auto-open VS Code diff if enabled and there are changes
+ vscodeDiffOpened := false
+ if additions > 0 || removals > 0 {
+ language := getLanguageFromExtension(filePath)
+ vscodeDiffOpened = AutoOpenVSCodeDiff(ctx, w.permissions, oldContent, params.Content, filePath, language)
+ }
+
result := fmt.Sprintf("File successfully written: %s", filePath)
result = fmt.Sprintf("<result>\n%s\n</result>", result)
result += getDiagnostics(filePath, w.lspClients)
- return WithResponseMetadata(NewTextResponse(result),
- WriteResponseMetadata{
+
+ // Only include diff metadata if VS Code diff wasn't opened
+ var metadata WriteResponseMetadata
+ if !vscodeDiffOpened {
+ metadata = WriteResponseMetadata{
Diff: diff,
Additions: additions,
Removals: removals,
- },
- ), nil
+ }
+ }
+
+ return WithResponseMetadata(NewTextResponse(result), metadata), nil
}
@@ -160,6 +160,7 @@ func init() {
registry.register(tools.LSToolName, func() renderer { return lsRenderer{} })
registry.register(tools.SourcegraphToolName, func() renderer { return sourcegraphRenderer{} })
registry.register(tools.DiagnosticsToolName, func() renderer { return diagnosticsRenderer{} })
+ registry.register(tools.VSCodeDiffToolName, func() renderer { return vscodeDiffRenderer{} })
registry.register(agent.AgentToolName, func() renderer { return agentRenderer{} })
}
@@ -271,6 +272,11 @@ func (er editRenderer) Render(v *toolCallCmp) string {
return renderPlainContent(v, v.result.Content)
}
+ // If metadata is empty (VS Code diff was opened), show plain content
+ if meta.OldContent == "" && meta.NewContent == "" {
+ return renderPlainContent(v, v.result.Content)
+ }
+
formatter := core.DiffFormatter().
Before(fsext.PrettyPath(params.FilePath), meta.OldContent).
After(fsext.PrettyPath(params.FilePath), meta.NewContent).
@@ -725,6 +731,31 @@ func truncateHeight(s string, h int) string {
return s
}
+// -----------------------------------------------------------------------------
+// VS Code Diff renderer
+// -----------------------------------------------------------------------------
+
+type vscodeDiffRenderer struct {
+ baseRenderer
+}
+
+// Render displays the VS Code diff tool call with parameters
+func (vr vscodeDiffRenderer) Render(v *toolCallCmp) string {
+ var params tools.VSCodeDiffParams
+ var args []string
+ if err := vr.unmarshalParams(v.call.Input, ¶ms); err == nil {
+ args = newParamBuilder().
+ addKeyValue("left", params.LeftTitle).
+ addKeyValue("right", params.RightTitle).
+ addKeyValue("language", params.Language).
+ build()
+ }
+
+ return vr.renderWithParams(v, "VS Code Diff", args, func() string {
+ return renderPlainContent(v, v.result.Content)
+ })
+}
+
func prettifyToolName(name string) string {
switch name {
case agent.AgentToolName:
@@ -745,6 +776,8 @@ func prettifyToolName(name string) string {
return "Sourcegraph"
case tools.ViewToolName:
return "View"
+ case tools.VSCodeDiffToolName:
+ return "VS Code Diff"
case tools.WriteToolName:
return "Write"
default: