feat(renderer): introduce BaseRenderer class and enhance CodingAgentRenderer interface with new methods #453

Author: phodal

mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/render/BaseRenderer.kt

@@ -0,0 +1,107 @@
+package cc.unitmesh.agent.render
+
+/**
+ * Base abstract renderer providing common functionality
+ * All specific renderer implementations should extend this class
+ */
+abstract class BaseRenderer : CodingAgentRenderer {
+    protected val reasoningBuffer = StringBuilder()
+    protected var isInDevinBlock = false
+    protected var lastIterationReasoning = ""
+    protected var consecutiveRepeats = 0
+    
+    /**
+     * Common devin block filtering logic
+     */
+    protected fun filterDevinBlocks(content: String): String {
+        var filtered = content
+        
+        // Remove complete devin blocks
+        filtered = filtered.replace(Regex("<devin[^>]*>[\\s\\S]*?</devin>"), "")
+        
+        // Handle incomplete devin blocks at the end
+        val openDevinIndex = filtered.lastIndexOf("<devin")
+        if (openDevinIndex != -1) {
+            val closeDevinIndex = filtered.indexOf("</devin>", openDevinIndex)
+            if (closeDevinIndex == -1) {
+                // Incomplete devin block, remove it
+                filtered = filtered.substring(0, openDevinIndex)
+            }
+        }
+        
+        // Remove partial devin tags
+        filtered = filtered.replace(Regex("<de(?:v(?:i(?:n)?)?)?$|<$"), "")
+        
+        return filtered
+    }
+    
+    /**
+     * Check for incomplete devin blocks
+     */
+    protected fun hasIncompleteDevinBlock(content: String): Boolean {
+        val lastOpenDevin = content.lastIndexOf("<devin")
+        val lastCloseDevin = content.lastIndexOf("</devin>")
+        
+        // Check for partial opening tags
+        val partialDevinPattern = Regex("<de(?:v(?:i(?:n)?)?)?$|<$")
+        val hasPartialTag = partialDevinPattern.containsMatchIn(content)
+        
+        return lastOpenDevin > lastCloseDevin || hasPartialTag
+    }
+    
+    /**
+     * Calculate similarity between two strings for repeat detection
+     */
+    protected fun calculateSimilarity(str1: String, str2: String): Double {
+        if (str1.isEmpty() || str2.isEmpty()) return 0.0
+        
+        val words1 = str1.lowercase().split(Regex("\\s+"))
+        val words2 = str2.lowercase().split(Regex("\\s+"))
+        
+        val commonWords = words1.intersect(words2.toSet())
+        val totalWords = maxOf(words1.size, words2.size)
+        
+        return if (totalWords > 0) commonWords.size.toDouble() / totalWords else 0.0
+    }
+    
+    /**
+     * Clean up excessive newlines in content
+     */
+    protected fun cleanNewlines(content: String): String {
+        return content.replace(Regex("\n{3,}"), "\n\n")
+    }
+    
+    /**
+     * Default implementation for LLM response start
+     */
+    override fun renderLLMResponseStart() {
+        reasoningBuffer.clear()
+        isInDevinBlock = false
+    }
+    
+    /**
+     * Default implementation for LLM response end with similarity checking
+     */
+    override fun renderLLMResponseEnd() {
+        val currentReasoning = reasoningBuffer.toString().trim()
+        val similarity = calculateSimilarity(currentReasoning, lastIterationReasoning)
+        
+        if (similarity > 0.8 && lastIterationReasoning.isNotEmpty()) {
+            consecutiveRepeats++
+            if (consecutiveRepeats >= 2) {
+                renderRepeatAnalysisWarning()
+            }
+        } else {
+            consecutiveRepeats = 0
+        }
+        
+        lastIterationReasoning = currentReasoning
+    }
+    
+    /**
+     * Render warning for repetitive analysis - can be overridden by subclasses
+     */
+    protected open fun renderRepeatAnalysisWarning() {
+        renderError("Agent appears to be repeating similar analysis...")
+    }
+}

mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/render/CodingAgentRenderer.kt

@@ -1,18 +1,33 @@
 package cc.unitmesh.agent.render
 
 /**
- * Output renderer interface for CodingAgent
- * Allows customization of output formatting (e.g., CLI vs TUI)
+ * Core renderer interface for CodingAgent
+ * Defines the contract for all renderer implementations
  */
 interface CodingAgentRenderer {
+    // Lifecycle methods
     fun renderIterationHeader(current: Int, max: Int)
     fun renderLLMResponseStart()
     fun renderLLMResponseChunk(chunk: String)
     fun renderLLMResponseEnd()
+
+    // Tool execution methods
     fun renderToolCall(toolName: String, paramsStr: String)
     fun renderToolResult(toolName: String, success: Boolean, output: String?, fullOutput: String?)
+
+    // Status and completion methods
     fun renderTaskComplete()
     fun renderFinalResult(success: Boolean, message: String, iterations: Int)
     fun renderError(message: String)
     fun renderRepeatWarning(toolName: String, count: Int)
+}
+
+/**
+ * Renderer type enumeration for different UI implementations
+ */
+enum class RendererType {
+    CONSOLE,    // Default console output
+    CLI,        // Enhanced CLI with colors and formatting
+    TUI,        // Terminal UI with interactive elements
+    WEB         // Web-based UI
 }

mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/render/DefaultCodingAgentRenderer.kt

@@ -1,42 +1,38 @@
 package cc.unitmesh.agent.render
 
 /**
- * Default console renderer
+ * Default console renderer - simple text output
+ * Suitable for basic console applications and testing
  */
-class DefaultCodingAgentRenderer : CodingAgentRenderer {
-    private val reasoningBuffer = StringBuilder()
-    private var isInDevinBlock = false
+class DefaultCodingAgentRenderer : BaseRenderer() {
 
     override fun renderIterationHeader(current: Int, max: Int) {
         println("\n[$current/$max] Analyzing and executing...")
     }
 
     override fun renderLLMResponseStart() {
-        reasoningBuffer.clear()
-        isInDevinBlock = false
+        super.renderLLMResponseStart()
         print("💭 ")
     }
 
     override fun renderLLMResponseChunk(chunk: String) {
-        // Parse chunk to detect devin blocks
         reasoningBuffer.append(chunk)
-        val text = reasoningBuffer.toString()
 
-        // Check if we're entering or leaving a devin block
-        if (text.contains("<devin>")) {
-            isInDevinBlock = true
-        }
-        if (text.contains("</devin>")) {
-            isInDevinBlock = false
+        // Wait for more content if we detect an incomplete devin block
+        if (hasIncompleteDevinBlock(reasoningBuffer.toString())) {
+            return
         }
 
-        // Only print if not in devin block
-        if (!isInDevinBlock && !chunk.contains("<devin>") && !chunk.contains("</devin>")) {
-            print(chunk)
-        }
+        // Filter devin blocks and output clean content
+        val processedContent = filterDevinBlocks(reasoningBuffer.toString())
+        val cleanContent = cleanNewlines(processedContent)
+
+        // Simple output for default renderer
+        print(cleanContent)
     }
 
     override fun renderLLMResponseEnd() {
+        super.renderLLMResponseEnd()
         println("\n")
     }
 

mpp-core/src/jsMain/kotlin/cc/unitmesh/agent/RendererExports.kt

@@ -1,26 +1,53 @@
 package cc.unitmesh.agent
 
 import cc.unitmesh.agent.render.CodingAgentRenderer
+import cc.unitmesh.agent.render.RendererType
 import kotlin.js.JsExport
 
 /**
  * JS-friendly renderer interface
  * Allows TypeScript to provide custom rendering implementations
+ * This interface mirrors the Kotlin CodingAgentRenderer interface
  */
 @JsExport
 interface JsCodingAgentRenderer {
+    // Lifecycle methods
     fun renderIterationHeader(current: Int, max: Int)
     fun renderLLMResponseStart()
     fun renderLLMResponseChunk(chunk: String)
     fun renderLLMResponseEnd()
+
+    // Tool execution methods
     fun renderToolCall(toolName: String, paramsStr: String)
     fun renderToolResult(toolName: String, success: Boolean, output: String?, fullOutput: String?)
+
+    // Status and completion methods
     fun renderTaskComplete()
     fun renderFinalResult(success: Boolean, message: String, iterations: Int)
     fun renderError(message: String)
     fun renderRepeatWarning(toolName: String, count: Int)
 }
 
+/**
+ * Renderer factory for creating different types of renderers
+ */
+@JsExport
+object RendererFactory {
+    /**
+     * Create a renderer adapter from JS implementation
+     */
+    fun createRenderer(jsRenderer: JsCodingAgentRenderer): CodingAgentRenderer {
+        return JsRendererAdapter(jsRenderer)
+    }
+
+    /**
+     * Get renderer type information for JS consumers
+     */
+    fun getRendererTypes(): Array<String> {
+        return RendererType.values().map { it.name }.toTypedArray()
+    }
+}
+
 /**
  * Adapter to convert JS renderer to Kotlin renderer
  */