feat(acp): add config dialog and engine switching in IDEA plugin #536

- Add IdeaAcpConfigDialogWrapper for managing ACP agents with list, add/edit/delete, preset detection, and config.yaml persistence
- Extend IdeaAgentViewModel with ACP engine support, agent loading, and switching between AutoDev LLM and ACP agents
- Update SwingBottomToolbar to include ACP agents in model selector with separators and configuration option
- Integrate ACP engine into IdeaAgentApp and IdeaDevInInputArea for unified message routing and UI state
- Connect ACP ViewModel to shared renderer for consistent timeline output

Author: phodal

mpp-idea/src/main/kotlin/cc/unitmesh/devins/idea/editor/SwingBottomToolbar.kt

@@ -54,10 +54,20 @@ class SwingBottomToolbar(
     private var onConfigureClick: () -> Unit = {}
     private var onAddNewConfig: () -> Unit = {}
     private var onRefreshCopilot: () -> Unit = {}
+    private var onAcpAgentSelect: (String) -> Unit = {} // ACP agent key
+    private var onConfigureAcp: () -> Unit = {}
+    private var onSwitchToAutodev: () -> Unit = {}
     private var isProcessing = false
     private var isEnhancing = false
     private var isRefreshingCopilot = false
     private var imageCount = 0
+
+    // Track ACP agent entries in the combo box
+    // Format: list of (comboIndex, agentKey) for ACP items
+    private var acpAgentEntries: List<Pair<Int, String>> = emptyList()
+    private val ACP_SEPARATOR = "--- ACP Agents ---"
+    private val ACP_CONFIGURE = "Configure ACP..."
+    private var isComboUpdating = false
 
     // Refresh GitHub Copilot button (only shown when Copilot is configured)
     private val refreshCopilotButton = JButton(AllIcons.Actions.Refresh).apply {
@@ -77,11 +87,31 @@ class SwingBottomToolbar(
         val leftPanel = JPanel(FlowLayout(FlowLayout.LEFT, 4, 0)).apply {
             isOpaque = false
 
-            modelComboBox.preferredSize = Dimension(150, 28)
+            modelComboBox.preferredSize = Dimension(180, 28)
             modelComboBox.addActionListener {
+                if (isComboUpdating) return@addActionListener
                 val selectedIndex = modelComboBox.selectedIndex
-                if (selectedIndex >= 0 && selectedIndex < availableConfigs.size) {
-                    onConfigSelect(availableConfigs[selectedIndex])
+                val selectedItem = modelComboBox.selectedItem as? String
+
+                when {
+                    // "Configure ACP..." item
+                    selectedItem == ACP_CONFIGURE -> {
+                        onConfigureAcp()
+                    }
+                    // Separator (not selectable, reset)
+                    selectedItem == ACP_SEPARATOR -> {
+                        // Do nothing
+                    }
+                    // ACP agent entry
+                    acpAgentEntries.any { it.first == selectedIndex } -> {
+                        val agentKey = acpAgentEntries.first { it.first == selectedIndex }.second
+                        onAcpAgentSelect(agentKey)
+                    }
+                    // Regular LLM config
+                    selectedIndex in availableConfigs.indices -> {
+                        onSwitchToAutodev()
+                        onConfigSelect(availableConfigs[selectedIndex])
+                    }
                 }
             }
             add(modelComboBox)
@@ -172,19 +202,81 @@ class SwingBottomToolbar(
 
     fun setAvailableConfigs(configs: List<NamedModelConfig>) {
         availableConfigs = configs
-        modelComboBox.removeAllItems()
-        configs.forEach { modelComboBox.addItem(it.name) }
+        rebuildComboBox()
+    }
+
+    /**
+     * Set available ACP agents and rebuild the combo box.
+     */
+    fun setAcpAgents(agents: Map<String, cc.unitmesh.config.AcpAgentConfig>) {
+        rebuildComboBoxWithAcp(agents)
+    }
+
+    private fun rebuildComboBox() {
+        rebuildComboBoxWithAcp(emptyMap())
+    }
+
+    private fun rebuildComboBoxWithAcp(agents: Map<String, cc.unitmesh.config.AcpAgentConfig>) {
+        isComboUpdating = true
+        try {
+            modelComboBox.removeAllItems()
+            acpAgentEntries = emptyList()
+
+            // Add LLM configs
+            availableConfigs.forEach { modelComboBox.addItem(it.name) }
+
+            // Add ACP agents section
+            if (agents.isNotEmpty()) {
+                val separatorIndex = modelComboBox.itemCount
+                modelComboBox.addItem(ACP_SEPARATOR)
+
+                val entries = mutableListOf<Pair<Int, String>>()
+                agents.forEach { (key, config) ->
+                    val displayName = config.name.ifBlank { key }
+                    val idx = modelComboBox.itemCount
+                    modelComboBox.addItem("ACP: $displayName")
+                    entries.add(idx to key)
+                }
+                acpAgentEntries = entries
+
+                // Add "Configure ACP..." at the end
+                modelComboBox.addItem(ACP_CONFIGURE)
+            }
+        } finally {
+            isComboUpdating = false
+        }
     }
 
     fun setCurrentConfigName(name: String?) {
         if (name != null) {
-            val index = availableConfigs.indexOfFirst { it.name == name }
-            if (index >= 0) {
-                modelComboBox.selectedIndex = index
+            isComboUpdating = true
+            try {
+                val index = availableConfigs.indexOfFirst { it.name == name }
+                if (index >= 0) {
+                    modelComboBox.selectedIndex = index
+                }
+            } finally {
+                isComboUpdating = false
             }
         }
     }
 
+    /**
+     * Select an ACP agent in the combo box by key.
+     */
+    fun setCurrentAcpAgent(agentKey: String?) {
+        if (agentKey == null) return
+        isComboUpdating = true
+        try {
+            val entry = acpAgentEntries.firstOrNull { it.second == agentKey }
+            if (entry != null) {
+                modelComboBox.selectedIndex = entry.first
+            }
+        } finally {
+            isComboUpdating = false
+        }
+    }
+
     fun setOnConfigSelect(callback: (NamedModelConfig) -> Unit) {
         onConfigSelect = callback
     }
@@ -250,5 +342,17 @@ class SwingBottomToolbar(
     fun setImageEnabled(enabled: Boolean) {
         imageButton.isEnabled = enabled
     }
+
+    fun setOnAcpAgentSelect(callback: (String) -> Unit) {
+        onAcpAgentSelect = callback
+    }
+
+    fun setOnConfigureAcp(callback: () -> Unit) {
+        onConfigureAcp = callback
+    }
+
+    fun setOnSwitchToAutodev(callback: () -> Unit) {
+        onSwitchToAutodev = callback
+    }
 }
 

mpp-idea/src/main/kotlin/cc/unitmesh/devins/idea/toolwindow/IdeaAgentApp.kt

@@ -15,8 +15,10 @@ import cc.unitmesh.devins.idea.toolwindow.codereview.IdeaCodeReviewContent
 import cc.unitmesh.devins.idea.toolwindow.codereview.IdeaCodeReviewViewModel
 import cc.unitmesh.devins.idea.components.header.IdeaAgentTabsHeader
 import cc.unitmesh.devins.idea.components.IdeaVerticalResizableSplitPane
+import cc.unitmesh.config.AcpAgentConfig
 import cc.unitmesh.devins.idea.toolwindow.acp.IdeaAcpAgentContent
 import cc.unitmesh.devins.idea.toolwindow.acp.IdeaAcpAgentViewModel
+import cc.unitmesh.devins.idea.toolwindow.acp.IdeaAcpConfigDialogWrapper
 import cc.unitmesh.devins.idea.toolwindow.knowledge.IdeaKnowledgeContent
 import cc.unitmesh.devins.idea.toolwindow.knowledge.IdeaKnowledgeViewModel
 import cc.unitmesh.devins.idea.toolwindow.remote.IdeaRemoteAgentContent
@@ -85,6 +87,37 @@ fun IdeaAgentApp(
     // Check if GitHub Copilot is available
     val isCopilotAvailable = remember { GithubCopilotDetector.isGithubCopilotConfigured() }
 
+    // Engine state (AutoDev vs ACP)
+    var currentEngine by remember { mutableStateOf(IdeaEngine.AUTODEV) }
+    var acpAgents by remember { mutableStateOf<Map<String, AcpAgentConfig>>(emptyMap()) }
+    var currentAcpAgentKey by remember { mutableStateOf<String?>(null) }
+    var showAcpConfigDialog by remember { mutableStateOf(false) }
+    var acpIsConnected by remember { mutableStateOf(false) }
+    var acpIsExecuting by remember { mutableStateOf(false) }
+
+    // Collect engine state
+    IdeaLaunchedEffect(viewModel, project = project) {
+        viewModel.currentEngine.collect { currentEngine = it }
+    }
+    IdeaLaunchedEffect(viewModel, project = project) {
+        viewModel.acpAgents.collect { acpAgents = it }
+    }
+    IdeaLaunchedEffect(viewModel, project = project) {
+        viewModel.currentAcpAgentKey.collect { currentAcpAgentKey = it }
+    }
+    IdeaLaunchedEffect(viewModel, project = project) {
+        viewModel.showAcpConfigDialog.collect { showAcpConfigDialog = it }
+    }
+    IdeaLaunchedEffect(viewModel.acpViewModel, project = project) {
+        viewModel.acpViewModel.isConnected.collect { acpIsConnected = it }
+    }
+    IdeaLaunchedEffect(viewModel.acpViewModel, project = project) {
+        viewModel.acpViewModel.isExecuting.collect { acpIsExecuting = it }
+    }
+
+    // Effective isProcessing: check both engines
+    val effectiveIsProcessing = if (currentEngine == IdeaEngine.ACP) acpIsExecuting else isExecuting
+
     // Collect StateFlows manually using IdeaLaunchedEffect to avoid ClassLoader conflicts
     IdeaLaunchedEffect(viewModel, project = project) {
         viewModel.currentAgentType.collect { currentAgentType = it }
@@ -234,7 +267,7 @@ fun IdeaAgentApp(
                         IdeaDevInInputArea(
                             project = project,
                             parentDisposable = viewModel,
-                            isProcessing = isExecuting,
+                            isProcessing = effectiveIsProcessing,
                             onSend = { viewModel.sendMessage(it) },
                             onAbort = { viewModel.cancelTask() },
                             workspacePath = project.basePath,
@@ -305,6 +338,18 @@ fun IdeaAgentApp(
                             },
                             onMultimodalAnalysisComplete = { result, error ->
                                 viewModel.renderer.completeMultimodalAnalysis(result, error)
+                            },
+                            // ACP engine integration
+                            acpAgents = acpAgents,
+                            currentAcpAgentKey = if (currentEngine == IdeaEngine.ACP) currentAcpAgentKey else null,
+                            onAcpAgentSelect = { agentKey ->
+                                viewModel.switchToAcpAgent(agentKey)
+                            },
+                            onConfigureAcp = {
+                                viewModel.setShowAcpConfigDialog(true)
+                            },
+                            onSwitchToAutodev = {
+                                viewModel.switchToAutodev()
                             }
                         )
                     }
@@ -494,5 +539,27 @@ fun IdeaAgentApp(
         }
         onDispose { }
     }
+
+    // ACP Agent Configuration Dialog
+    DisposableEffect(showAcpConfigDialog) {
+        if (showAcpConfigDialog) {
+            com.intellij.openapi.application.ApplicationManager.getApplication().invokeLater {
+                IdeaAcpConfigDialogWrapper.show(
+                    project = project,
+                    agents = acpAgents,
+                    activeKey = currentAcpAgentKey,
+                    onSave = { newAgents, newActiveKey ->
+                        // Reload ACP agents and update selection
+                        viewModel.reloadAcpAgents()
+                        if (newActiveKey != null) {
+                            viewModel.switchToAcpAgent(newActiveKey)
+                        }
+                    }
+                )
+                viewModel.setShowAcpConfigDialog(false)
+            }
+        }
+        onDispose { }
+    }
 }