deepdebug-local-agent 1.0.18 → 1.0.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepdebug-local-agent",
-  "version": "1.0.18",
+  "version": "1.0.19",
   "description": "DeepDebug Local Agent - AI-powered code debugging assistant",
   "private": false,
   "type": "module",

package/src/exec-utils.js

@@ -47,20 +47,38 @@ export function run(cmd, args, cwd, timeoutMs = 10 * 60 * 1000) {
  * @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}`);
+    console.log(`[BUILD] [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)
+            // Prefer ./mvnw wrapper over system mvn
+            const fs = await import("fs");
+            const path = await import("path");
+            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
+                    };
+                }
+            }
+
             const args = skipTests
-                ? ["clean", "install", "-DskipTests", "-q"]
-                : ["clean", "install", "-q"];
+                ? ["compile", "-q", "-DskipTests"]
+                : ["test", "-q"];
 
-            console.log(`🔨 [COMPILE] Running: mvn ${args.join(" ")}`);
-            result = await run("mvn", args, cwd);
+            console.log(`[BUILD] [COMPILE] Running: ${mvnCmd} ${args.join(" ")}`);
+            result = await run(mvnCmd, args, cwd);
         }
         else if (language === "java" && buildTool === "gradle") {
             // Gradle: clean build
@@ -68,12 +86,12 @@ export async function compileAndTest({ language, buildTool, cwd, skipTests = fal
                 ? ["clean", "build", "-x", "test"]
                 : ["clean", "build"];
 
-            console.log(`🔨 [COMPILE] Running: ./gradlew ${args.join(" ")}`);
+            console.log(`[BUILD] [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`);
+            console.log(`[BUILD] [COMPILE] Running: npm install`);
             const installResult = await run("npm", ["install", "--silent"], cwd);
 
             if (installResult.code !== 0) {
@@ -81,7 +99,7 @@ export async function compileAndTest({ language, buildTool, cwd, skipTests = fal
             }
 
             if (!skipTests) {
-                console.log(`🔨 [COMPILE] Running: npm test`);
+                console.log(`[BUILD] [COMPILE] Running: npm test`);
                 result = await run("npm", ["test", "--silent"], cwd);
             } else {
                 result = installResult;
@@ -89,7 +107,7 @@ export async function compileAndTest({ language, buildTool, cwd, skipTests = fal
         }
         else if (language === "node" || buildTool === "yarn") {
             // Yarn
-            console.log(`🔨 [COMPILE] Running: yarn install`);
+            console.log(`[BUILD] [COMPILE] Running: yarn install`);
             const installResult = await run("yarn", ["install", "--silent"], cwd);
 
             if (installResult.code !== 0) {
@@ -97,7 +115,7 @@ export async function compileAndTest({ language, buildTool, cwd, skipTests = fal
             }
 
             if (!skipTests) {
-                console.log(`🔨 [COMPILE] Running: yarn test`);
+                console.log(`[BUILD] [COMPILE] Running: yarn test`);
                 result = await run("yarn", ["test", "--silent"], cwd);
             } else {
                 result = installResult;
@@ -106,7 +124,7 @@ export async function compileAndTest({ language, buildTool, cwd, skipTests = fal
         else if (language === "python") {
             // Python: pytest
             if (!skipTests) {
-                console.log(`🔨 [COMPILE] Running: pytest`);
+                console.log(`[BUILD] [COMPILE] Running: pytest`);
                 result = await run("pytest", [], cwd);
             } else {
                 // Python doesn't have a compile step, just return success
@@ -115,7 +133,7 @@ export async function compileAndTest({ language, buildTool, cwd, skipTests = fal
         }
         else if (language === "go") {
             // Go: build and optionally test
-            console.log(`🔨 [COMPILE] Running: go build ./...`);
+            console.log(`[BUILD] [COMPILE] Running: go build ./...`);
             const buildResult = await run("go", ["build", "./..."], cwd);
 
             if (buildResult.code !== 0) {
@@ -123,7 +141,7 @@ export async function compileAndTest({ language, buildTool, cwd, skipTests = fal
             }
 
             if (!skipTests) {
-                console.log(`🔨 [COMPILE] Running: go test ./...`);
+                console.log(`[BUILD] [COMPILE] Running: go test ./...`);
                 result = await run("go", ["test", "./..."], cwd);
             } else {
                 result = buildResult;
@@ -131,7 +149,7 @@ export async function compileAndTest({ language, buildTool, cwd, skipTests = fal
         }
         else if (language === ".net" || language === "dotnet") {
             // .NET: build and optionally test
-            console.log(`🔨 [COMPILE] Running: dotnet build`);
+            console.log(`[BUILD] [COMPILE] Running: dotnet build`);
             const buildResult = await run("dotnet", ["build"], cwd);
 
             if (buildResult.code !== 0) {
@@ -139,14 +157,14 @@ export async function compileAndTest({ language, buildTool, cwd, skipTests = fal
             }
 
             if (!skipTests) {
-                console.log(`🔨 [COMPILE] Running: dotnet test`);
+                console.log(`[BUILD] [COMPILE] Running: dotnet test`);
                 result = await run("dotnet", ["test"], cwd);
             } else {
                 result = buildResult;
             }
         }
         else {
-            console.error(`❌ [COMPILE] Unsupported: ${language}/${buildTool}`);
+            console.error(`[ERR] [COMPILE] Unsupported: ${language}/${buildTool}`);
             return {
                 code: 1,
                 stdout: "",
@@ -157,18 +175,18 @@ export async function compileAndTest({ language, buildTool, cwd, skipTests = fal
 
         // Log result
         if (result.code === 0) {
-            console.log(`✅ [COMPILE] Success in ${result.duration}ms`);
+            console.log(`[OK] [COMPILE] Success in ${result.duration}ms`);
         } else {
-            console.error(`❌ [COMPILE] Failed with code ${result.code}`);
+            console.error(`[ERR] [COMPILE] Failed with code ${result.code}`);
             if (result.stderr) {
-                console.error(`❌ [COMPILE] Error: ${result.stderr.substring(0, 500)}`);
+                console.error(`[ERR] [COMPILE] Error: ${result.stderr.substring(0, 500)}`);
             }
         }
 
         return result;
 
     } catch (err) {
-        console.error(`❌ [COMPILE] Exception: ${err.message}`);
+        console.error(`[ERR] [COMPILE] Exception: ${err.message}`);
         return {
             code: 1,
             stdout: "",

package/src/server.js

@@ -1795,28 +1795,48 @@ app.post("/workspace/test-local/compile", async (req, res) => {
             skipTests: true
         });
 
-        if (compileResult.code !== 0) {
+        if (!compileResult.success) {
             TEST_LOCAL_STATE.status = "error";
+
+            const errorOutput = (compileResult.steps || [])
+                .map(s => s.stderr || '')
+                .filter(Boolean)
+                .join('\n')
+                .trim();
+
+            const stdoutOutput = (compileResult.steps || [])
+                .map(s => s.stdout || '')
+                .filter(Boolean)
+                .join('\n')
+                .trim();
+
+            const totalDuration = (compileResult.steps || [])
+                .reduce((sum, s) => sum + (s.duration || 0), 0);
+
             TEST_LOCAL_STATE.compilationResult = {
                 success: false,
-                error: compileResult.stderr,
-                duration: compileResult.duration
+                error: errorOutput || 'Compilation failed',
+                duration: totalDuration
             };
 
             return res.json({
                 ok: false,
-                error: compileResult.stderr,
-                stdout: compileResult.stdout,
-                duration: compileResult.duration
+                error: errorOutput || 'Compilation failed',
+                stdout: stdoutOutput,
+                steps: compileResult.steps,
+                duration: totalDuration
             });
         }
 
+        const totalDuration = (compileResult.steps || [])
+            .reduce((sum, s) => sum + (s.duration || 0), 0);
+
         TEST_LOCAL_STATE.status = "compiled";
         TEST_LOCAL_STATE.compilationResult = {
             success: true,
             language: meta.language,
             buildTool: meta.buildTool,
-            duration: compileResult.duration
+            duration: totalDuration
         };
 
         console.log("[TEST-LOCAL] Compilation successful");
@@ -1825,8 +1845,8 @@ app.post("/workspace/test-local/compile", async (req, res) => {
             ok: true,
             language: meta.language,
             buildTool: meta.buildTool,
-            duration: compileResult.duration,
-            stdout: compileResult.stdout
+            duration: totalDuration,
+            stdout: (compileResult.steps || []).map(s => s.stdout || '').filter(Boolean).join('\n').trim()
         });
     } catch (err) {
         console.error("[TEST-LOCAL] Compilation failed:", err.message);
@@ -5375,13 +5395,13 @@ app.post("/workspace/:workspaceId/run", async (req, res) => {
 // Connects Local Agent to Gateway  no public URL needed
 // ============================================
 async function startWebSocketTunnel(port, gatewayUrl, apiKey, tenantId) {
-    if (!gatewayUrl || !apiKey || !tenantId) {
-        console.log('WebSocket tunnel skipped: missing gatewayUrl, apiKey or tenantId in ~/.deepdebug/config.json');
+    if (!gatewayUrl || !tenantId) {
+        console.log('WebSocket tunnel skipped: missing gatewayUrl or tenantId');
         return;
     }
 
     const wsUrl = gatewayUrl.replace(/^https:\/\//, 'wss://').replace(/^http:\/\//, 'ws://');
-    const fullUrl = `${wsUrl}/api/v1/agent/ws?tenantId=${encodeURIComponent(tenantId)}&apiKey=${encodeURIComponent(apiKey)}`;
+    const fullUrl = `${wsUrl}/api/v1/agent/ws?tenantId=${encodeURIComponent(tenantId)}${apiKey ? '&apiKey=' + encodeURIComponent(apiKey) : ''}`;
 
     let reconnectDelay = 2000;
     let isShuttingDown = false;
@@ -5792,6 +5812,125 @@ app.get("/setup/auth-status", async (req, res) => {
     }
 });
 
+// ============================================
+// SPRINT 1  S1-T2: POST /workspace/test-local/run-single
+// Run a single test class (faster than full suite)
+// ============================================
+
+/**
+ * POST /workspace/test-local/run-single
+ *
+ * Runs a single test class by name  much faster than running the full suite.
+ * Used by the agentic loop (tool: run_single_test) to validate a specific fix
+ * without waiting for all tests to complete.
+ *
+ * Body:
+ *   { className: "BookingServiceTest" }
+ *   OR { testFile: "src/test/java/com/example/BookingServiceTest.java" }
+ *
+ * Response:
+ *   { ok, className, passed, failed, skipped, total, duration, output, failures[], exitCode }
+ */
+app.post("/workspace/test-local/run-single", async (req, res) => {
+    const wsRoot = resolveWorkspaceRoot(req);
+    if (!wsRoot) return res.status(400).json({ error: "workspace not set" });
+
+    const { className, testFile } = req.body || {};
+
+    // Resolve class name from either param
+    let resolvedClass = className;
+    if (!resolvedClass && testFile) {
+        resolvedClass = path.basename(testFile, '.java');
+    }
+
+    if (!resolvedClass || !resolvedClass.trim()) {
+        return res.status(400).json({
+            ok: false,
+            error: "className or testFile is required. Example: { className: 'BookingServiceTest' }"
+        });
+    }
+
+    resolvedClass = resolvedClass.trim();
+    console.log(`[RUN-SINGLE] Running test class: ${resolvedClass} in ${wsRoot}`);
+
+    const startTime = Date.now();
+
+    try {
+        const meta = await detectProject(wsRoot);
+
+        let result;
+
+        if (meta.buildTool === 'maven') {
+            // mvn test -Dtest=ClassName -q (sem clean para ser mais rapido)
+            result = await run('mvn', ['test', `-Dtest=${resolvedClass}`, '-q'], wsRoot);
+        } else if (meta.buildTool === 'gradle') {
+            const gradleCmd = fs.existsSync(path.join(wsRoot, 'gradlew')) ? './gradlew' : 'gradle';
+            result = await run(gradleCmd, ['test', '--tests', `*.${resolvedClass}`], wsRoot);
+        } else if (meta.language === 'node') {
+            result = await run('npx', ['jest', resolvedClass, '--no-coverage'], wsRoot);
+        } else {
+            return res.status(400).json({
+                ok: false,
+                error: `Single test not supported for buildTool: ${meta.buildTool}. Use /workspace/test-local/compile instead.`
+            });
+        }
+
+        const duration = Date.now() - startTime;
+        const output = (result.stdout || '') + (result.stderr || '');
+
+        // Parse Maven Surefire / JUnit output
+        const testsRunMatch = output.match(/Tests run: (\d+)/);
+        const failuresMatch = output.match(/Failures: (\d+)/);
+        const errorsMatch   = output.match(/Errors: (\d+)/);
+        const skippedMatch  = output.match(/Skipped: (\d+)/);
+
+        const total    = testsRunMatch ? parseInt(testsRunMatch[1]) : 0;
+        const failures = failuresMatch ? parseInt(failuresMatch[1]) : 0;
+        const errors   = errorsMatch   ? parseInt(errorsMatch[1])   : 0;
+        const skipped  = skippedMatch  ? parseInt(skippedMatch[1])  : 0;
+        const passed   = total - failures - errors - skipped;
+        const success  = result.code === 0 && failures === 0 && errors === 0;
+
+        // Extract failure names from output
+        const failureDetails = [];
+        const failureRegex = /FAILED\s+([^\n]+)/g;
+        let match;
+        while ((match = failureRegex.exec(output)) !== null) {
+            failureDetails.push(match[1].trim());
+        }
+
+        console.log(`[RUN-SINGLE] ${resolvedClass}: ${success ? 'PASSED' : 'FAILED'} ` +
+            `(${duration}ms, ${passed}/${total})`);
+
+        res.json({
+            ok: success,
+            className: resolvedClass,
+            passed,
+            failed: failures + errors,
+            skipped,
+            total,
+            duration,
+            output: output.length > 8000 ? output.substring(0, 8000) + '\n...[truncated]' : output,
+            failures: failureDetails,
+            exitCode: result.code
+        });
+
+    } catch (err) {
+        const duration = Date.now() - startTime;
+        console.error(`[RUN-SINGLE] Failed for ${resolvedClass}:`, err.message);
+        res.status(500).json({
+            ok: false,
+            className: resolvedClass,
+            error: err.message,
+            duration,
+            passed: 0,
+            failed: 1,
+            skipped: 0,
+            total: 0
+        });
+    }
+});
+
 // ============================================
 // START SERVER