Apply new edit tool to diff (RooCodeInc#3944)

* add ls file tool description, parsing, and return formatting

* add json tool definition and remove extra '.'

* changeset

* use separate function for new format

* using json

* add grep tool new format

* add editTool definition

* Map MultiEdit tool to StreamingJsonReplacer with logs

* Adding support for non streamed json

* Adding logging

* moving multiedit tool into tool defs

---------

Co-authored-by: Elephant Lumps <[email protected]>
Co-authored-by: Cline Evaluation <[email protected]>
Co-authored-by: pashpashpash <[email protected]>

Author: 4 people

.changeset/olive-cameras-provide.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": minor
+---
+
+Add grep tool with new parsing format

.changeset/soft-ravens-glow.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": minor
+---
+
+Add edit tool definition

src/core/assistant-message/diff-json.ts

@@ -1,4 +1,7 @@
 import { JSONParser } from "@streamparser/json"
+import * as fs from "fs"
+import * as path from "path"
+import * as os from "os"
 
 // Fallback type definition based on the error message: "Property 'value' is optional in type 'ParsedElementInfo'"
 type ParsedElementInfo = {
@@ -9,8 +12,8 @@ type ParsedElementInfo = {
 }
 
 export interface ReplacementItem {
-	old_str: string
-	new_str: string
+	old_string: string
+	new_string: string
 }
 
 export interface ChangeLocation {
@@ -27,109 +30,243 @@ export class StreamingJsonReplacer {
 	private onErrorCallback: (error: Error) => void
 	private itemsProcessed: number = 0
 	private successfullyParsedItems: ReplacementItem[] = []
+	private logFilePath: string
 
 	constructor(
 		initialContent: string,
 		onContentUpdatedCallback: (newContent: string, isFinalItem: boolean, changeLocation?: ChangeLocation) => void,
 		onErrorCallback: (error: Error) => void,
 	) {
+		// Initialize log file path
+		const timestamp = new Date().toISOString().replace(/[:.]/g, "-")
+		this.logFilePath = path.join(os.homedir(), "Documents", `streaming-json-replacer-debug-${timestamp}.log`)
+
+		// Initialize log file
+		this.log("StreamingJsonReplacer Debug Log Started", "INFO")
+		this.log("Timestamp: " + new Date().toISOString(), "INFO")
+		this.log("Constructor called with initial content length: " + initialContent.length, "INFO")
+		this.log("Initial content preview: " + initialContent.substring(0, 200) + "...", "INFO")
+
 		this.currentFileContent = initialContent
 		this.onContentUpdated = onContentUpdatedCallback
 		this.onErrorCallback = onErrorCallback
 
-		this.parser = new JSONParser({ paths: ["$.replacements.*"] })
+		this.log("Initializing JSONParser with paths: ['$.*']", "INFO")
+		this.parser = new JSONParser({ paths: ["$.*"] })
 
 		this.parser.onValue = (parsedElementInfo: ParsedElementInfo) => {
+			this.log("onValue callback triggered")
+			this.log("parsedElementInfo: " + JSON.stringify(parsedElementInfo, null, 2))
+
 			const { value } = parsedElementInfo // Destructure to get value, which might be undefined
+			this.log("Extracted value: " + JSON.stringify(value))
+			this.log("Value type: " + typeof value)
+
 			// This callback is triggered for each item matched by '$.replacements.*'
-			if (value && typeof value === "object" && "old_str" in value && "new_str" in value) {
+			if (value && typeof value === "object" && "old_string" in value && "new_string" in value) {
+				this.log("Found valid replacement item structure")
 				const item = value as ReplacementItem // Value here is confirmed to be an object
+				this.log("Replacement item: " + JSON.stringify(item, null, 2))
+
+				if (typeof item.old_string === "string" && typeof item.new_string === "string") {
+					this.log("Item has valid string types for old_string and new_string")
+					this.log("old_string length: " + item.old_string.length)
+					this.log("new_string length: " + item.new_string.length)
+					this.log(
+						"old_string preview: " +
+							(item.old_string.substring(0, 100) + (item.old_string.length > 100 ? "..." : "")),
+					)
+					this.log(
+						"new_string preview: " +
+							(item.new_string.substring(0, 100) + (item.new_string.length > 100 ? "..." : "")),
+					)
 
-				if (typeof item.old_str === "string" && typeof item.new_str === "string") {
 					this.successfullyParsedItems.push(item) // Store the structurally valid item
+					this.log("Added item to successfullyParsedItems. Total count: " + this.successfullyParsedItems.length)
+
+					if (this.currentFileContent.includes(item.old_string)) {
+						this.log("old_string found in current file content - proceeding with replacement")
 
-					if (this.currentFileContent.includes(item.old_str)) {
 						// Calculate the change location before making the replacement
-						const changeLocation = this.calculateChangeLocation(item.old_str, item.new_str)
+						const changeLocation = this.calculateChangeLocation(item.old_string, item.new_string)
+						this.log("Calculated change location: " + JSON.stringify(changeLocation))
+
+						const beforeLength = this.currentFileContent.length
+						this.currentFileContent = this.currentFileContent.replace(item.old_string, item.new_string)
+						const afterLength = this.currentFileContent.length
+						this.log("Content length before replacement: " + beforeLength)
+						this.log("Content length after replacement: " + afterLength)
+						this.log("Length difference: " + (afterLength - beforeLength))
 
-						this.currentFileContent = this.currentFileContent.replace(item.old_str, item.new_str)
 						this.itemsProcessed++
+						this.log("Incremented itemsProcessed to: " + this.itemsProcessed)
+
 						// Notify that an item has been processed. The `isFinalItem` argument here is tricky
 						// as we don't know from the parser alone if this is the *absolute* last item
 						// until the stream ends. The caller (Task.ts) will manage the final update.
 						// For now, we'll pass `false` and let Task.ts handle the final diff view update.
+						this.log("Calling onContentUpdated callback")
 						this.onContentUpdated(this.currentFileContent, false, changeLocation)
+						this.log("onContentUpdated callback completed")
 					} else {
-						const snippet = item.old_str.length > 50 ? item.old_str.substring(0, 47) + "..." : item.old_str
-						const error = new Error(`Streaming Replacement failed: 'old_str' not found. Snippet: "${snippet}"`)
+						this.log("old_string NOT found in current file content - generating error", "ERROR")
+						this.log("Current file content length: " + this.currentFileContent.length)
+						this.log("Current file content preview: " + this.currentFileContent.substring(0, 200) + "...")
+
+						const snippet = item.old_string.length > 50 ? item.old_string.substring(0, 47) + "..." : item.old_string
+						const error = new Error(`Streaming Replacement failed: 'old_string' not found. Snippet: "${snippet}"`)
+						this.log("Calling onErrorCallback with error: " + error.message, "ERROR")
 						this.onErrorCallback(error) // Call our own error callback
 					}
 				} else {
+					this.log(
+						"Invalid string types - old_string type: " +
+							typeof item.old_string +
+							", new_string type: " +
+							typeof item.new_string,
+						"ERROR",
+					)
 					const error = new Error(`Invalid item structure in replacements stream: ${JSON.stringify(item)}`)
+					this.log("Calling onErrorCallback with error: " + error.message, "ERROR")
 					this.onErrorCallback(error) // Call our own error callback
 				}
 			} else if (value && (Array.isArray(value) || (typeof value === "object" && "replacements" in value))) {
 				// This might be the 'replacements' array itself or the root object.
 				// The `paths: ['$.replacements.*']` should mean we only get items.
 				// If we get here, it's likely the root object if paths wasn't specific enough or if it's an empty replacements array.
-				console.log("Streaming parser emitted container:", value)
+				this.log("Streaming parser emitted container: " + JSON.stringify(value))
+				this.log(
+					"Container type - isArray: " +
+						Array.isArray(value) +
+						", hasReplacements: " +
+						(typeof value === "object" && "replacements" in value),
+				)
 			} else {
 				// Value is not a ReplacementItem or a known container, could be an issue with the JSON structure or path.
 				// If `paths` is correct, this path should ideally not be hit often for valid streams.
-				console.warn("Streaming parser emitted unexpected value:", value)
+				this.log("Streaming parser emitted unexpected value: " + JSON.stringify(value), "WARN")
+				this.log("Unexpected value type: " + typeof value, "WARN")
+				this.log("Has old_string: " + (value && typeof value === "object" && "old_string" in value), "WARN")
+				this.log("Has new_string: " + (value && typeof value === "object" && "new_string" in value), "WARN")
 			}
 		}
 
 		this.parser.onError = (err: Error) => {
+			this.log("Parser onError callback triggered", "ERROR")
+			this.log("Error details: " + JSON.stringify(err), "ERROR")
+			this.log("Error message: " + err.message, "ERROR")
+			this.log("Error stack: " + err.stack, "ERROR")
+
 			// Propagate the error to the caller via the callback
+			this.log("Calling onErrorCallback with parser error", "ERROR")
 			this.onErrorCallback(err)
 			// Note: The @streamparser/json library might throw synchronously on write if onError is not set,
 			// or if it re-throws. We'll ensure Task.ts wraps write/end in try-catch.
 		}
+
+		this.log("Constructor completed - parser setup finished")
+
+		// Log to console where the debug file is located
+		console.log(`[StreamingJsonReplacer] Debug logging to file: ${this.logFilePath}`)
 	}
 
 	public write(jsonChunk: string): void {
-		// Errors during write will be caught by the parser's onError or thrown.
-		this.parser.write(jsonChunk)
+		this.log("write() called")
+		this.log("JSON chunk length: " + jsonChunk.length)
+		this.log("JSON chunk preview: " + jsonChunk.substring(0, 200) + (jsonChunk.length > 200 ? "..." : ""))
+
+		try {
+			// Errors during write will be caught by the parser's onError or thrown.
+			this.log("Calling parser.write()")
+			this.parser.write(jsonChunk)
+			this.log("parser.write() completed successfully")
+		} catch (error) {
+			this.log("Exception during parser.write(): " + error, "ERROR")
+			throw error
+		}
 	}
 
 	public getCurrentContent(): string {
+		this.log("getCurrentContent() called")
+		this.log("Current content length: " + this.currentFileContent.length)
 		return this.currentFileContent
 	}
 
 	public getSuccessfullyParsedItems(): ReplacementItem[] {
+		this.log("getSuccessfullyParsedItems() called")
+		this.log("Returning copy of " + this.successfullyParsedItems.length + " items")
 		return [...this.successfullyParsedItems] // Return a copy
 	}
 
 	private calculateChangeLocation(oldStr: string, newStr: string): ChangeLocation {
+		this.log("calculateChangeLocation() called")
+		this.log("oldStr length: " + oldStr.length)
+		this.log("newStr length: " + newStr.length)
+		this.log("oldStr preview: " + oldStr.substring(0, 50) + (oldStr.length > 50 ? "..." : ""))
+		this.log("newStr preview: " + newStr.substring(0, 50) + (newStr.length > 50 ? "..." : ""))
+
 		// Find the index where the old string starts
 		const startIndex = this.currentFileContent.indexOf(oldStr)
+		this.log("startIndex found: " + startIndex)
+
 		if (startIndex === -1) {
+			this.log("startIndex is -1 - old string not found in content!", "WARN")
+			this.log("This shouldn't happen since we already checked includes()", "WARN")
 			// This shouldn't happen since we already checked includes(), but just in case
 			return { startLine: 0, endLine: 0, startChar: 0, endChar: 0 }
 		}
 
 		// Calculate line numbers by counting newlines before the start index
 		const contentBeforeStart = this.currentFileContent.substring(0, startIndex)
+		this.log("contentBeforeStart length: " + contentBeforeStart.length)
+
 		const startLine = (contentBeforeStart.match(/\n/g) || []).length
+		this.log("calculated startLine: " + startLine)
 
 		// Calculate the end index after replacement
 		const endIndex = startIndex + oldStr.length
+		this.log("calculated endIndex: " + endIndex)
+
 		const contentBeforeEnd = this.currentFileContent.substring(0, endIndex)
+		this.log("contentBeforeEnd length: " + contentBeforeEnd.length)
+
 		const endLine = (contentBeforeEnd.match(/\n/g) || []).length
+		this.log("calculated endLine: " + endLine)
 
 		// Calculate character positions within their respective lines
 		const lastNewlineBeforeStart = contentBeforeStart.lastIndexOf("\n")
+		this.log("lastNewlineBeforeStart: " + lastNewlineBeforeStart)
+
 		const startChar = lastNewlineBeforeStart === -1 ? startIndex : startIndex - lastNewlineBeforeStart - 1
+		this.log("calculated startChar: " + startChar)
 
 		const lastNewlineBeforeEnd = contentBeforeEnd.lastIndexOf("\n")
+		this.log("lastNewlineBeforeEnd: " + lastNewlineBeforeEnd)
+
 		const endChar = lastNewlineBeforeEnd === -1 ? endIndex : endIndex - lastNewlineBeforeEnd - 1
+		this.log("calculated endChar: " + endChar)
 
-		return {
+		const result = {
 			startLine,
 			endLine,
 			startChar,
 			endChar,
 		}
+
+		this.log("calculateChangeLocation() returning: " + JSON.stringify(result))
+		return result
+	}
+
+	private log(message: string, level: "INFO" | "WARN" | "ERROR" = "INFO"): void {
+		const timestamp = new Date().toISOString()
+		const logLine = `[${timestamp}] [${level}] ${message}\n`
+
+		try {
+			fs.appendFileSync(this.logFilePath, logLine)
+		} catch (error) {
+			// Fallback to console if file logging fails
+			console.error("Failed to write to log file:", error)
+			console.log(`[${level}] ${message}`)
+		}
 	}
 }

src/core/assistant-message/index.ts

@@ -1,6 +1,6 @@
 export type AssistantMessageContent = TextContent | ToolUse
 
-export { parseAssistantMessageV1, parseAssistantMessageV2 } from "./parse-assistant-message"
+export { parseAssistantMessageV1, parseAssistantMessageV2, parseAssistantMessageV3 } from "./parse-assistant-message"
 
 export interface TextContent {
 	type: "text"

src/core/assistant-message/parse-assistant-message.ts

@@ -539,6 +539,7 @@ export function parseAssistantMessageV3(assistantMessage: string): AssistantMess
 		if (
 			inFunctionCalls &&
 			currentInvokeName === "" &&
+			!currentToolUse && // Don't create a new tool if we already have one
 			currentCharIndex >= isInvokeStart.length - 1 &&
 			assistantMessage.startsWith(isInvokeStart, currentCharIndex - isInvokeStart.length + 1)
 		) {
@@ -686,6 +687,16 @@ export function parseAssistantMessageV3(assistantMessage: string): AssistantMess
 					}
 				}
 
+				// If this is a MultiEdit invoke, create a replace_in_file tool
+				if (currentInvokeName === "MultiEdit") {
+					currentToolUse = {
+						type: "tool_use",
+						name: "replace_in_file",
+						params: {},
+						partial: true,
+					}
+				}
+
 				continue
 			}
 		}
@@ -821,6 +832,16 @@ export function parseAssistantMessageV3(assistantMessage: string): AssistantMess
 				}
 			}
 
+			// Map parameter to tool params for MultiEdit
+			if (currentToolUse && currentInvokeName === "MultiEdit") {
+				if (currentParameterName === "file_path") {
+					currentToolUse.params["path"] = value
+				} else if (currentParameterName === "edits") {
+					// Save the value to the diff parameter for replace_in_file
+					currentToolUse.params["diff"] = value
+				}
+			}
+
 			currentParameterName = ""
 			continue
 		}
@@ -849,13 +870,13 @@ export function parseAssistantMessageV3(assistantMessage: string): AssistantMess
 					currentInvokeName === "LoadMcpDocumentation" ||
 					currentInvokeName === "AttemptCompletion" ||
 					currentInvokeName === "BrowserAction" ||
-					currentInvokeName === "NewTask")
+					currentInvokeName === "NewTask" ||
+					currentInvokeName === "MultiEdit")
 			) {
 				currentToolUse.partial = false
 				contentBlocks.push(currentToolUse)
 				currentToolUse = undefined
 			}
-
 			currentInvokeName = ""
 			continue
 		}
@@ -868,6 +889,12 @@ export function parseAssistantMessageV3(assistantMessage: string): AssistantMess
 		) {
 			inFunctionCalls = false
 			currentTextContentStart = currentCharIndex + 1
+			// Start a new text content block for any text after function_calls
+			currentTextContent = {
+				type: "text",
+				content: "",
+				partial: true,
+			}
 			continue
 		}