feat(mpp-idea): add live terminal, MCP config, file search and various improvements

.github/workflows/build.yml

@@ -117,6 +117,13 @@ jobs:
     continue-on-error: true
     steps:
       # Check out the current repository
+      # Free GitHub Actions Environment Disk Space
+      - name: Maximize Build Space
+        uses: jlumbroso/free-disk-space@main
+        with:
+          tool-cache: false
+          large-packages: false
+
       - name: Fetch Sources
         uses: actions/checkout@v4
 

exts/devins-lang/src/main/kotlin/cc/unitmesh/devti/language/compiler/exec/file/FileInsCommand.kt

@@ -13,8 +13,8 @@ import cc.unitmesh.devti.util.relativePath
 import com.intellij.openapi.application.runReadAction
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.psi.PsiCompiledFile
 import com.intellij.psi.PsiManager
-import com.intellij.psi.impl.compiled.ClsFileImpl
 import com.intellij.psi.search.FilenameIndex
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.search.PsiShortNamesCache
@@ -65,23 +65,19 @@ class FileInsCommand(private val myProject: Project, private val prop: String) :
             val language = psiFile?.language?.displayName ?: ""
 
             val fileContent = when (psiFile) {
-                is ClsFileImpl -> {
-                    psiFile.text
+                is PsiCompiledFile -> {
+                    // For compiled files (like .class files), get the decompiled text
+                    psiFile.decompiledPsiFile?.text ?: virtualFile.readText()
                 }
 
                 else -> {
-                    runReadAction { virtualFile.readText() }
+                    virtualFile.readText()
                 }
             }
 
             Pair(fileContent, language)
         }
 
-        if (content == null) {
-            AutoDevNotifications.warn(myProject, "Cannot read file: $prop")
-            return "Cannot read file: $prop"
-        }
-
         val fileContent = splitLines(range, content)
 
         val realPath = virtualFile.relativePath(myProject)

exts/devins-lang/src/main/kotlin/cc/unitmesh/devti/language/run/DevInsProgramRunner.kt

@@ -13,17 +13,18 @@ import com.intellij.execution.runners.ExecutionEnvironment
 import com.intellij.execution.runners.GenericProgramRunner
 import com.intellij.execution.runners.showRunContent
 import com.intellij.execution.ui.RunContentDescriptor
-import com.intellij.openapi.Disposable
 import com.intellij.openapi.application.ApplicationManager
-import com.intellij.openapi.fileEditor.FileDocumentManager
+import com.intellij.openapi.util.Disposer
+import com.intellij.util.messages.MessageBusConnection
 import kotlinx.coroutines.launch
 import java.util.concurrent.atomic.AtomicReference
 
-class DevInsProgramRunner : GenericProgramRunner<RunnerSettings>(), Disposable {
+class DevInsProgramRunner : GenericProgramRunner<RunnerSettings>() {
     private val RUNNER_ID: String = "DevInsProgramRunner"
 
-    private val connection = ApplicationManager.getApplication().messageBus.connect(this)
-
+    // Use lazy initialization to avoid memory leak - connection is created per execution
+    // and tied to the project's lifecycle, not the runner's lifecycle
+    private var connection: MessageBusConnection? = null
     private var isSubscribed = false
 
     override fun getRunnerId(): String = RUNNER_ID
@@ -40,7 +41,15 @@ class DevInsProgramRunner : GenericProgramRunner<RunnerSettings>(), Disposable {
 
         ApplicationManager.getApplication().invokeAndWait {
             if (!isSubscribed) {
-                connection.subscribe(DevInsRunListener.TOPIC, object : DevInsRunListener {
+                // Connect to project's message bus instead of application's
+                // This ensures proper disposal when the project is closed
+                val projectConnection = environment.project.messageBus.connect()
+                connection = projectConnection
+
+                // Register for disposal with the project
+                Disposer.register(environment.project, projectConnection)
+
+                projectConnection.subscribe(DevInsRunListener.TOPIC, object : DevInsRunListener {
                     override fun runFinish(
                         allOutput: String,
                         llmOutput: String,
@@ -67,8 +76,4 @@ class DevInsProgramRunner : GenericProgramRunner<RunnerSettings>(), Disposable {
 
         return result.get()
     }
-
-    override fun dispose() {
-        connection.disconnect()
-    }
 }

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

@@ -86,7 +86,7 @@ class CodingAgent(
     private val toolOrchestrator = ToolOrchestrator(toolRegistry, policyEngine, renderer, mcpConfigService = mcpToolConfigService)
 
     private val errorRecoveryAgent = ErrorRecoveryAgent(projectPath, llmService)
-    private val analysisAgent = AnalysisAgent(llmService, contentThreshold = 5000)
+    private val analysisAgent = AnalysisAgent(llmService, contentThreshold = 15000)
     private val mcpToolsInitializer = McpToolsInitializer()
 
     // 执行器

mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/executor/CodingAgentExecutor.kt

@@ -18,14 +18,27 @@ import kotlinx.coroutines.coroutineScope
 import kotlinx.datetime.Clock
 import cc.unitmesh.agent.orchestrator.ToolExecutionContext as OrchestratorContext
 
+/**
+ * Configuration for async shell execution timeout behavior
+ */
+data class AsyncShellConfig(
+    /** Initial wait timeout in milliseconds before notifying AI that process is still running */
+    val initialWaitTimeoutMs: Long = 60_000L, // 1 minute
+    /** Maximum total wait time in milliseconds */
+    val maxWaitTimeoutMs: Long = 300_000L, // 5 minutes
+    /** Interval for checking process status after initial timeout */
+    val checkIntervalMs: Long = 30_000L // 30 seconds
+)
+
 class CodingAgentExecutor(
     projectPath: String,
     llmService: KoogLLMService,
     toolOrchestrator: ToolOrchestrator,
     renderer: CodingAgentRenderer,
     maxIterations: Int = 100,
     private val subAgentManager: SubAgentManager? = null,
-    enableLLMStreaming: Boolean = true
+    enableLLMStreaming: Boolean = true,
+    private val asyncShellConfig: AsyncShellConfig = AsyncShellConfig()
 ) : BaseAgentExecutor(
     projectPath = projectPath,
     llmService = llmService,
@@ -202,12 +215,17 @@ class CodingAgentExecutor(
                 environment = emptyMap()
             )
 
-            val executionResult = toolOrchestrator.executeToolCall(
+            var executionResult = toolOrchestrator.executeToolCall(
                 toolName,
                 params,
                 executionContext
             )
 
+            // Handle Pending result (async shell execution)
+            if (executionResult.isPending) {
+                executionResult = handlePendingResult(executionResult, toolName, params)
+            }
+
             results.add(Triple(toolName, params, executionResult))
 
             val stepResult = AgentStep(
@@ -240,7 +258,8 @@ class CodingAgentExecutor(
                     }
                 }
                 is ToolResult.AgentResult -> if (!result.success) result.content else stepResult.result
-                else -> stepResult.result
+                is ToolResult.Pending -> stepResult.result // Should not happen after handlePendingResult
+                is ToolResult.Success -> stepResult.result
             }
 
             val contentHandlerResult = checkForLongContent(toolName, fullOutput ?: "", executionResult)
@@ -260,8 +279,9 @@ class CodingAgentExecutor(
             }
 
             // 错误恢复处理
-            if (!executionResult.isSuccess) {
-                val command = if (toolName == "shell") params["command"] as? String else null
+            // 跳过用户取消的场景 - 用户取消是明确的意图，不需要显示额外的错误消息
+            val wasCancelledByUser = executionResult.metadata["cancelled"] == "true"
+            if (!executionResult.isSuccess && !executionResult.isPending && !wasCancelledByUser) {
                 val errorMessage = executionResult.content ?: "Unknown error"
 
                 renderer.renderError("Tool execution failed: $errorMessage")
@@ -271,6 +291,112 @@ class CodingAgentExecutor(
         results
     }
 
+    /**
+     * Handle a Pending result from async shell execution.
+     * Waits for the session to complete with timeout handling.
+     * If the process takes longer than initialWaitTimeoutMs, returns a special result
+     * indicating the process is still running (similar to Augment's behavior).
+     */
+    private suspend fun handlePendingResult(
+        pendingResult: ToolExecutionResult,
+        toolName: String,
+        params: Map<String, Any>
+    ): ToolExecutionResult {
+        val pending = pendingResult.result as? ToolResult.Pending
+            ?: return pendingResult
+
+        val sessionId = pending.sessionId
+        val command = pending.command
+        val startTime = pendingResult.startTime
+
+        // First, try to wait for the initial timeout
+        val initialResult = renderer.awaitSessionResult(sessionId, asyncShellConfig.initialWaitTimeoutMs)
+
+        return when (initialResult) {
+            is ToolResult.Success -> {
+                // Process completed within initial timeout
+                val endTime = Clock.System.now().toEpochMilliseconds()
+                ToolExecutionResult.success(
+                    executionId = pendingResult.executionId,
+                    toolName = toolName,
+                    content = initialResult.content,
+                    startTime = startTime,
+                    endTime = endTime,
+                    metadata = initialResult.metadata + mapOf("sessionId" to sessionId)
+                )
+            }
+            is ToolResult.Error -> {
+                // Process failed
+                val endTime = Clock.System.now().toEpochMilliseconds()
+                ToolExecutionResult.failure(
+                    executionId = pendingResult.executionId,
+                    toolName = toolName,
+                    error = initialResult.message,
+                    startTime = startTime,
+                    endTime = endTime,
+                    metadata = initialResult.metadata + mapOf("sessionId" to sessionId)
+                )
+            }
+            is ToolResult.Pending -> {
+                // Process is still running after initial timeout
+                // Return a special result to inform the AI
+                val elapsedSeconds = (Clock.System.now().toEpochMilliseconds() - startTime) / 1000
+                val stillRunningMessage = buildString {
+                    appendLine("⏳ Process is still running after ${elapsedSeconds}s")
+                    appendLine("Command: $command")
+                    appendLine("Session ID: $sessionId")
+                    appendLine()
+                    appendLine("The process is executing in the background. You can:")
+                    appendLine("1. Continue with other tasks while waiting")
+                    appendLine("2. Check the terminal output in the UI for real-time progress")
+                    appendLine("3. The result will be available when the process completes")
+                }
+
+                // Return as a "success" with the still-running message
+                // This allows the agent to continue and make decisions
+                val endTime = Clock.System.now().toEpochMilliseconds()
+                ToolExecutionResult(
+                    executionId = pendingResult.executionId,
+                    toolName = toolName,
+                    result = ToolResult.Success(
+                        content = stillRunningMessage,
+                        metadata = mapOf(
+                            "status" to "still_running",
+                            "sessionId" to sessionId,
+                            "command" to command,
+                            "elapsedSeconds" to elapsedSeconds.toString()
+                        )
+                    ),
+                    startTime = startTime,
+                    endTime = endTime,
+                    state = ToolExecutionState.Executing(pendingResult.executionId, startTime),
+                    metadata = mapOf(
+                        "sessionId" to sessionId,
+                        "isAsync" to "true",
+                        "stillRunning" to "true"
+                    )
+                )
+            }
+            is ToolResult.AgentResult -> {
+                // Unexpected, but handle it
+                val endTime = Clock.System.now().toEpochMilliseconds()
+                ToolExecutionResult(
+                    executionId = pendingResult.executionId,
+                    toolName = toolName,
+                    result = initialResult,
+                    startTime = startTime,
+                    endTime = endTime,
+                    state = if (initialResult.success) {
+                        ToolExecutionState.Success(pendingResult.executionId, initialResult, endTime - startTime)
+                    } else {
+                        ToolExecutionState.Failed(pendingResult.executionId, initialResult.content, endTime - startTime)
+                    },
+                    metadata = mapOf("sessionId" to sessionId)
+                )
+            }
+        }
+    }
+
     private fun recordFileEdit(params: Map<String, Any>) {
         val path = params["path"] as? String
         val content = params["content"] as? String
@@ -343,6 +469,13 @@ class CodingAgentExecutor(
             return null
         }
 
+        // 对于用户取消的命令，不需要分析输出
+        // 用户取消是明确的意图，不需要对取消前的输出做分析
+        val wasCancelledByUser = executionResult.metadata["cancelled"] == "true"
+        if (wasCancelledByUser) {
+            return null
+        }
+
         // 检测内容类型
         val contentType = when {
             toolName == "glob" -> "file-list"

mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/executor/DocumentAgentExecutor.kt

@@ -300,6 +300,7 @@ class DocumentAgentExecutor(
      * P1: Check for long content and delegate to AnalysisAgent for summarization
      * NOTE: Code content (from $.code.* queries) is NOT summarized to preserve actual code
      * NOTE: Live Session output is NOT summarized to preserve real-time terminal output
+     * NOTE: User cancelled commands are NOT summarized - cancellation is explicit user intent
      */
     private suspend fun checkForLongContent(
         toolName: String,
@@ -318,6 +319,13 @@ class DocumentAgentExecutor(
             return null
         }
 
+        // 对于用户取消的命令，不需要分析输出
+        // 用户取消是明确的意图，不需要对取消前的输出做分析
+        val wasCancelledByUser = executionResult.metadata["cancelled"] == "true"
+        if (wasCancelledByUser) {
+            return null
+        }
+
         val isCodeContent = output.contains("📘 class ") ||
                            output.contains("⚡ fun ") ||
                            output.contains("Found") && output.contains("entities") ||