Add a search-and-replace diff strategy

Author: mrubens

CHANGELOG.md

@@ -1,5 +1,13 @@
 # Roo Cline Changelog
 
+## [2.1.17]
+
+- Switch to search/replace diffs in experimental diff editing mode
+
+## [2.1.16]
+
+- Allow copying prompts from the history screen
+
 ## [2.1.15]
 
 - Incorporate dbasclpy's [PR](https://github.com/RooVetGit/Roo-Cline/pull/54) to add support for gemini-exp-1206

README.md

@@ -9,6 +9,7 @@ A fork of Cline, an autonomous coding agent, with some added experimental config
 - Support for OpenRouter compression
 - Support for editing through diffs (very experimental)
 - Support for gemini-exp-1206
+- Support for copying prompts from the history screen
 
 Here's an example of Roo-Cline autonomously creating a snake game with "Always approve write operations" and "Always approve browser actions" turned on:
 

package-lock.json

@@ -3,7 +3,7 @@
   "displayName": "Roo Cline",
   "description": "A fork of Cline, an autonomous coding agent, with some added experimental configuration and automation features.",
   "publisher": "RooVeterinaryInc",
-  "version": "2.1.16",
+  "version": "2.1.17",
   "icon": "assets/icons/rocket.png",
   "galleryBanner": {
     "color": "#617A91",

package.json

@@ -1,16 +1,16 @@
 import type { DiffStrategy } from './types'
 import { UnifiedDiffStrategy } from './strategies/unified'
-
+import { SearchReplaceDiffStrategy } from './strategies/search-replace'
 /**
  * Get the appropriate diff strategy for the given model
  * @param model The name of the model being used (e.g., 'gpt-4', 'claude-3-opus')
  * @returns The appropriate diff strategy for the model
  */
 export function getDiffStrategy(model: string): DiffStrategy {
-    // For now, return UnifiedDiffStrategy for all models
+    // For now, return SearchReplaceDiffStrategy for all models
     // This architecture allows for future optimizations based on model capabilities
-    return new UnifiedDiffStrategy()
+    return new SearchReplaceDiffStrategy()
 }
 
 export type { DiffStrategy }
-export { UnifiedDiffStrategy }
+export { UnifiedDiffStrategy, SearchReplaceDiffStrategy }

src/core/diff/DiffStrategy.ts

@@ -0,0 +1,191 @@
+import { SearchReplaceDiffStrategy } from '../search-replace'
+
+describe('SearchReplaceDiffStrategy', () => {
+    let strategy: SearchReplaceDiffStrategy
+
+    beforeEach(() => {
+        strategy = new SearchReplaceDiffStrategy()
+    })
+
+    describe('applyDiff', () => {
+        it('should replace matching content', () => {
+            const originalContent = `function hello() {
+    console.log("hello")
+}
+`
+            const diffContent = `test.ts
+<<<<<<< SEARCH
+function hello() {
+    console.log("hello")
+}
+=======
+function hello() {
+    console.log("hello world")
+}
+>>>>>>> REPLACE`
+
+            const result = strategy.applyDiff(originalContent, diffContent)
+            expect(result).toBe(`function hello() {
+    console.log("hello world")
+}
+`)
+        })
+
+        it('should handle extra whitespace in search/replace blocks', () => {
+            const originalContent = `function test() {
+    return true;
+}
+`
+            const diffContent = `test.ts
+<<<<<<< SEARCH
+
+function test() {
+    return true;
+}
+
+=======
+function test() {
+    return false;
+}
+>>>>>>> REPLACE`
+
+            const result = strategy.applyDiff(originalContent, diffContent)
+            expect(result).toBe(`function test() {
+    return false;
+}
+`)
+        })
+
+        it('should match content with different surrounding whitespace', () => {
+            const originalContent = `
+function example() {
+    return 42;
+}
+
+`
+            const diffContent = `test.ts
+<<<<<<< SEARCH
+function example() {
+    return 42;
+}
+=======
+function example() {
+    return 43;
+}
+>>>>>>> REPLACE`
+
+            const result = strategy.applyDiff(originalContent, diffContent)
+            expect(result).toBe(`
+function example() {
+    return 43;
+}
+
+`)
+        })
+
+        it('should return false if search content does not match', () => {
+            const originalContent = `function hello() {
+    console.log("hello")
+}
+`
+            const diffContent = `test.ts
+<<<<<<< SEARCH
+function hello() {
+    console.log("wrong")
+}
+=======
+function hello() {
+    console.log("hello world")
+}
+>>>>>>> REPLACE`
+
+            const result = strategy.applyDiff(originalContent, diffContent)
+            expect(result).toBe(false)
+        })
+
+        it('should return false if diff format is invalid', () => {
+            const originalContent = `function hello() {
+    console.log("hello")
+}
+`
+            const diffContent = `test.ts
+Invalid diff format`
+
+            const result = strategy.applyDiff(originalContent, diffContent)
+            expect(result).toBe(false)
+        })
+
+        it('should handle multiple lines with proper indentation', () => {
+            const originalContent = `class Example {
+    constructor() {
+        this.value = 0
+    }
+
+    getValue() {
+        return this.value
+    }
+}
+`
+            const diffContent = `test.ts
+<<<<<<< SEARCH
+    getValue() {
+        return this.value
+    }
+=======
+    getValue() {
+        // Add logging
+        console.log("Getting value")
+        return this.value
+    }
+>>>>>>> REPLACE`
+
+            const result = strategy.applyDiff(originalContent, diffContent)
+            expect(result).toBe(`class Example {
+    constructor() {
+        this.value = 0
+    }
+
+    getValue() {
+        // Add logging
+        console.log("Getting value")
+        return this.value
+    }
+}
+`)
+        })
+
+        it('should preserve whitespace exactly in the output', () => {
+            const originalContent = "    indented\n        more indented\n    back\n"
+            const diffContent = `test.ts
+<<<<<<< SEARCH
+    indented
+        more indented
+    back
+=======
+    modified
+        still indented
+    end
+>>>>>>> REPLACE`
+
+            const result = strategy.applyDiff(originalContent, diffContent)
+            expect(result).toBe("    modified\n        still indented\n    end\n")
+        })
+    })
+
+    describe('getToolDescription', () => {
+        it('should include the current working directory', () => {
+            const cwd = '/test/dir'
+            const description = strategy.getToolDescription(cwd)
+            expect(description).toContain(`relative to the current working directory ${cwd}`)
+        })
+
+        it('should include required format elements', () => {
+            const description = strategy.getToolDescription('/test')
+            expect(description).toContain('<<<<<<< SEARCH')
+            expect(description).toContain('=======')
+            expect(description).toContain('>>>>>>> REPLACE')
+            expect(description).toContain('<apply_diff>')
+            expect(description).toContain('</apply_diff>')
+        })
+    })
+})

src/core/diff/strategies/__tests__/search-replace.test.ts

@@ -0,0 +1,88 @@
+import { DiffStrategy } from "../types"
+
+export class SearchReplaceDiffStrategy implements DiffStrategy {
+    getToolDescription(cwd: string): string {
+        return `## apply_diff
+Description: Request to replace existing code using search and replace blocks.
+This tool allows for precise, surgical replaces to files by specifying exactly what content to search for and what to replace it with.
+Only use this tool when you need to replace/fix existing code.
+The tool will maintain proper indentation and formatting while making changes.
+Only a single operation is allowed per tool use.
+The SEARCH section must exactly match existing content including whitespace and indentation.
+
+Parameters:
+- path: (required) The path of the file to modify (relative to the current working directory ${cwd})
+- diff: (required) The search/replace blocks defining the changes.
+
+Format:
+1. First line must be the file path
+2. Followed by search/replace blocks:
+   \`\`\`
+   <<<<<<< SEARCH
+   [exact content to find including whitespace]
+   =======
+   [new content to replace with]
+   >>>>>>> REPLACE
+   \`\`\`
+
+Example:
+
+Original file:
+\`\`\`
+def calculate_total(items):
+    total = 0
+    for item in items:
+        total += item
+    return total
+\`\`\`
+
+Search/Replace content:
+\`\`\`
+main.py
+<<<<<<< SEARCH
+def calculate_total(items):
+    total = 0
+    for item in items:
+        total += item
+    return total
+=======
+def calculate_total(items):
+    """Calculate total with 10% markup"""
+    return sum(item * 1.1 for item in items)
+>>>>>>> REPLACE
+\`\`\`
+
+Usage:
+<apply_diff>
+<path>File path here</path>
+<diff>
+Your search/replace content here
+</diff>
+</apply_diff>`
+    }
+
+    applyDiff(originalContent: string, diffContent: string): string | false {
+        // Extract the search and replace blocks
+        const match = diffContent.match(/<<<<<<< SEARCH\n([\s\S]*?)\n=======\n([\s\S]*?)\n>>>>>>> REPLACE/);
+        if (!match) {
+            return false;
+        }
+
+        const [_, searchContent, replaceContent] = match;
+        
+        // Trim both search and replace content
+        const trimmedSearch = searchContent.trim();
+        const trimmedReplace = replaceContent.trim();
+        
+        // Trim the original content for comparison
+        const trimmedOriginal = originalContent.trim();
+        
+        // Verify the search content exists in the trimmed original
+        if (!trimmedOriginal.includes(trimmedSearch)) {
+            return false;
+        }
+
+        // Replace the content, maintaining original whitespace
+        return originalContent.replace(trimmedSearch, trimmedReplace);
+    }
+}