deepdebug-local-agent 0.3.1

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

@@ -0,0 +1,466 @@
+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';
+
+/**
+ * NpmRuntime
+ *
+ * Runtime para projetos Node.js com npm.
+ * Suporta Express, NestJS, Next.js, React, Vue, etc.
+ */
+export class NpmRuntime extends BaseRuntime {
+
+    constructor() {
+        super();
+        this.framework = null;
+        this.packageJson = null;
+    }
+
+    // ==========================================
+    // IDENTIFICATION
+    // ==========================================
+
+    getId() {
+        return 'node-npm';
+    }
+
+    getName() {
+        return 'Node.js (npm)';
+    }
+
+    getLanguage() {
+        return 'node';
+    }
+
+    getBuildTool() {
+        return 'npm';
+    }
+
+    // ==========================================
+    // DETECTION
+    // ==========================================
+
+    getMarkerFiles() {
+        return ['package.json'];
+    }
+
+    async isCompatible(workspacePath) {
+        const pkgPath = path.join(workspacePath, 'package.json');
+        const yarnLock = path.join(workspacePath, 'yarn.lock');
+
+        // Se tem yarn.lock, prefere YarnRuntime
+        if (await exists(yarnLock)) {
+            return false;
+        }
+
+        return exists(pkgPath);
+    }
+
+    async detectProject(workspacePath) {
+        const pkgPath = path.join(workspacePath, 'package.json');
+        const content = await readFile(pkgPath, 'utf8');
+        this.packageJson = JSON.parse(content);
+
+        const name = this.packageJson.name || path.basename(workspacePath);
+        const version = this.packageJson.version || '0.0.1';
+
+        // Detectar framework
+        const framework = this.detectFramework(this.packageJson);
+        this.framework = framework;
+
+        // Detectar porta
+        const port = await this.detectPort(workspacePath);
+
+        return {
+            name,
+            version,
+            language: 'node',
+            framework,
+            buildTool: 'npm',
+            port
+        };
+    }
+
+    detectFramework(pkg) {
+        const deps = {
+            ...pkg.dependencies,
+            ...pkg.devDependencies
+        };
+
+        // Frontend frameworks
+        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';
+
+        // Backend frameworks
+        if (deps['@nestjs/core']) return 'nestjs';
+        if (deps['express']) return 'express';
+        if (deps['fastify']) return 'fastify';
+        if (deps['koa']) return 'koa';
+        if (deps['hapi'] || deps['@hapi/hapi']) return 'hapi';
+
+        // Outras ferramentas
+        if (deps['electron']) return 'electron';
+
+        return 'node-plain';
+    }
+
+    // ==========================================
+    // BUILD & RUN
+    // ==========================================
+
+    async install(workspacePath, options = {}) {
+        const startTime = Date.now();
+        const args = ['install'];
+
+        if (options.production) {
+            args.push('--production');
+        }
+        if (options.silent) {
+            args.push('--silent');
+        }
+
+        const result = await run('npm', args, workspacePath);
+
+        return {
+            ...result,
+            duration: Date.now() - startTime
+        };
+    }
+
+    async build(workspacePath, options = {}) {
+        const startTime = Date.now();
+
+        // Verificar se existe script de build
+        if (!this.packageJson?.scripts?.build) {
+            return {
+                code: 0,
+                stdout: 'No build script defined',
+                stderr: '',
+                duration: Date.now() - startTime
+            };
+        }
+
+        const result = await run('npm', ['run', 'build'], workspacePath);
+
+        return {
+            ...result,
+            duration: Date.now() - startTime
+        };
+    }
+
+    getStartCommand(options = {}) {
+        const framework = options.framework || this.framework || 'node-plain';
+        const port = options.port || 3000;
+
+        // Comandos específicos por framework
+        const commands = {
+            'next': {
+                cmd: 'npm',
+                args: ['run', 'dev'],
+                env: { PORT: String(port) }
+            },
+            'nuxt': {
+                cmd: 'npm',
+                args: ['run', 'dev'],
+                env: { PORT: String(port) }
+            },
+            'nestjs': {
+                cmd: 'npm',
+                args: ['run', 'start:dev'],
+                env: { PORT: String(port) }
+            },
+            'express': {
+                cmd: 'npm',
+                args: ['start'],
+                env: { PORT: String(port) }
+            },
+            'fastify': {
+                cmd: 'npm',
+                args: ['start'],
+                env: { PORT: String(port) }
+            },
+            'react': {
+                cmd: 'npm',
+                args: ['start'],
+                env: { PORT: String(port) }
+            },
+            'vue': {
+                cmd: 'npm',
+                args: ['run', 'serve'],
+                env: { PORT: String(port) }
+            },
+            'angular': {
+                cmd: 'npm',
+                args: ['start', '--', '--port', String(port)],
+                env: {}
+            }
+        };
+
+        return commands[framework] || {
+            cmd: 'npm',
+            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,
+            'fastify': /Server listening/i,
+            'react': /compiled successfully|You can now view/i,
+            'vue': /App running at/i,
+            'angular': /Compiled successfully|Angular Live/i
+        };
+
+        return patterns[this.framework] || /listening|started|ready|running/i;
+    }
+
+    getDefaultPort() {
+        const defaults = {
+            'next': 3000,
+            'nuxt': 3000,
+            'nestjs': 3000,
+            'express': 3000,
+            'fastify': 3000,
+            'react': 3000,
+            'vue': 8080,
+            'angular': 4200
+        };
+
+        return defaults[this.framework] || 3000;
+    }
+
+    async detectPort(workspacePath) {
+        // Tentar .env
+        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]);
+        }
+
+        // Tentar .env.local
+        const envLocalPath = path.join(workspacePath, '.env.local');
+        if (await exists(envLocalPath)) {
+            const content = await readFile(envLocalPath, 'utf8');
+            const match = content.match(/^PORT\s*=\s*(\d+)/m);
+            if (match) return parseInt(match[1]);
+        }
+
+        // Para Next.js, verificar next.config.js
+        if (this.framework === 'next') {
+            const nextConfigPath = path.join(workspacePath, 'next.config.js');
+            if (await exists(nextConfigPath)) {
+                const content = await readFile(nextConfigPath, '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();
+
+        // Verificar se existe script de test
+        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('npm', ['test', '--', '--passWithNoTests'], workspacePath);
+
+        const testResult = this.parseTestOutput(result);
+        testResult.duration = Date.now() - startTime;
+
+        return testResult;
+    }
+
+    async testSingle(workspacePath, testFile) {
+        const startTime = Date.now();
+
+        // Detectar test runner
+        const deps = {
+            ...this.packageJson?.dependencies,
+            ...this.packageJson?.devDependencies
+        };
+
+        let args = ['test', '--'];
+
+        if (deps['jest']) {
+            args.push(testFile);
+        } else if (deps['mocha']) {
+            args.push(testFile);
+        } else if (deps['vitest']) {
+            args = ['run', 'vitest', testFile];
+        }
+
+        const result = await run('npm', args, workspacePath);
+
+        const testResult = this.parseTestOutput(result);
+        testResult.duration = Date.now() - startTime;
+
+        return testResult;
+    }
+
+    parseTestOutput(result) {
+        const output = result.stdout + result.stderr;
+
+        // Jest output format
+        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: this.extractJestFailures(output)
+            };
+        }
+
+        // Mocha output format
+        const mochaMatch = output.match(/(\d+)\s+passing.*?(\d+)?\s*failing/s);
+        if (mochaMatch) {
+            return {
+                success: result.code === 0,
+                passed: parseInt(mochaMatch[1]) || 0,
+                failed: parseInt(mochaMatch[2]) || 0,
+                skipped: 0,
+                duration: 0,
+                output,
+                failures: []
+            };
+        }
+
+        // Fallback
+        return {
+            success: result.code === 0,
+            passed: result.code === 0 ? 1 : 0,
+            failed: result.code === 0 ? 0 : 1,
+            skipped: 0,
+            duration: 0,
+            output,
+            failures: []
+        };
+    }
+
+    extractJestFailures(output) {
+        const failures = [];
+        const failureRegex = /● (.+)/g;
+
+        let match;
+        while ((match = failureRegex.exec(output)) !== null) {
+            failures.push({
+                testName: match[1],
+                message: '',
+                stackTrace: ''
+            });
+        }
+
+        return 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 = [];
+
+        // ES6 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('/')
+            });
+        }
+
+        // CommonJS requires
+        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
+        };
+    }
+
+    async postPatchActions(workspacePath, modifiedFiles) {
+        // Rodar prettier se disponível
+        const deps = {
+            ...this.packageJson?.dependencies,
+            ...this.packageJson?.devDependencies
+        };
+
+        if (deps['prettier']) {
+            for (const file of modifiedFiles) {
+                await run('npx', ['prettier', '--write', file], workspacePath);
+            }
+        }
+    }
+}
+
+export default NpmRuntime;