hakalab-mcp 2.0.0 → 2.1.0

package/IDE_INTEGRATION_EXAMPLES.md

@@ -0,0 +1,1497 @@
+# Ejemplos de Integración IDE - Hakalab-MCP
+
+**Ejemplos prácticos de código para integración con plugins de IntelliJ IDEA y PyCharm**
+
+## 📋 Contenido
+
+1. [Configuración del Cliente MCP](#configuración-del-cliente-mcp)
+2. [Implementación de Herramientas](#implementación-de-herramientas)
+3. [UI Components](#ui-components)
+4. [AI Agent Integration](#ai-agent-integration)
+5. [Code Generation](#code-generation)
+6. [Test Execution](#test-execution)
+
+---
+
+## 🔧 Configuración del Cliente MCP
+
+### MCPClient.kt
+```kotlin
+package com.hakalab.mcp.client
+
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.module.kotlin.KotlinModule
+import kotlinx.coroutines.*
+import java.io.*
+import java.util.concurrent.TimeUnit
+
+class MCPClient(private val config: MCPConfig) {
+    private val objectMapper = ObjectMapper().registerModule(KotlinModule())
+    private var process: Process? = null
+    private var writer: BufferedWriter? = null
+    private var reader: BufferedReader? = null
+    private var requestId = 0
+    
+    suspend fun connect(): Boolean = withContext(Dispatchers.IO) {
+        try {
+            val processBuilder = ProcessBuilder(config.command, *config.args.toTypedArray())
+            processBuilder.environment().putAll(config.env)
+            
+            process = processBuilder.start()
+            writer = process!!.outputStream.bufferedWriter()
+            reader = process!!.inputStream.bufferedReader()
+            
+            // Initialize MCP connection
+            val initRequest = MCPRequest(
+                jsonrpc = "2.0",
+                id = getNextRequestId(),
+                method = "initialize",
+                params = mapOf(
+                    "protocolVersion" to "2024-11-05",
+                    "capabilities" to mapOf(
+                        "tools" to emptyMap<String, Any>()
+                    ),
+                    "clientInfo" to mapOf(
+                        "name" to "hakalab-ide-plugin",
+                        "version" to "1.0.0"
+                    )
+                )
+            )
+            
+            sendRequest(initRequest)
+            val response = readResponse()
+            response.error == null
+        } catch (e: Exception) {
+            false
+        }
+    }
+    
+    suspend fun callTool(toolName: String, arguments: Map<String, Any>): MCPResponse {
+        return withContext(Dispatchers.IO) {
+            val request = MCPRequest(
+                jsonrpc = "2.0",
+                id = getNextRequestId(),
+                method = "tools/call",
+                params = mapOf(
+                    "name" to toolName,
+                    "arguments" to arguments
+                )
+            )
+            
+            sendRequest(request)
+            readResponse()
+        }
+    }
+    
+    suspend fun listTools(): List<MCPTool> {
+        return withContext(Dispatchers.IO) {
+            val request = MCPRequest(
+                jsonrpc = "2.0",
+                id = getNextRequestId(),
+                method = "tools/list",
+                params = emptyMap<String, Any>()
+            )
+            
+            sendRequest(request)
+            val response = readResponse()
+            
+            response.result?.get("tools")?.let { tools ->
+                objectMapper.convertValue(tools, Array<MCPTool>::class.java).toList()
+            } ?: emptyList()
+        }
+    }
+    
+    private fun sendRequest(request: MCPRequest) {
+        val json = objectMapper.writeValueAsString(request)
+        writer?.write(json)
+        writer?.newLine()
+        writer?.flush()
+    }
+    
+    private fun readResponse(): MCPResponse {
+        val line = reader?.readLine() ?: throw IOException("No response from MCP server")
+        return objectMapper.readValue(line, MCPResponse::class.java)
+    }
+    
+    private fun getNextRequestId(): String = (++requestId).toString()
+    
+    fun disconnect() {
+        writer?.close()
+        reader?.close()
+        process?.destroyForcibly()
+    }
+}
+
+data class MCPConfig(
+    val command: String = "npx",
+    val args: List<String> = listOf("-y", "hakalab-mcp"),
+    val env: Map<String, String> = mapOf(
+        "NODE_ENV" to "production",
+        "DEBUG" to "false"
+    ),
+    val timeout: Long = 30000
+)
+
+data class MCPRequest(
+    val jsonrpc: String,
+    val id: String,
+    val method: String,
+    val params: Map<String, Any>
+)
+
+data class MCPResponse(
+    val jsonrpc: String,
+    val id: String,
+    val result: Map<String, Any>? = null,
+    val error: MCPError? = null
+)
+
+data class MCPError(
+    val code: Int,
+    val message: String,
+    val data: Any? = null
+)
+
+data class MCPTool(
+    val name: String,
+    val description: String,
+    val inputSchema: Map<String, Any>
+)
+```
+
+---
+
+## 🛠️ Implementación de Herramientas
+
+### ToolExecutor.kt
+```kotlin
+package com.hakalab.mcp.tools
+
+import com.intellij.openapi.progress.ProgressIndicator
+import com.intellij.openapi.progress.Task
+import com.intellij.openapi.project.Project
+import kotlinx.coroutines.runBlocking
+
+class ToolExecutor(
+    private val project: Project,
+    private val mcpClient: MCPClient
+) {
+    
+    fun executeBrowserAutomation(workflow: BrowserWorkflow) {
+        object : Task.Backgroundable(project, "Executing Browser Automation", true) {
+            override fun run(indicator: ProgressIndicator) {
+                runBlocking {
+                    try {
+                        indicator.text = "Opening browser..."
+                        val browserResult = mcpClient.callTool("open_browser", workflow.browserConfig)
+                        
+                        if (!browserResult.isSuccess()) {
+                            throw Exception("Failed to open browser: ${browserResult.error?.message}")
+                        }
+                        
+                        workflow.steps.forEachIndexed { index, step ->
+                            indicator.text = "Executing step ${index + 1}/${workflow.steps.size}: ${step.description}"
+                            indicator.fraction = (index + 1).toDouble() / workflow.steps.size
+                            
+                            val result = mcpClient.callTool(step.toolName, step.parameters)
+                            
+                            if (!result.isSuccess()) {
+                                throw Exception("Step failed: ${result.error?.message}")
+                            }
+                            
+                            // Optional: Take screenshot after each step
+                            if (step.takeScreenshot) {
+                                mcpClient.callTool("take_screenshot", mapOf(
+                                    "filename" to "step_${index + 1}_${step.toolName}.png"
+                                ))
+                            }
+                        }
+                        
+                        indicator.text = "Closing browser..."
+                        mcpClient.callTool("close_browser", emptyMap())
+                        
+                        showSuccessNotification("Browser automation completed successfully")
+                        
+                    } catch (e: Exception) {
+                        showErrorNotification("Browser automation failed: ${e.message}")
+                    }
+                }
+            }
+        }.queue()
+    }
+    
+    fun createTestSuite(testSuiteConfig: TestSuiteConfig) {
+        object : Task.Backgroundable(project, "Creating Test Suite", false) {
+            override fun run(indicator: ProgressIndicator) {
+                runBlocking {
+                    try {
+                        indicator.text = "Creating test suite..."
+                        
+                        val result = mcpClient.callTool("create_test_suite", mapOf(
+                            "feature_name" to testSuiteConfig.featureName,
+                            "scenarios" to testSuiteConfig.scenarios,
+                            "page_elements" to testSuiteConfig.pageElements,
+                            "tags" to testSuiteConfig.tags
+                        ))
+                        
+                        if (result.isSuccess()) {
+                            // Refresh project files
+                            project.baseDir.refresh(false, true)
+                            showSuccessNotification("Test suite created successfully")
+                            
+                            // Open generated files
+                            openGeneratedFiles(testSuiteConfig.featureName)
+                        } else {
+                            throw Exception(result.error?.message ?: "Unknown error")
+                        }
+                        
+                    } catch (e: Exception) {
+                        showErrorNotification("Failed to create test suite: ${e.message}")
+                    }
+                }
+            }
+        }.queue()
+    }
+    
+    fun executeTests(testConfig: TestExecutionConfig) {
+        object : Task.Backgroundable(project, "Executing Tests", true) {
+            override fun run(indicator: ProgressIndicator) {
+                runBlocking {
+                    try {
+                        indicator.text = "Executing tests..."
+                        
+                        val result = mcpClient.callTool("execute_tests", mapOf(
+                            "tags" to testConfig.tags,
+                            "feature_file" to testConfig.featureFile,
+                            "parallel" to testConfig.parallel
+                        ))
+                        
+                        if (result.isSuccess()) {
+                            indicator.text = "Generating Allure report..."
+                            mcpClient.callTool("generate_allure_report", emptyMap())
+                            
+                            showTestResults(result)
+                        } else {
+                            throw Exception(result.error?.message ?: "Test execution failed")
+                        }
+                        
+                    } catch (e: Exception) {
+                        showErrorNotification("Test execution failed: ${e.message}")
+                    }
+                }
+            }
+        }.queue()
+    }
+    
+    private fun MCPResponse.isSuccess(): Boolean = error == null
+    
+    private fun showSuccessNotification(message: String) {
+        // Implementation for success notification
+    }
+    
+    private fun showErrorNotification(message: String) {
+        // Implementation for error notification
+    }
+    
+    private fun openGeneratedFiles(featureName: String) {
+        // Implementation to open generated files in editor
+    }
+    
+    private fun showTestResults(result: MCPResponse) {
+        // Implementation to show test results in tool window
+    }
+}
+
+data class BrowserWorkflow(
+    val name: String,
+    val browserConfig: Map<String, Any>,
+    val steps: List<WorkflowStep>
+)
+
+data class WorkflowStep(
+    val toolName: String,
+    val parameters: Map<String, Any>,
+    val description: String,
+    val takeScreenshot: Boolean = false
+)
+
+data class TestSuiteConfig(
+    val featureName: String,
+    val scenarios: List<Map<String, Any>>,
+    val pageElements: List<Map<String, Any>>,
+    val tags: List<String>
+)
+
+data class TestExecutionConfig(
+    val tags: List<String> = emptyList(),
+    val featureFile: String? = null,
+    val parallel: Boolean = false
+)
+```
+
+---
+
+## 🎨 UI Components
+
+### MCPToolWindow.kt
+```kotlin
+package com.hakalab.mcp.ui
+
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.wm.ToolWindow
+import com.intellij.openapi.wm.ToolWindowFactory
+import com.intellij.ui.content.ContentFactory
+import javax.swing.*
+import java.awt.*
+import java.awt.event.ActionEvent
+
+class MCPToolWindowFactory : ToolWindowFactory {
+    override fun createToolWindowContent(project: Project, toolWindow: ToolWindow) {
+        val mcpToolWindow = MCPToolWindow(project)
+        val content = ContentFactory.SERVICE.getInstance()
+            .createContent(mcpToolWindow.getContent(), "", false)
+        toolWindow.contentManager.addContent(content)
+    }
+}
+
+class MCPToolWindow(private val project: Project) {
+    private val mcpClient = MCPClient(MCPConfig())
+    private val toolExecutor = ToolExecutor(project, mcpClient)
+    
+    fun getContent(): JComponent {
+        val panel = JPanel(BorderLayout())
+        
+        // Create tabbed pane
+        val tabbedPane = JTabbedPane()
+        
+        // Browser Automation Tab
+        tabbedPane.addTab("Browser Automation", createBrowserAutomationPanel())
+        
+        // Test Creation Tab
+        tabbedPane.addTab("Test Creation", createTestCreationPanel())
+        
+        // Test Execution Tab
+        tabbedPane.addTab("Test Execution", createTestExecutionPanel())
+        
+        // Tools Tab
+        tabbedPane.addTab("Available Tools", createToolsPanel())
+        
+        panel.add(tabbedPane, BorderLayout.CENTER)
+        
+        return panel
+    }
+    
+    private fun createBrowserAutomationPanel(): JPanel {
+        val panel = JPanel(GridBagLayout())
+        val gbc = GridBagConstraints()
+        
+        // Engine selection
+        gbc.gridx = 0; gbc.gridy = 0; gbc.anchor = GridBagConstraints.WEST
+        panel.add(JLabel("Engine:"), gbc)
+        
+        gbc.gridx = 1; gbc.fill = GridBagConstraints.HORIZONTAL
+        val engineCombo = JComboBox(arrayOf("selenium", "playwright"))
+        panel.add(engineCombo, gbc)
+        
+        // Browser selection
+        gbc.gridx = 0; gbc.gridy = 1; gbc.fill = GridBagConstraints.NONE
+        panel.add(JLabel("Browser:"), gbc)
+        
+        gbc.gridx = 1; gbc.fill = GridBagConstraints.HORIZONTAL
+        val browserCombo = JComboBox(arrayOf("chrome", "firefox", "edge", "safari"))
+        panel.add(browserCombo, gbc)
+        
+        // URL field
+        gbc.gridx = 0; gbc.gridy = 2; gbc.fill = GridBagConstraints.NONE
+        panel.add(JLabel("URL:"), gbc)
+        
+        gbc.gridx = 1; gbc.fill = GridBagConstraints.HORIZONTAL
+        val urlField = JTextField("https://")
+        panel.add(urlField, gbc)
+        
+        // Actions area
+        gbc.gridx = 0; gbc.gridy = 3; gbc.gridwidth = 2; gbc.fill = GridBagConstraints.BOTH
+        val actionsArea = JTextArea(10, 40)
+        actionsArea.text = """
+            # Example automation script:
+            # 1. Open browser
+            # 2. Navigate to URL
+            # 3. Fill form fields
+            # 4. Click submit
+            # 5. Take screenshot
+            # 6. Close browser
+        """.trimIndent()
+        panel.add(JScrollPane(actionsArea), gbc)
+        
+        // Execute button
+        gbc.gridy = 4; gbc.fill = GridBagConstraints.NONE
+        val executeButton = JButton("Execute Automation")
+        executeButton.addActionListener { executeAutomation(engineCombo, browserCombo, urlField, actionsArea) }
+        panel.add(executeButton, gbc)
+        
+        return panel
+    }
+    
+    private fun createTestCreationPanel(): JPanel {
+        val panel = JPanel(GridBagLayout())
+        val gbc = GridBagConstraints()
+        
+        // Feature name
+        gbc.gridx = 0; gbc.gridy = 0; gbc.anchor = GridBagConstraints.WEST
+        panel.add(JLabel("Feature Name:"), gbc)
+        
+        gbc.gridx = 1; gbc.fill = GridBagConstraints.HORIZONTAL
+        val featureNameField = JTextField()
+        panel.add(featureNameField, gbc)
+        
+        // Scenarios
+        gbc.gridx = 0; gbc.gridy = 1; gbc.fill = GridBagConstraints.NONE
+        panel.add(JLabel("Scenarios:"), gbc)
+        
+        gbc.gridx = 1; gbc.gridy = 1; gbc.fill = GridBagConstraints.BOTH; gbc.weightx = 1.0; gbc.weighty = 0.5
+        val scenariosArea = JTextArea()
+        scenariosArea.text = """
+            Scenario: User login
+              Given I am on the login page
+              When I enter valid credentials
+              Then I should be logged in
+        """.trimIndent()
+        panel.add(JScrollPane(scenariosArea), gbc)
+        
+        // Page elements
+        gbc.gridy = 2
+        val elementsArea = JTextArea()
+        elementsArea.text = """
+            username_field,ID,username
+            password_field,ID,password
+            login_button,CSS,.login-btn
+        """.trimIndent()
+        panel.add(JScrollPane(elementsArea), gbc)
+        
+        // Create button
+        gbc.gridy = 3; gbc.fill = GridBagConstraints.NONE; gbc.weighty = 0.0
+        val createButton = JButton("Create Test Suite")
+        createButton.addActionListener { createTestSuite(featureNameField, scenariosArea, elementsArea) }
+        panel.add(createButton, gbc)
+        
+        return panel
+    }
+    
+    private fun createTestExecutionPanel(): JPanel {
+        val panel = JPanel(GridBagLayout())
+        val gbc = GridBagConstraints()
+        
+        // Tags filter
+        gbc.gridx = 0; gbc.gridy = 0; gbc.anchor = GridBagConstraints.WEST
+        panel.add(JLabel("Tags:"), gbc)
+        
+        gbc.gridx = 1; gbc.fill = GridBagConstraints.HORIZONTAL
+        val tagsField = JTextField("selenium,critical")
+        panel.add(tagsField, gbc)
+        
+        // Feature file
+        gbc.gridx = 0; gbc.gridy = 1; gbc.fill = GridBagConstraints.NONE
+        panel.add(JLabel("Feature File:"), gbc)
+        
+        gbc.gridx = 1; gbc.fill = GridBagConstraints.HORIZONTAL
+        val featureFileField = JTextField()
+        panel.add(featureFileField, gbc)
+        
+        // Parallel execution
+        gbc.gridx = 0; gbc.gridy = 2; gbc.gridwidth = 2
+        val parallelCheckbox = JCheckBox("Parallel Execution")
+        panel.add(parallelCheckbox, gbc)
+        
+        // Execute button
+        gbc.gridy = 3
+        val executeButton = JButton("Execute Tests")
+        executeButton.addActionListener { executeTests(tagsField, featureFileField, parallelCheckbox) }
+        panel.add(executeButton, gbc)
+        
+        // Results area
+        gbc.gridy = 4; gbc.fill = GridBagConstraints.BOTH; gbc.weightx = 1.0; gbc.weighty = 1.0
+        val resultsArea = JTextArea()
+        resultsArea.isEditable = false
+        panel.add(JScrollPane(resultsArea), gbc)
+        
+        return panel
+    }
+    
+    private fun createToolsPanel(): JPanel {
+        val panel = JPanel(BorderLayout())
+        
+        // Tools list
+        val toolsModel = DefaultListModel<String>()
+        val toolsList = JList(toolsModel)
+        
+        // Load available tools
+        SwingUtilities.invokeLater {
+            loadAvailableTools(toolsModel)
+        }
+        
+        panel.add(JScrollPane(toolsList), BorderLayout.CENTER)
+        
+        // Tool details
+        val detailsArea = JTextArea()
+        detailsArea.isEditable = false
+        panel.add(JScrollPane(detailsArea), BorderLayout.SOUTH)
+        
+        // Show tool details on selection
+        toolsList.addListSelectionListener { e ->
+            if (!e.valueIsAdjusting) {
+                val selectedTool = toolsList.selectedValue
+                if (selectedTool != null) {
+                    showToolDetails(selectedTool, detailsArea)
+                }
+            }
+        }
+        
+        return panel
+    }
+    
+    private fun executeAutomation(
+        engineCombo: JComboBox<String>,
+        browserCombo: JComboBox<String>,
+        urlField: JTextField,
+        actionsArea: JTextArea
+    ) {
+        val workflow = BrowserWorkflow(
+            name = "Custom Automation",
+            browserConfig = mapOf(
+                "engine" to engineCombo.selectedItem,
+                "browser" to browserCombo.selectedItem
+            ),
+            steps = parseAutomationSteps(actionsArea.text, urlField.text)
+        )
+        
+        toolExecutor.executeBrowserAutomation(workflow)
+    }
+    
+    private fun createTestSuite(
+        featureNameField: JTextField,
+        scenariosArea: JTextArea,
+        elementsArea: JTextArea
+    ) {
+        val config = TestSuiteConfig(
+            featureName = featureNameField.text,
+            scenarios = parseScenarios(scenariosArea.text),
+            pageElements = parsePageElements(elementsArea.text),
+            tags = listOf("automated", "ui")
+        )
+        
+        toolExecutor.createTestSuite(config)
+    }
+    
+    private fun executeTests(
+        tagsField: JTextField,
+        featureFileField: JTextField,
+        parallelCheckbox: JCheckBox
+    ) {
+        val config = TestExecutionConfig(
+            tags = tagsField.text.split(",").map { it.trim() },
+            featureFile = featureFileField.text.takeIf { it.isNotBlank() },
+            parallel = parallelCheckbox.isSelected
+        )
+        
+        toolExecutor.executeTests(config)
+    }
+    
+    private fun loadAvailableTools(model: DefaultListModel<String>) {
+        // Load tools asynchronously
+    }
+    
+    private fun showToolDetails(toolName: String, detailsArea: JTextArea) {
+        // Show tool details
+    }
+    
+    private fun parseAutomationSteps(actionsText: String, url: String): List<WorkflowStep> {
+        // Parse automation steps from text
+        return listOf(
+            WorkflowStep("navigate_to_url", mapOf("url" to url), "Navigate to URL")
+        )
+    }
+    
+    private fun parseScenarios(scenariosText: String): List<Map<String, Any>> {
+        // Parse scenarios from text
+        return emptyList()
+    }
+    
+    private fun parsePageElements(elementsText: String): List<Map<String, Any>> {
+        // Parse page elements from CSV-like text
+        return emptyList()
+    }
+}
+```
+
+---
+
+## 🤖 AI Agent Integration
+
+### AIAssistant.kt
+```kotlin
+package com.hakalab.mcp.ai
+
+import com.intellij.openapi.editor.Editor
+import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiFile
+
+class AIAssistant(
+    private val project: Project,
+    private val mcpClient: MCPClient
+) {
+    
+    fun generateTestFromCode(psiFile: PsiFile, editor: Editor): String {
+        val codeContext = analyzeCode(psiFile, editor)
+        
+        return when (codeContext.type) {
+            CodeType.WEB_PAGE -> generateWebPageTest(codeContext)
+            CodeType.API_ENDPOINT -> generateAPITest(codeContext)
+            CodeType.FORM_HANDLER -> generateFormTest(codeContext)
+            else -> generateGenericTest(codeContext)
+        }
+    }
+    
+    fun suggestAutomationSteps(context: String): List<AutomationSuggestion> {
+        val suggestions = mutableListOf<AutomationSuggestion>()
+        
+        // Analyze context and suggest appropriate MCP tools
+        when {
+            context.contains("login", ignoreCase = true) -> {
+                suggestions.addAll(getLoginAutomationSuggestions())
+            }
+            context.contains("form", ignoreCase = true) -> {
+                suggestions.addAll(getFormAutomationSuggestions())
+            }
+            context.contains("navigation", ignoreCase = true) -> {
+                suggestions.addAll(getNavigationAutomationSuggestions())
+            }
+            context.contains("test", ignoreCase = true) -> {
+                suggestions.addAll(getTestCreationSuggestions())
+            }
+        }
+        
+        return suggestions
+    }
+    
+    fun generatePageObject(htmlContent: String): PageObjectCode {
+        val elements = extractElementsFromHTML(htmlContent)
+        
+        val pageObjectCode = buildString {
+            appendLine("from selenium.webdriver.common.by import By")
+            appendLine()
+            appendLine("class GeneratedPage:")
+            appendLine("    def __init__(self, browser):")
+            appendLine("        self.browser = browser")
+            appendLine()
+            
+            elements.forEach { element ->
+                appendLine("    ${element.name} = (By.${element.locatorType}, \"${element.locator}\")")
+            }
+        }
+        
+        return PageObjectCode(
+            className = "GeneratedPage",
+            code = pageObjectCode,
+            elements = elements
+        )
+    }
+    
+    fun optimizeSelector(originalSelector: String, context: ElementContext): SelectorOptimization {
+        val alternatives = generateSelectorAlternatives(originalSelector, context)
+        
+        return SelectorOptimization(
+            original = originalSelector,
+            recommended = alternatives.first(),
+            alternatives = alternatives,
+            reasoning = "Optimized for stability and performance"
+        )
+    }
+    
+    private fun analyzeCode(psiFile: PsiFile, editor: Editor): CodeContext {
+        // Analyze the code to understand its purpose and structure
+        return CodeContext(
+            type = CodeType.WEB_PAGE,
+            elements = emptyList(),
+            actions = emptyList(),
+            metadata = emptyMap()
+        )
+    }
+    
+    private fun generateWebPageTest(context: CodeContext): String {
+        return buildString {
+            appendLine("Feature: ${context.getFeatureName()}")
+            appendLine("  Automated test for web page functionality")
+            appendLine()
+            appendLine("  Scenario: Basic page interaction")
+            appendLine("    Given I open the browser")
+            appendLine("    When I navigate to the page")
+            appendLine("    Then I should see the expected elements")
+        }
+    }
+    
+    private fun getLoginAutomationSuggestions(): List<AutomationSuggestion> {
+        return listOf(
+            AutomationSuggestion(
+                tool = "open_browser",
+                description = "Open browser for login testing",
+                parameters = mapOf("browser" to "chrome", "engine" to "playwright"),
+                priority = 1
+            ),
+            AutomationSuggestion(
+                tool = "navigate_to_url",
+                description = "Navigate to login page",
+                parameters = mapOf("url" to "https://example.com/login"),
+                priority = 2
+            ),
+            AutomationSuggestion(
+                tool = "fill_input",
+                description = "Fill username field",
+                parameters = mapOf("selector" to "#username", "text" to "testuser"),
+                priority = 3
+            ),
+            AutomationSuggestion(
+                tool = "fill_input",
+                description = "Fill password field",
+                parameters = mapOf("selector" to "#password", "text" to "password123"),
+                priority = 4
+            ),
+            AutomationSuggestion(
+                tool = "click_element",
+                description = "Click login button",
+                parameters = mapOf("selector" to "button[type='submit']"),
+                priority = 5
+            ),
+            AutomationSuggestion(
+                tool = "take_screenshot",
+                description = "Capture login result",
+                parameters = mapOf("filename" to "login-result.png"),
+                priority = 6
+            )
+        )
+    }
+    
+    private fun getFormAutomationSuggestions(): List<AutomationSuggestion> {
+        return listOf(
+            AutomationSuggestion(
+                tool = "fill_input",
+                description = "Fill form fields",
+                parameters = mapOf("selector" to "input[name='field']", "text" to "value"),
+                priority = 1
+            ),
+            AutomationSuggestion(
+                tool = "select_option",
+                description = "Select dropdown option",
+                parameters = mapOf("selector" to "select[name='dropdown']", "value" to "option1"),
+                priority = 2
+            ),
+            AutomationSuggestion(
+                tool = "click_element",
+                description = "Submit form",
+                parameters = mapOf("selector" to "input[type='submit']"),
+                priority = 3
+            )
+        )
+    }
+    
+    private fun getNavigationAutomationSuggestions(): List<AutomationSuggestion> {
+        return listOf(
+            AutomationSuggestion(
+                tool = "navigate_to_url",
+                description = "Navigate to page",
+                parameters = mapOf("url" to "https://example.com"),
+                priority = 1
+            ),
+            AutomationSuggestion(
+                tool = "click_element",
+                description = "Click navigation link",
+                parameters = mapOf("selector" to "a[href='/page']"),
+                priority = 2
+            ),
+            AutomationSuggestion(
+                tool = "go_back",
+                description = "Navigate back",
+                parameters = emptyMap(),
+                priority = 3
+            )
+        )
+    }
+    
+    private fun getTestCreationSuggestions(): List<AutomationSuggestion> {
+        return listOf(
+            AutomationSuggestion(
+                tool = "create_test_suite",
+                description = "Create comprehensive test suite",
+                parameters = mapOf(
+                    "feature_name" to "New Feature",
+                    "scenarios" to listOf(mapOf("name" to "Basic scenario"))
+                ),
+                priority = 1
+            ),
+            AutomationSuggestion(
+                tool = "create_page_object",
+                description = "Create page object model",
+                parameters = mapOf(
+                    "page_name" to "HomePage",
+                    "elements" to listOf(mapOf("name" to "element", "type" to "ID", "locator" to "id"))
+                ),
+                priority = 2
+            )
+        )
+    }
+    
+    private fun extractElementsFromHTML(htmlContent: String): List<PageElement> {
+        // Parse HTML and extract interactive elements
+        return emptyList()
+    }
+    
+    private fun generateSelectorAlternatives(selector: String, context: ElementContext): List<String> {
+        // Generate alternative selectors based on context
+        return listOf(selector)
+    }
+}
+
+data class CodeContext(
+    val type: CodeType,
+    val elements: List<String>,
+    val actions: List<String>,
+    val metadata: Map<String, Any>
+) {
+    fun getFeatureName(): String = metadata["featureName"] as? String ?: "Generated Feature"
+}
+
+enum class CodeType {
+    WEB_PAGE, API_ENDPOINT, FORM_HANDLER, GENERIC
+}
+
+data class AutomationSuggestion(
+    val tool: String,
+    val description: String,
+    val parameters: Map<String, Any>,
+    val priority: Int
+)
+
+data class PageObjectCode(
+    val className: String,
+    val code: String,
+    val elements: List<PageElement>
+)
+
+data class PageElement(
+    val name: String,
+    val locatorType: String,
+    val locator: String
+)
+
+data class ElementContext(
+    val tagName: String,
+    val attributes: Map<String, String>,
+    val parentContext: String
+)
+
+data class SelectorOptimization(
+    val original: String,
+    val recommended: String,
+    val alternatives: List<String>,
+    val reasoning: String
+)
+```
+
+---
+
+## 🔧 Code Generation
+
+### CodeGenerator.kt
+```kotlin
+package com.hakalab.mcp.codegen
+
+import com.intellij.openapi.command.WriteCommandAction
+import com.intellij.openapi.editor.Editor
+import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiFile
+import com.intellij.psi.PsiFileFactory
+
+class CodeGenerator(private val project: Project) {
+    
+    fun generateBDDFeature(config: FeatureConfig): String {
+        return buildString {
+            // Feature header
+            if (config.tags.isNotEmpty()) {
+                appendLine(config.tags.joinToString(" ") { "@$it" })
+            }
+            appendLine("Feature: ${config.name}")
+            appendLine("  ${config.description}")
+            appendLine()
+            
+            // Background (if any)
+            config.background?.let { background ->
+                appendLine("  Background:")
+                background.steps.forEach { step ->
+                    appendLine("    $step")
+                }
+                appendLine()
+            }
+            
+            // Scenarios
+            config.scenarios.forEach { scenario ->
+                if (scenario.tags.isNotEmpty()) {
+                    appendLine("  ${scenario.tags.joinToString(" ") { "@$it" }}")
+                }
+                appendLine("  Scenario: ${scenario.name}")
+                if (scenario.description.isNotEmpty()) {
+                    appendLine("    ${scenario.description}")
+                }
+                scenario.steps.forEach { step ->
+                    appendLine("    $step")
+                }
+                appendLine()
+            }
+        }
+    }
+    
+    fun generateStepDefinitions(feature: String, language: Language = Language.PYTHON): String {
+        val steps = extractStepsFromFeature(feature)
+        
+        return when (language) {
+            Language.PYTHON -> generatePythonSteps(steps)
+            Language.JAVA -> generateJavaSteps(steps)
+            Language.JAVASCRIPT -> generateJavaScriptSteps(steps)
+        }
+    }
+    
+    fun generatePageObject(elements: List<PageElement>, language: Language = Language.PYTHON): String {
+        return when (language) {
+            Language.PYTHON -> generatePythonPageObject(elements)
+            Language.JAVA -> generateJavaPageObject(elements)
+            Language.JAVASCRIPT -> generateJavaScriptPageObject(elements)
+        }
+    }
+    
+    fun generateAutomationScript(workflow: AutomationWorkflow): String {
+        return buildString {
+            appendLine("# Generated automation script")
+            appendLine("# Workflow: ${workflow.name}")
+            appendLine()
+            
+            // Imports
+            appendLine("import asyncio")
+            appendLine("from hakalab_mcp_client import MCPClient")
+            appendLine()
+            
+            // Main function
+            appendLine("async def main():")
+            appendLine("    client = MCPClient()")
+            appendLine("    await client.connect()")
+            appendLine()
+            
+            // Workflow steps
+            workflow.steps.forEach { step ->
+                appendLine("    # ${step.description}")
+                appendLine("    result = await client.call_tool('${step.toolName}', {")
+                step.parameters.forEach { (key, value) ->
+                    appendLine("        '$key': ${formatValue(value)},")
+                }
+                appendLine("    })")
+                appendLine("    print(f'${step.toolName}: {result}')")
+                appendLine()
+            }
+            
+            appendLine("    await client.disconnect()")
+            appendLine()
+            appendLine("if __name__ == '__main__':")
+            appendLine("    asyncio.run(main())")
+        }
+    }
+    
+    fun insertCodeIntoEditor(editor: Editor, code: String, insertAtCursor: Boolean = true) {
+        WriteCommandAction.runWriteCommandAction(project) {
+            val document = editor.document
+            val offset = if (insertAtCursor) editor.caretModel.offset else document.textLength
+            document.insertString(offset, code)
+        }
+    }
+    
+    fun createNewFile(fileName: String, content: String, directory: String = ""): PsiFile {
+        val fileType = getFileTypeFromExtension(fileName)
+        
+        return WriteCommandAction.computeAndWait<PsiFile, Exception> {
+            PsiFileFactory.getInstance(project).createFileFromText(fileName, fileType, content)
+        }
+    }
+    
+    private fun generatePythonSteps(steps: List<StepInfo>): String {
+        return buildString {
+            appendLine("from behave import given, when, then")
+            appendLine("from assertpy import assert_that")
+            appendLine("import asyncio")
+            appendLine("from hakalab_mcp_client import MCPClient")
+            appendLine()
+            
+            steps.forEach { step ->
+                val stepType = step.type.lowercase()
+                val functionName = step.text
+                    .replace(Regex("[^\\w\\s]"), "")
+                    .replace(Regex("\\s+"), "_")
+                    .lowercase()
+                
+                appendLine("@$stepType('${step.text}')")
+                appendLine("def ${functionName}(context):")
+                appendLine("    \"\"\"")
+                appendLine("    Step: ${step.text}")
+                appendLine("    \"\"\"")
+                appendLine("    # TODO: Implement step logic using MCP tools")
+                appendLine("    # Example:")
+                appendLine("    # result = await context.mcp_client.call_tool('click_element', {")
+                appendLine("    #     'selector': '#element-id'")
+                appendLine("    # })")
+                appendLine("    pass")
+                appendLine()
+            }
+        }
+    }
+    
+    private fun generateJavaSteps(steps: List<StepInfo>): String {
+        return buildString {
+            appendLine("import io.cucumber.java.en.*;")
+            appendLine("import static org.junit.Assert.*;")
+            appendLine()
+            appendLine("public class StepDefinitions {")
+            appendLine()
+            
+            steps.forEach { step ->
+                val methodName = step.text
+                    .replace(Regex("[^\\w\\s]"), "")
+                    .replace(Regex("\\s+"), "_")
+                    .lowercase()
+                
+                appendLine("    @${step.type}(\"${step.text}\")")
+                appendLine("    public void ${methodName}() {")
+                appendLine("        // TODO: Implement step logic using MCP tools")
+                appendLine("        // Example MCP tool call would go here")
+                appendLine("    }")
+                appendLine()
+            }
+            
+            appendLine("}")
+        }
+    }
+    
+    private fun generateJavaScriptSteps(steps: List<StepInfo>): String {
+        return buildString {
+            appendLine("const { Given, When, Then } = require('@cucumber/cucumber');")
+            appendLine("const { MCPClient } = require('hakalab-mcp-client');")
+            appendLine()
+            
+            steps.forEach { step ->
+                val stepType = step.type
+                appendLine("${stepType}('${step.text}', async function () {")
+                appendLine("  // TODO: Implement step logic using MCP tools")
+                appendLine("  // const result = await this.mcpClient.callTool('tool_name', {});")
+                appendLine("});")
+                appendLine()
+            }
+        }
+    }
+    
+    private fun generatePythonPageObject(elements: List<PageElement>): String {
+        return buildString {
+            appendLine("from selenium.webdriver.common.by import By")
+            appendLine()
+            appendLine("class GeneratedPage:")
+            appendLine("    def __init__(self, browser):")
+            appendLine("        self.browser = browser")
+            appendLine()
+            
+            elements.forEach { element ->
+                appendLine("    ${element.name} = (By.${element.locatorType}, \"${element.locator}\")")
+            }
+            
+            appendLine()
+            appendLine("    def wait_for_page_load(self):")
+            appendLine("        # Wait for page to load completely")
+            appendLine("        pass")
+        }
+    }
+    
+    private fun generateJavaPageObject(elements: List<PageElement>): String {
+        return buildString {
+            appendLine("import org.openqa.selenium.By;")
+            appendLine("import org.openqa.selenium.WebDriver;")
+            appendLine("import org.openqa.selenium.WebElement;")
+            appendLine()
+            appendLine("public class GeneratedPage {")
+            appendLine("    private WebDriver driver;")
+            appendLine()
+            appendLine("    public GeneratedPage(WebDriver driver) {")
+            appendLine("        this.driver = driver;")
+            appendLine("    }")
+            appendLine()
+            
+            elements.forEach { element ->
+                appendLine("    private By ${element.name}Locator = By.${element.locatorType.lowercase()}(\"${element.locator}\");")
+                appendLine()
+                appendLine("    public WebElement get${element.name.capitalize()}() {")
+                appendLine("        return driver.findElement(${element.name}Locator);")
+                appendLine("    }")
+                appendLine()
+            }
+            
+            appendLine("}")
+        }
+    }
+    
+    private fun generateJavaScriptPageObject(elements: List<PageElement>): String {
+        return buildString {
+            appendLine("class GeneratedPage {")
+            appendLine("    constructor(page) {")
+            appendLine("        this.page = page;")
+            appendLine("    }")
+            appendLine()
+            
+            elements.forEach { element ->
+                val selectorMethod = when (element.locatorType.uppercase()) {
+                    "ID" -> "page.locator('#${element.locator}')"
+                    "CSS_SELECTOR" -> "page.locator('${element.locator}')"
+                    "XPATH" -> "page.locator('xpath=${element.locator}')"
+                    else -> "page.locator('${element.locator}')"
+                }
+                
+                appendLine("    get ${element.name}() {")
+                appendLine("        return this.$selectorMethod;")
+                appendLine("    }")
+                appendLine()
+            }
+            
+            appendLine("}")
+            appendLine()
+            appendLine("module.exports = GeneratedPage;")
+        }
+    }
+    
+    private fun extractStepsFromFeature(feature: String): List<StepInfo> {
+        val steps = mutableListOf<StepInfo>()
+        val stepPattern = Regex("^\\s*(Given|When|Then|And|But)\\s+(.+)$", RegexOption.MULTILINE)
+        
+        stepPattern.findAll(feature).forEach { match ->
+            val type = match.groupValues[1]
+            val text = match.groupValues[2]
+            steps.add(StepInfo(type, text))
+        }
+        
+        return steps
+    }
+    
+    private fun formatValue(value: Any): String {
+        return when (value) {
+            is String -> "'$value'"
+            is Number -> value.toString()
+            is Boolean -> value.toString()
+            else -> "'$value'"
+        }
+    }
+    
+    private fun getFileTypeFromExtension(fileName: String): com.intellij.openapi.fileTypes.FileType {
+        // Return appropriate file type based on extension
+        return com.intellij.openapi.fileTypes.PlainTextFileType.INSTANCE
+    }
+}
+
+data class FeatureConfig(
+    val name: String,
+    val description: String,
+    val tags: List<String>,
+    val background: BackgroundConfig?,
+    val scenarios: List<ScenarioConfig>
+)
+
+data class BackgroundConfig(
+    val steps: List<String>
+)
+
+data class ScenarioConfig(
+    val name: String,
+    val description: String,
+    val tags: List<String>,
+    val steps: List<String>
+)
+
+data class StepInfo(
+    val type: String,
+    val text: String
+)
+
+data class AutomationWorkflow(
+    val name: String,
+    val description: String,
+    val steps: List<WorkflowStep>
+)
+
+enum class Language {
+    PYTHON, JAVA, JAVASCRIPT
+}
+```
+
+---
+
+## 🧪 Test Execution
+
+### TestRunner.kt
+```kotlin
+package com.hakalab.mcp.testing
+
+import com.intellij.execution.configurations.ConfigurationFactory
+import com.intellij.execution.configurations.ConfigurationType
+import com.intellij.execution.configurations.RunConfiguration
+import com.intellij.execution.configurations.RunConfigurationBase
+import com.intellij.openapi.project.Project
+import kotlinx.coroutines.runBlocking
+
+class MCPTestRunner(
+    private val project: Project,
+    private val mcpClient: MCPClient
+) {
+    
+    fun runSingleTest(testFile: String): TestResult {
+        return runBlocking {
+            try {
+                val result = mcpClient.callTool("execute_tests", mapOf(
+                    "feature_file" to testFile
+                ))
+                
+                if (result.error == null) {
+                    // Generate report
+                    mcpClient.callTool("generate_allure_report", emptyMap())
+                    
+                    TestResult.success(
+                        testFile = testFile,
+                        output = result.result?.get("message") as? String ?: "Test completed",
+                        duration = 0L // TODO: Extract duration from result
+                    )
+                } else {
+                    TestResult.failure(
+                        testFile = testFile,
+                        error = result.error.message,
+                        output = result.error.data as? String ?: ""
+                    )
+                }
+            } catch (e: Exception) {
+                TestResult.failure(
+                    testFile = testFile,
+                    error = e.message ?: "Unknown error",
+                    output = e.stackTraceToString()
+                )
+            }
+        }
+    }
+    
+    fun runTestSuite(tags: List<String> = emptyList(), parallel: Boolean = false): TestSuiteResult {
+        return runBlocking {
+            try {
+                val result = mcpClient.callTool("execute_tests", mapOf(
+                    "tags" to tags,
+                    "parallel" to parallel
+                ))
+                
+                if (result.error == null) {
+                    // Generate report
+                    val reportResult = mcpClient.callTool("generate_allure_report", emptyMap())
+                    
+                    TestSuiteResult.success(
+                        totalTests = 0, // TODO: Extract from result
+                        passedTests = 0,
+                        failedTests = 0,
+                        skippedTests = 0,
+                        duration = 0L,
+                        reportPath = extractReportPath(reportResult)
+                    )
+                } else {
+                    TestSuiteResult.failure(
+                        error = result.error.message,
+                        output = result.error.data as? String ?: ""
+                    )
+                }
+            } catch (e: Exception) {
+                TestSuiteResult.failure(
+                    error = e.message ?: "Unknown error",
+                    output = e.stackTraceToString()
+                )
+            }
+        }
+    }
+    
+    fun validateTestFiles(): ValidationResult {
+        return runBlocking {
+            try {
+                val result = mcpClient.callTool("sanitize_tests", emptyMap())
+                
+                if (result.error == null) {
+                    ValidationResult.success(
+                        message = result.result?.get("message") as? String ?: "All tests are valid"
+                    )
+                } else {
+                    ValidationResult.failure(
+                        issues = parseValidationIssues(result.error.data as? String ?: "")
+                    )
+                }
+            } catch (e: Exception) {
+                ValidationResult.failure(
+                    issues = listOf(ValidationIssue(
+                        file = "unknown",
+                        line = 0,
+                        message = e.message ?: "Validation failed",
+                        severity = ValidationSeverity.ERROR
+                    ))
+                )
+            }
+        }
+    }
+    
+    fun listAvailableTests(): List<TestFileInfo> {
+        return runBlocking {
+            try {
+                val result = mcpClient.callTool("list_test_files", mapOf(
+                    "file_type" to "all"
+                ))
+                
+                if (result.error == null) {
+                    parseTestFilesList(result.result?.get("message") as? String ?: "")
+                } else {
+                    emptyList()
+                }
+            } catch (e: Exception) {
+                emptyList()
+            }
+        }
+    }
+    
+    private fun extractReportPath(reportResult: MCPResponse): String? {
+        return reportResult.result?.get("report_path") as? String
+    }
+    
+    private fun parseValidationIssues(output: String): List<ValidationIssue> {
+        // Parse validation output and extract issues
+        return emptyList()
+    }
+    
+    private fun parseTestFilesList(output: String): List<TestFileInfo> {
+        // Parse test files list output
+        return emptyList()
+    }
+}
+
+sealed class TestResult {
+    data class Success(
+        val testFile: String,
+        val output: String,
+        val duration: Long
+    ) : TestResult()
+    
+    data class Failure(
+        val testFile: String,
+        val error: String,
+        val output: String
+    ) : TestResult()
+    
+    companion object {
+        fun success(testFile: String, output: String, duration: Long) = Success(testFile, output, duration)
+        fun failure(testFile: String, error: String, output: String) = Failure(testFile, error, output)
+    }
+}
+
+sealed class TestSuiteResult {
+    data class Success(
+        val totalTests: Int,
+        val passedTests: Int,
+        val failedTests: Int,
+        val skippedTests: Int,
+        val duration: Long,
+        val reportPath: String?
+    ) : TestSuiteResult()
+    
+    data class Failure(
+        val error: String,
+        val output: String
+    ) : TestSuiteResult()
+    
+    companion object {
+        fun success(
+            totalTests: Int,
+            passedTests: Int,
+            failedTests: Int,
+            skippedTests: Int,
+            duration: Long,
+            reportPath: String?
+        ) = Success(totalTests, passedTests, failedTests, skippedTests, duration, reportPath)
+        
+        fun failure(error: String, output: String) = Failure(error, output)
+    }
+}
+
+sealed class ValidationResult {
+    data class Success(val message: String) : ValidationResult()
+    data class Failure(val issues: List<ValidationIssue>) : ValidationResult()
+    
+    companion object {
+        fun success(message: String) = Success(message)
+        fun failure(issues: List<ValidationIssue>) = Failure(issues)
+    }
+}
+
+data class ValidationIssue(
+    val file: String,
+    val line: Int,
+    val message: String,
+    val severity: ValidationSeverity
+)
+
+enum class ValidationSeverity {
+    ERROR, WARNING, INFO
+}
+
+data class TestFileInfo(
+    val name: String,
+    val type: TestFileType,
+    val path: String,
+    val lastModified: Long
+)
+
+enum class TestFileType {
+    FEATURE, STEPS, PAGE_OBJECT
+}
+
+// Run Configuration for MCP Tests
+class MCPTestConfiguration(
+    project: Project,
+    factory: ConfigurationFactory,
+    name: String
+) : RunConfigurationBase<Any>(project, factory, name) {
+    
+    var testFile: String = ""
+    var tags: String = ""
+    var parallel: Boolean = false
+    
+    override fun getConfigurationEditor() = MCPTestConfigurationEditor()
+    
+    override fun getState(executor: com.intellij.execution.Executor, environment: com.intellij.execution.runners.ExecutionEnvironment) =
+        MCPTestRunState(environment, this)
+}
+
+class MCPTestConfigurationType : ConfigurationType {
+    override fun getDisplayName() = "MCP Test"
+    override fun getConfigurationTypeDescription() = "Run tests using Hakalab-MCP"
+    override fun getIcon() = null // TODO: Add icon
+    override fun getId() = "MCPTestConfiguration"
+    override fun getConfigurationFactories() = arrayOf(MCPTestConfigurationFactory(this))
+}
+
+class MCPTestConfigurationFactory(type: ConfigurationType) : ConfigurationFactory(type) {
+    override fun createTemplateConfiguration(project: Project): RunConfiguration {
+        return MCPTestConfiguration(project, this, "MCP Test")
+    }
+    
+    override fun getId() = "MCPTestConfigurationFactory"
+}
+```
+
+---
+
+Esta guía técnica proporciona todos los detalles necesarios para integrar Hakalab-MCP con plugins de IntelliJ IDEA y PyCharm, incluyendo ejemplos completos de código, configuraciones, y patrones de implementación para que la IA pueda utilizar efectivamente todas las capacidades del MCP.