Merge pull request #1 from phodal/feat/idea-agent-toolwindow

feat(mpp-idea): add Agent ToolWindow with tab-based navigation

Author: phodal

mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/subagent/DomainDictAgent.kt

@@ -46,7 +46,7 @@ class KoogLLMService(
     private var hasFailedCompressionAttempt = false
 
     fun streamPrompt(
-        userPrompt: String, 
+        userPrompt: String,
         fileSystem: ProjectFileSystem = EmptyFileSystem(),
         historyMessages: List<Message> = emptyList(),
         compileDevIns: Boolean = true,
@@ -58,37 +58,61 @@ class KoogLLMService(
         } else {
             userPrompt
         }
-        
+
+        val promptLength = finalPrompt.length
+        logger.info { "🚀 [LLM] Starting stream request - prompt length: $promptLength chars, model: ${config.modelName}" }
+        val startTime = Clock.System.now().toEpochMilliseconds()
+
         val prompt = buildPrompt(finalPrompt, historyMessages)
-        executor.executeStreaming(prompt, model)
-            .cancellable()
-            .collect { frame ->
-                when (frame) {
-                    is StreamFrame.Append -> emit(frame.text)
-                    is StreamFrame.End -> {
-                        logger.debug { "StreamFrame.End -> finishReason=${frame.finishReason}, metaInfo=${frame.metaInfo}" }
-                        frame.metaInfo?.let { metaInfo ->
-                            lastTokenInfo = TokenInfo(
-                                totalTokens = metaInfo.totalTokensCount ?: 0,
-                                inputTokens = metaInfo.inputTokensCount ?: 0,
-                                outputTokens = metaInfo.outputTokensCount ?: 0,
-                                timestamp = Clock.System.now().toEpochMilliseconds()
-                            )
-                            
-                            onTokenUpdate?.invoke(lastTokenInfo)
-                            if (compressionConfig.autoCompressionEnabled) {
-                                val maxTokens = getMaxTokens()
-                                if (lastTokenInfo.needsCompression(maxTokens, compressionConfig.contextPercentageThreshold)) {
-                                    onCompressionNeeded?.invoke(lastTokenInfo.inputTokens, maxTokens)
+        var chunkCount = 0
+        var totalChars = 0
+
+        try {
+            executor.executeStreaming(prompt, model)
+                .cancellable()
+                .collect { frame ->
+                    when (frame) {
+                        is StreamFrame.Append -> {
+                            chunkCount++
+                            totalChars += frame.text.length
+                            if (chunkCount == 1) {
+                                val ttfb = Clock.System.now().toEpochMilliseconds() - startTime
+                                logger.info { "📥 [LLM] First chunk received - TTFB: ${ttfb}ms" }
+                            }
+                            emit(frame.text)
+                        }
+                        is StreamFrame.End -> {
+                            val elapsed = Clock.System.now().toEpochMilliseconds() - startTime
+                            logger.info { "✅ [LLM] Stream completed - chunks: $chunkCount, chars: $totalChars, time: ${elapsed}ms" }
+                            logger.debug { "StreamFrame.End -> finishReason=${frame.finishReason}, metaInfo=${frame.metaInfo}" }
+                            frame.metaInfo?.let { metaInfo ->
+                                lastTokenInfo = TokenInfo(
+                                    totalTokens = metaInfo.totalTokensCount ?: 0,
+                                    inputTokens = metaInfo.inputTokensCount ?: 0,
+                                    outputTokens = metaInfo.outputTokensCount ?: 0,
+                                    timestamp = Clock.System.now().toEpochMilliseconds()
+                                )
+                                logger.info { "📊 [LLM] Token usage - input: ${lastTokenInfo.inputTokens}, output: ${lastTokenInfo.outputTokens}, total: ${lastTokenInfo.totalTokens}" }
+
+                                onTokenUpdate?.invoke(lastTokenInfo)
+                                if (compressionConfig.autoCompressionEnabled) {
+                                    val maxTokens = getMaxTokens()
+                                    if (lastTokenInfo.needsCompression(maxTokens, compressionConfig.contextPercentageThreshold)) {
+                                        onCompressionNeeded?.invoke(lastTokenInfo.inputTokens, maxTokens)
+                                    }
                                 }
                             }
+
+                            messagesSinceLastCompression++
                         }
-                        
-                        messagesSinceLastCompression++
+                        is StreamFrame.ToolCall -> { /* Tool calls (可以后续扩展) */ }
                     }
-                    is StreamFrame.ToolCall -> { /* Tool calls (可以后续扩展) */ }
                 }
-            }
+        } catch (e: Exception) {
+            val elapsed = Clock.System.now().toEpochMilliseconds() - startTime
+            logger.error { "❌ [LLM] Stream error after ${elapsed}ms - chunks: $chunkCount, error: ${e.message}" }
+            throw e
+        }
     }
 
     suspend fun sendPrompt(prompt: String): String {

mpp-core/src/commonMain/kotlin/cc/unitmesh/llm/KoogLLMService.kt

@@ -2,11 +2,10 @@ package cc.unitmesh.agent.subagent
 
 import kotlin.test.Test
 import kotlin.test.assertEquals
-import kotlin.test.assertNotNull
 import kotlin.test.assertTrue
 
 /**
- * Test for DomainDictAgent data classes and Deep Research flow
+ * Test for DomainDictAgent data classes
  */
 class DomainDictAgentTest {
 
@@ -32,7 +31,7 @@ class DomainDictAgentTest {
         )
 
         assertEquals("Simple query", context.userQuery)
-        assertEquals(7, context.maxIterations) // New default value for Deep Research
+        assertEquals(1, context.maxIterations) // Default value is 1
         assertEquals(null, context.focusArea)
         assertEquals(null, context.currentDict)
     }
@@ -78,251 +77,13 @@ class DomainDictAgentTest {
         assertTrue(csvRow.contains("Gateway | API | GatewayService"))
     }
 
-    // ============= Deep Research Step 1: Problem Definition Tests =============
-
-    @Test
-    fun testProblemDefinitionCreation() {
-        val problemDef = ProblemDefinition(
-            goal = "Optimize domain dictionary for authentication module",
-            scope = "Authentication and authorization related code",
-            depth = "Comprehensive analysis",
-            deliverableFormat = "CSV",
-            constraints = listOf("Focus on security terms", "Exclude test files")
-        )
-
-        assertEquals("Optimize domain dictionary for authentication module", problemDef.goal)
-        assertEquals(2, problemDef.constraints.size)
-    }
-
-    // ============= Deep Research Step 2: Research Dimensions Tests =============
-
-    @Test
-    fun testResearchDimensionCreation() {
-        val dimension = ResearchDimension(
-            name = "Core Domain",
-            description = "Main business logic entities",
-            priority = 5,
-            queries = listOf("*Service*.kt", "*Repository*.kt")
-        )
-
-        assertEquals("Core Domain", dimension.name)
-        assertEquals(5, dimension.priority)
-        assertEquals(2, dimension.queries.size)
-    }
-
-    @Test
-    fun testResearchDimensionPriority() {
-        val dimensions = listOf(
-            ResearchDimension("Core", "Core domain", 5),
-            ResearchDimension("Infra", "Infrastructure", 3),
-            ResearchDimension("API", "API layer", 4)
-        )
-
-        val sorted = dimensions.sortedByDescending { it.priority }
-        assertEquals("Core", sorted[0].name)
-        assertEquals("API", sorted[1].name)
-        assertEquals("Infra", sorted[2].name)
-    }
-
-    // ============= Deep Research Step 3: Information Plan Tests =============
-
-    @Test
-    fun testInformationPlanCreation() {
-        val plan = InformationPlan(
-            searchPaths = listOf("src/main", "src/commonMain"),
-            filePatterns = listOf("*Agent*.kt", "*Service*.kt"),
-            knowledgeSources = listOf("source code", "README"),
-            analysisStrategies = listOf("class analysis", "function analysis")
-        )
-
-        assertEquals(2, plan.searchPaths.size)
-        assertEquals(2, plan.filePatterns.size)
-        assertEquals(2, plan.analysisStrategies.size)
-    }
-
-    // ============= Deep Research Step 4: Dimension Result Tests =============
-
-    @Test
-    fun testDimensionResearchResult() {
-        val result = DimensionResearchResult(
-            dimension = "Core Domain",
-            collected = listOf("class:UserService", "fun:authenticate"),
-            organized = mapOf(
-                "classes" to listOf("UserService", "AuthService"),
-                "functions" to listOf("authenticate", "authorize")
-            ),
-            validated = true,
-            conflicts = emptyList(),
-            conclusion = "Found 2 classes and 2 functions",
-            newEntries = listOf(
-                DomainEntry("Auth", "AuthService", "Authentication service")
-            )
-        )
-
-        assertEquals("Core Domain", result.dimension)
-        assertTrue(result.validated)
-        assertEquals(1, result.newEntries.size)
-        assertEquals(2, result.collected.size)
-    }
-
-    // ============= Deep Research Step 5: Second-Order Insights Tests =============
-
-    @Test
-    fun testSecondOrderInsights() {
-        val insights = SecondOrderInsights(
-            principles = listOf("Domain terms reflect business concepts"),
-            patterns = listOf("*Service suffix for business logic"),
-            frameworks = listOf("Clean Architecture"),
-            unifiedModel = "Domain vocabulary mirrors the ubiquitous language"
-        )
-
-        assertEquals(1, insights.principles.size)
-        assertEquals(1, insights.patterns.size)
-        assertTrue(insights.unifiedModel.contains("ubiquitous"))
-    }
-
-    // ============= Deep Research Step 6: Research Narrative Tests =============
-
-    @Test
-    fun testResearchNarrative() {
-        val narrative = ResearchNarrative(
-            summary = "Comprehensive analysis of domain vocabulary",
-            keyFindings = listOf("Found 50 domain terms", "Identified 3 modules"),
-            implications = listOf("Need to add authentication terms"),
-            recommendations = listOf("Review generated entries", "Add more payment terms")
-        )
-
-        assertEquals(2, narrative.keyFindings.size)
-        assertEquals(2, narrative.recommendations.size)
-    }
-
-    // ============= Deep Research Step 7: Final Deliverables Tests =============
-
-    @Test
-    fun testFinalDeliverables() {
-        val deliverables = FinalDeliverables(
-            updatedDictionary = "Chinese,Code Translation,Description\nAuth,AuthService,Auth module",
-            changeLog = listOf("Added: Auth -> AuthService"),
-            qualityMetrics = mapOf("completeness" to 0.85f, "relevance" to 0.9f),
-            nextSteps = listOf("Review dictionary", "Test enhancement")
-        )
-
-        assertTrue(deliverables.updatedDictionary.contains("Chinese,Code Translation"))
-        assertEquals(1, deliverables.changeLog.size)
-        assertEquals(0.85f, deliverables.qualityMetrics["completeness"])
-    }
-
-    // ============= Deep Research State Tests =============
-
-    @Test
-    fun testDeepResearchStateInitial() {
-        val state = DeepResearchState()
-
-        assertEquals(0, state.step)
-        assertEquals("", state.stepName)
-        assertEquals(false, state.isComplete)
-        assertTrue(state.dimensions.isEmpty())
-    }
-
-    @Test
-    fun testDeepResearchStateProgression() {
-        var state = DeepResearchState()
-
-        // Step 1
-        state = state.copy(
-            step = 1,
-            stepName = "Clarify",
-            problemDefinition = ProblemDefinition("goal", "scope", "depth", "format")
-        )
-        assertEquals(1, state.step)
-        assertNotNull(state.problemDefinition)
-
-        // Step 2
-        state = state.copy(
-            step = 2,
-            stepName = "Decompose",
-            dimensions = listOf(
-                ResearchDimension("Dim1", "desc", 5),
-                ResearchDimension("Dim2", "desc", 3)
-            )
-        )
-        assertEquals(2, state.step)
-        assertEquals(2, state.dimensions.size)
-
-        // Complete
-        state = state.copy(
-            step = 7,
-            stepName = "Actionization",
-            isComplete = true
-        )
-        assertTrue(state.isComplete)
-    }
-
-    // ============= Legacy Compatibility Tests =============
-
-    @Test
-    fun testDictAssessmentCreation() {
-        val assessment = DictAssessment(
-            satisfiesRequirement = false,
-            completenessScore = 0.6f,
-            relevanceScore = 0.8f,
-            gaps = listOf("Missing authentication terms", "Missing payment terms"),
-            reasoning = "Current dictionary lacks auth-related vocabulary"
-        )
-
-        assertEquals(false, assessment.satisfiesRequirement)
-        assertEquals(0.6f, assessment.completenessScore)
-        assertEquals(0.8f, assessment.relevanceScore)
-        assertEquals(2, assessment.gaps.size)
-    }
-
-    @Test
-    fun testSuggestionTypes() {
-        val types = SuggestionType.entries
-        assertTrue(types.contains(SuggestionType.ADD_TERMS))
-        assertTrue(types.contains(SuggestionType.REFINE_TRANSLATION))
-        assertTrue(types.contains(SuggestionType.ADD_DESCRIPTION))
-        assertTrue(types.contains(SuggestionType.QUERY_MORE_FILES))
-        assertTrue(types.contains(SuggestionType.CLUSTER_ANALYSIS))
-        assertTrue(types.contains(SuggestionType.COMPLETE))
-    }
-
-    @Test
-    fun testDomainDictReviewResult() {
-        val reviewResult = DomainDictReviewResult(
-            iteration = 1,
-            assessment = DictAssessment(
-                satisfiesRequirement = false,
-                completenessScore = 0.5f,
-                relevanceScore = 0.7f,
-                reasoning = "Needs more terms"
-            ),
-            suggestions = listOf(
-                DictSuggestion(
-                    type = SuggestionType.ADD_TERMS,
-                    description = "Add authentication terms"
-                )
-            ),
-            queriesNeeded = listOf("$.code.class(*Auth*)"),
-            newEntries = listOf(
-                DomainEntry("Auth", "Auth", "Authentication module")
-            )
-        )
-
-        assertEquals(1, reviewResult.iteration)
-        assertEquals(false, reviewResult.assessment.satisfiesRequirement)
-        assertEquals(1, reviewResult.suggestions.size)
-        assertEquals(1, reviewResult.queriesNeeded.size)
-        assertEquals(1, reviewResult.newEntries.size)
-    }
-
     // ============= Schema Tests =============
 
     @Test
     fun testDomainDictAgentSchemaExampleUsage() {
         val example = DomainDictAgentSchema.getExampleUsage("domain-dict-agent")
         assertTrue(example.contains("/domain-dict-agent"))
-        assertTrue(example.contains("userQuery"))
+        assertTrue(example.contains("focusArea"))
     }
 
     // ============= CSV Generation Tests =============