test(write-file): add unit and integration tests for WriteFileTool #453

Add comprehensive tests for WriteFileTool, including handling of multiline and special character content. Improve ToolCallParser to better parse parameters and extract content. Allow blank file content in ToolOrchestrator. Fix escape sequence processing order.

Author: phodal

mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/orchestrator/ToolOrchestrator.kt

@@ -235,13 +235,16 @@ class ToolOrchestrator(
             return ToolResult.Error("File path cannot be empty")
         }
 
-        if (content.isNullOrBlank()) {
-            return ToolResult.Error("File content cannot be empty. Please provide the content parameter with the file content to write. Example: /write-file path=\"$path\" content=\"your content here\"")
+        if (content == null) {
+            return ToolResult.Error("File content parameter is missing. Please provide the content parameter with the file content to write. Example: /write-file path=\"$path\" content=\"your content here\"")
         }
 
+        // Allow empty content (blank files are valid)
+        val actualContent = content
+
         val writeFileParams = cc.unitmesh.agent.tool.impl.WriteFileParams(
             path = path,
-            content = content,
+            content = actualContent,
             createDirectories = params["createDirectories"] as? Boolean ?: true,
             overwrite = params["overwrite"] as? Boolean ?: true,
             append = params["append"] as? Boolean ?: false

mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/parser/EscapeSequenceProcessor.kt

@@ -8,15 +8,25 @@ object EscapeSequenceProcessor {
 
     /**
      * Process escape sequences in a string
+     * Order matters: process \\\\ first to avoid double processing
      */
     fun processEscapeSequences(content: String): String {
-        return content
-            .replace("\\n", "\n")
-            .replace("\\r", "\r")
-            .replace("\\t", "\t")
-            .replace("\\\"", "\"")
-            .replace("\\'", "'")
-            .replace("\\\\", "\\")
+        var result = content
+
+        // Process double backslash first to avoid conflicts
+        result = result.replace("\\\\", "\u0001") // Temporary placeholder
+
+        // Process other escape sequences
+        result = result.replace("\\n", "\n")
+        result = result.replace("\\r", "\r")
+        result = result.replace("\\t", "\t")
+        result = result.replace("\\\"", "\"")
+        result = result.replace("\\'", "'")
+
+        // Restore single backslashes
+        result = result.replace("\u0001", "\\")
+
+        return result
     }
 
     /**

mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/parser/ToolCallParser.kt

@@ -96,42 +96,69 @@ class ToolCallParser {
     }
 
     private fun parseKeyValueParameters(rest: String, params: MutableMap<String, Any>) {
+        // Use regex-based parsing for better handling of complex content
+        val paramPattern = Regex("""(\w+)="([^"\\]*(?:\\.[^"\\]*)*)"(?:\s|$)""")
+        val matches = paramPattern.findAll(rest)
+
+        for (match in matches) {
+            val key = match.groupValues[1]
+            val value = match.groupValues[2]
+            params[key] = escapeProcessor.processEscapeSequences(value)
+        }
+
+        // Fallback to character-by-character parsing for edge cases
+        if (params.isEmpty()) {
+            parseKeyValueParametersCharByChar(rest, params)
+        }
+    }
+
+    private fun parseKeyValueParametersCharByChar(rest: String, params: MutableMap<String, Any>) {
         val remaining = rest.toCharArray().toList()
         var i = 0
-        
+
         while (i < remaining.size) {
+            // Skip whitespace
+            while (i < remaining.size && remaining[i].isWhitespace()) i++
+            if (i >= remaining.size) break
+
             // Find key
             val keyStart = i
             while (i < remaining.size && remaining[i] != '=') i++
             if (i >= remaining.size) break
-            
+
             val key = remaining.subList(keyStart, i).joinToString("").trim()
             i++ // skip '='
-            
+
+            // Skip whitespace after =
+            while (i < remaining.size && remaining[i].isWhitespace()) i++
             if (i >= remaining.size || remaining[i] != '"') {
                 i++
                 continue
             }
-            
+
             i++ // skip opening quote
             val valueStart = i
-            
-            // Find closing quote (handle escaped quotes)
+
+            // Find closing quote (handle escaped quotes and newlines)
             var escaped = false
+            var depth = 0
             while (i < remaining.size) {
                 when {
                     escaped -> escaped = false
                     remaining[i] == '\\' -> escaped = true
-                    remaining[i] == '"' -> break
+                    remaining[i] == '"' -> {
+                        // Check if this is really the end quote
+                        if (depth == 0) break
+                    }
                 }
                 i++
             }
-            
+
             if (i > valueStart && key.isNotEmpty()) {
                 val value = remaining.subList(valueStart, i).joinToString("")
                 params[key] = escapeProcessor.processEscapeSequences(value)
             }
-            
+
             i++ // skip closing quote
         }
     }
@@ -168,30 +195,38 @@ class ToolCallParser {
      * This looks for code blocks or content that appears to be intended for the file
      */
     private fun extractContentFromContext(llmResponse: String, devinBlock: DevinBlock): String? {
+        // First, try to extract content from within the devin block itself
+        val blockContent = devinBlock.content
+        val lines = blockContent.lines()
+        val toolCallLineIndex = lines.indexOfFirst { it.trim().startsWith("/write-file") }
+
+        if (toolCallLineIndex >= 0) {
+            // Check if the write-file command already has content parameter
+            val toolCallLine = lines[toolCallLineIndex].trim()
+            val contentMatch = Regex("""content="([^"\\]*(?:\\.[^"\\]*)*)"(?:\s|$)""").find(toolCallLine)
+            if (contentMatch != null) {
+                // Content is already in the command line, don't override it
+                return null
+            }
+
+            // Look for content after the tool call line within the same devin block
+            if (toolCallLineIndex < lines.size - 1) {
+                val contentLines = lines.subList(toolCallLineIndex + 1, lines.size)
+                val content = contentLines.joinToString("\n").trim()
+                if (content.isNotEmpty()) {
+                    return content
+                }
+            }
+        }
+
         // Look for code blocks after the devin block
         val afterBlock = llmResponse.substring(devinBlock.endOffset)
-
-        // Try to find code blocks with ```
         val codeBlockRegex = Regex("```(?:\\w+)?\\s*\\n([\\s\\S]*?)\\n```", RegexOption.MULTILINE)
         val codeMatch = codeBlockRegex.find(afterBlock)
         if (codeMatch != null) {
             return codeMatch.groupValues[1].trim()
         }
 
-        // Look for content in the same devin block after the tool call
-        val blockContent = devinBlock.content
-        val lines = blockContent.lines()
-        val toolCallLineIndex = lines.indexOfFirst { it.trim().startsWith("/write-file") }
-
-        if (toolCallLineIndex >= 0 && toolCallLineIndex < lines.size - 1) {
-            // Get content after the tool call line
-            val contentLines = lines.subList(toolCallLineIndex + 1, lines.size)
-            val content = contentLines.joinToString("\n").trim()
-            if (content.isNotEmpty()) {
-                return content
-            }
-        }
-
         // Look for content in the LLM response before the devin block
         val beforeBlock = llmResponse.substring(0, devinBlock.startOffset)
         val beforeCodeMatch = codeBlockRegex.find(beforeBlock)

mpp-core/src/commonTest/kotlin/cc/unitmesh/agent/tool/ToolTypeTest.kt

@@ -35,9 +35,7 @@ class ToolTypeTest {
         assertTrue(fileSystemTools.contains(ToolType.ReadFile))
         assertTrue(fileSystemTools.contains(ToolType.WriteFile))
         assertTrue(fileSystemTools.contains(ToolType.ListFiles))
-        assertTrue(fileSystemTools.contains(ToolType.EditFile))
-        assertTrue(fileSystemTools.contains(ToolType.PatchFile))
-        
+
         val executionTools = ToolType.byCategory(ToolCategory.Execution)
         assertTrue(executionTools.contains(ToolType.Shell))