deepdebug-local-agent 0.3.8 → 0.3.9

package/detectors/multi-project-detector.js

@@ -0,0 +1,191 @@
+import path from "path";
+import { exists, readdir, stat } from "../fs-utils.js";
+import { ServiceDetector } from "./service-detector.js";
+import { LanguageDetector } from "./language-detector.js";
+import { FrameworkDetector } from "./framework-detector.js";
+import { WorkspaceScanner } from "../workspace/scanner.js";
+import { FileReader } from "../workspace/file-reader.js";
+
+/**
+ * MultiProjectDetector
+ *
+ * Detecta múltiplos projetos dentro de um workspace
+ * Escaneia subpastas em busca de projetos independentes (pom.xml, package.json, etc)
+ */
+export class MultiProjectDetector {
+    constructor(workspaceRoot) {
+        this.workspaceRoot = workspaceRoot;
+        this.maxDepth = 2; // Escanear até 2 níveis de profundidade
+    }
+
+    /**
+     * Detecta todos os projetos no workspace
+     */
+    async detectProjects() {
+        console.log(`🔍 Scanning workspace for multiple projects: ${this.workspaceRoot}`);
+
+        const projects = [];
+
+        // 1️⃣ Verificar se o próprio workspace root é um projeto
+        if (await this.isProject(this.workspaceRoot)) {
+            console.log(`✅ Root is a project`);
+            projects.push({
+                name: path.basename(this.workspaceRoot),
+                path: this.workspaceRoot,
+                isRoot: true
+            });
+        }
+
+        // 2️⃣ Escanear subpastas em busca de projetos
+        const subProjects = await this.scanSubdirectories(this.workspaceRoot, 0);
+        projects.push(...subProjects);
+
+        console.log(`✅ Found ${projects.length} project(s) in workspace`);
+
+        // 3️⃣ Detectar serviços para cada projeto
+        const allServices = [];
+        for (const project of projects) {
+            console.log(`🔎 Detecting services in: ${project.name}`);
+            const services = await this.detectServicesInProject(project);
+            allServices.push(...services);
+        }
+
+        console.log(`✅ Total services detected: ${allServices.length}`);
+        return allServices;
+    }
+
+    /**
+     * Verifica se um diretório é um projeto
+     */
+    async isProject(dir) {
+        const markers = [
+            'pom.xml',           // Maven
+            'build.gradle',      // Gradle
+            'build.gradle.kts',  // Gradle Kotlin
+            'package.json',      // Node.js
+            'requirements.txt',  // Python
+            'pyproject.toml',    // Python Poetry
+            'go.mod',            // Go
+            'Cargo.toml',        // Rust
+            '.csproj',           // .NET (qualquer arquivo .csproj)
+            '.sln'               // .NET solution
+        ];
+
+        for (const marker of markers) {
+            // Para .csproj e .sln, procurar qualquer arquivo com extensão
+            if (marker.startsWith('.')) {
+                try {
+                    const files = await readdir(dir);
+                    if (files.some(f => f.endsWith(marker))) {
+                        return true;
+                    }
+                } catch {
+                    continue;
+                }
+            } else {
+                // Para markers específicos, verificar se existe
+                if (await exists(path.join(dir, marker))) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Escaneia subdiretórios recursivamente
+     */
+    async scanSubdirectories(dir, depth) {
+        if (depth >= this.maxDepth) {
+            return [];
+        }
+
+        const projects = [];
+
+        try {
+            const entries = await readdir(dir, { withFileTypes: true });
+
+            for (const entry of entries) {
+                if (!entry.isDirectory()) continue;
+
+                // Ignorar pastas comuns que não são projetos
+                const ignoreDirs = [
+                    'node_modules', 'target', 'build', 'dist', 'out',
+                    '.git', '.idea', '.vscode', '__pycache__',
+                    '.next', 'coverage', '.gradle', 'vendor',
+                    'venv', 'env', '.env'
+                ];
+
+                if (ignoreDirs.includes(entry.name)) {
+                    continue;
+                }
+
+                const fullPath = path.join(dir, entry.name);
+
+                // Verificar se é um projeto
+                if (await this.isProject(fullPath)) {
+                    console.log(`✅ Found project: ${entry.name}`);
+                    projects.push({
+                        name: entry.name,
+                        path: fullPath,
+                        isRoot: false
+                    });
+                    // Não escanear dentro de projetos encontrados
+                    continue;
+                }
+
+                // Continuar escaneando recursivamente
+                const subProjects = await this.scanSubdirectories(fullPath, depth + 1);
+                projects.push(...subProjects);
+            }
+        } catch (err) {
+            console.warn(`⚠️ Could not scan directory ${dir}: ${err.message}`);
+        }
+
+        return projects;
+    }
+
+    /**
+     * Detecta serviços em um projeto específico
+     */
+    async detectServicesInProject(project) {
+        try {
+            // Usar o scanner para analisar o projeto
+            const scanner = new WorkspaceScanner(project.path);
+            const structure = await scanner.scan();
+
+            // Detectar linguagem
+            const languageDetector = new LanguageDetector(structure.files);
+            const languageInfo = languageDetector.detect();
+
+            // Detectar framework
+            const fileReader = new FileReader(project.path);
+            const frameworkDetector = new FrameworkDetector(
+                languageInfo.primary,
+                structure.files,
+                fileReader
+            );
+            const frameworkInfo = await frameworkDetector.detect();
+
+            // Detectar serviços
+            const serviceDetector = new ServiceDetector(
+                project.path,
+                languageInfo,
+                frameworkInfo
+            );
+
+            const services = await serviceDetector.detect();
+
+            // Adicionar nome do workspace a cada serviço
+            return services.map(service => ({
+                ...service,
+                workspaceName: project.name,
+                workspacePath: this.workspaceRoot
+            }));
+        } catch (err) {
+            console.error(`❌ Error detecting services in ${project.name}: ${err.message}`);
+            return [];
+        }
+    }
+}

package/detectors/service-detector.js

@@ -0,0 +1,244 @@
+import path from "path";
+import { exists, readFile } from "../fs-utils.js";
+
+/**
+ * ServiceDetector
+ *
+ * Detecta serviços/microservices em um workspace
+ * Identifica: nome, porta, tipo, comando de start
+ */
+export class ServiceDetector {
+    constructor(root, languageInfo, frameworkInfo) {
+        this.root = root;
+        this.language = languageInfo.primary;
+        this.framework = frameworkInfo.framework;
+        this.buildTool = frameworkInfo.buildTool;
+    }
+
+    /**
+     * Detecta todos os serviços no workspace
+     */
+    async detect() {
+        const services = [];
+
+        // Detectar por tipo de projeto
+        if (this.language === "java" && this.framework === "spring-boot") {
+            const service = await this.detectSpringBootService();
+            if (service) services.push(service);
+        } else if (this.language === "node") {
+            const service = await this.detectNodeService();
+            if (service) services.push(service);
+        } else if (this.language === "python") {
+            const service = await this.detectPythonService();
+            if (service) services.push(service);
+        } else if (this.language === "dotnet") {
+            services.push(this.detectDotNetService());
+        } else if (this.language === "go") {
+            services.push(this.detectGoService());
+        }
+
+        return services;
+    }
+
+    /**
+     * Detecta serviço Spring Boot
+     */
+    async detectSpringBootService() {
+        const pomPath = path.join(this.root, "pom.xml");
+        const gradlePath = path.join(this.root, "build.gradle");
+
+        let serviceName = path.basename(this.root); // Fallback: nome da pasta
+        let port = 8080;
+
+        // Tentar extrair nome do pom.xml (ignorando o parent)
+        if (await exists(pomPath)) {
+            const content = await readFile(pomPath, "utf8");
+
+            // Remove o bloco <parent>...</parent> para não pegar o artifactId errado
+            const contentWithoutParent = content.replace(/<parent>[\s\S]*?<\/parent>/gi, '');
+            const artifactIdMatch = contentWithoutParent.match(/<artifactId>([^<]+)<\/artifactId>/);
+
+            if (artifactIdMatch) {
+                serviceName = artifactIdMatch[1].trim();
+            }
+        }
+
+        // Tentar extrair do build.gradle
+        if (await exists(gradlePath)) {
+            const content = await readFile(gradlePath, "utf8");
+            const nameMatch = content.match(/rootProject\.name\s*=\s*['"]([^'"]+)['"]/);
+            if (nameMatch) {
+                serviceName = nameMatch[1];
+            }
+        }
+
+        // Tentar detectar porta do application.yml/properties
+        port = await this.detectSpringBootPort();
+
+        return {
+            id: serviceName,
+            name: serviceName,
+            type: "spring-boot",
+            language: "java",
+            framework: "spring-boot",
+            buildTool: this.buildTool,
+            port,
+            status: "stopped",
+            path: this.root
+        };
+    }
+
+    /**
+     * Detecta porta do Spring Boot
+     */
+    async detectSpringBootPort() {
+        const candidates = [
+            "src/main/resources/application.yml",
+            "src/main/resources/application.yaml",
+            "src/main/resources/application.properties"
+        ];
+
+        for (const rel of candidates) {
+            const fullPath = path.join(this.root, rel);
+            if (await exists(fullPath)) {
+                const content = await readFile(fullPath, "utf8");
+
+                // YAML - múltiplos padrões
+                if (rel.endsWith(".yml") || rel.endsWith(".yaml")) {
+                    // Padrão 1: server:\n  port: 8080
+                    let match = content.match(/server:\s*\n\s*port:\s*(\d+)/);
+                    if (match) return parseInt(match[1]);
+
+                    // Padrão 2: server.port: 8080
+                    match = content.match(/server\.port:\s*(\d+)/);
+                    if (match) return parseInt(match[1]);
+
+                    // Padrão 3: port: ${PORT:8080}
+                    match = content.match(/port:\s*\$\{[^}]*:(\d+)\}/);
+                    if (match) return parseInt(match[1]);
+
+                    // Padrão 4: server:\n    port: 8080 (com mais espaços)
+                    match = content.match(/server:\s*[\r\n]+\s*port:\s*(\d+)/);
+                    if (match) return parseInt(match[1]);
+                }
+
+                // Properties
+                if (rel.endsWith(".properties")) {
+                    const match = content.match(/server\.port\s*=\s*(\d+)/);
+                    if (match) return parseInt(match[1]);
+                }
+            }
+        }
+
+        return 8080; // Default
+    }
+
+    /**
+     * Detecta serviço Node.js
+     */
+    async detectNodeService() {
+        const pkgPath = path.join(this.root, "package.json");
+        if (!await exists(pkgPath)) return null;
+
+        const content = await readFile(pkgPath, "utf8");
+        const pkg = JSON.parse(content);
+
+        return {
+            id: pkg.name || path.basename(this.root),
+            name: pkg.name || path.basename(this.root),
+            type: this.framework,
+            language: "node",
+            framework: this.framework,
+            buildTool: "npm",
+            port: await this.detectNodePort(),
+            status: "stopped",
+            path: this.root
+        };
+    }
+
+    /**
+     * Detecta porta do Node.js
+     */
+    async detectNodePort() {
+        // Tentar .env
+        const envPath = path.join(this.root, ".env");
+        if (await exists(envPath)) {
+            const content = await readFile(envPath, "utf8");
+            const match = content.match(/PORT\s*=\s*(\d+)/i);
+            if (match) return parseInt(match[1]);
+        }
+
+        // Defaults por framework
+        const defaults = {
+            "next": 3000,
+            "express": 3000,
+            "nestjs": 3000
+        };
+
+        return defaults[this.framework] || 3000;
+    }
+
+    /**
+     * Detecta serviço Python
+     */
+    async detectPythonService() {
+        return {
+            id: path.basename(this.root),
+            name: path.basename(this.root),
+            type: this.framework,
+            language: "python",
+            framework: this.framework,
+            buildTool: "pip",
+            port: await this.detectPythonPort(),
+            status: "stopped",
+            path: this.root
+        };
+    }
+
+    /**
+     * Detecta porta do Python
+     */
+    async detectPythonPort() {
+        const defaults = {
+            "django": 8000,
+            "flask": 5000,
+            "fastapi": 8000
+        };
+
+        return defaults[this.framework] || 8000;
+    }
+
+    /**
+     * Detecta serviço .NET
+     */
+    detectDotNetService() {
+        return {
+            id: path.basename(this.root),
+            name: path.basename(this.root),
+            type: "dotnet",
+            language: "dotnet",
+            framework: "dotnet",
+            buildTool: "dotnet",
+            port: 5000,
+            status: "stopped",
+            path: this.root
+        };
+    }
+
+    /**
+     * Detecta serviço Go
+     */
+    detectGoService() {
+        return {
+            id: path.basename(this.root),
+            name: path.basename(this.root),
+            type: "go",
+            language: "go",
+            framework: "go",
+            buildTool: "go",
+            port: 8080,
+            status: "stopped",
+            path: this.root
+        };
+    }
+}

package/detectors.js

@@ -0,0 +1,30 @@
+import path from "path";
+import { exists, readFile } from "./fs-utils.js";
+
+export async function detectProject(root) {
+    const markers = [
+        { file: "pom.xml", lang: "java", buildTool: "maven" },
+        { file: "build.gradle", lang: "java", buildTool: "gradle" },
+        { file: "package.json", lang: "node", buildTool: "npm" },
+        { file: "pyproject.toml", lang: "python", buildTool: "poetry" },
+        { file: "requirements.txt", lang: "python", buildTool: "pip" },
+        { file: "go.mod", lang: "go", buildTool: "go" }
+    ];
+
+    for (const m of markers) {
+        if (await exists(path.join(root, m.file))) {
+            return { language: m.lang, buildTool: m.buildTool, marker: m.file };
+        }
+    }
+
+    // .NET: procura primeiro nível
+    const dotnet = (await (await import("fs")).promises.readdir(root))
+        .find(f => f.endsWith(".csproj") || f.endsWith(".sln"));
+    if (dotnet) return { language: ".net", buildTool: "dotnet", marker: dotnet };
+
+    return { language: "unknown", buildTool: "unknown", marker: null };
+}
+
+export async function readText(root, relPath) {
+    return readFile(path.join(root, relPath), "utf8");
+}

package/exec-utils.js

@@ -0,0 +1,215 @@
+import { spawn } from "child_process";
+import stripAnsi from "strip-ansi";
+
+export function run(cmd, args, cwd, timeoutMs = 10 * 60 * 1000) {
+    return new Promise((resolve) => {
+        const start = Date.now();
+        const child = spawn(cmd, args, { cwd, shell: true });
+        let stdout = "";
+        let stderr = "";
+        const timer = setTimeout(() => {
+            try { child.kill("SIGKILL"); } catch {}
+        }, timeoutMs);
+
+        child.stdout.on("data", d => stdout += d.toString());
+        child.stderr.on("data", d => stderr += d.toString());
+
+        child.on("close", code => {
+            clearTimeout(timer);
+            resolve({
+                code,
+                stdout: stripAnsi(stdout),
+                stderr: stripAnsi(stderr),
+                duration: Date.now() - start
+            });
+        });
+
+        child.on("error", (err) => {
+            clearTimeout(timer);
+            resolve({
+                code: 1,
+                stdout: "",
+                stderr: err.message,
+                duration: Date.now() - start
+            });
+        });
+    });
+}
+
+/**
+ * Compile and optionally test a project
+ *
+ * @param {Object} options
+ * @param {string} options.language - Programming language (java, node, python, go, .net)
+ * @param {string} options.buildTool - Build tool (maven, gradle, npm, yarn)
+ * @param {string} options.cwd - Working directory
+ * @param {boolean} options.skipTests - Skip running tests (default: false)
+ * @returns {Promise<{code: number, stdout: string, stderr: string, duration: number}>}
+ */
+export async function compileAndTest({ language, buildTool, cwd, skipTests = false }) {
+    console.log(`🔨 [COMPILE] Language: ${language}, BuildTool: ${buildTool}, SkipTests: ${skipTests}`);
+
+    let result;
+    const start = Date.now();
+
+    try {
+        if (language === "java" && buildTool === "maven") {
+            // Maven: clean install (skip tests if requested)
+            const args = skipTests
+                ? ["clean", "install", "-DskipTests", "-q"]
+                : ["clean", "install", "-q"];
+
+            console.log(`🔨 [COMPILE] Running: mvn ${args.join(" ")}`);
+            result = await run("mvn", args, cwd);
+        }
+        else if (language === "java" && buildTool === "gradle") {
+            // Gradle: clean build
+            const args = skipTests
+                ? ["clean", "build", "-x", "test"]
+                : ["clean", "build"];
+
+            console.log(`🔨 [COMPILE] Running: ./gradlew ${args.join(" ")}`);
+            result = await run("./gradlew", args, cwd);
+        }
+        else if (language === "node" || buildTool === "npm") {
+            // Node/npm: install and optionally test
+            console.log(`🔨 [COMPILE] Running: npm install`);
+            const installResult = await run("npm", ["install", "--silent"], cwd);
+
+            if (installResult.code !== 0) {
+                return installResult;
+            }
+
+            if (!skipTests) {
+                console.log(`🔨 [COMPILE] Running: npm test`);
+                result = await run("npm", ["test", "--silent"], cwd);
+            } else {
+                result = installResult;
+            }
+        }
+        else if (language === "node" || buildTool === "yarn") {
+            // Yarn
+            console.log(`🔨 [COMPILE] Running: yarn install`);
+            const installResult = await run("yarn", ["install", "--silent"], cwd);
+
+            if (installResult.code !== 0) {
+                return installResult;
+            }
+
+            if (!skipTests) {
+                console.log(`🔨 [COMPILE] Running: yarn test`);
+                result = await run("yarn", ["test", "--silent"], cwd);
+            } else {
+                result = installResult;
+            }
+        }
+        else if (language === "python") {
+            // Python: pytest
+            if (!skipTests) {
+                console.log(`🔨 [COMPILE] Running: pytest`);
+                result = await run("pytest", [], cwd);
+            } else {
+                // Python doesn't have a compile step, just return success
+                result = { code: 0, stdout: "Python: No compilation needed", stderr: "", duration: 0 };
+            }
+        }
+        else if (language === "go") {
+            // Go: build and optionally test
+            console.log(`🔨 [COMPILE] Running: go build ./...`);
+            const buildResult = await run("go", ["build", "./..."], cwd);
+
+            if (buildResult.code !== 0) {
+                return buildResult;
+            }
+
+            if (!skipTests) {
+                console.log(`🔨 [COMPILE] Running: go test ./...`);
+                result = await run("go", ["test", "./..."], cwd);
+            } else {
+                result = buildResult;
+            }
+        }
+        else if (language === ".net" || language === "dotnet") {
+            // .NET: build and optionally test
+            console.log(`🔨 [COMPILE] Running: dotnet build`);
+            const buildResult = await run("dotnet", ["build"], cwd);
+
+            if (buildResult.code !== 0) {
+                return buildResult;
+            }
+
+            if (!skipTests) {
+                console.log(`🔨 [COMPILE] Running: dotnet test`);
+                result = await run("dotnet", ["test"], cwd);
+            } else {
+                result = buildResult;
+            }
+        }
+        else {
+            console.error(`❌ [COMPILE] Unsupported: ${language}/${buildTool}`);
+            return {
+                code: 1,
+                stdout: "",
+                stderr: `Unsupported language/build tool: ${language}/${buildTool}`,
+                duration: Date.now() - start
+            };
+        }
+
+        // Log result
+        if (result.code === 0) {
+            console.log(`✅ [COMPILE] Success in ${result.duration}ms`);
+        } else {
+            console.error(`❌ [COMPILE] Failed with code ${result.code}`);
+            if (result.stderr) {
+                console.error(`❌ [COMPILE] Error: ${result.stderr.substring(0, 500)}`);
+            }
+        }
+
+        return result;
+
+    } catch (err) {
+        console.error(`❌ [COMPILE] Exception: ${err.message}`);
+        return {
+            code: 1,
+            stdout: "",
+            stderr: err.message,
+            duration: Date.now() - start
+        };
+    }
+}
+
+/**
+ * Legacy function for backward compatibility
+ * Returns { steps: [...] } format
+ */
+export async function compileAndTestLegacy({ language, buildTool, cwd }) {
+    if (language === "java" && buildTool === "maven") {
+        const c1 = await run("mvn", "clean -q".split(" "), cwd);
+        const c2 = await run("mvn", "test -q".split(" "), cwd);
+        return { steps: [c1, c2] };
+    }
+    if (language === "java" && buildTool === "gradle") {
+        const c1 = await run("./gradlew", ["clean"], cwd);
+        const c2 = await run("./gradlew", ["test"], cwd);
+        return { steps: [c1, c2] };
+    }
+    if (language === "node") {
+        const c1 = await run("npm", ["install", "--silent"], cwd);
+        const c2 = await run("npm", ["test", "--silent"], cwd);
+        return { steps: [c1, c2] };
+    }
+    if (language === "python") {
+        const c1 = await run("pytest", [], cwd);
+        return { steps: [c1] };
+    }
+    if (language === "go") {
+        const c1 = await run("go", ["test", "./..."], cwd);
+        return { steps: [c1] };
+    }
+    if (language === ".net") {
+        const c1 = await run("dotnet", ["build"], cwd);
+        const c2 = await run("dotnet", ["test"], cwd);
+        return { steps: [c1, c2] };
+    }
+    return { steps: [{ code: 1, stdout: "", stderr: "Unsupported language/build tool" }] };
+}