deepdebug-local-agent 0.3.1

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

@@ -0,0 +1,339 @@
+import path from 'path';
+import { readFile, readdir, stat } from '../../utils/fs-utils.js';
+
+/**
+ * JavaIntegrationAnalyzer
+ *
+ * Analisa código Java para encontrar integrações HTTP:
+ * - RestTemplate
+ * - WebClient
+ * - FeignClient
+ * - HttpClient (Java 11+)
+ * - OkHttp
+ * - Retrofit
+ */
+export class JavaIntegrationAnalyzer {
+
+    constructor(workspacePath) {
+        this.workspacePath = workspacePath;
+        this.integrations = [];
+    }
+
+    /**
+     * Encontra todas as integrações no workspace
+     * @returns {Promise<Integration[]>}
+     */
+    async findAll() {
+        this.integrations = [];
+
+        const srcPath = path.join(this.workspacePath, 'src/main/java');
+        await this.scanDirectory(srcPath);
+
+        return this.integrations;
+    }
+
+    /**
+     * Escaneia diretório recursivamente
+     */
+    async scanDirectory(dir) {
+        try {
+            const entries = await readdir(dir, { withFileTypes: true });
+
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+
+                if (entry.isDirectory()) {
+                    await this.scanDirectory(fullPath);
+                } else if (entry.name.endsWith('.java')) {
+                    await this.analyzeFile(fullPath);
+                }
+            }
+        } catch (e) {
+            // Diretório não existe ou erro de leitura
+        }
+    }
+
+    /**
+     * Analisa um arquivo Java
+     */
+    async analyzeFile(filePath) {
+        try {
+            const content = await readFile(filePath, 'utf8');
+            const relativePath = path.relative(this.workspacePath, filePath);
+            const lines = content.split('\n');
+
+            // Analisar cada tipo de integração
+            this.findRestTemplate(content, relativePath, lines);
+            this.findWebClient(content, relativePath, lines);
+            this.findFeignClient(content, relativePath, lines);
+            this.findHttpClient(content, relativePath, lines);
+            this.findKafka(content, relativePath, lines);
+            this.findRabbitMQ(content, relativePath, lines);
+
+        } catch (e) {
+            // Erro ao ler arquivo
+        }
+    }
+
+    /**
+     * Encontra uso de RestTemplate
+     */
+    findRestTemplate(content, filePath, lines) {
+        // Padrões de RestTemplate
+        const patterns = [
+            // Injeção
+            { regex: /@Autowired\s*\n?\s*(?:private|protected|public)?\s*RestTemplate\s+\w+/g, type: 'injection' },
+            { regex: /private\s+(?:final\s+)?RestTemplate\s+\w+/g, type: 'field' },
+
+            // Chamadas HTTP
+            { regex: /restTemplate\.(getForObject|getForEntity|postForObject|postForEntity|exchange|put|delete)\s*\(/gi, type: 'call' },
+
+            // Criação
+            { regex: /new\s+RestTemplate\s*\(/g, type: 'instantiation' },
+            { regex: /RestTemplateBuilder/g, type: 'builder' }
+        ];
+
+        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.extractHttpMethod(match[0]);
+
+                this.integrations.push({
+                    type: 'rest-template',
+                    subType: pattern.type,
+                    file: filePath,
+                    line,
+                    targetUrl: url,
+                    method,
+                    snippet: lines[line - 1]?.trim() || match[0]
+                });
+            }
+        }
+    }
+
+    /**
+     * Encontra uso de WebClient (Spring WebFlux)
+     */
+    findWebClient(content, filePath, lines) {
+        const patterns = [
+            { regex: /WebClient\.builder\(\)/g, type: 'builder' },
+            { regex: /WebClient\.create\s*\(/g, type: 'create' },
+            { regex: /\.get\(\)\s*\.uri\s*\(/g, type: 'get' },
+            { regex: /\.post\(\)\s*\.uri\s*\(/g, type: 'post' },
+            { regex: /\.put\(\)\s*\.uri\s*\(/g, type: 'put' },
+            { regex: /\.delete\(\)\s*\.uri\s*\(/g, type: 'delete' },
+            { regex: /\.patch\(\)\s*\.uri\s*\(/g, type: 'patch' }
+        ];
+
+        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: 'web-client',
+                    subType: pattern.type,
+                    file: filePath,
+                    line,
+                    targetUrl: url,
+                    method: pattern.type.toUpperCase(),
+                    snippet: lines[line - 1]?.trim() || match[0]
+                });
+            }
+        }
+    }
+
+    /**
+     * Encontra FeignClient
+     */
+    findFeignClient(content, filePath, lines) {
+        // @FeignClient annotation
+        const feignRegex = /@FeignClient\s*\(\s*(?:name\s*=\s*)?["']?([^"'\s,)]+)["']?/g;
+
+        let match;
+        while ((match = feignRegex.exec(content)) !== null) {
+            const line = this.getLineNumber(content, match.index);
+            const serviceName = match[1];
+
+            // Extrair URL se especificada
+            const urlMatch = content.substring(match.index, match.index + 200)
+                .match(/url\s*=\s*["']([^"']+)["']/);
+
+            this.integrations.push({
+                type: 'feign-client',
+                subType: 'declaration',
+                file: filePath,
+                line,
+                targetUrl: urlMatch ? urlMatch[1] : null,
+                serviceName,
+                method: null,
+                snippet: lines[line - 1]?.trim() || match[0]
+            });
+        }
+
+        // Métodos do FeignClient
+        const methodPatterns = [
+            { regex: /@GetMapping\s*\(?\s*["']?([^"'\s)]*)/g, method: 'GET' },
+            { regex: /@PostMapping\s*\(?\s*["']?([^"'\s)]*)/g, method: 'POST' },
+            { regex: /@PutMapping\s*\(?\s*["']?([^"'\s)]*)/g, method: 'PUT' },
+            { regex: /@DeleteMapping\s*\(?\s*["']?([^"'\s)]*)/g, method: 'DELETE' },
+            { regex: /@PatchMapping\s*\(?\s*["']?([^"'\s)]*)/g, method: 'PATCH' }
+        ];
+
+        // Só procurar métodos se arquivo tem @FeignClient
+        if (content.includes('@FeignClient')) {
+            for (const pattern of methodPatterns) {
+                let methodMatch;
+                while ((methodMatch = pattern.regex.exec(content)) !== null) {
+                    const line = this.getLineNumber(content, methodMatch.index);
+
+                    this.integrations.push({
+                        type: 'feign-client',
+                        subType: 'method',
+                        file: filePath,
+                        line,
+                        targetUrl: methodMatch[1] || '/',
+                        method: pattern.method,
+                        snippet: lines[line - 1]?.trim() || methodMatch[0]
+                    });
+                }
+            }
+        }
+    }
+
+    /**
+     * Encontra Java HttpClient (11+)
+     */
+    findHttpClient(content, filePath, lines) {
+        const patterns = [
+            { regex: /HttpClient\.newBuilder\(\)/g, type: 'builder' },
+            { regex: /HttpClient\.newHttpClient\(\)/g, type: 'create' },
+            { regex: /HttpRequest\.newBuilder\(\)/g, type: 'request' }
+        ];
+
+        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: 'http-client',
+                    subType: pattern.type,
+                    file: filePath,
+                    line,
+                    targetUrl: url,
+                    method: null,
+                    snippet: lines[line - 1]?.trim() || match[0]
+                });
+            }
+        }
+    }
+
+    /**
+     * Encontra integrações Kafka
+     */
+    findKafka(content, filePath, lines) {
+        const patterns = [
+            { regex: /@KafkaListener\s*\(\s*topics\s*=\s*["']([^"']+)["']/g, type: 'consumer' },
+            { regex: /kafkaTemplate\.send\s*\(\s*["']([^"']+)["']/gi, type: 'producer' },
+            { regex: /@SendTo\s*\(\s*["']([^"']+)["']\s*\)/g, type: 'reply' }
+        ];
+
+        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],
+                    snippet: lines[line - 1]?.trim() || match[0]
+                });
+            }
+        }
+    }
+
+    /**
+     * Encontra integrações RabbitMQ
+     */
+    findRabbitMQ(content, filePath, lines) {
+        const patterns = [
+            { regex: /@RabbitListener\s*\(\s*queues\s*=\s*["']([^"']+)["']/g, type: 'consumer' },
+            { regex: /rabbitTemplate\.convertAndSend\s*\(/gi, type: 'producer' },
+            { regex: /@RabbitHandler/g, type: 'handler' }
+        ];
+
+        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: 'rabbitmq',
+                    subType: pattern.type,
+                    file: filePath,
+                    line,
+                    queue: match[1] || null,
+                    snippet: lines[line - 1]?.trim() || match[0]
+                });
+            }
+        }
+    }
+
+    // ==========================================
+    // HELPERS
+    // ==========================================
+
+    /**
+     * Obtém número da linha a partir do índice
+     */
+    getLineNumber(content, index) {
+        return content.substring(0, index).split('\n').length;
+    }
+
+    /**
+     * Tenta extrair URL do contexto
+     */
+    extractUrl(content, startIndex) {
+        // Procurar URL nos próximos 500 caracteres
+        const context = content.substring(startIndex, startIndex + 500);
+
+        // Padrões de URL
+        const urlPatterns = [
+            /"(https?:\/\/[^"]+)"/,
+            /'(https?:\/\/[^']+)'/,
+            /\$\{([^}]+)\}/,  // Property placeholder
+            /"([^"]*\/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;
+    }
+
+    /**
+     * Extrai método HTTP da chamada
+     */
+    extractHttpMethod(snippet) {
+        if (/getFor|\.get\(/i.test(snippet)) return 'GET';
+        if (/postFor|\.post\(/i.test(snippet)) return 'POST';
+        if (/\.put\(/i.test(snippet)) return 'PUT';
+        if (/\.delete\(/i.test(snippet)) return 'DELETE';
+        if (/\.patch\(/i.test(snippet)) return 'PATCH';
+        if (/exchange/i.test(snippet)) return 'EXCHANGE';
+        return null;
+    }
+}
+
+export default JavaIntegrationAnalyzer;