deepdebug-local-agent 0.3.1

package/src/runtimes/java/maven-runtime.js

@@ -0,0 +1,418 @@
+import path from 'path';
+import { BaseRuntime } from '../base-runtime.js';
+import { exists, readFile } from '../../utils/fs-utils.js';
+import { run } from '../../utils/exec-utils.js';
+
+/**
+ * MavenRuntime
+ *
+ * Runtime para projetos Java com Maven.
+ * Suporta Spring Boot, Quarkus, e projetos Maven genéricos.
+ */
+export class MavenRuntime extends BaseRuntime {
+
+    constructor() {
+        super();
+        this.framework = null; // Detectado dinamicamente
+    }
+
+    // ==========================================
+    // IDENTIFICATION
+    // ==========================================
+
+    getId() {
+        return 'java-maven';
+    }
+
+    getName() {
+        return 'Java (Maven)';
+    }
+
+    getLanguage() {
+        return 'java';
+    }
+
+    getBuildTool() {
+        return 'maven';
+    }
+
+    // ==========================================
+    // DETECTION
+    // ==========================================
+
+    getMarkerFiles() {
+        return ['pom.xml'];
+    }
+
+    async isCompatible(workspacePath) {
+        const pomPath = path.join(workspacePath, 'pom.xml');
+        return exists(pomPath);
+    }
+
+    async detectProject(workspacePath) {
+        const pomPath = path.join(workspacePath, 'pom.xml');
+        const pomContent = await readFile(pomPath, 'utf8');
+
+        // Parse básico do pom.xml
+        const name = this.extractXmlValue(pomContent, 'artifactId') ||
+            path.basename(workspacePath);
+        const version = this.extractXmlValue(pomContent, 'version') || '0.0.1';
+
+        // Detectar framework
+        const framework = this.detectFramework(pomContent);
+        this.framework = framework;
+
+        // Detectar porta
+        const port = await this.detectPort(workspacePath);
+
+        return {
+            name,
+            version,
+            language: 'java',
+            framework,
+            buildTool: 'maven',
+            port
+        };
+    }
+
+    detectFramework(pomContent) {
+        if (pomContent.includes('spring-boot-starter') ||
+            pomContent.includes('org.springframework.boot')) {
+            return 'spring-boot';
+        }
+        if (pomContent.includes('quarkus')) {
+            return 'quarkus';
+        }
+        if (pomContent.includes('micronaut')) {
+            return 'micronaut';
+        }
+        if (pomContent.includes('jakarta.') || pomContent.includes('javax.')) {
+            return 'jakarta-ee';
+        }
+        return 'java-plain';
+    }
+
+    /**
+     * Extrai valor XML ignorando o bloco <parent>
+     * Isso é necessário porque o <parent> tem seu próprio artifactId/version
+     */
+    extractXmlValue(xml, tag) {
+        // Remove o bloco <parent>...</parent> para não pegar valores do parent
+        const xmlWithoutParent = xml.replace(/<parent>[\s\S]*?<\/parent>/gi, '');
+
+        const regex = new RegExp(`<${tag}>([^<]+)</${tag}>`);
+        const match = xmlWithoutParent.match(regex);
+        return match ? match[1].trim() : null;
+    }
+
+    // ==========================================
+    // BUILD & RUN
+    // ==========================================
+
+    async install(workspacePath, options = {}) {
+        const startTime = Date.now();
+        const result = await run('mvn', ['dependency:resolve', '-q'], workspacePath);
+
+        return {
+            ...result,
+            duration: Date.now() - startTime
+        };
+    }
+
+    async build(workspacePath, options = {}) {
+        const startTime = Date.now();
+        const skipTests = options.skipTests ? '-DskipTests' : '';
+        const args = ['compile', '-q'];
+        if (skipTests) args.push(skipTests);
+
+        const result = await run('mvn', args, workspacePath);
+
+        return {
+            ...result,
+            duration: Date.now() - startTime
+        };
+    }
+
+    getStartCommand(options = {}) {
+        const framework = options.framework || this.framework || 'spring-boot';
+        const port = options.port; // Pode ser undefined se não precisa sobrescrever
+        const profile = options.profile || 'default';
+
+        if (framework === 'spring-boot') {
+            const args = [
+                'spring-boot:run',
+                '-Dspring-boot.run.fork=false'  // Mantém Java no mesmo processo
+            ];
+
+            // Só adiciona porta se foi explicitamente fornecida
+            // Se o projeto já tem porta no application.yml, não precisa
+            if (port) {
+                args.push(`-Dspring-boot.run.arguments=--server.port=${port}`);
+            }
+
+            // Perfil ativo
+            if (profile !== 'default') {
+                args.push(`-Dspring.profiles.active=${profile}`);
+            }
+
+            return {
+                cmd: 'mvn',
+                args,
+                env: port ? { SERVER_PORT: String(port) } : {}
+            };
+        }
+
+        if (framework === 'quarkus') {
+            return {
+                cmd: 'mvn',
+                args: [
+                    'quarkus:dev',
+                    `-Dquarkus.http.port=${port || 8080}`,
+                    '-q'
+                ],
+                env: {
+                    QUARKUS_HTTP_PORT: String(port || 8080)
+                }
+            };
+        }
+
+        // Fallback genérico
+        return {
+            cmd: 'mvn',
+            args: ['exec:java', '-q'],
+            env: {}
+        };
+    }
+
+    getReadyPattern() {
+        if (this.framework === 'spring-boot') {
+            return /Started \w+ in \d+\.?\d* seconds/i;
+        }
+        if (this.framework === 'quarkus') {
+            return /Quarkus .* started in/i;
+        }
+        return /started|listening|ready/i;
+    }
+
+    getDefaultPort() {
+        if (this.framework === 'quarkus') {
+            return 8080;
+        }
+        return 8080;
+    }
+
+    async detectPort(workspacePath) {
+        // Tentar application.properties
+        const propsPath = path.join(workspacePath, 'src/main/resources/application.properties');
+        if (await exists(propsPath)) {
+            const content = await readFile(propsPath, 'utf8');
+            const port = this.extractPortFromProperties(content);
+            if (port) return port;
+        }
+
+        // Tentar application.yml
+        const ymlPath = path.join(workspacePath, 'src/main/resources/application.yml');
+        if (await exists(ymlPath)) {
+            const content = await readFile(ymlPath, 'utf8');
+            const port = this.extractPortFromYaml(content);
+            if (port) return port;
+        }
+
+        // Tentar application.yaml
+        const yamlPath = path.join(workspacePath, 'src/main/resources/application.yaml');
+        if (await exists(yamlPath)) {
+            const content = await readFile(yamlPath, 'utf8');
+            const port = this.extractPortFromYaml(content);
+            if (port) return port;
+        }
+
+        return this.getDefaultPort();
+    }
+
+    /**
+     * Extrai porta de application.properties
+     * Suporta: server.port=8090 ou server.port=${PORT:8090}
+     */
+    extractPortFromProperties(content) {
+        // Primeiro tenta: server.port=8090
+        let match = content.match(/server\.port\s*=\s*(\d+)/);
+        if (match) return parseInt(match[1]);
+
+        // Depois tenta: server.port=${PORT:8090} ou ${SERVER_PORT:8090}
+        match = content.match(/server\.port\s*=\s*\$\{[^:}]+:(\d+)\}/);
+        if (match) return parseInt(match[1]);
+
+        return null;
+    }
+
+    /**
+     * Extrai porta de application.yml/yaml
+     * Suporta: port: 8090 ou port: ${PORT:8090}
+     */
+    extractPortFromYaml(content) {
+        // Primeiro tenta: port: 8090
+        let match = content.match(/port:\s*(\d+)/);
+        if (match) return parseInt(match[1]);
+
+        // Depois tenta: port: ${PORT:8090} ou port: ${SERVER_PORT:8090}
+        match = content.match(/port:\s*\$\{[^:}]+:(\d+)\}/);
+        if (match) return parseInt(match[1]);
+
+        return null;
+    }
+
+    // ==========================================
+    // TEST
+    // ==========================================
+
+    async test(workspacePath, options = {}) {
+        const startTime = Date.now();
+
+        // Clean primeiro
+        await run('mvn', ['clean', '-q'], workspacePath);
+
+        // Rodar testes
+        const result = await run('mvn', ['test', '-q'], workspacePath);
+
+        const testResult = this.parseTestOutput(result);
+        testResult.duration = Date.now() - startTime;
+
+        return testResult;
+    }
+
+    async testSingle(workspacePath, testFile) {
+        const startTime = Date.now();
+
+        // Extrair nome da classe do caminho
+        const className = path.basename(testFile, '.java');
+
+        const result = await run('mvn', [
+            'test',
+            `-Dtest=${className}`,
+            '-q'
+        ], workspacePath);
+
+        const testResult = this.parseTestOutput(result);
+        testResult.duration = Date.now() - startTime;
+
+        return testResult;
+    }
+
+    parseTestOutput(result) {
+        const output = result.stdout + result.stderr;
+
+        // Tentar parsear output do Surefire/JUnit
+        const testsRunMatch = output.match(/Tests run: (\d+)/);
+        const failuresMatch = output.match(/Failures: (\d+)/);
+        const errorsMatch = output.match(/Errors: (\d+)/);
+        const skippedMatch = output.match(/Skipped: (\d+)/);
+
+        const total = testsRunMatch ? parseInt(testsRunMatch[1]) : 0;
+        const failures = failuresMatch ? parseInt(failuresMatch[1]) : 0;
+        const errors = errorsMatch ? parseInt(errorsMatch[1]) : 0;
+        const skipped = skippedMatch ? parseInt(skippedMatch[1]) : 0;
+        const passed = total - failures - errors - skipped;
+
+        return {
+            success: result.code === 0 && failures === 0 && errors === 0,
+            passed,
+            failed: failures + errors,
+            skipped,
+            duration: 0,
+            output,
+            failures: this.extractFailures(output)
+        };
+    }
+
+    extractFailures(output) {
+        const failures = [];
+        const failureRegex = /Failed tests?:\s*([\s\S]*?)(?=Tests run:|$)/gi;
+        const match = failureRegex.exec(output);
+
+        if (match) {
+            const lines = match[1].split('\n').filter(l => l.trim());
+            for (const line of lines) {
+                failures.push({
+                    testName: line.trim(),
+                    message: '',
+                    stackTrace: ''
+                });
+            }
+        }
+
+        return failures;
+    }
+
+    // ==========================================
+    // CODE ANALYSIS
+    // ==========================================
+
+    getFileExtensions() {
+        return ['.java'];
+    }
+
+    async findIntegrations(workspacePath) {
+        const integrations = [];
+        const { JavaIntegrationAnalyzer } = await import('./java-integrations.js');
+        const analyzer = new JavaIntegrationAnalyzer(workspacePath);
+
+        return analyzer.findAll();
+    }
+
+    async analyzeImports(filePath, content) {
+        const imports = [];
+        const importRegex = /import\s+(static\s+)?([a-zA-Z0-9_.]+)(?:\.\*)?;/g;
+
+        let match;
+        while ((match = importRegex.exec(content)) !== null) {
+            const fullImport = match[2];
+            const isStatic = !!match[1];
+
+            imports.push({
+                name: fullImport,
+                type: isStatic ? 'static-import' : 'import',
+                isExternal: !fullImport.startsWith('com.') ||
+                    fullImport.includes('springframework') ||
+                    fullImport.includes('jakarta') ||
+                    fullImport.includes('javax')
+            });
+        }
+
+        return imports;
+    }
+
+    // ==========================================
+    // PATCH
+    // ==========================================
+
+    async validatePatch(workspacePath, diff) {
+        // Validar se os arquivos existem
+        const errors = [];
+
+        // Extrair arquivos do diff
+        const fileRegex = /^[\+\-]{3}\s+[ab]\/(.+)$/gm;
+        let match;
+
+        while ((match = fileRegex.exec(diff)) !== null) {
+            const filePath = path.join(workspacePath, match[1]);
+            if (match[0].startsWith('---') && !(await exists(filePath))) {
+                // Arquivo sendo modificado não existe
+                if (!diff.includes('+++ /dev/null')) {
+                    errors.push(`File not found: ${match[1]}`);
+                }
+            }
+        }
+
+        return {
+            valid: errors.length === 0,
+            errors
+        };
+    }
+
+    async postPatchActions(workspacePath, modifiedFiles) {
+        // Opcional: rodar formatter após patch
+        // await run('mvn', ['formatter:format', '-q'], workspacePath);
+    }
+}
+
+export default MavenRuntime;

package/src/runtimes/node/node-integrations.js

@@ -0,0 +1,247 @@
+import path from 'path';
+import { readFile, readdir } from '../../utils/fs-utils.js';
+
+/**
+ * NodeIntegrationAnalyzer
+ *
+ * Analisa código Node.js/TypeScript para encontrar integrações HTTP:
+ * - axios
+ * - fetch / node-fetch
+ * - got
+ * - HttpService (NestJS)
+ */
+export class NodeIntegrationAnalyzer {
+
+    constructor(workspacePath) {
+        this.workspacePath = workspacePath;
+        this.integrations = [];
+    }
+
+    async findAll() {
+        this.integrations = [];
+
+        const srcPath = path.join(this.workspacePath, 'src');
+        await this.scanDirectory(srcPath);
+        await this.scanDirectory(this.workspacePath, 1);
+
+        return this.integrations;
+    }
+
+    async scanDirectory(dir, maxDepth = 10, currentDepth = 0) {
+        if (currentDepth > maxDepth) return;
+
+        try {
+            const entries = await readdir(dir, { withFileTypes: true });
+
+            for (const entry of entries) {
+                if (['node_modules', 'dist', 'build', '.git', 'coverage'].includes(entry.name)) {
+                    continue;
+                }
+
+                const fullPath = path.join(dir, entry.name);
+
+                if (entry.isDirectory()) {
+                    await this.scanDirectory(fullPath, maxDepth, currentDepth + 1);
+                } else if (/\.(js|ts|jsx|tsx|mjs|cjs)$/.test(entry.name)) {
+                    await this.analyzeFile(fullPath);
+                }
+            }
+        } catch (e) {
+            // Directory not found
+        }
+    }
+
+    async analyzeFile(filePath) {
+        try {
+            const content = await readFile(filePath, 'utf8');
+            const relativePath = path.relative(this.workspacePath, filePath);
+            const lines = content.split('\n');
+
+            this.findAxios(content, relativePath, lines);
+            this.findFetch(content, relativePath, lines);
+            this.findGot(content, relativePath, lines);
+            this.findNestHttpService(content, relativePath, lines);
+            this.findKafka(content, relativePath, lines);
+            this.findAmqp(content, relativePath, lines);
+
+        } catch (e) {
+            // Error reading file
+        }
+    }
+
+    findAxios(content, filePath, lines) {
+        const patterns = [
+            { regex: /axios\.(get|post|put|patch|delete|head|options)\s*\(/gi, type: 'call' },
+            { regex: /axios\s*\(\s*\{/g, type: 'config-call' },
+            { regex: /axios\.create\s*\(/g, type: 'instance' }
+        ];
+
+        for (const pattern of patterns) {
+            let match;
+            while ((match = pattern.regex.exec(content)) !== null) {
+                const line = this.getLineNumber(content, match.index);
+                const url = this.extractUrl(content, match.index);
+
+                this.integrations.push({
+                    type: 'axios',
+                    subType: pattern.type,
+                    file: filePath,
+                    line,
+                    targetUrl: url,
+                    method: match[1]?.toUpperCase() || null,
+                    snippet: lines[line - 1]?.trim() || match[0]
+                });
+            }
+        }
+    }
+
+    findFetch(content, filePath, lines) {
+        const patterns = [
+            { regex: /fetch\s*\(\s*['"`]/g, type: 'call' },
+            { regex: /fetch\s*\(\s*\$\{/g, type: 'template-call' }
+        ];
+
+        for (const pattern of patterns) {
+            let match;
+            while ((match = pattern.regex.exec(content)) !== null) {
+                const line = this.getLineNumber(content, match.index);
+                const url = this.extractUrl(content, match.index);
+                const method = this.extractFetchMethod(content, match.index);
+
+                this.integrations.push({
+                    type: 'fetch',
+                    subType: pattern.type,
+                    file: filePath,
+                    line,
+                    targetUrl: url,
+                    method,
+                    snippet: lines[line - 1]?.trim() || match[0]
+                });
+            }
+        }
+    }
+
+    findGot(content, filePath, lines) {
+        const patterns = [
+            { regex: /got\.(get|post|put|patch|delete|head)\s*\(/gi, type: 'call' },
+            { regex: /got\s*\(\s*['"`]/g, type: 'call' }
+        ];
+
+        for (const pattern of patterns) {
+            let match;
+            while ((match = pattern.regex.exec(content)) !== null) {
+                const line = this.getLineNumber(content, match.index);
+                const url = this.extractUrl(content, match.index);
+
+                this.integrations.push({
+                    type: 'got',
+                    subType: pattern.type,
+                    file: filePath,
+                    line,
+                    targetUrl: url,
+                    method: match[1]?.toUpperCase() || 'GET',
+                    snippet: lines[line - 1]?.trim() || match[0]
+                });
+            }
+        }
+    }
+
+    findNestHttpService(content, filePath, lines) {
+        const patterns = [
+            { regex: /this\.httpService\.(get|post|put|patch|delete|head)\s*\(/gi, type: 'call' }
+        ];
+
+        for (const pattern of patterns) {
+            let match;
+            while ((match = pattern.regex.exec(content)) !== null) {
+                const line = this.getLineNumber(content, match.index);
+                const url = this.extractUrl(content, match.index);
+
+                this.integrations.push({
+                    type: 'nest-http-service',
+                    subType: pattern.type,
+                    file: filePath,
+                    line,
+                    targetUrl: url,
+                    method: match[1]?.toUpperCase() || null,
+                    snippet: lines[line - 1]?.trim() || match[0]
+                });
+            }
+        }
+    }
+
+    findKafka(content, filePath, lines) {
+        const patterns = [
+            { regex: /\.send\s*\(\s*\{\s*topic\s*:\s*['"]([^'"]+)['"]/g, type: 'producer' },
+            { regex: /\.subscribe\s*\(\s*\{\s*topic\s*:\s*['"]([^'"]+)['"]/g, type: 'consumer' }
+        ];
+
+        for (const pattern of patterns) {
+            let match;
+            while ((match = pattern.regex.exec(content)) !== null) {
+                const line = this.getLineNumber(content, match.index);
+
+                this.integrations.push({
+                    type: 'kafka',
+                    subType: pattern.type,
+                    file: filePath,
+                    line,
+                    topic: match[1] || null,
+                    snippet: lines[line - 1]?.trim() || match[0]
+                });
+            }
+        }
+    }
+
+    findAmqp(content, filePath, lines) {
+        const patterns = [
+            { regex: /\.sendToQueue\s*\(\s*['"]([^'"]+)['"]/g, type: 'producer' },
+            { regex: /\.consume\s*\(\s*['"]([^'"]+)['"]/g, type: 'consumer' }
+        ];
+
+        for (const pattern of patterns) {
+            let match;
+            while ((match = pattern.regex.exec(content)) !== null) {
+                const line = this.getLineNumber(content, match.index);
+
+                this.integrations.push({
+                    type: 'amqp',
+                    subType: pattern.type,
+                    file: filePath,
+                    line,
+                    queue: match[1] || null,
+                    snippet: lines[line - 1]?.trim() || match[0]
+                });
+            }
+        }
+    }
+
+    getLineNumber(content, index) {
+        return content.substring(0, index).split('\n').length;
+    }
+
+    extractUrl(content, startIndex) {
+        const context = content.substring(startIndex, startIndex + 500);
+
+        const urlPatterns = [
+            /['"`](https?:\/\/[^'"`]+)['"`]/,
+            /['"`]([^'"`]*\/api\/[^'"`]+)['"`]/,
+            /['"`](\/[a-zA-Z][a-zA-Z0-9/\-_{}:]+)['"`]/
+        ];
+
+        for (const pattern of urlPatterns) {
+            const match = context.match(pattern);
+            if (match) return match[1];
+        }
+
+        return null;
+    }
+
+    extractFetchMethod(content, startIndex) {
+        const context = content.substring(startIndex, startIndex + 300);
+        const methodMatch = context.match(/method\s*:\s*['"](\w+)['"]/i);
+        return methodMatch ? methodMatch[1].toUpperCase() : 'GET';
+    }
+}
+
+export default NodeIntegrationAnalyzer;