deepdebug-local-agent 0.3.1

package/src/utils/environment-diagnostics.js

@@ -0,0 +1,666 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import path from 'path';
+import os from 'os';
+
+const execAsync = promisify(exec);
+
+/**
+ * EnvironmentDiagnostics
+ *
+ * Detecta automaticamente ferramentas de desenvolvimento instaladas no sistema.
+ * Útil para debugging e setup do ambiente.
+ */
+export class EnvironmentDiagnostics {
+
+    constructor() {
+        this.cache = null;
+        this.cacheTime = 0;
+        this.cacheTTL = 60000; // 1 minuto
+    }
+
+    /**
+     * Executa diagnóstico completo do ambiente
+     */
+    async diagnose() {
+        // Usar cache se ainda válido
+        if (this.cache && (Date.now() - this.cacheTime) < this.cacheTTL) {
+            return this.cache;
+        }
+
+        const startTime = Date.now();
+
+        const [
+            system,
+            java,
+            maven,
+            gradle,
+            node,
+            npm,
+            yarn,
+            python,
+            pip,
+            go,
+            dotnet,
+            git,
+            docker
+        ] = await Promise.all([
+            this.getSystemInfo(),
+            this.detectJava(),
+            this.detectMaven(),
+            this.detectGradle(),
+            this.detectNode(),
+            this.detectNpm(),
+            this.detectYarn(),
+            this.detectPython(),
+            this.detectPip(),
+            this.detectGo(),
+            this.detectDotnet(),
+            this.detectGit(),
+            this.detectDocker()
+        ]);
+
+        const result = {
+            timestamp: new Date().toISOString(),
+            diagnosisTime: Date.now() - startTime,
+            system,
+            tools: {
+                java,
+                maven,
+                gradle,
+                node,
+                npm,
+                yarn,
+                python,
+                pip,
+                go,
+                dotnet,
+                git,
+                docker
+            },
+            summary: this.generateSummary({ java, maven, gradle, node, npm, yarn, python, go, dotnet }),
+            issues: this.detectIssues({ java, maven, gradle, node, npm, yarn, python, go, dotnet })
+        };
+
+        this.cache = result;
+        this.cacheTime = Date.now();
+
+        return result;
+    }
+
+    /**
+     * Informações do sistema
+     */
+    async getSystemInfo() {
+        return {
+            platform: os.platform(),
+            arch: os.arch(),
+            release: os.release(),
+            hostname: os.hostname(),
+            cpus: os.cpus().length,
+            memory: {
+                total: Math.round(os.totalmem() / 1024 / 1024 / 1024 * 100) / 100, // GB
+                free: Math.round(os.freemem() / 1024 / 1024 / 1024 * 100) / 100 // GB
+            },
+            uptime: Math.floor(os.uptime() / 3600), // hours
+            user: os.userInfo().username,
+            home: os.homedir(),
+            shell: process.env.SHELL || 'unknown'
+        };
+    }
+
+    /**
+     * Detecta Java
+     */
+    async detectJava() {
+        const result = {
+            installed: false,
+            version: null,
+            vendor: null,
+            javaHome: process.env.JAVA_HOME || null,
+            path: null
+        };
+
+        try {
+            // Tentar java -version
+            const { stderr } = await execAsync('java -version 2>&1');
+            const output = stderr || '';
+
+            result.installed = true;
+
+            // Extrair versão (ex: "openjdk version "17.0.1"")
+            const versionMatch = output.match(/version\s+"([^"]+)"/);
+            if (versionMatch) {
+                result.version = versionMatch[1];
+            }
+
+            // Extrair vendor
+            if (output.includes('OpenJDK')) {
+                result.vendor = 'OpenJDK';
+            } else if (output.includes('Oracle')) {
+                result.vendor = 'Oracle';
+            } else if (output.includes('Azul')) {
+                result.vendor = 'Azul Zulu';
+            } else if (output.includes('Amazon')) {
+                result.vendor = 'Amazon Corretto';
+            } else if (output.includes('Eclipse')) {
+                result.vendor = 'Eclipse Temurin';
+            }
+
+            // Encontrar path
+            const { stdout: whichOutput } = await execAsync('which java').catch(() => ({ stdout: '' }));
+            result.path = whichOutput.trim() || null;
+
+        } catch (err) {
+            result.error = err.message;
+        }
+
+        return result;
+    }
+
+    /**
+     * Detecta Maven
+     */
+    async detectMaven() {
+        const result = {
+            installed: false,
+            version: null,
+            path: null,
+            mavenHome: process.env.MAVEN_HOME || process.env.M2_HOME || null
+        };
+
+        try {
+            const { stdout } = await execAsync('mvn -version 2>&1');
+
+            result.installed = true;
+
+            // Extrair versão (ex: "Apache Maven 3.9.0")
+            const versionMatch = stdout.match(/Apache Maven (\d+\.\d+\.\d+)/);
+            if (versionMatch) {
+                result.version = versionMatch[1];
+            }
+
+            // Extrair Java version usado pelo Maven
+            const javaMatch = stdout.match(/Java version: ([^\n,]+)/);
+            if (javaMatch) {
+                result.javaVersion = javaMatch[1].trim();
+            }
+
+            // Encontrar path
+            const { stdout: whichOutput } = await execAsync('which mvn').catch(() => ({ stdout: '' }));
+            result.path = whichOutput.trim() || null;
+
+        } catch (err) {
+            result.error = err.message;
+        }
+
+        return result;
+    }
+
+    /**
+     * Detecta Gradle
+     */
+    async detectGradle() {
+        const result = {
+            installed: false,
+            version: null,
+            path: null,
+            gradleHome: process.env.GRADLE_HOME || null
+        };
+
+        try {
+            const { stdout } = await execAsync('gradle -version 2>&1');
+
+            result.installed = true;
+
+            // Extrair versão (ex: "Gradle 8.0")
+            const versionMatch = stdout.match(/Gradle (\d+\.\d+\.?\d*)/);
+            if (versionMatch) {
+                result.version = versionMatch[1];
+            }
+
+            // Encontrar path
+            const { stdout: whichOutput } = await execAsync('which gradle').catch(() => ({ stdout: '' }));
+            result.path = whichOutput.trim() || null;
+
+        } catch (err) {
+            result.error = err.message;
+        }
+
+        return result;
+    }
+
+    /**
+     * Detecta Node.js
+     */
+    async detectNode() {
+        const result = {
+            installed: false,
+            version: null,
+            path: null
+        };
+
+        try {
+            const { stdout } = await execAsync('node -version 2>&1');
+
+            result.installed = true;
+            result.version = stdout.trim().replace('v', '');
+
+            // Encontrar path
+            const { stdout: whichOutput } = await execAsync('which node').catch(() => ({ stdout: '' }));
+            result.path = whichOutput.trim() || null;
+
+        } catch (err) {
+            result.error = err.message;
+        }
+
+        return result;
+    }
+
+    /**
+     * Detecta npm
+     */
+    async detectNpm() {
+        const result = {
+            installed: false,
+            version: null,
+            path: null,
+            globalPrefix: null
+        };
+
+        try {
+            const { stdout } = await execAsync('npm -version 2>&1');
+
+            result.installed = true;
+            result.version = stdout.trim();
+
+            // Prefix global
+            const { stdout: prefixOutput } = await execAsync('npm config get prefix').catch(() => ({ stdout: '' }));
+            result.globalPrefix = prefixOutput.trim() || null;
+
+            // Encontrar path
+            const { stdout: whichOutput } = await execAsync('which npm').catch(() => ({ stdout: '' }));
+            result.path = whichOutput.trim() || null;
+
+        } catch (err) {
+            result.error = err.message;
+        }
+
+        return result;
+    }
+
+    /**
+     * Detecta Yarn
+     */
+    async detectYarn() {
+        const result = {
+            installed: false,
+            version: null,
+            path: null
+        };
+
+        try {
+            const { stdout } = await execAsync('yarn -version 2>&1');
+
+            result.installed = true;
+            result.version = stdout.trim();
+
+            // Encontrar path
+            const { stdout: whichOutput } = await execAsync('which yarn').catch(() => ({ stdout: '' }));
+            result.path = whichOutput.trim() || null;
+
+        } catch (err) {
+            result.error = err.message;
+        }
+
+        return result;
+    }
+
+    /**
+     * Detecta Python
+     */
+    async detectPython() {
+        const result = {
+            installed: false,
+            version: null,
+            path: null,
+            python3: false
+        };
+
+        try {
+            // Tentar python3 primeiro
+            const { stdout } = await execAsync('python3 --version 2>&1').catch(() =>
+                execAsync('python --version 2>&1')
+            );
+
+            result.installed = true;
+
+            // Extrair versão (ex: "Python 3.11.0")
+            const versionMatch = stdout.match(/Python (\d+\.\d+\.?\d*)/);
+            if (versionMatch) {
+                result.version = versionMatch[1];
+                result.python3 = result.version.startsWith('3');
+            }
+
+            // Encontrar path
+            const { stdout: whichOutput } = await execAsync('which python3 || which python').catch(() => ({ stdout: '' }));
+            result.path = whichOutput.trim() || null;
+
+        } catch (err) {
+            result.error = err.message;
+        }
+
+        return result;
+    }
+
+    /**
+     * Detecta pip
+     */
+    async detectPip() {
+        const result = {
+            installed: false,
+            version: null,
+            path: null
+        };
+
+        try {
+            const { stdout } = await execAsync('pip3 --version 2>&1').catch(() =>
+                execAsync('pip --version 2>&1')
+            );
+
+            result.installed = true;
+
+            // Extrair versão (ex: "pip 23.0.1")
+            const versionMatch = stdout.match(/pip (\d+\.\d+\.?\d*)/);
+            if (versionMatch) {
+                result.version = versionMatch[1];
+            }
+
+            // Encontrar path
+            const { stdout: whichOutput } = await execAsync('which pip3 || which pip').catch(() => ({ stdout: '' }));
+            result.path = whichOutput.trim() || null;
+
+        } catch (err) {
+            result.error = err.message;
+        }
+
+        return result;
+    }
+
+    /**
+     * Detecta Go
+     */
+    async detectGo() {
+        const result = {
+            installed: false,
+            version: null,
+            path: null,
+            gopath: process.env.GOPATH || null,
+            goroot: process.env.GOROOT || null
+        };
+
+        try {
+            const { stdout } = await execAsync('go version 2>&1');
+
+            result.installed = true;
+
+            // Extrair versão (ex: "go version go1.21.0 darwin/amd64")
+            const versionMatch = stdout.match(/go(\d+\.\d+\.?\d*)/);
+            if (versionMatch) {
+                result.version = versionMatch[1];
+            }
+
+            // Encontrar path
+            const { stdout: whichOutput } = await execAsync('which go').catch(() => ({ stdout: '' }));
+            result.path = whichOutput.trim() || null;
+
+        } catch (err) {
+            result.error = err.message;
+        }
+
+        return result;
+    }
+
+    /**
+     * Detecta .NET
+     */
+    async detectDotnet() {
+        const result = {
+            installed: false,
+            version: null,
+            sdks: [],
+            runtimes: [],
+            path: null
+        };
+
+        try {
+            const { stdout } = await execAsync('dotnet --version 2>&1');
+
+            result.installed = true;
+            result.version = stdout.trim();
+
+            // Listar SDKs
+            const { stdout: sdkOutput } = await execAsync('dotnet --list-sdks 2>&1').catch(() => ({ stdout: '' }));
+            result.sdks = sdkOutput.trim().split('\n').filter(Boolean);
+
+            // Listar Runtimes
+            const { stdout: runtimeOutput } = await execAsync('dotnet --list-runtimes 2>&1').catch(() => ({ stdout: '' }));
+            result.runtimes = runtimeOutput.trim().split('\n').filter(Boolean).slice(0, 5); // Limitar
+
+            // Encontrar path
+            const { stdout: whichOutput } = await execAsync('which dotnet').catch(() => ({ stdout: '' }));
+            result.path = whichOutput.trim() || null;
+
+        } catch (err) {
+            result.error = err.message;
+        }
+
+        return result;
+    }
+
+    /**
+     * Detecta Git
+     */
+    async detectGit() {
+        const result = {
+            installed: false,
+            version: null,
+            path: null,
+            user: null,
+            email: null
+        };
+
+        try {
+            const { stdout } = await execAsync('git --version 2>&1');
+
+            result.installed = true;
+
+            // Extrair versão (ex: "git version 2.39.0")
+            const versionMatch = stdout.match(/git version (\d+\.\d+\.?\d*)/);
+            if (versionMatch) {
+                result.version = versionMatch[1];
+            }
+
+            // User e email
+            const { stdout: userOutput } = await execAsync('git config --global user.name').catch(() => ({ stdout: '' }));
+            result.user = userOutput.trim() || null;
+
+            const { stdout: emailOutput } = await execAsync('git config --global user.email').catch(() => ({ stdout: '' }));
+            result.email = emailOutput.trim() || null;
+
+            // Encontrar path
+            const { stdout: whichOutput } = await execAsync('which git').catch(() => ({ stdout: '' }));
+            result.path = whichOutput.trim() || null;
+
+        } catch (err) {
+            result.error = err.message;
+        }
+
+        return result;
+    }
+
+    /**
+     * Detecta Docker
+     */
+    async detectDocker() {
+        const result = {
+            installed: false,
+            version: null,
+            running: false,
+            path: null
+        };
+
+        try {
+            const { stdout } = await execAsync('docker --version 2>&1');
+
+            result.installed = true;
+
+            // Extrair versão (ex: "Docker version 24.0.0, build xxx")
+            const versionMatch = stdout.match(/Docker version (\d+\.\d+\.?\d*)/);
+            if (versionMatch) {
+                result.version = versionMatch[1];
+            }
+
+            // Verificar se está rodando
+            try {
+                await execAsync('docker info 2>&1');
+                result.running = true;
+            } catch {
+                result.running = false;
+            }
+
+            // Encontrar path
+            const { stdout: whichOutput } = await execAsync('which docker').catch(() => ({ stdout: '' }));
+            result.path = whichOutput.trim() || null;
+
+        } catch (err) {
+            result.error = err.message;
+        }
+
+        return result;
+    }
+
+    /**
+     * Gera sumário das capacidades
+     */
+    generateSummary(tools) {
+        const capabilities = [];
+
+        if (tools.java?.installed && tools.maven?.installed) {
+            capabilities.push('java-maven');
+        }
+        if (tools.java?.installed && tools.gradle?.installed) {
+            capabilities.push('java-gradle');
+        }
+        if (tools.node?.installed && tools.npm?.installed) {
+            capabilities.push('node-npm');
+        }
+        if (tools.node?.installed && tools.yarn?.installed) {
+            capabilities.push('node-yarn');
+        }
+        if (tools.python?.installed) {
+            capabilities.push('python');
+        }
+        if (tools.go?.installed) {
+            capabilities.push('go');
+        }
+        if (tools.dotnet?.installed) {
+            capabilities.push('dotnet');
+        }
+
+        return {
+            capabilities,
+            canRunJava: tools.java?.installed && (tools.maven?.installed || tools.gradle?.installed),
+            canRunNode: tools.node?.installed && (tools.npm?.installed || tools.yarn?.installed),
+            canRunPython: tools.python?.installed,
+            canRunGo: tools.go?.installed,
+            canRunDotnet: tools.dotnet?.installed
+        };
+    }
+
+    /**
+     * Detecta problemas de configuração
+     */
+    detectIssues(tools) {
+        const issues = [];
+
+        // Java sem JAVA_HOME
+        if (tools.java?.installed && !process.env.JAVA_HOME) {
+            issues.push({
+                severity: 'warning',
+                tool: 'java',
+                message: 'JAVA_HOME não está configurado',
+                fix: 'export JAVA_HOME=$(/usr/libexec/java_home)'
+            });
+        }
+
+        // Java instalado mas Maven não
+        if (tools.java?.installed && !tools.maven?.installed) {
+            issues.push({
+                severity: 'info',
+                tool: 'maven',
+                message: 'Maven não está instalado (necessário para projetos Maven)',
+                fix: 'brew install maven'
+            });
+        }
+
+        // Node sem npm
+        if (tools.node?.installed && !tools.npm?.installed) {
+            issues.push({
+                severity: 'error',
+                tool: 'npm',
+                message: 'Node está instalado mas npm não foi encontrado',
+                fix: 'Reinstale o Node.js'
+            });
+        }
+
+        // Python 2 ao invés de 3
+        if (tools.python?.installed && !tools.python?.python3) {
+            issues.push({
+                severity: 'warning',
+                tool: 'python',
+                message: 'Python 2 detectado. Recomendado usar Python 3',
+                fix: 'brew install python3'
+            });
+        }
+
+        return issues;
+    }
+
+    /**
+     * Diagnóstico rápido apenas para uma linguagem
+     */
+    async diagnoseFor(language) {
+        switch (language) {
+            case 'java':
+                return {
+                    java: await this.detectJava(),
+                    maven: await this.detectMaven(),
+                    gradle: await this.detectGradle()
+                };
+            case 'node':
+                return {
+                    node: await this.detectNode(),
+                    npm: await this.detectNpm(),
+                    yarn: await this.detectYarn()
+                };
+            case 'python':
+                return {
+                    python: await this.detectPython(),
+                    pip: await this.detectPip()
+                };
+            case 'go':
+                return {
+                    go: await this.detectGo()
+                };
+            case 'dotnet':
+                return {
+                    dotnet: await this.detectDotnet()
+                };
+            default:
+                return await this.diagnose();
+        }
+    }
+}
+
+export default EnvironmentDiagnostics;