deepdebug-local-agent 0.3.1

package/src/ai-engine.js

@@ -0,0 +1,861 @@
+// ============================================
+// 🧠 AI VIBE CODING ENGINE
+// Ficheiro: ai-engine.js
+// Coloca em: ~/deepdebug-local-agent/src/ai-engine.js
+// ============================================
+
+import { EventEmitter } from "events";
+import fs from "fs";
+import path from "path";
+import { exec } from "child_process";
+import { promisify } from "util";
+
+const execAsync = promisify(exec);
+
+/**
+ * AIVibeCodingEngine
+ *
+ * Sistema universal de auto-healing que usa AI para resolver
+ * QUALQUER erro automaticamente - não apenas startup.
+ *
+ * Features:
+ * - Monitorização de erros em tempo real
+ * - Classificação automática de erros
+ * - Quick fixes locais (sem chamar AI)
+ * - Escala para AI quando quick fixes falham
+ * - Histórico de fixes para reutilização
+ */
+export class AIVibeCodingEngine extends EventEmitter {
+    constructor(processManager, getWorkspaceRoot) {
+        super();
+        this.processManager = processManager;
+        this.getWorkspaceRoot = getWorkspaceRoot;
+        this.gatewayUrl = process.env.GATEWAY_URL || 'http://localhost:8085';
+        this.maxRetries = 3;
+        this.isActive = true;
+
+        // Histórico
+        this.errorHistory = [];
+        this.fixHistory = [];
+        this.pendingFixes = [];
+
+        // Estado
+        this.currentSession = null;
+        this.lastSuccessfulConfig = null;
+
+        console.log('🧠 [AI-Engine] Vibe Coding Engine initialized');
+        console.log('🧠 [AI-Engine] Gateway URL:', this.gatewayUrl);
+
+        this.setupErrorMonitoring();
+    }
+
+    // ============================================
+    // ERROR MONITORING
+    // ============================================
+
+    setupErrorMonitoring() {
+        // Monitorar logs do ProcessManager
+        this.processManager.on('log', async ({ serviceId, message, type }) => {
+            if (this.isActive && message && this.isError(message)) {
+                await this.handleRuntimeError(serviceId, message, type);
+            }
+        });
+
+        // Monitorar crashes
+        this.processManager.on('stopped', async ({ serviceId, code, signal }) => {
+            if (this.isActive && code !== 0 && code !== null) {
+                console.log(`🧠 [AI-Engine] Process ${serviceId} crashed (code: ${code})`);
+                await this.handleCrash(serviceId, code, signal);
+            }
+        });
+
+        // Monitorar erros de processo
+        this.processManager.on('error', async ({ serviceId, error }) => {
+            if (this.isActive) {
+                console.log(`🧠 [AI-Engine] Process error: ${error}`);
+                await this.handleProcessError(serviceId, error);
+            }
+        });
+    }
+
+    // ============================================
+    // ERROR DETECTION & CLASSIFICATION
+    // ============================================
+
+    isError(message) {
+        if (!message || typeof message !== 'string') return false;
+
+        const errorPatterns = [
+            // Java/Spring
+            /exception/i,
+            /error.*failed/i,
+            /failed.*to.*start/i,
+            /application.*run.*failed/i,
+            /bean.*creation.*exception/i,
+            /no.*qualifying.*bean/i,
+            /could.*not.*autowire/i,
+            /circular.*dependency/i,
+
+            // Database
+            /connection.*refused/i,
+            /unable.*to.*connect/i,
+            /access.*denied.*for.*user/i,
+            /unknown.*database/i,
+            /table.*doesn.*exist/i,
+            /sql.*syntax.*error/i,
+            /jdbc.*exception/i,
+            /hikari.*pool/i,
+
+            // Network/Port
+            /port.*in.*use/i,
+            /address.*already.*in.*use/i,
+            /bind.*failed/i,
+            /connection.*timed.*out/i,
+
+            // Compilation/Build
+            /compilation.*failed/i,
+            /syntax.*error/i,
+            /cannot.*resolve/i,
+            /cannot.*find.*symbol/i,
+
+            // Runtime
+            /null.*pointer/i,
+            /class.*not.*found/i,
+            /no.*such.*method/i,
+            /illegal.*argument/i,
+            /stack.*overflow/i,
+            /out.*of.*memory/i,
+
+            // File/Permission
+            /no.*such.*file/i,
+            /permission.*denied/i,
+
+            // Node.js
+            /module.*not.*found/i,
+            /cannot.*find.*module/i,
+            /enoent/i,
+            /eaddrinuse/i
+        ];
+
+        return errorPatterns.some(p => p.test(message));
+    }
+
+    classifyError(message) {
+        if (!message) return { type: 'unknown', severity: 'low', autoFixable: false };
+
+        const classifications = {
+            'database_connection': {
+                patterns: [/connection.*refused.*\d{4}/i, /jdbc/i, /hikari/i, /datasource/i, /sql.*server/i, /mysql/i, /postgres/i],
+                severity: 'high',
+                autoFixable: true
+            },
+            'database_schema': {
+                patterns: [/table.*doesn.*exist/i, /unknown.*column/i, /sql.*syntax/i],
+                severity: 'medium',
+                autoFixable: false
+            },
+            'port_conflict': {
+                patterns: [/port.*in.*use/i, /address.*already/i, /eaddrinuse/i, /bind.*failed/i],
+                severity: 'medium',
+                autoFixable: true
+            },
+            'dependency_missing': {
+                patterns: [/class.*not.*found/i, /no.*such.*method/i, /module.*not.*found/i],
+                severity: 'high',
+                autoFixable: true
+            },
+            'compilation': {
+                patterns: [/compilation.*failed/i, /syntax.*error/i, /cannot.*resolve/i, /cannot.*find.*symbol/i],
+                severity: 'high',
+                autoFixable: true
+            },
+            'configuration': {
+                patterns: [/no.*qualifying.*bean/i, /could.*not.*autowire/i, /property.*not.*found/i],
+                severity: 'medium',
+                autoFixable: true
+            },
+            'permission': {
+                patterns: [/permission.*denied/i, /access.*denied/i, /eacces/i],
+                severity: 'high',
+                autoFixable: false
+            },
+            'memory': {
+                patterns: [/out.*of.*memory/i, /heap.*space/i, /gc.*overhead/i],
+                severity: 'critical',
+                autoFixable: false
+            },
+            'null_pointer': {
+                patterns: [/null.*pointer/i, /cannot.*invoke.*null/i],
+                severity: 'medium',
+                autoFixable: true
+            },
+            'circular_dependency': {
+                patterns: [/circular.*dependency/i, /circular.*reference/i],
+                severity: 'high',
+                autoFixable: true
+            }
+        };
+
+        for (const [type, config] of Object.entries(classifications)) {
+            if (config.patterns.some(p => p.test(message))) {
+                return { type, ...config };
+            }
+        }
+
+        return { type: 'unknown', severity: 'low', autoFixable: false };
+    }
+
+    // ============================================
+    // ERROR HANDLERS
+    // ============================================
+
+    async handleRuntimeError(serviceId, errorMessage, type) {
+        const classification = this.classifyError(errorMessage);
+
+        // Debounce: evitar duplicatas em 5 segundos
+        const recentSimilar = this.errorHistory.find(e =>
+            e.classification.type === classification.type &&
+            Date.now() - e.timestamp < 5000
+        );
+
+        if (recentSimilar) return;
+
+        const errorEntry = {
+            id: `err_${Date.now()}`,
+            serviceId,
+            message: errorMessage,
+            classification,
+            timestamp: Date.now(),
+            handled: false
+        };
+
+        this.errorHistory.push(errorEntry);
+        this.trimHistory();
+
+        console.log(`🧠 [AI-Engine] Error detected: ${classification.type} (${classification.severity})`);
+        console.log(`   Message: ${errorMessage.substring(0, 150)}...`);
+
+        // Emitir evento
+        this.emit('error_detected', errorEntry);
+
+        // Se auto-fixável, preparar fix
+        if (classification.autoFixable) {
+            const quickFix = this.getQuickFix(classification.type, errorMessage);
+            if (quickFix) {
+                console.log(`💡 [AI-Engine] Quick fix available: ${quickFix.description}`);
+                this.pendingFixes.push({
+                    errorId: errorEntry.id,
+                    fix: quickFix,
+                    timestamp: Date.now()
+                });
+
+                this.emit('fix_available', { error: errorEntry, fix: quickFix });
+            }
+        }
+    }
+
+    async handleCrash(serviceId, exitCode, signal) {
+        console.log(`🧠 [AI-Engine] Handling crash for ${serviceId}...`);
+
+        const recentErrors = this.errorHistory
+            .filter(e => e.serviceId === serviceId && Date.now() - e.timestamp < 60000)
+            .slice(-10);
+
+        this.emit('crash_detected', { serviceId, exitCode, signal, recentErrors });
+
+        if (this.pendingFixes.length > 0) {
+            console.log(`💡 [AI-Engine] ${this.pendingFixes.length} fixes pending for next start`);
+        }
+    }
+
+    async handleProcessError(serviceId, error) {
+        const classification = this.classifyError(error);
+
+        this.errorHistory.push({
+            id: `proc_err_${Date.now()}`,
+            serviceId,
+            message: error,
+            classification,
+            timestamp: Date.now(),
+            source: 'process'
+        });
+    }
+
+    // ============================================
+    // QUICK FIXES
+    // ============================================
+
+    getQuickFix(errorType, message) {
+        const fixes = {
+            'database_connection': () => ({
+                description: 'Database unavailable - switch to test/local profile',
+                action: 'change_profile',
+                profiles: ['test', 'local', 'h2', 'memory'],
+                priority: 1
+            }),
+            'port_conflict': () => {
+                const portMatch = message.match(/port[:\s]*(\d+)/i);
+                const currentPort = portMatch ? parseInt(portMatch[1]) : 8080;
+                return {
+                    description: `Port ${currentPort} in use - try ${currentPort + 1}`,
+                    action: 'change_port',
+                    currentPort,
+                    newPort: currentPort + 1,
+                    priority: 1
+                };
+            },
+            'dependency_missing': () => ({
+                description: 'Missing dependency - clean and reinstall',
+                action: 'reinstall_dependencies',
+                priority: 2
+            }),
+            'compilation': () => ({
+                description: 'Compilation error - analyze with AI',
+                action: 'analyze_with_ai',
+                priority: 3
+            }),
+            'configuration': () => ({
+                description: 'Configuration error - use default config',
+                action: 'use_default_config',
+                priority: 2
+            }),
+            'null_pointer': () => ({
+                description: 'Null pointer - analyze stacktrace with AI',
+                action: 'analyze_with_ai',
+                priority: 3
+            }),
+            'circular_dependency': () => ({
+                description: 'Circular dependency - analyze with AI',
+                action: 'analyze_with_ai',
+                priority: 3
+            })
+        };
+
+        const fixFn = fixes[errorType];
+        return fixFn ? fixFn() : null;
+    }
+
+    // ============================================
+    // AUTO-HEALING START
+    // ============================================
+
+    async startWithAutoHealing(config) {
+        console.log('🧠 [AI-Engine] Starting with auto-healing...');
+        console.log(`🧠 [AI-Engine] Config: ${config.command} ${(config.args || []).join(' ')}`);
+
+        this.currentSession = {
+            startTime: Date.now(),
+            attempts: [],
+            originalConfig: { ...config }
+        };
+
+        let currentConfig = { ...config };
+        let attempts = 0;
+        let lastError = null;
+
+        while (attempts < this.maxRetries) {
+            attempts++;
+            console.log(`\n🔄 [AI-Engine] Attempt ${attempts}/${this.maxRetries}`);
+
+            // Aplicar fixes pendentes
+            if (attempts > 1 && this.pendingFixes.length > 0) {
+                const fix = this.pendingFixes.shift();
+                console.log(`💡 [AI-Engine] Applying fix: ${fix.fix.description}`);
+                currentConfig = await this.applyFix(currentConfig, fix.fix);
+            }
+
+            // Recompilar se necessário
+            if (currentConfig.recompile) {
+                console.log('🔨 [AI-Engine] Recompiling...');
+                const compileResult = await this.recompile();
+                if (!compileResult.success) {
+                    lastError = compileResult.error;
+                    const aiAnalysis = await this.analyzeWithAI('compilation', compileResult.error, currentConfig);
+                    if (aiAnalysis?.fix) {
+                        this.pendingFixes.push({ fix: aiAnalysis.fix });
+                    }
+                    continue;
+                }
+                delete currentConfig.recompile;
+            }
+
+            // Tentar iniciar
+            const result = await this.attemptStart(currentConfig);
+
+            this.currentSession.attempts.push({
+                attempt: attempts,
+                config: { ...currentConfig },
+                result: result.success ? 'success' : 'failed',
+                error: result.error,
+                timestamp: Date.now()
+            });
+
+            if (result.success) {
+                console.log(`\n✅ [AI-Engine] Success after ${attempts} attempt(s)`);
+
+                this.lastSuccessfulConfig = { ...currentConfig };
+
+                if (attempts > 1) {
+                    this.fixHistory.push({
+                        originalConfig: this.currentSession.originalConfig,
+                        fixedConfig: currentConfig,
+                        attempts,
+                        timestamp: Date.now()
+                    });
+                }
+
+                this.emit('start_success', { attempts, config: currentConfig, autoHealed: attempts > 1 });
+
+                return {
+                    ok: true,
+                    attempts,
+                    config: currentConfig,
+                    autoHealed: attempts > 1,
+                    session: this.currentSession
+                };
+            }
+
+            // Falhou
+            lastError = result.error;
+            console.log(`❌ [AI-Engine] Attempt ${attempts} failed: ${lastError?.substring(0, 100)}...`);
+
+            // Obter fix
+            const fix = await this.getFix(result.error, result.logs, currentConfig);
+
+            if (fix) {
+                console.log(`💡 [AI-Engine] Fix: ${fix.description}`);
+                currentConfig = await this.applyFix(currentConfig, fix);
+            } else {
+                // Tentar AI
+                console.log(`🤖 [AI-Engine] Requesting AI analysis...`);
+                const aiAnalysis = await this.analyzeWithAI('startup', lastError, currentConfig);
+                if (aiAnalysis?.newConfig) {
+                    console.log(`🤖 [AI-Engine] AI suggested: ${aiAnalysis.suggestion}`);
+                    currentConfig = aiAnalysis.newConfig;
+                } else {
+                    console.log(`⚠️ [AI-Engine] No fix available`);
+                    break;
+                }
+            }
+        }
+
+        console.log(`\n❌ [AI-Engine] Failed after ${attempts} attempts`);
+
+        this.emit('start_failed', { attempts, lastError, session: this.currentSession });
+
+        return {
+            ok: false,
+            attempts,
+            error: lastError,
+            config: currentConfig,
+            session: this.currentSession
+        };
+    }
+
+    async attemptStart(config) {
+        return new Promise(async (resolve) => {
+            const logs = [];
+            let startupError = null;
+            let resolved = false;
+
+            const cleanup = () => {
+                this.processManager.off('log', logListener);
+                this.processManager.off('started', startedListener);
+                this.processManager.off('stopped', stoppedListener);
+                clearTimeout(timeout);
+            };
+
+            const logListener = ({ serviceId, message }) => {
+                if (serviceId === 'test-local' && message) {
+                    logs.push(message);
+                    if (this.isError(message) && !startupError) {
+                        startupError = message;
+                    }
+                }
+            };
+
+            const startedListener = ({ serviceId }) => {
+                if (serviceId === 'test-local' && !resolved) {
+                    resolved = true;
+                    cleanup();
+                    resolve({ success: true, logs });
+                }
+            };
+
+            const stoppedListener = ({ serviceId, code }) => {
+                if (serviceId === 'test-local' && code !== 0 && !resolved) {
+                    resolved = true;
+                    cleanup();
+                    resolve({
+                        success: false,
+                        error: startupError || `Process exited with code ${code}`,
+                        logs,
+                        exitCode: code
+                    });
+                }
+            };
+
+            const timeout = setTimeout(() => {
+                if (!resolved) {
+                    resolved = true;
+                    cleanup();
+                    if (!startupError) {
+                        resolve({ success: true, logs, partial: true });
+                    } else {
+                        resolve({ success: false, error: startupError, logs, timeout: true });
+                    }
+                }
+            }, 90000);
+
+            this.processManager.on('log', logListener);
+            this.processManager.on('started', startedListener);
+            this.processManager.on('stopped', stoppedListener);
+
+            try {
+                await this.processManager.start('test-local', config);
+            } catch (err) {
+                if (!resolved) {
+                    resolved = true;
+                    cleanup();
+                    resolve({ success: false, error: err.message, logs });
+                }
+            }
+        });
+    }
+
+    // ============================================
+    // FIX RESOLUTION
+    // ============================================
+
+    async getFix(error, logs, currentConfig) {
+        const classification = this.classifyError(error);
+
+        // Quick fix local
+        const quickFix = this.getQuickFix(classification.type, error);
+        if (quickFix && quickFix.action !== 'analyze_with_ai') {
+            return quickFix;
+        }
+
+        // Verificar histórico
+        const similarFix = this.findSimilarFix(classification.type);
+        if (similarFix) {
+            console.log(`📚 [AI-Engine] Found similar fix in history`);
+            return {
+                description: 'Applying previously successful fix',
+                action: 'apply_historical',
+                config: similarFix.fixedConfig
+            };
+        }
+
+        return quickFix;
+    }
+
+    findSimilarFix(errorType) {
+        return this.fixHistory.find(f => {
+            const originalErrors = this.errorHistory.filter(e =>
+                e.timestamp >= f.timestamp - 60000 &&
+                e.timestamp <= f.timestamp
+            );
+            return originalErrors.some(e => e.classification?.type === errorType);
+        });
+    }
+
+    async applyFix(config, fix) {
+        const newConfig = { ...config };
+
+        switch (fix.action) {
+            case 'change_profile':
+                const profiles = fix.profiles || ['test', 'local', 'h2'];
+                const currentProfile = config.profile;
+                const nextProfile = profiles.find(p => p !== currentProfile) || profiles[0];
+
+                newConfig.profile = nextProfile;
+                newConfig.args = this.updateArgs(config.args, 'profile', nextProfile);
+                newConfig.env = {
+                    ...config.env,
+                    SPRING_PROFILES_ACTIVE: nextProfile
+                };
+                console.log(`   → Profile: ${currentProfile} → ${nextProfile}`);
+                break;
+
+            case 'change_port':
+                const newPort = fix.newPort || (config.port || 8080) + 1;
+                newConfig.port = newPort;
+                newConfig.args = this.updateArgs(config.args, 'port', newPort);
+                newConfig.env = {
+                    ...config.env,
+                    SERVER_PORT: String(newPort),
+                    PORT: String(newPort)
+                };
+                console.log(`   → Port: ${config.port} → ${newPort}`);
+                break;
+
+            case 'reinstall_dependencies':
+                newConfig.recompile = true;
+                newConfig.cleanInstall = true;
+                console.log(`   → Will reinstall dependencies`);
+                break;
+
+            case 'use_default_config':
+                newConfig.profile = null;
+                newConfig.args = this.removeArg(config.args, 'profile');
+                delete newConfig.env?.SPRING_PROFILES_ACTIVE;
+                console.log(`   → Using default config`);
+                break;
+
+            case 'apply_historical':
+                if (fix.config) {
+                    Object.assign(newConfig, fix.config);
+                    console.log(`   → Applied historical fix`);
+                }
+                break;
+
+            case 'analyze_with_ai':
+                newConfig.needsAIAnalysis = true;
+                break;
+        }
+
+        return newConfig;
+    }
+
+    // ============================================
+    // AI ANALYSIS
+    // ============================================
+
+    async analyzeWithAI(errorType, error, currentConfig) {
+        console.log(`🤖 [AI-Engine] Requesting AI analysis for ${errorType}...`);
+
+        try {
+            const workspaceRoot = this.getWorkspaceRoot();
+            const configFiles = this.collectConfigFiles(workspaceRoot);
+            const recentLogs = this.errorHistory.slice(-20).map(e => e.message).join('\n');
+
+            const response = await fetch(`${this.gatewayUrl}/api/test-local/analyze-startup-error`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-Tenant-ID': 'default'
+                },
+                body: JSON.stringify({
+                    context: {
+                        workspace: workspaceRoot,
+                        error,
+                        logs: recentLogs,
+                        configFiles,
+                        errorType
+                    },
+                    currentConfig,
+                    attempt: this.currentSession?.attempts?.length || 0,
+                    errorHistory: this.errorHistory.slice(-10)
+                }),
+                signal: AbortSignal.timeout(30000)
+            });
+
+            if (response.ok) {
+                const analysis = await response.json();
+                console.log(`🤖 [AI-Engine] AI response received`);
+                return analysis;
+            } else {
+                console.log(`⚠️ [AI-Engine] Gateway returned ${response.status}`);
+            }
+        } catch (err) {
+            console.log(`⚠️ [AI-Engine] AI unavailable: ${err.message}`);
+        }
+
+        // Fallback local
+        return this.localAIFallback(errorType, error, currentConfig);
+    }
+
+    localAIFallback(errorType, error, currentConfig) {
+        console.log(`🔧 [AI-Engine] Using local fallback`);
+
+        if (errorType === 'startup' || errorType === 'database_connection') {
+            const triedProfiles = this.currentSession?.attempts
+                ?.map(a => a.config?.profile)
+                ?.filter(Boolean) || [];
+
+            const allProfiles = ['test', 'local', 'h2', 'dev', 'default'];
+            const nextProfile = allProfiles.find(p => !triedProfiles.includes(p));
+
+            if (nextProfile) {
+                return {
+                    suggestion: `Trying ${nextProfile} profile`,
+                    newConfig: {
+                        ...currentConfig,
+                        profile: nextProfile,
+                        args: this.updateArgs(currentConfig.args, 'profile', nextProfile),
+                        env: {
+                            ...currentConfig.env,
+                            SPRING_PROFILES_ACTIVE: nextProfile
+                        }
+                    }
+                };
+            }
+        }
+
+        return null;
+    }
+
+    // ============================================
+    // COMPILATION
+    // ============================================
+
+    async recompile() {
+        const workspaceRoot = this.getWorkspaceRoot();
+        if (!workspaceRoot) {
+            return { success: false, error: 'No workspace set' };
+        }
+
+        try {
+            // Importar detectProject dinamicamente para evitar dependência circular
+            const { detectProject } = await import('./detectors.js');
+            const meta = await detectProject(workspaceRoot);
+
+            let cmd;
+            if (meta.buildTool === 'maven') {
+                cmd = 'mvn clean install -DskipTests';
+            } else if (meta.buildTool === 'gradle') {
+                cmd = './gradlew clean build -x test';
+            } else if (meta.buildTool === 'npm' || meta.buildTool === 'yarn') {
+                cmd = `${meta.buildTool} install`;
+            } else {
+                return { success: true };
+            }
+
+            console.log(`🔨 [AI-Engine] Running: ${cmd}`);
+
+            const { stdout, stderr } = await execAsync(cmd, {
+                cwd: workspaceRoot,
+                timeout: 300000
+            });
+
+            return { success: true, stdout, stderr };
+        } catch (err) {
+            return { success: false, error: err.message, stderr: err.stderr };
+        }
+    }
+
+    // ============================================
+    // CONFIG FILES COLLECTION
+    // ============================================
+
+    collectConfigFiles(workspaceRoot) {
+        if (!workspaceRoot) return {};
+
+        const configs = {};
+        const paths = [
+            'src/main/resources/application.yml',
+            'src/main/resources/application.yaml',
+            'src/main/resources/application.properties',
+            'src/main/resources/application-dev.yml',
+            'src/main/resources/application-local.yml',
+            'src/main/resources/application-test.yml',
+            'src/main/resources/application-h2.yml',
+            'pom.xml',
+            'build.gradle',
+            'package.json',
+            '.env'
+        ];
+
+        const fs = require('fs');
+        const path = require('path');
+
+        for (const p of paths) {
+            const fullPath = path.join(workspaceRoot, p);
+            if (fs.existsSync(fullPath)) {
+                try {
+                    const content = fs.readFileSync(fullPath, 'utf8');
+                    configs[p] = content.substring(0, 5000);
+                } catch (e) {}
+            }
+        }
+
+        return configs;
+    }
+
+    // ============================================
+    // HELPER METHODS
+    // ============================================
+
+    updateArgs(args, type, value) {
+        if (!args) args = [];
+        let newArgs = [...args];
+
+        if (type === 'profile') {
+            newArgs = newArgs.filter(a =>
+                !a.includes('spring.profiles.active') &&
+                !a.includes('spring-boot.run.profiles')
+            );
+            const jarIndex = newArgs.findIndex(a => a === '-jar');
+            if (jarIndex >= 0) {
+                newArgs.splice(jarIndex, 0, `-Dspring.profiles.active=${value}`);
+            } else {
+                newArgs.unshift(`-Dspring.profiles.active=${value}`);
+            }
+        }
+
+        if (type === 'port') {
+            newArgs = newArgs.filter(a => !a.includes('server.port'));
+            newArgs.push(`--server.port=${value}`);
+        }
+
+        return newArgs;
+    }
+
+    removeArg(args, type) {
+        if (!args) return [];
+
+        if (type === 'profile') {
+            return args.filter(a =>
+                !a.includes('spring.profiles.active') &&
+                !a.includes('spring-boot.run.profiles')
+            );
+        }
+
+        return args;
+    }
+
+    trimHistory() {
+        if (this.errorHistory.length > 200) {
+            this.errorHistory = this.errorHistory.slice(-200);
+        }
+        if (this.fixHistory.length > 50) {
+            this.fixHistory = this.fixHistory.slice(-50);
+        }
+    }
+
+    // ============================================
+    // PUBLIC API
+    // ============================================
+
+    getStatus() {
+        return {
+            active: this.isActive,
+            gatewayUrl: this.gatewayUrl,
+            maxRetries: this.maxRetries,
+            currentSession: this.currentSession,
+            stats: {
+                totalErrors: this.errorHistory.length,
+                totalFixes: this.fixHistory.length,
+                pendingFixes: this.pendingFixes.length
+            },
+            recentErrors: this.errorHistory.slice(-5),
+            recentFixes: this.fixHistory.slice(-3),
+            lastSuccessfulConfig: this.lastSuccessfulConfig
+        };
+    }
+
+    setActive(active) {
+        this.isActive = active;
+        console.log(`🧠 [AI-Engine] Auto-healing ${active ? 'enabled' : 'disabled'}`);
+    }
+
+    clearHistory() {
+        this.errorHistory = [];
+        this.fixHistory = [];
+        this.pendingFixes = [];
+        console.log('🧠 [AI-Engine] History cleared');
+    }
+}
+
+export default AIVibeCodingEngine;