deepdebug-local-agent 1.0.20 → 1.0.21

package/Dockerfile.full

@@ -0,0 +1,63 @@
+# ================================================================
+# DeepDebug Local Agent - Full Stack (with build tools)
+# ================================================================
+# This image includes Java 17, Maven, Node.js, Python, and Git
+# for compilation and testing in Cloud Engineer provisioned
+# environments. Used when the client has OAuth connected and
+# we provision a compilation container in their cloud.
+# ================================================================
+
+# Stage 1: Build Node.js agent
+FROM node:20-slim AS builder
+
+WORKDIR /build
+COPY package*.json ./
+RUN npm install --omit=dev && npm cache clean --force
+COPY src/ ./src/
+
+# Stage 2: Full runtime with build tools
+FROM node:20-slim
+
+# Install Java 17 + Maven for Spring Boot projects
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        openjdk-17-jdk-headless \
+        maven \
+        git \
+        curl \
+        openssh-client \
+        python3 \
+        python3-pip \
+        && rm -rf /var/lib/apt/lists/*
+
+ENV JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64
+ENV PATH=$PATH:$JAVA_HOME/bin:/usr/share/maven/bin
+
+# Verify all tools are installed
+RUN java -version && mvn -version && node -v && git --version
+
+# Git safe directory for NFS mounted workspaces
+RUN git config --global --add safe.directory '*'
+
+# Create non-root user
+RUN groupadd -r deepdebug && useradd -r -g deepdebug -m deepdebug
+
+WORKDIR /app
+
+# Copy built Node.js agent
+COPY --from=builder /build/node_modules ./node_modules
+COPY --from=builder /build/src ./src
+COPY --from=builder /build/package*.json ./
+
+# Maven dependencies cache directory
+RUN mkdir -p /home/deepdebug/.m2 && chown -R deepdebug:deepdebug /home/deepdebug
+
+# Workspace mount point
+RUN mkdir -p /mnt/workspaces && chown -R deepdebug:deepdebug /mnt/workspaces
+
+EXPOSE 8080
+
+ENV NODE_ENV=production
+ENV PORT=8080
+
+CMD ["node", "src/server.js"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepdebug-local-agent",
-  "version": "1.0.20",
+  "version": "1.0.21",
   "description": "DeepDebug Local Agent - AI-powered code debugging assistant",
   "private": false,
   "type": "module",
@@ -37,6 +37,7 @@
     "cors": "^2.8.5",
     "express": "^4.19.2",
     "js-yaml": "^4.1.0",
+    "pg": "^8.20.0",
     "pidusage": "^3.0.2",
     "properties-reader": "^2.3.0",
     "strip-ansi": "^7.1.0",
@@ -45,8 +46,8 @@
   },
   "devDependencies": {
     "esbuild": "^0.20.0",
-    "pkg": "^5.8.1",
-    "eslint": "^8.57.0"
+    "eslint": "^8.57.0",
+    "pkg": "^5.8.1"
   },
   "engines": {
     "node": ">=18.0.0"

package/src/detectors/language-detector.js

@@ -17,12 +17,18 @@ export class LanguageDetector {
     findMarkers() {
         const markers = {
             java: this.files.some(f => f.name === 'pom.xml' || f.name === 'build.gradle'),
+            kotlin: this.files.some(f => f.name === 'build.gradle.kts'),
             node: this.files.some(f => f.name === 'package.json'),
             python: this.files.some(f => f.name === 'requirements.txt' || f.name === 'pyproject.toml'),
-            dotnet: this.files.some(f => f.name.endsWith('.csproj') || f.name.endsWith('.sln')),
+            dotnet: this.files.some(f => f.name?.endsWith('.csproj') || f.name?.endsWith('.sln')),
             go: this.files.some(f => f.name === 'go.mod'),
             php: this.files.some(f => f.name === 'composer.json'),
-            ruby: this.files.some(f => f.name === 'Gemfile')
+            ruby: this.files.some(f => f.name === 'Gemfile' || f.name === 'Rakefile'),
+            rust: this.files.some(f => f.name === 'Cargo.toml'),
+            dart: this.files.some(f => f.name === 'pubspec.yaml'),
+            elixir: this.files.some(f => f.name === 'mix.exs'),
+            docker: this.files.some(f => f.name === 'Dockerfile'),
+            static: this.files.some(f => f.name === 'index.html'),
         };
         return markers;
     }
@@ -37,20 +43,24 @@ export class LanguageDetector {
     }
 
     determinePrimaryLanguage(markers, extensions) {
-        // Prioridade: markers > extensões
         const detected = Object.entries(markers)
             .filter(([_, exists]) => exists)
             .map(([lang]) => lang);
 
         if (detected.length === 1) return detected[0];
         if (detected.length > 1) {
-            // Múltiplas linguagens, escolhe por extensões
-            const sortedExts = Object.entries(extensions)
-                .sort((a, b) => b[1] - a[1]);
-            return this.mapExtToLang(sortedExts[0]?.[0]);
+            // Filter out meta-markers (docker, static) if real languages exist
+            const realLangs = detected.filter(l => l !== 'docker' && l !== 'static');
+            if (realLangs.length === 1) return realLangs[0];
+            if (realLangs.length > 1) {
+                const sortedExts = Object.entries(extensions)
+                    .sort((a, b) => b[1] - a[1]);
+                return this.mapExtToLang(sortedExts[0]?.[0]) || realLangs[0];
+            }
+            return detected[0];
         }
 
-        // Fallback: extensão mais comum
+        // Fallback: most common extension
         const sortedExts = Object.entries(extensions)
             .sort((a, b) => b[1] - a[1]);
         return this.mapExtToLang(sortedExts[0]?.[0]) || 'unknown';
@@ -59,6 +69,7 @@ export class LanguageDetector {
     mapExtToLang(ext) {
         const map = {
             '.java': 'java',
+            '.kt': 'kotlin',
             '.js': 'node',
             '.ts': 'node',
             '.jsx': 'node',
@@ -67,7 +78,13 @@ export class LanguageDetector {
             '.cs': 'dotnet',
             '.go': 'go',
             '.php': 'php',
-            '.rb': 'ruby'
+            '.rb': 'ruby',
+            '.rs': 'rust',
+            '.dart': 'dart',
+            '.ex': 'elixir',
+            '.exs': 'elixir',
+            '.swift': 'swift',
+            '.scala': 'scala',
         };
         return map[ext] || null;
     }
@@ -77,13 +94,13 @@ export class LanguageDetector {
         return Object.keys(extensions)
             .map(ext => this.mapExtToLang(ext))
             .filter(lang => lang && lang !== primary)
-            .filter((v, i, a) => a.indexOf(v) === i); // unique
+            .filter((v, i, a) => a.indexOf(v) === i);
     }
 
     calculateConfidence(markers) {
         const markerCount = Object.values(markers).filter(Boolean).length;
         if (markerCount === 0) return 0.3;
         if (markerCount === 1) return 0.9;
-        return 0.7; // Múltiplos markers = projeto polyglot
+        return 0.7;
     }
-}
+}

package/src/detectors.js

@@ -2,27 +2,310 @@ import path from "path";
 import { exists, readFile } from "./fs-utils.js";
 
 export async function detectProject(root) {
+    const fs = (await import("fs")).promises;
+    const pathModule = await import("path");
+    const pathExt = pathModule.default || pathModule;
+
+    // Phase 1: Check well-known marker files
+    // Swift / iOS markers go FIRST so a Package.swift at the root beats a
+    // stray Java pom.xml sitting next to an xcworkspace (VisionHammer slice
+    // 5 hardening).
     const markers = [
+        { file: "Package.swift", lang: "swift", buildTool: "swiftpm" },
+        { file: "Podfile", lang: "swift", buildTool: "cocoapods" },
+        { file: "Podfile.lock", lang: "swift", buildTool: "cocoapods" },
         { file: "pom.xml", lang: "java", buildTool: "maven" },
         { file: "build.gradle", lang: "java", buildTool: "gradle" },
+        { file: "build.gradle.kts", lang: "kotlin", 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" }
+        { file: "go.mod", lang: "go", buildTool: "go" },
+        { file: "Gemfile", lang: "ruby", buildTool: "bundler" },
+        { file: "Rakefile", lang: "ruby", buildTool: "rake" },
+        { file: "pubspec.yaml", lang: "dart", buildTool: "flutter" },
+        { file: "composer.json", lang: "php", buildTool: "composer" },
+        { file: "Cargo.toml", lang: "rust", buildTool: "cargo" },
+        { file: "mix.exs", lang: "elixir", buildTool: "mix" },
     ];
 
     for (const m of markers) {
-        if (await exists(path.join(root, m.file))) {
-            return { language: m.lang, buildTool: m.buildTool, marker: m.file };
+        const fullPath = path.join(root, m.file);
+        if (await exists(fullPath)) {
+            const result = { language: m.lang, buildTool: m.buildTool, marker: m.file };
+
+            // Refine: build.gradle.kts with kotlin plugin -> kotlin
+            if (m.file === "build.gradle" || m.file === "build.gradle.kts") {
+                try {
+                    const content = await fs.readFile(fullPath, "utf8");
+                    if (content.includes("org.jetbrains.kotlin") || content.includes("kotlin(")) {
+                        result.language = "kotlin";
+                    }
+                } catch (_) {}
+            }
+
+            // Refine: Gemfile -> detect Rails vs Sinatra
+            if (m.file === "Gemfile") {
+                try {
+                    const content = await fs.readFile(fullPath, "utf8");
+                    if (content.includes("rails")) result.framework = "rails";
+                    else if (content.includes("sinatra")) result.framework = "sinatra";
+                } catch (_) {}
+            }
+
+            // Refine: package.json -> detect framework
+            if (m.file === "package.json") {
+                try {
+                    const pkg = JSON.parse(await fs.readFile(fullPath, "utf8"));
+                    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+                    if (deps["next"]) result.framework = "next";
+                    else if (deps["nuxt"]) result.framework = "nuxt";
+                    else if (deps["react"]) result.framework = "react";
+                    else if (deps["vue"]) result.framework = "vue";
+                    else if (deps["express"]) result.framework = "express";
+                    else if (deps["fastify"]) result.framework = "fastify";
+                    else if (deps["@angular/core"]) result.framework = "angular";
+                    else if (deps["svelte"]) result.framework = "svelte";
+                } catch (_) {}
+            }
+
+            // Refine: pom.xml -> detect Spring Boot
+            if (m.file === "pom.xml") {
+                try {
+                    const content = await fs.readFile(fullPath, "utf8");
+                    if (content.includes("spring-boot")) result.framework = "spring-boot";
+                    else if (content.includes("quarkus")) result.framework = "quarkus";
+                    else if (content.includes("micronaut")) result.framework = "micronaut";
+                } catch (_) {}
+            }
+
+            // Refine: pubspec.yaml -> detect Flutter
+            if (m.file === "pubspec.yaml") {
+                try {
+                    const content = await fs.readFile(fullPath, "utf8");
+                    if (content.includes("flutter:")) result.framework = "flutter";
+                } catch (_) {}
+            }
+
+            return result;
         }
     }
 
-    // .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 };
+    // Phase 2: native mobile — iOS / Android
+    let rootFiles;
+    try {
+        rootFiles = await fs.readdir(root);
+    } catch (_) {
+        return { language: "unknown", buildTool: "unknown", marker: null };
+    }
+
+    const hasRootFile = name => rootFiles.includes(name);
+    const hasRootDirSuffix = suffix => rootFiles.some(f => f.endsWith(suffix));
+
+    if (hasRootFile("Podfile") || hasRootFile("Podfile.lock") || hasRootFile("Package.swift")
+        || hasRootDirSuffix(".xcodeproj") || hasRootDirSuffix(".xcworkspace")) {
+        const framework = await detectAppleFramework(root, fs, pathExt);
+        return {
+            language: "ios",
+            buildTool: "xcodebuild",
+            framework,
+            marker: hasRootFile("Podfile") ? "Podfile"
+                : hasRootFile("Package.swift") ? "Package.swift"
+                : rootFiles.find(f => f.endsWith(".xcodeproj") || f.endsWith(".xcworkspace"))
+        };
+    }
+
+    // Phase 2b: recursive scan up to 2 levels for *.xcodeproj / *.xcworkspace
+    // so iOS apps living under ios/, apps/ios/, etc. are still detected.
+    try {
+        for (const entry of rootFiles) {
+            const level1 = path.join(root, entry);
+            let level1Stat;
+            try { level1Stat = await fs.stat(level1); } catch (_) { continue; }
+            if (!level1Stat.isDirectory()) continue;
+            let level1Entries;
+            try { level1Entries = await fs.readdir(level1); } catch (_) { continue; }
+            if (level1Entries.some(f => f.endsWith(".xcodeproj") || f.endsWith(".xcworkspace"))) {
+                const framework = await detectAppleFramework(level1, fs, pathExt);
+                return {
+                    language: "ios",
+                    buildTool: "xcodebuild",
+                    framework,
+                    marker: level1Entries.find(f => f.endsWith(".xcodeproj") || f.endsWith(".xcworkspace"))
+                };
+            }
+            for (const sub of level1Entries) {
+                const level2 = path.join(level1, sub);
+                let level2Stat;
+                try { level2Stat = await fs.stat(level2); } catch (_) { continue; }
+                if (!level2Stat.isDirectory()) continue;
+                let level2Entries;
+                try { level2Entries = await fs.readdir(level2); } catch (_) { continue; }
+                if (level2Entries.some(f => f.endsWith(".xcodeproj") || f.endsWith(".xcworkspace"))) {
+                    const framework = await detectAppleFramework(level2, fs, pathExt);
+                    return {
+                        language: "ios",
+                        buildTool: "xcodebuild",
+                        framework,
+                        marker: level2Entries.find(f => f.endsWith(".xcodeproj") || f.endsWith(".xcworkspace"))
+                    };
+                }
+            }
+        }
+    } catch (_) {}
+
+    if (hasRootFile("gradlew") || hasRootFile("gradlew.bat") || hasRootFile("settings.gradle")
+        || hasRootFile("settings.gradle.kts") || hasRootFile("gradle.properties")
+        || await exists(path.join(root, "app", "src", "main", "AndroidManifest.xml"))
+        || await exists(path.join(root, "AndroidManifest.xml"))) {
+        const framework = await detectAndroidFramework(root, fs, pathExt);
+        return {
+            language: "android",
+            buildTool: "gradle",
+            framework,
+            marker: hasRootFile("gradlew") ? "gradlew"
+                : hasRootFile("settings.gradle") ? "settings.gradle"
+                : hasRootFile("settings.gradle.kts") ? "settings.gradle.kts"
+                : "AndroidManifest.xml"
+        };
+    }
+
+    // Phase 3: .NET — check for .csproj or .sln in root
+
+    const dotnetFile = rootFiles.find(f => f.endsWith(".csproj") || f.endsWith(".sln"));
+    if (dotnetFile) {
+        return { language: "dotnet", buildTool: "dotnet", marker: dotnetFile };
+    }
+
+    // Phase 4: Docker-only — Dockerfile without any other language marker
+    if (rootFiles.includes("Dockerfile") || rootFiles.includes("docker-compose.yml") || rootFiles.includes("docker-compose.yaml")) {
+        return { language: "docker", buildTool: "docker", marker: "Dockerfile" };
+    }
+
+    // Phase 5: Static site — index.html without backend markers
+    if (rootFiles.includes("index.html")) {
+        return { language: "static", buildTool: "none", marker: "index.html" };
+    }
+
+    // Phase 6: Infer from file extensions
+    const extCount = {};
+    for (const f of rootFiles) {
+        const ext = path.extname(f).toLowerCase();
+        if (ext) extCount[ext] = (extCount[ext] || 0) + 1;
+    }
+    // Also scan one level deep (src/ or lib/)
+    for (const dir of ["src", "lib", "app", "cmd"]) {
+        try {
+            const subFiles = await fs.readdir(path.join(root, dir));
+            for (const f of subFiles) {
+                const ext = path.extname(f).toLowerCase();
+                if (ext) extCount[ext] = (extCount[ext] || 0) + 1;
+            }
+        } catch (_) {}
+    }
+
+    const extMap = {
+        ".java": "java", ".kt": "kotlin", ".scala": "scala",
+        ".js": "node", ".ts": "node", ".jsx": "node", ".tsx": "node",
+        ".py": "python",
+        ".go": "go",
+        ".rb": "ruby",
+        ".rs": "rust",
+        ".cs": "dotnet",
+        ".php": "php",
+        ".dart": "dart",
+        ".ex": "elixir", ".exs": "elixir",
+        ".swift": "swift",
+    };
+
+    const langCount = {};
+    for (const [ext, count] of Object.entries(extCount)) {
+        const lang = extMap[ext];
+        if (lang) langCount[lang] = (langCount[lang] || 0) + count;
+    }
+
+    const sorted = Object.entries(langCount).sort((a, b) => b[1] - a[1]);
+    if (sorted.length > 0) {
+        const [lang, count] = sorted[0];
+        console.log(`[detectProject] Inferred ${lang} from ${count} files (extensions: ${JSON.stringify(extCount)})`);
+        return { language: lang, buildTool: "unknown", marker: `inferred from ${count} .${lang} files` };
+    }
+
+    // Phase 7: Unknown — log root files for diagnostics
+    console.warn(`[detectProject] Unknown stack in ${root}. Root files: ${rootFiles.join(", ")}`);
+    return { language: "unknown", buildTool: "unknown", marker: null, rootFiles };
+}
+
+async function detectAppleFramework(root, fs, pathExt) {
+    const swiftSources = await collectFiles(root, fs, pathExt, file => file.endsWith(".swift"), 4);
+    for (const file of swiftSources.slice(0, 12)) {
+        try {
+            const content = await fs.readFile(file, "utf8");
+            if (content.includes("import SwiftUI") || content.includes("SwiftUI")) return "swiftui";
+            if (content.includes("UIKit")) return "uikit";
+        } catch (_) {}
+    }
+    return "ios";
+}
+
+async function detectAndroidFramework(root, fs, pathExt) {
+    const candidateFiles = [
+        path.join(root, "app", "build.gradle"),
+        path.join(root, "app", "build.gradle.kts"),
+        path.join(root, "build.gradle"),
+        path.join(root, "build.gradle.kts"),
+    ];
+
+    for (const file of candidateFiles) {
+        try {
+            const content = await fs.readFile(file, "utf8");
+            if (content.includes("androidx.compose") || content.includes("compose = true")) {
+                return "jetpack-compose";
+            }
+        } catch (_) {}
+    }
+
+    const kotlinSources = await collectFiles(root, fs, pathExt, file => file.endsWith(".kt"), 4);
+    for (const file of kotlinSources.slice(0, 12)) {
+        try {
+            const content = await fs.readFile(file, "utf8");
+            if (content.includes("androidx.compose")) return "jetpack-compose";
+        } catch (_) {}
+    }
+
+    return "android";
+}
+
+async function collectFiles(root, fs, pathExt, predicate, maxDepth) {
+    const results = [];
+    const ignored = new Set([".git", "node_modules", "build", ".build", "DerivedData", ".gradle"]);
+
+    async function walk(dir, depth) {
+        if (depth > maxDepth) return;
+        let entries = [];
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        } catch (_) {
+            return;
+        }
+
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (!ignored.has(entry.name)) {
+                    await walk(fullPath, depth + 1);
+                }
+                continue;
+            }
+
+            if (predicate(fullPath, entry)) {
+                results.push(fullPath);
+            }
+        }
+    }
 
-    return { language: "unknown", buildTool: "unknown", marker: null };
+    await walk(root, 0);
+    return results;
 }
 
 export async function readText(root, relPath) {

package/src/exec-utils.js

@@ -56,23 +56,25 @@ export async function compileAndTest({ language, buildTool, cwd, skipTests = fal
 
     try {
         if (language === "java" && buildTool === "maven") {
-            // Prefer ./mvnw wrapper over system mvn
+            // Prefer system mvn (installed in Docker), fallback to ./mvnw
             const fs = await import("fs");
             const path = await import("path");
+            const checkMvn = await run("which", ["mvn"], cwd, 5000);
             const hasMvnw = fs.existsSync(path.join(cwd, "mvnw"));
-            const mvnCmd = hasMvnw ? "./mvnw" : "mvn";
-
-            // Verify build tool is available before attempting
-            if (!hasMvnw) {
-                const check = await run("which mvn", [], cwd);
-                if (check.code !== 0) {
-                    return {
-                        code: 1,
-                        stdout: "",
-                        stderr: "Maven not found: neither ./mvnw nor mvn is available in this environment.",
-                        duration: Date.now() - start
-                    };
-                }
+            let mvnCmd;
+            if (checkMvn.code === 0) {
+                mvnCmd = "mvn"; // system Maven (always works, no permission issues)
+            } else if (hasMvnw) {
+                // Fix permission on NFS-mounted mvnw
+                await run("chmod", ["+x", path.join(cwd, "mvnw")], cwd, 5000);
+                mvnCmd = "./mvnw";
+            } else {
+                return {
+                    code: 1,
+                    stdout: "",
+                    stderr: "Maven not found: neither mvn nor ./mvnw is available.",
+                    duration: Date.now() - start
+                };
             }
 
             // Fix for maven-compiler-plugin 3.8.1 + Java 17:
@@ -154,9 +156,10 @@ export async function compileAndTest({ language, buildTool, cwd, skipTests = fal
                 }
             }
 
+            // -e flag shows full error stack traces from Maven
             const args = skipTests
-                ? ["compile", "-DskipTests", ...javaCompatFlags]
-                : ["test", ...javaCompatFlags];
+                ? ["compile", "-DskipTests", "-e", ...javaCompatFlags]
+                : ["test", "-e", ...javaCompatFlags];
 
             console.log(`[BUILD] [COMPILE] Running: ${mvnCmd} ${args.join(" ")}`);
             result = await run(mvnCmd, args, cwd, 10 * 60 * 1000, mavenEnv);

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

@@ -121,9 +121,10 @@ export class MavenRuntime extends BaseRuntime {
 
     async build(workspacePath, options = {}) {
         const startTime = Date.now();
-        const skipTests = options.skipTests ? '-DskipTests' : '';
-        const args = ['compile', '-q'];
-        if (skipTests) args.push(skipTests);
+        const skipTests = options.skipTests !== false;
+        // No -q flag: compilation errors must be visible to the AI agent
+        const args = ['compile', '-e'];
+        if (skipTests) args.push('-DskipTests');
 
         const result = await run('mvn', args, workspacePath);