deepdebug-local-agent 0.3.1

package/src/runtimes/base-runtime.js

@@ -0,0 +1,290 @@
+/**
+ * BaseRuntime
+ *
+ * Interface abstrata para todos os runtimes de linguagem.
+ * Cada linguagem (Java, Node, Python, etc.) deve implementar esta interface.
+ *
+ * @abstract
+ */
+export class BaseRuntime {
+
+    constructor() {
+        if (this.constructor === BaseRuntime) {
+            throw new Error('BaseRuntime is abstract and cannot be instantiated directly');
+        }
+    }
+
+    // ==========================================
+    // IDENTIFICATION
+    // ==========================================
+
+    /**
+     * Identificador único do runtime
+     * @returns {string} Ex: 'java-maven', 'node-npm', 'python-pip'
+     */
+    getId() {
+        throw new Error('Method getId() must be implemented');
+    }
+
+    /**
+     * Nome amigável do runtime
+     * @returns {string} Ex: 'Java (Maven)', 'Node.js (npm)'
+     */
+    getName() {
+        throw new Error('Method getName() must be implemented');
+    }
+
+    /**
+     * Linguagem do runtime
+     * @returns {string} Ex: 'java', 'node', 'python', 'dotnet', 'go'
+     */
+    getLanguage() {
+        throw new Error('Method getLanguage() must be implemented');
+    }
+
+    /**
+     * Build tool usado
+     * @returns {string} Ex: 'maven', 'gradle', 'npm', 'yarn', 'pip'
+     */
+    getBuildTool() {
+        throw new Error('Method getBuildTool() must be implemented');
+    }
+
+    // ==========================================
+    // DETECTION
+    // ==========================================
+
+    /**
+     * Arquivos marcadores que indicam este runtime
+     * @returns {string[]} Ex: ['pom.xml'], ['package.json']
+     */
+    getMarkerFiles() {
+        throw new Error('Method getMarkerFiles() must be implemented');
+    }
+
+    /**
+     * Verifica se este runtime é compatível com o workspace
+     * @param {string} workspacePath - Caminho do workspace
+     * @returns {Promise<boolean>}
+     */
+    async isCompatible(workspacePath) {
+        throw new Error('Method isCompatible() must be implemented');
+    }
+
+    /**
+     * Detecta informações do projeto
+     * @param {string} workspacePath - Caminho do workspace
+     * @returns {Promise<ProjectInfo>}
+     */
+    async detectProject(workspacePath) {
+        throw new Error('Method detectProject() must be implemented');
+    }
+
+    // ==========================================
+    // BUILD & RUN
+    // ==========================================
+
+    /**
+     * Instala dependências do projeto
+     * @param {string} workspacePath - Caminho do workspace
+     * @param {object} options - Opções adicionais
+     * @returns {Promise<CommandResult>}
+     */
+    async install(workspacePath, options = {}) {
+        throw new Error('Method install() must be implemented');
+    }
+
+    /**
+     * Compila o projeto
+     * @param {string} workspacePath - Caminho do workspace
+     * @param {object} options - Opções adicionais
+     * @returns {Promise<CommandResult>}
+     */
+    async build(workspacePath, options = {}) {
+        throw new Error('Method build() must be implemented');
+    }
+
+    /**
+     * Retorna o comando para iniciar o serviço
+     * @param {object} options - Opções (port, profile, etc.)
+     * @returns {StartCommand} { cmd: string, args: string[], env?: object }
+     */
+    getStartCommand(options = {}) {
+        throw new Error('Method getStartCommand() must be implemented');
+    }
+
+    /**
+     * Padrão regex para detectar quando o serviço está pronto
+     * @returns {RegExp}
+     */
+    getReadyPattern() {
+        throw new Error('Method getReadyPattern() must be implemented');
+    }
+
+    /**
+     * Porta padrão do framework
+     * @returns {number}
+     */
+    getDefaultPort() {
+        return 8080;
+    }
+
+    /**
+     * Detecta a porta configurada no projeto
+     * @param {string} workspacePath - Caminho do workspace
+     * @returns {Promise<number|null>}
+     */
+    async detectPort(workspacePath) {
+        return this.getDefaultPort();
+    }
+
+    // ==========================================
+    // TEST
+    // ==========================================
+
+    /**
+     * Executa testes do projeto
+     * @param {string} workspacePath - Caminho do workspace
+     * @param {object} options - Opções (testFile, coverage, etc.)
+     * @returns {Promise<TestResult>}
+     */
+    async test(workspacePath, options = {}) {
+        throw new Error('Method test() must be implemented');
+    }
+
+    /**
+     * Executa um teste específico
+     * @param {string} workspacePath - Caminho do workspace
+     * @param {string} testFile - Arquivo de teste
+     * @returns {Promise<TestResult>}
+     */
+    async testSingle(workspacePath, testFile) {
+        throw new Error('Method testSingle() must be implemented');
+    }
+
+    // ==========================================
+    // CODE ANALYSIS
+    // ==========================================
+
+    /**
+     * Extensões de arquivo suportadas
+     * @returns {string[]} Ex: ['.java'], ['.js', '.ts']
+     */
+    getFileExtensions() {
+        throw new Error('Method getFileExtensions() must be implemented');
+    }
+
+    /**
+     * Encontra integrações HTTP no código
+     * @param {string} workspacePath - Caminho do workspace
+     * @returns {Promise<Integration[]>}
+     */
+    async findIntegrations(workspacePath) {
+        return [];
+    }
+
+    /**
+     * Analisa imports/dependências de um arquivo
+     * @param {string} filePath - Caminho do arquivo
+     * @param {string} content - Conteúdo do arquivo
+     * @returns {Promise<Dependency[]>}
+     */
+    async analyzeImports(filePath, content) {
+        return [];
+    }
+
+    // ==========================================
+    // PATCH
+    // ==========================================
+
+    /**
+     * Valida se um diff é aplicável
+     * @param {string} workspacePath - Caminho do workspace
+     * @param {string} diff - Unified diff
+     * @returns {Promise<ValidationResult>}
+     */
+    async validatePatch(workspacePath, diff) {
+        return { valid: true, errors: [] };
+    }
+
+    /**
+     * Ações pós-patch (ex: reformatar código)
+     * @param {string} workspacePath - Caminho do workspace
+     * @param {string[]} modifiedFiles - Arquivos modificados
+     * @returns {Promise<void>}
+     */
+    async postPatchActions(workspacePath, modifiedFiles) {
+        // Override nas implementações específicas
+    }
+}
+
+// ==========================================
+// TYPE DEFINITIONS
+// ==========================================
+
+/**
+ * @typedef {object} ProjectInfo
+ * @property {string} name - Nome do projeto
+ * @property {string} version - Versão
+ * @property {string} language - Linguagem
+ * @property {string} framework - Framework detectado
+ * @property {string} buildTool - Build tool
+ * @property {number} port - Porta configurada
+ */
+
+/**
+ * @typedef {object} CommandResult
+ * @property {number} code - Exit code
+ * @property {string} stdout - Standard output
+ * @property {string} stderr - Standard error
+ * @property {number} duration - Duração em ms
+ */
+
+/**
+ * @typedef {object} StartCommand
+ * @property {string} cmd - Comando
+ * @property {string[]} args - Argumentos
+ * @property {object} [env] - Variáveis de ambiente adicionais
+ */
+
+/**
+ * @typedef {object} TestResult
+ * @property {boolean} success - Se todos os testes passaram
+ * @property {number} passed - Número de testes que passaram
+ * @property {number} failed - Número de testes que falharam
+ * @property {number} skipped - Número de testes ignorados
+ * @property {number} duration - Duração em ms
+ * @property {string} output - Output completo
+ * @property {TestFailure[]} failures - Lista de falhas
+ */
+
+/**
+ * @typedef {object} TestFailure
+ * @property {string} testName - Nome do teste
+ * @property {string} message - Mensagem de erro
+ * @property {string} stackTrace - Stack trace
+ */
+
+/**
+ * @typedef {object} Integration
+ * @property {string} type - Tipo (rest-template, feign, axios, etc.)
+ * @property {string} file - Arquivo onde foi encontrado
+ * @property {number} line - Linha
+ * @property {string} targetUrl - URL alvo (se detectável)
+ * @property {string} method - Método HTTP (se detectável)
+ */
+
+/**
+ * @typedef {object} Dependency
+ * @property {string} name - Nome da dependência
+ * @property {string} type - Tipo (import, require, using)
+ * @property {boolean} isExternal - Se é externa ao projeto
+ */
+
+/**
+ * @typedef {object} ValidationResult
+ * @property {boolean} valid - Se o patch é válido
+ * @property {string[]} errors - Lista de erros
+ */
+
+export default BaseRuntime;

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

@@ -0,0 +1,378 @@
+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';
+
+/**
+ * GradleRuntime
+ *
+ * Runtime para projetos Java com Gradle.
+ * Suporta Spring Boot, Quarkus, e projetos Gradle genéricos.
+ */
+export class GradleRuntime extends BaseRuntime {
+
+    constructor() {
+        super();
+        this.framework = null;
+        this.useWrapper = true; // Usar ./gradlew por padrão
+    }
+
+    // ==========================================
+    // IDENTIFICATION
+    // ==========================================
+
+    getId() {
+        return 'java-gradle';
+    }
+
+    getName() {
+        return 'Java (Gradle)';
+    }
+
+    getLanguage() {
+        return 'java';
+    }
+
+    getBuildTool() {
+        return 'gradle';
+    }
+
+    // ==========================================
+    // DETECTION
+    // ==========================================
+
+    getMarkerFiles() {
+        return ['build.gradle', 'build.gradle.kts'];
+    }
+
+    async isCompatible(workspacePath) {
+        const groovyPath = path.join(workspacePath, 'build.gradle');
+        const kotlinPath = path.join(workspacePath, 'build.gradle.kts');
+
+        return await exists(groovyPath) || await exists(kotlinPath);
+    }
+
+    async detectProject(workspacePath) {
+        let buildContent = '';
+
+        const groovyPath = path.join(workspacePath, 'build.gradle');
+        const kotlinPath = path.join(workspacePath, 'build.gradle.kts');
+
+        if (await exists(groovyPath)) {
+            buildContent = await readFile(groovyPath, 'utf8');
+        } else if (await exists(kotlinPath)) {
+            buildContent = await readFile(kotlinPath, 'utf8');
+        }
+
+        // Verificar se existe wrapper
+        const wrapperPath = path.join(workspacePath, 'gradlew');
+        this.useWrapper = await exists(wrapperPath);
+
+        // Detectar nome do projeto
+        const settingsPath = path.join(workspacePath, 'settings.gradle');
+        const settingsKtsPath = path.join(workspacePath, 'settings.gradle.kts');
+        let name = path.basename(workspacePath);
+
+        if (await exists(settingsPath)) {
+            const settings = await readFile(settingsPath, 'utf8');
+            const match = settings.match(/rootProject\.name\s*=\s*['"]([^'"]+)['"]/);
+            if (match) name = match[1];
+        } else if (await exists(settingsKtsPath)) {
+            const settings = await readFile(settingsKtsPath, 'utf8');
+            const match = settings.match(/rootProject\.name\s*=\s*"([^"]+)"/);
+            if (match) name = match[1];
+        }
+
+        // Detectar versão
+        const versionMatch = buildContent.match(/version\s*=?\s*['"]([^'"]+)['"]/);
+        const version = versionMatch ? versionMatch[1] : '0.0.1';
+
+        // Detectar framework
+        const framework = this.detectFramework(buildContent);
+        this.framework = framework;
+
+        // Detectar porta
+        const port = await this.detectPort(workspacePath);
+
+        return {
+            name,
+            version,
+            language: 'java',
+            framework,
+            buildTool: 'gradle',
+            port
+        };
+    }
+
+    detectFramework(buildContent) {
+        if (buildContent.includes('org.springframework.boot') ||
+            buildContent.includes('spring-boot')) {
+            return 'spring-boot';
+        }
+        if (buildContent.includes('quarkus')) {
+            return 'quarkus';
+        }
+        if (buildContent.includes('micronaut')) {
+            return 'micronaut';
+        }
+        return 'java-plain';
+    }
+
+    // ==========================================
+    // BUILD & RUN
+    // ==========================================
+
+    getGradleCommand() {
+        return this.useWrapper ? './gradlew' : 'gradle';
+    }
+
+    async install(workspacePath, options = {}) {
+        const startTime = Date.now();
+        const cmd = this.getGradleCommand();
+        const result = await run(cmd, ['dependencies', '--quiet'], workspacePath);
+
+        return {
+            ...result,
+            duration: Date.now() - startTime
+        };
+    }
+
+    async build(workspacePath, options = {}) {
+        const startTime = Date.now();
+        const cmd = this.getGradleCommand();
+        const args = ['build', '-x', 'test', '--quiet'];
+
+        const result = await run(cmd, args, workspacePath);
+
+        return {
+            ...result,
+            duration: Date.now() - startTime
+        };
+    }
+
+    getStartCommand(options = {}) {
+        const cmd = this.getGradleCommand();
+        const framework = options.framework || this.framework || 'spring-boot';
+        const port = options.port || 8080;
+        const profile = options.profile || 'default';
+
+        if (framework === 'spring-boot') {
+            return {
+                cmd,
+                args: [
+                    'bootRun',
+                    `--args='--server.port=${port} --spring.profiles.active=${profile}'`,
+                    '--quiet'
+                ],
+                env: {
+                    SERVER_PORT: String(port)
+                }
+            };
+        }
+
+        if (framework === 'quarkus') {
+            return {
+                cmd,
+                args: [
+                    'quarkusDev',
+                    `-Dquarkus.http.port=${port}`,
+                    '--quiet'
+                ],
+                env: {
+                    QUARKUS_HTTP_PORT: String(port)
+                }
+            };
+        }
+
+        // Fallback
+        return {
+            cmd,
+            args: ['run', '--quiet'],
+            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() {
+        return 8080;
+    }
+
+    async detectPort(workspacePath) {
+        // Mesma lógica do Maven - configs são iguais
+        const propsPath = path.join(workspacePath, 'src/main/resources/application.properties');
+        if (await exists(propsPath)) {
+            const content = await readFile(propsPath, 'utf8');
+            const match = content.match(/server\.port\s*=\s*(\d+)/);
+            if (match) return parseInt(match[1]);
+        }
+
+        const ymlPath = path.join(workspacePath, 'src/main/resources/application.yml');
+        if (await exists(ymlPath)) {
+            const content = await readFile(ymlPath, 'utf8');
+            const match = content.match(/port:\s*(\d+)/);
+            if (match) return parseInt(match[1]);
+        }
+
+        return this.getDefaultPort();
+    }
+
+    // ==========================================
+    // TEST
+    // ==========================================
+
+    async test(workspacePath, options = {}) {
+        const startTime = Date.now();
+        const cmd = this.getGradleCommand();
+
+        // Clean primeiro
+        await run(cmd, ['clean', '--quiet'], workspacePath);
+
+        // Rodar testes
+        const result = await run(cmd, ['test', '--quiet'], workspacePath);
+
+        const testResult = this.parseTestOutput(result, workspacePath);
+        testResult.duration = Date.now() - startTime;
+
+        return testResult;
+    }
+
+    async testSingle(workspacePath, testFile) {
+        const startTime = Date.now();
+        const cmd = this.getGradleCommand();
+
+        // Extrair nome da classe
+        const className = path.basename(testFile, '.java');
+
+        const result = await run(cmd, [
+            'test',
+            '--tests',
+            className,
+            '--quiet'
+        ], workspacePath);
+
+        const testResult = this.parseTestOutput(result, workspacePath);
+        testResult.duration = Date.now() - startTime;
+
+        return testResult;
+    }
+
+    async parseTestOutput(result, workspacePath) {
+        const output = result.stdout + result.stderr;
+
+        // Tentar ler relatório XML do Gradle se disponível
+        const reportDir = path.join(workspacePath, 'build/test-results/test');
+
+        // Parse básico do output
+        let passed = 0;
+        let failed = 0;
+        let skipped = 0;
+
+        // Gradle output format
+        const summaryMatch = output.match(/(\d+)\s+tests?\s+completed,\s+(\d+)\s+failed/);
+        if (summaryMatch) {
+            const total = parseInt(summaryMatch[1]);
+            failed = parseInt(summaryMatch[2]);
+            passed = total - failed;
+        }
+
+        const skippedMatch = output.match(/(\d+)\s+skipped/);
+        if (skippedMatch) {
+            skipped = parseInt(skippedMatch[1]);
+        }
+
+        return {
+            success: result.code === 0 && failed === 0,
+            passed,
+            failed,
+            skipped,
+            duration: 0,
+            output,
+            failures: this.extractFailures(output)
+        };
+    }
+
+    extractFailures(output) {
+        const failures = [];
+
+        // Gradle mostra falhas com formato específico
+        const failureRegex = /(\w+Test)\s+>\s+(\w+).*FAILED/g;
+        let match;
+
+        while ((match = failureRegex.exec(output)) !== null) {
+            failures.push({
+                testName: `${match[1]}.${match[2]}`,
+                message: '',
+                stackTrace: ''
+            });
+        }
+
+        return failures;
+    }
+
+    // ==========================================
+    // CODE ANALYSIS
+    // ==========================================
+
+    getFileExtensions() {
+        return ['.java', '.kt']; // Suporte a Kotlin também
+    }
+
+    async findIntegrations(workspacePath) {
+        const { JavaIntegrationAnalyzer } = await import('./java-integrations.js');
+        const analyzer = new JavaIntegrationAnalyzer(workspacePath);
+        return analyzer.findAll();
+    }
+
+    async analyzeImports(filePath, content) {
+        // Mesma lógica do Maven
+        const imports = [];
+        const importRegex = /import\s+(static\s+)?([a-zA-Z0-9_.]+)(?:\.\*)?;/g;
+
+        let match;
+        while ((match = importRegex.exec(content)) !== null) {
+            imports.push({
+                name: match[2],
+                type: match[1] ? 'static-import' : 'import',
+                isExternal: !match[2].startsWith('com.')
+            });
+        }
+
+        return imports;
+    }
+
+    // ==========================================
+    // PATCH
+    // ==========================================
+
+    async validatePatch(workspacePath, diff) {
+        const errors = [];
+
+        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))) {
+                if (!diff.includes('+++ /dev/null')) {
+                    errors.push(`File not found: ${match[1]}`);
+                }
+            }
+        }
+
+        return {
+            valid: errors.length === 0,
+            errors
+        };
+    }
+}
+
+export default GradleRuntime;