feat(grep): truncate search results to 2000 characters #453

Limit grep tool output to 2000 characters and indicate when results are truncated to prevent excessively long responses.

Author: phodal

mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/tool/impl/GrepTool.kt

@@ -18,37 +18,37 @@ data class GrepParams(
      * The regular expression pattern to search for in file contents
      */
     val pattern: String,
-    
+
     /**
      * The directory to search in (optional, defaults to project root)
      */
     val path: String? = null,
-    
+
     /**
      * File pattern to include in the search (e.g. "*.kt", "*.{ts,js}")
      */
     val include: String? = null,
-    
+
     /**
      * File pattern to exclude from the search
      */
     val exclude: String? = null,
-    
+
     /**
      * Whether the search should be case-sensitive
      */
     val caseSensitive: Boolean = false,
-    
+
     /**
      * Maximum number of matches to return
      */
     val maxMatches: Int = 100,
-    
+
     /**
      * Number of context lines to show before and after each match
      */
     val contextLines: Int = 0,
-    
+
     /**
      * Whether to search recursively in subdirectories
      */
@@ -133,29 +133,27 @@ class GrepInvocation(
     tool: GrepTool,
     private val fileSystem: ToolFileSystem
 ) : BaseToolInvocation<GrepParams, ToolResult>(params, tool) {
-    
+
     override fun getDescription(): String {
         val searchPath = params.path ?: "project root"
         val includeDesc = params.include?.let { " (include: $it)" } ?: ""
         val excludeDesc = params.exclude?.let { " (exclude: $it)" } ?: ""
         return "Search for pattern '${params.pattern}' in $searchPath$includeDesc$excludeDesc"
     }
-    
+
     override fun getToolLocations(): List<ToolLocation> {
         val searchPath = params.path ?: fileSystem.getProjectPath() ?: "."
         return listOf(ToolLocation(searchPath, LocationType.DIRECTORY))
     }
-    
+
     override suspend fun execute(context: ToolExecutionContext): ToolResult {
         return ToolErrorUtils.safeExecute(ToolErrorType.INVALID_PATTERN) {
             val searchPath = params.path ?: fileSystem.getProjectPath() ?: "."
-            
-            // Validate search path exists
+
             if (!fileSystem.exists(searchPath)) {
                 throw ToolException("Search path not found: $searchPath", ToolErrorType.DIRECTORY_NOT_FOUND)
             }
-            
-            // Create regex pattern
+
             val regex = try {
                 if (params.caseSensitive) {
                     Regex(params.pattern)
@@ -165,25 +163,23 @@ class GrepInvocation(
             } catch (e: Exception) {
                 throw ToolException("Invalid regex pattern: ${params.pattern}", ToolErrorType.INVALID_PATTERN)
             }
-            
-            // Find files to search
+
             val filesToSearch = findFilesToSearch(searchPath)
-            
-            // Search for matches
+
             val matches = mutableListOf<GrepMatch>()
             var totalMatches = 0
-            
+
             for (file in filesToSearch) {
                 if (totalMatches >= params.maxMatches) break
-                
+
                 val fileMatches = searchInFile(file, regex)
                 matches.addAll(fileMatches.take(params.maxMatches - totalMatches))
                 totalMatches += fileMatches.size
             }
-            
+
             // Format results
             val resultText = formatResults(matches, filesToSearch.size)
-            
+
             val metadata = mapOf(
                 "pattern" to params.pattern,
                 "search_path" to searchPath,
@@ -194,66 +190,66 @@ class GrepInvocation(
                 "include_pattern" to (params.include ?: ""),
                 "exclude_pattern" to (params.exclude ?: "")
             )
-            
+
             ToolResult.Success(resultText, metadata)
         }
     }
-    
+
     private fun findFilesToSearch(searchPath: String): List<String> {
         val files = mutableListOf<String>()
-        
+
         fun collectFiles(path: String) {
             val pathFiles = fileSystem.listFiles(path)
-            
+
             for (file in pathFiles) {
                 val fileInfo = fileSystem.getFileInfo(file)
-                
+
                 if (fileInfo?.isDirectory == true && params.recursive) {
                     collectFiles(file)
                 } else if (fileInfo?.isDirectory == false) {
                     // Check include/exclude patterns
                     val fileName = file.substringAfterLast('/')
-                    
+
                     val shouldInclude = params.include?.let { pattern ->
                         matchesGlobPattern(fileName, pattern)
                     } ?: true
-                    
+
                     val shouldExclude = params.exclude?.let { pattern ->
                         matchesGlobPattern(fileName, pattern)
                     } ?: false
-                    
+
                     if (shouldInclude && !shouldExclude) {
                         files.add(file)
                     }
                 }
             }
         }
-        
+
         collectFiles(searchPath)
         return files.sorted()
     }
-    
+
     private suspend fun searchInFile(filePath: String, regex: Regex): List<GrepMatch> {
         val matches = mutableListOf<GrepMatch>()
-        
+
         try {
             val content = fileSystem.readFile(filePath) ?: return emptyList()
             val lines = content.lines()
-            
+
             lines.forEachIndexed { index, line ->
                 val matchResults = regex.findAll(line)
-                
+
                 for (matchResult in matchResults) {
                     val contextBefore = if (params.contextLines > 0) {
                         val startIndex = (index - params.contextLines).coerceAtLeast(0)
                         lines.subList(startIndex, index)
                     } else emptyList()
-                    
+
                     val contextAfter = if (params.contextLines > 0) {
                         val endIndex = (index + params.contextLines + 1).coerceAtMost(lines.size)
                         lines.subList(index + 1, endIndex)
                     } else emptyList()
-                    
+
                     matches.add(
                         GrepMatch(
                             file = filePath,
@@ -270,54 +266,49 @@ class GrepInvocation(
         } catch (e: Exception) {
             // Skip files that can't be read
         }
-        
+
         return matches
     }
-    
+
     private fun formatResults(matches: List<GrepMatch>, filesSearched: Int): String {
         if (matches.isEmpty()) {
             return "No matches found for pattern '${params.pattern}' in $filesSearched files."
         }
-        
-        val result = StringBuilder()
-        result.appendLine("Found ${matches.size} matches for pattern '${params.pattern}' in $filesSearched files:")
-        result.appendLine()
-        
+
+        val sb = StringBuilder()
+        sb.appendLine("Found ${matches.size} matches for pattern '${params.pattern}' in $filesSearched files:")
+        sb.appendLine()
+
         var currentFile = ""
-        
+        val maxChars = 2000
+
         for (match in matches) {
+            if (sb.length > maxChars) {
+                sb.appendLine()
+                sb.appendLine("... (results truncated to $maxChars characters)")
+                break
+            }
+
             if (match.file != currentFile) {
-                if (currentFile.isNotEmpty()) result.appendLine()
-                result.appendLine("File: ${match.file}")
+                if (currentFile.isNotEmpty()) sb.appendLine()
+                sb.appendLine("### ${match.file}")
                 currentFile = match.file
             }
-            
-            // Show context before
-            match.contextBefore.forEachIndexed { index, contextLine ->
-                val lineNum = match.lineNumber - match.contextBefore.size + index
-                result.appendLine("  $lineNum: $contextLine")
+
+            match.contextBefore.forEach { contextLine ->
+                sb.appendLine(contextLine)
             }
-            
-            // Show the match line with highlighting
-            val line = match.line
-            val beforeMatch = line.substring(0, match.matchStart)
-            val matchText = line.substring(match.matchStart, match.matchEnd)
-            val afterMatch = line.substring(match.matchEnd)
-            
-            result.appendLine("→ ${match.lineNumber}: $beforeMatch**$matchText**$afterMatch")
-            
-            // Show context after
-            match.contextAfter.forEachIndexed { index, contextLine ->
-                val lineNum = match.lineNumber + index + 1
-                result.appendLine("  $lineNum: $contextLine")
+
+            sb.appendLine(match.line)
+
+            match.contextAfter.forEach { contextLine ->
+                sb.appendLine(contextLine)
             }
-            
-            if (params.contextLines > 0) result.appendLine()
         }
-        
-        return result.toString().trim()
+
+        return sb.toString()
     }
-    
+
     private fun matchesGlobPattern(fileName: String, pattern: String): Boolean {
         // Simple glob pattern matching
         val regexPattern = pattern
@@ -327,7 +318,7 @@ class GrepInvocation(
             .replace("{", "(")
             .replace("}", ")")
             .replace(",", "|")
-        
+
         return fileName.matches(Regex(regexPattern))
     }
 }
@@ -338,25 +329,26 @@ class GrepInvocation(
 class GrepTool(
     private val fileSystem: ToolFileSystem
 ) : BaseExecutableTool<GrepParams, ToolResult>() {
-    
+
     override val name: String = "grep"
-    override val description: String = """Searches for a regular expression pattern within the content of files in a specified directory (or current working directory). Can filter files by a glob pattern. Returns the lines containing matches, along with their file paths and line numbers.""".trimIndent()
-    
+    override val description: String =
+        """Searches for a regular expression pattern within the content of files in a specified directory (or current working directory). Can filter files by a glob pattern. Returns the lines containing matches, along with their file paths and line numbers.""".trimIndent()
+
     override val metadata: ToolMetadata = ToolMetadata(
         displayName = "Search Content",
         tuiEmoji = "🔍",
         composeIcon = "search",
         category = ToolCategory.Search,
         schema = GrepSchema
     )
-    
+
     override fun getParameterClass(): String = GrepParams::class.simpleName ?: "GrepParams"
-    
-    override fun createToolInvocation(params: GrepParams): ToolInvocation<GrepParams, ToolResult> {
+
+    public override fun createToolInvocation(params: GrepParams): ToolInvocation<GrepParams, ToolResult> {
         validateParameters(params)
         return GrepInvocation(params, this, fileSystem)
     }
-    
+
     private fun validateParameters(params: GrepParams) {
         if (params.pattern.isBlank()) {
             throw ToolException("Search pattern cannot be empty", ToolErrorType.MISSING_REQUIRED_PARAMETER)