deepdebug-local-agent 0.3.1

package/src/runtimes/node/yarn-runtime.js

@@ -0,0 +1,354 @@
+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';
+
+/**
+ * YarnRuntime
+ *
+ * Runtime para projetos Node.js com Yarn.
+ * Suporta Express, NestJS, Next.js, React, Vue, etc.
+ */
+export class YarnRuntime extends BaseRuntime {
+
+    constructor() {
+        super();
+        this.framework = null;
+        this.packageJson = null;
+        this.yarnVersion = 1; // 1 ou 2+
+    }
+
+    // ==========================================
+    // IDENTIFICATION
+    // ==========================================
+
+    getId() {
+        return 'node-yarn';
+    }
+
+    getName() {
+        return 'Node.js (Yarn)';
+    }
+
+    getLanguage() {
+        return 'node';
+    }
+
+    getBuildTool() {
+        return 'yarn';
+    }
+
+    // ==========================================
+    // DETECTION
+    // ==========================================
+
+    getMarkerFiles() {
+        return ['yarn.lock', 'package.json'];
+    }
+
+    async isCompatible(workspacePath) {
+        const yarnLock = path.join(workspacePath, 'yarn.lock');
+        return exists(yarnLock);
+    }
+
+    async detectProject(workspacePath) {
+        const pkgPath = path.join(workspacePath, 'package.json');
+        const content = await readFile(pkgPath, 'utf8');
+        this.packageJson = JSON.parse(content);
+
+        // Detectar versão do Yarn
+        const yarnrcPath = path.join(workspacePath, '.yarnrc.yml');
+        if (await exists(yarnrcPath)) {
+            this.yarnVersion = 2;
+        }
+
+        const name = this.packageJson.name || path.basename(workspacePath);
+        const version = this.packageJson.version || '0.0.1';
+
+        const framework = this.detectFramework(this.packageJson);
+        this.framework = framework;
+
+        const port = await this.detectPort(workspacePath);
+
+        return {
+            name,
+            version,
+            language: 'node',
+            framework,
+            buildTool: 'yarn',
+            port
+        };
+    }
+
+    detectFramework(pkg) {
+        const deps = {
+            ...pkg.dependencies,
+            ...pkg.devDependencies
+        };
+
+        if (deps['next']) return 'next';
+        if (deps['nuxt']) return 'nuxt';
+        if (deps['@angular/core']) return 'angular';
+        if (deps['vue']) return deps['nuxt'] ? 'nuxt' : 'vue';
+        if (deps['react']) return deps['next'] ? 'next' : 'react';
+        if (deps['svelte']) return 'svelte';
+        if (deps['@nestjs/core']) return 'nestjs';
+        if (deps['express']) return 'express';
+        if (deps['fastify']) return 'fastify';
+        if (deps['koa']) return 'koa';
+
+        return 'node-plain';
+    }
+
+    // ==========================================
+    // BUILD & RUN
+    // ==========================================
+
+    async install(workspacePath, options = {}) {
+        const startTime = Date.now();
+        const args = this.yarnVersion >= 2 ? ['install'] : [];
+
+        if (options.production && this.yarnVersion < 2) {
+            args.push('--production');
+        }
+
+        const result = await run('yarn', args, workspacePath);
+
+        return {
+            ...result,
+            duration: Date.now() - startTime
+        };
+    }
+
+    async build(workspacePath, options = {}) {
+        const startTime = Date.now();
+
+        if (!this.packageJson?.scripts?.build) {
+            return {
+                code: 0,
+                stdout: 'No build script defined',
+                stderr: '',
+                duration: Date.now() - startTime
+            };
+        }
+
+        const result = await run('yarn', ['build'], workspacePath);
+
+        return {
+            ...result,
+            duration: Date.now() - startTime
+        };
+    }
+
+    getStartCommand(options = {}) {
+        const framework = options.framework || this.framework || 'node-plain';
+        const port = options.port || 3000;
+
+        const commands = {
+            'next': {
+                cmd: 'yarn',
+                args: ['dev'],
+                env: { PORT: String(port) }
+            },
+            'nuxt': {
+                cmd: 'yarn',
+                args: ['dev'],
+                env: { PORT: String(port) }
+            },
+            'nestjs': {
+                cmd: 'yarn',
+                args: ['start:dev'],
+                env: { PORT: String(port) }
+            },
+            'express': {
+                cmd: 'yarn',
+                args: ['start'],
+                env: { PORT: String(port) }
+            },
+            'react': {
+                cmd: 'yarn',
+                args: ['start'],
+                env: { PORT: String(port) }
+            },
+            'vue': {
+                cmd: 'yarn',
+                args: ['serve'],
+                env: { PORT: String(port) }
+            }
+        };
+
+        return commands[framework] || {
+            cmd: 'yarn',
+            args: ['start'],
+            env: { PORT: String(port) }
+        };
+    }
+
+    getReadyPattern() {
+        const patterns = {
+            'next': /ready.*started server on/i,
+            'nuxt': /Listening on/i,
+            'nestjs': /Nest application successfully started/i,
+            'express': /listening on port|server (is )?running/i,
+            'react': /compiled successfully|You can now view/i,
+            'vue': /App running at/i
+        };
+
+        return patterns[this.framework] || /listening|started|ready|running/i;
+    }
+
+    getDefaultPort() {
+        const defaults = {
+            'next': 3000,
+            'nuxt': 3000,
+            'nestjs': 3000,
+            'express': 3000,
+            'react': 3000,
+            'vue': 8080
+        };
+
+        return defaults[this.framework] || 3000;
+    }
+
+    async detectPort(workspacePath) {
+        const envPath = path.join(workspacePath, '.env');
+        if (await exists(envPath)) {
+            const content = await readFile(envPath, 'utf8');
+            const match = content.match(/^PORT\s*=\s*(\d+)/m);
+            if (match) return parseInt(match[1]);
+        }
+
+        return this.getDefaultPort();
+    }
+
+    // ==========================================
+    // TEST
+    // ==========================================
+
+    async test(workspacePath, options = {}) {
+        const startTime = Date.now();
+
+        if (!this.packageJson?.scripts?.test) {
+            return {
+                success: true,
+                passed: 0,
+                failed: 0,
+                skipped: 0,
+                duration: Date.now() - startTime,
+                output: 'No test script defined',
+                failures: []
+            };
+        }
+
+        const result = await run('yarn', ['test', '--passWithNoTests'], workspacePath);
+
+        const testResult = this.parseTestOutput(result);
+        testResult.duration = Date.now() - startTime;
+
+        return testResult;
+    }
+
+    async testSingle(workspacePath, testFile) {
+        const startTime = Date.now();
+
+        const result = await run('yarn', ['test', testFile], workspacePath);
+
+        const testResult = this.parseTestOutput(result);
+        testResult.duration = Date.now() - startTime;
+
+        return testResult;
+    }
+
+    parseTestOutput(result) {
+        const output = result.stdout + result.stderr;
+
+        const jestMatch = output.match(/Tests:\s+(\d+)\s+passed,?\s*(\d+)?\s*failed?,?\s*(\d+)?\s*skipped?/i);
+        if (jestMatch) {
+            return {
+                success: result.code === 0,
+                passed: parseInt(jestMatch[1]) || 0,
+                failed: parseInt(jestMatch[2]) || 0,
+                skipped: parseInt(jestMatch[3]) || 0,
+                duration: 0,
+                output,
+                failures: []
+            };
+        }
+
+        return {
+            success: result.code === 0,
+            passed: result.code === 0 ? 1 : 0,
+            failed: result.code === 0 ? 0 : 1,
+            skipped: 0,
+            duration: 0,
+            output,
+            failures: []
+        };
+    }
+
+    // ==========================================
+    // CODE ANALYSIS
+    // ==========================================
+
+    getFileExtensions() {
+        return ['.js', '.ts', '.jsx', '.tsx', '.mjs', '.cjs'];
+    }
+
+    async findIntegrations(workspacePath) {
+        const { NodeIntegrationAnalyzer } = await import('./node-integrations.js');
+        const analyzer = new NodeIntegrationAnalyzer(workspacePath);
+        return analyzer.findAll();
+    }
+
+    async analyzeImports(filePath, content) {
+        const imports = [];
+
+        const es6Regex = /import\s+(?:{[^}]+}|\*\s+as\s+\w+|\w+)\s+from\s+['"]([^'"]+)['"]/g;
+        let match;
+        while ((match = es6Regex.exec(content)) !== null) {
+            imports.push({
+                name: match[1],
+                type: 'import',
+                isExternal: !match[1].startsWith('.') && !match[1].startsWith('/')
+            });
+        }
+
+        const cjsRegex = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+        while ((match = cjsRegex.exec(content)) !== null) {
+            imports.push({
+                name: match[1],
+                type: 'require',
+                isExternal: !match[1].startsWith('.') && !match[1].startsWith('/')
+            });
+        }
+
+        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 YarnRuntime;

package/src/runtimes/runtime-registry.js

@@ -0,0 +1,256 @@
+import path from 'path';
+import { exists } from '../utils/fs-utils.js';
+
+/**
+ * RuntimeRegistry
+ *
+ * Factory/Registry para gerenciar e detectar runtimes de linguagem.
+ * Singleton que mantém todos os runtimes registrados.
+ */
+export class RuntimeRegistry {
+
+    constructor() {
+        this.runtimes = new Map();
+        this.markerIndex = new Map(); // marker file -> runtime id
+    }
+
+    /**
+     * Registra um runtime
+     * @param {BaseRuntime} runtime - Instância do runtime
+     */
+    register(runtime) {
+        const id = runtime.getId();
+        this.runtimes.set(id, runtime);
+
+        // Indexar por marker files para detecção rápida
+        for (const marker of runtime.getMarkerFiles()) {
+            if (!this.markerIndex.has(marker)) {
+                this.markerIndex.set(marker, []);
+            }
+            this.markerIndex.get(marker).push(id);
+        }
+
+        console.log(`📦 Registered runtime: ${id}`);
+    }
+
+    /**
+     * Obtém um runtime pelo ID
+     * @param {string} id - ID do runtime
+     * @returns {BaseRuntime|null}
+     */
+    get(id) {
+        return this.runtimes.get(id) || null;
+    }
+
+    /**
+     * Lista todos os runtimes registrados
+     * @returns {BaseRuntime[]}
+     */
+    list() {
+        return Array.from(this.runtimes.values());
+    }
+
+    /**
+     * Lista IDs dos runtimes registrados
+     * @returns {string[]}
+     */
+    listIds() {
+        return Array.from(this.runtimes.keys());
+    }
+
+    /**
+     * Auto-detecta o runtime de um workspace
+     * @param {string} workspacePath - Caminho do workspace
+     * @returns {Promise<BaseRuntime|null>}
+     */
+    async detectRuntime(workspacePath) {
+        console.log(`🔍 Detecting runtime for: ${workspacePath}`);
+
+        // Prioridade de detecção (mais específico primeiro)
+        const detectionOrder = [
+            // Java
+            'pom.xml',
+            'build.gradle',
+            'build.gradle.kts',
+            // Node
+            'package.json',
+            // Python
+            'pyproject.toml',
+            'requirements.txt',
+            'setup.py',
+            // .NET
+            '*.csproj',
+            '*.sln',
+            // Go
+            'go.mod',
+            // SAP
+            'mta.yaml',
+            '.cdsrc.json',
+        ];
+
+        for (const marker of detectionOrder) {
+            const candidates = this.markerIndex.get(marker) || [];
+
+            for (const runtimeId of candidates) {
+                const runtime = this.runtimes.get(runtimeId);
+
+                if (await runtime.isCompatible(workspacePath)) {
+                    console.log(`✅ Detected runtime: ${runtimeId}`);
+                    return runtime;
+                }
+            }
+        }
+
+        // Fallback: tentar cada runtime
+        for (const runtime of this.runtimes.values()) {
+            if (await runtime.isCompatible(workspacePath)) {
+                console.log(`✅ Detected runtime (fallback): ${runtime.getId()}`);
+                return runtime;
+            }
+        }
+
+        console.log(`⚠️ No runtime detected for: ${workspacePath}`);
+        return null;
+    }
+
+    /**
+     * Detecta runtime e retorna informações do projeto
+     * @param {string} workspacePath - Caminho do workspace
+     * @returns {Promise<{runtime: BaseRuntime, project: ProjectInfo}|null>}
+     */
+    async analyzeWorkspace(workspacePath) {
+        const runtime = await this.detectRuntime(workspacePath);
+
+        if (!runtime) {
+            return null;
+        }
+
+        const project = await runtime.detectProject(workspacePath);
+
+        return {
+            runtime,
+            project
+        };
+    }
+
+    /**
+     * Obtém runtime por linguagem e build tool
+     * @param {string} language - Linguagem
+     * @param {string} buildTool - Build tool
+     * @returns {BaseRuntime|null}
+     */
+    getByLanguageAndTool(language, buildTool) {
+        const id = `${language}-${buildTool}`;
+
+        // Tentar match exato
+        if (this.runtimes.has(id)) {
+            return this.runtimes.get(id);
+        }
+
+        // Tentar match por linguagem
+        for (const runtime of this.runtimes.values()) {
+            if (runtime.getLanguage() === language &&
+                runtime.getBuildTool() === buildTool) {
+                return runtime;
+            }
+        }
+
+        // Fallback: qualquer runtime da linguagem
+        for (const runtime of this.runtimes.values()) {
+            if (runtime.getLanguage() === language) {
+                return runtime;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Lista runtimes por linguagem
+     * @param {string} language - Linguagem
+     * @returns {BaseRuntime[]}
+     */
+    listByLanguage(language) {
+        return Array.from(this.runtimes.values())
+            .filter(r => r.getLanguage() === language);
+    }
+}
+
+// ==========================================
+// SINGLETON INSTANCE
+// ==========================================
+
+let instance = null;
+
+/**
+ * Obtém a instância singleton do RuntimeRegistry
+ * @returns {RuntimeRegistry}
+ */
+export function getRuntimeRegistry() {
+    if (!instance) {
+        instance = new RuntimeRegistry();
+    }
+    return instance;
+}
+
+/**
+ * Inicializa o registry com todos os runtimes disponíveis
+ * @returns {Promise<RuntimeRegistry>}
+ */
+export async function initializeRuntimes() {
+    const registry = getRuntimeRegistry();
+
+    // Import dinâmico dos runtimes
+    try {
+        // Java
+        const { MavenRuntime } = await import('./java/maven-runtime.js');
+        const { GradleRuntime } = await import('./java/gradle-runtime.js');
+        registry.register(new MavenRuntime());
+        registry.register(new GradleRuntime());
+    } catch (e) {
+        console.warn('⚠️ Java runtimes not available:', e.message);
+    }
+
+    try {
+        // Node.js
+        const { NpmRuntime } = await import('./node/npm-runtime.js');
+        const { YarnRuntime } = await import('./node/yarn-runtime.js');
+        registry.register(new NpmRuntime());
+        registry.register(new YarnRuntime());
+    } catch (e) {
+        console.warn('⚠️ Node runtimes not available:', e.message);
+    }
+
+    try {
+        // Python
+        const { PipRuntime } = await import('./python/pip-runtime.js');
+        const { PoetryRuntime } = await import('./python/poetry-runtime.js');
+        registry.register(new PipRuntime());
+        registry.register(new PoetryRuntime());
+    } catch (e) {
+        console.warn('⚠️ Python runtimes not available:', e.message);
+    }
+
+    try {
+        // .NET
+        const { DotNetRuntime } = await import('./dotnet/dotnet-runtime.js');
+        registry.register(new DotNetRuntime());
+    } catch (e) {
+        console.warn('⚠️ .NET runtime not available:', e.message);
+    }
+
+    try {
+        // Go
+        const { GoRuntime } = await import('./go/go-runtime.js');
+        registry.register(new GoRuntime());
+    } catch (e) {
+        console.warn('⚠️ Go runtime not available:', e.message);
+    }
+
+    console.log(`📦 RuntimeRegistry initialized with ${registry.listIds().length} runtimes`);
+    console.log(`   Available: ${registry.listIds().join(', ')}`);
+
+    return registry;
+}
+
+export default RuntimeRegistry;