project-scan 1.0.1 → 1.0.4

package/lib/test-runner.js

@@ -2,28 +2,38 @@
 /**
  * test-runner.js — Universal test runner
  * Detects and executes test frameworks across all major languages.
- * Returns structured results: suite name, status, passed/failed/skipped counts, output.
+ * Returns structured results with per-test-case breakdown (LeetCode style).
+ *
+ * Supported:
+ *   Web:     Jest, Vitest, Mocha
+ *   Python:  pytest
+ *   Go:      go test
+ *   Rust:    cargo test
+ *   Java:    Maven (JUnit), Gradle
+ *   PHP:     PHPUnit
+ *   Ruby:    RSpec
+ *   Dart:    flutter test / dart test
+ *   C#:      dotnet test
+ *   C++:     GoogleTest (via CTest), Catch2
+ *   DSA:     Standalone Python/JS/TS/C++ scripts with inline test functions
  */
 
 const { execSync, spawnSync } = require('child_process');
 const fs   = require('fs');
 const path = require('path');
 
-// ─── Per-language runner configs ─────────────────────────────────────────────
+const IS_WIN = process.platform === 'win32';
+
+// ─── Runners ──────────────────────────────────────────────────────────────────
 
-/**
- * Each runner: { name, detect(rootDir), run(rootDir) → RunResult }
- * RunResult: { suite, passed, failed, skipped, duration, status, output, error? }
- */
 const RUNNERS = [
 
-  // ── Node.js: Jest ──────────────────────────────────────────────────────────
+  // ── Jest ────────────────────────────────────────────────────────────────────
   {
     name: 'Jest',
     detect(root) {
       const pkg = tryReadJSON(path.join(root, 'package.json'));
       if (pkg && (allDeps(pkg).includes('jest') || pkg.jest)) return true;
-      // subdirectory package.jsons
       return findSubPackages(root).some(p => {
         const sp = tryReadJSON(p);
         return sp && (allDeps(sp).includes('jest') || sp.jest || sp.scripts?.test?.includes('jest'));
@@ -34,62 +44,41 @@ const RUNNERS = [
         const pkg = tryReadJSON(path.join(dir, 'package.json'));
         return pkg && (allDeps(pkg).includes('jest') || pkg.jest || pkg.scripts?.test?.includes('jest'));
       });
-      const results = [];
-      for (const dir of targets) {
-        const label = dir === root ? '(root)' : path.relative(root, dir);
-        results.push(runJest(dir, label));
-      }
-      return results;
+      return targets.map(dir => runJest(dir, dir === root ? '(root)' : path.relative(root, dir)));
     }
   },
 
-  // ── Node.js: Vitest ────────────────────────────────────────────────────────
+  // ── Vitest ──────────────────────────────────────────────────────────────────
   {
     name: 'Vitest',
     detect(root) {
       const pkg = tryReadJSON(path.join(root, 'package.json'));
       if (pkg && allDeps(pkg).includes('vitest')) return true;
-      return findSubPackages(root).some(p => {
-        const sp = tryReadJSON(p);
-        return sp && allDeps(sp).includes('vitest');
-      });
+      return findSubPackages(root).some(p => { const sp = tryReadJSON(p); return sp && allDeps(sp).includes('vitest'); });
     },
     run(root) {
       const targets = [root, ...findSubDirs(root)].filter(dir => {
         const pkg = tryReadJSON(path.join(dir, 'package.json'));
         return pkg && allDeps(pkg).includes('vitest');
       });
-      return targets.map(dir => runCommand({
-        dir, label: dir === root ? '(root)' : path.relative(root, dir),
-        cmd: hasBin(dir, 'vitest') ? 'npx vitest run --reporter=verbose' : null,
-        suite: 'Vitest',
-        parseOutput: parseVitestOutput,
-      }));
+      return targets.map(dir => runVitest(dir, dir === root ? '(root)' : path.relative(root, dir)));
     }
   },
 
-  // ── Node.js: Mocha ─────────────────────────────────────────────────────────
+  // ── Mocha ───────────────────────────────────────────────────────────────────
   {
     name: 'Mocha',
     detect(root) {
       const pkg = tryReadJSON(path.join(root, 'package.json'));
       if (pkg && allDeps(pkg).includes('mocha')) return true;
-      return findSubPackages(root).some(p => {
-        const sp = tryReadJSON(p);
-        return sp && allDeps(sp).includes('mocha');
-      });
+      return findSubPackages(root).some(p => { const sp = tryReadJSON(p); return sp && allDeps(sp).includes('mocha'); });
     },
     run(root) {
-      return [runCommand({
-        dir: root, label: '(root)',
-        cmd: 'npx mocha --reporter spec',
-        suite: 'Mocha',
-        parseOutput: parseMochaOutput,
-      })];
+      return [runCommand({ dir: root, label: '(root)', cmd: 'npx mocha --reporter spec', suite: 'Mocha', parseOutput: parseMochaOutput })];
     }
   },
 
-  // ── Python: pytest ─────────────────────────────────────────────────────────
+  // ── pytest ──────────────────────────────────────────────────────────────────
   {
     name: 'pytest',
     detect(root) {
@@ -100,53 +89,46 @@ const RUNNERS = [
              hasSourceExt(root, '.py');
     },
     run(root) {
-      const cmd = commandExists('pytest') ? 'pytest -v --tb=short 2>&1'
-               : commandExists('python3') ? 'python3 -m pytest -v --tb=short 2>&1'
-               : commandExists('python')  ? 'python -m pytest -v --tb=short 2>&1'
-               : null;
-      return [runCommand({ dir: root, label: '(root)', cmd, suite: 'pytest', parseOutput: parsePytestOutput })];
+      const base = commandExists('pytest') ? 'pytest'
+                 : commandExists('python3') ? 'python3 -m pytest'
+                 : commandExists('python')  ? 'python -m pytest'
+                 : null;
+      if (!base) return [{ suite: 'pytest (root)', status: 'skipped', passed: 0, failed: 0, skipped: 0, output: 'pytest not found in PATH.', duration: 0 }];
+      return [runPytest(root, base)];
     }
   },
 
-  // ── Go: go test ────────────────────────────────────────────────────────────
+  // ── Go test ─────────────────────────────────────────────────────────────────
   {
     name: 'Go test',
     detect(root) { return fs.existsSync(path.join(root, 'go.mod')); },
     run(root) {
-      return [runCommand({
-        dir: root, label: '(root)',
-        cmd: commandExists('go') ? 'go test ./... -v 2>&1' : null,
-        suite: 'Go test',
-        parseOutput: parseGoTestOutput,
-      })];
+      if (!commandExists('go')) return [{ suite: 'Go test (root)', status: 'skipped', passed: 0, failed: 0, skipped: 0, output: 'go not found in PATH.', duration: 0 }];
+      return [runGoTest(root)];
     }
   },
 
-  // ── Rust: cargo test ───────────────────────────────────────────────────────
+  // ── Cargo test ──────────────────────────────────────────────────────────────
   {
     name: 'Cargo test',
     detect(root) { return fs.existsSync(path.join(root, 'Cargo.toml')); },
     run(root) {
-      return [runCommand({
-        dir: root, label: '(root)',
-        cmd: commandExists('cargo') ? 'cargo test 2>&1' : null,
-        suite: 'Cargo test',
-        parseOutput: parseCargoOutput,
-      })];
+      if (!commandExists('cargo')) return [{ suite: 'Cargo test (root)', status: 'skipped', passed: 0, failed: 0, skipped: 0, output: 'cargo not found in PATH.', duration: 0 }];
+      return [runCargoTest(root)];
     }
   },
 
-  // ── Java/Kotlin: Maven ─────────────────────────────────────────────────────
+  // ── Maven ───────────────────────────────────────────────────────────────────
   {
     name: 'Maven',
     detect(root) { return fs.existsSync(path.join(root, 'pom.xml')); },
     run(root) {
-      const cmd = commandExists('mvn') ? 'mvn test -B 2>&1' : null;
+      const cmd = commandExists('mvn') ? 'mvn test -B' : null;
       return [runCommand({ dir: root, label: '(root)', cmd, suite: 'Maven', parseOutput: parseMavenOutput })];
     }
   },
 
-  // ── Java/Kotlin: Gradle ────────────────────────────────────────────────────
+  // ── Gradle ──────────────────────────────────────────────────────────────────
   {
     name: 'Gradle',
     detect(root) {
@@ -154,210 +136,661 @@ const RUNNERS = [
              fs.existsSync(path.join(root, 'build.gradle.kts'));
     },
     run(root) {
-      const gradleCmd = fs.existsSync(path.join(root, 'gradlew')) ? './gradlew' : (commandExists('gradle') ? 'gradle' : null);
-      return [runCommand({ dir: root, label: '(root)', cmd: gradleCmd ? `${gradleCmd} test 2>&1` : null, suite: 'Gradle', parseOutput: parseGradleOutput })];
+      const wrapperWin  = path.join(root, 'gradlew.bat');
+      const wrapperUnix = path.join(root, 'gradlew');
+      const gradleCmd = fs.existsSync(IS_WIN ? wrapperWin : wrapperUnix)
+        ? (IS_WIN ? 'gradlew.bat' : './gradlew')
+        : (commandExists('gradle') ? 'gradle' : null);
+      return [runCommand({ dir: root, label: '(root)', cmd: gradleCmd ? `${gradleCmd} test` : null, suite: 'Gradle', parseOutput: parseGradleOutput })];
     }
   },
 
-  // ── PHP: PHPUnit ───────────────────────────────────────────────────────────
+  // ── PHPUnit ─────────────────────────────────────────────────────────────────
   {
     name: 'PHPUnit',
     detect(root) {
-      return fs.existsSync(path.join(root, 'phpunit.xml'))       ||
-             fs.existsSync(path.join(root, 'phpunit.xml.dist'))  ||
-             fs.existsSync(path.join(root, 'vendor/bin/phpunit')) ||
+      return fs.existsSync(path.join(root, 'phpunit.xml'))               ||
+             fs.existsSync(path.join(root, 'phpunit.xml.dist'))          ||
+             fs.existsSync(path.join(root, 'vendor', 'bin', 'phpunit'))  ||
              hasSourceExt(root, '.php');
     },
     run(root) {
-      const cmd = fs.existsSync(path.join(root, 'vendor/bin/phpunit')) ? './vendor/bin/phpunit --testdox 2>&1'
-               : commandExists('phpunit') ? 'phpunit --testdox 2>&1' : null;
+      const vendorBin = path.join(root, 'vendor', 'bin', 'phpunit');
+      const cmd = fs.existsSync(vendorBin) ? `"${vendorBin}" --testdox`
+               : commandExists('phpunit') ? 'phpunit --testdox' : null;
       return [runCommand({ dir: root, label: '(root)', cmd, suite: 'PHPUnit', parseOutput: parsePHPUnitOutput })];
     }
   },
 
-  // ── Ruby: RSpec ────────────────────────────────────────────────────────────
+  // ── RSpec ───────────────────────────────────────────────────────────────────
   {
     name: 'RSpec',
     detect(root) {
-      return fs.existsSync(path.join(root, 'Gemfile'))   ||
-             fs.existsSync(path.join(root, '.rspec'))    ||
+      return fs.existsSync(path.join(root, 'Gemfile')) ||
+             fs.existsSync(path.join(root, '.rspec'))  ||
              fs.existsSync(path.join(root, 'spec'));
     },
     run(root) {
-      const cmd = commandExists('rspec') ? 'rspec --format progress 2>&1' : (commandExists('bundle') ? 'bundle exec rspec --format progress 2>&1' : null);
+      const cmd = commandExists('rspec') ? 'rspec --format documentation' : (commandExists('bundle') ? 'bundle exec rspec --format documentation' : null);
       return [runCommand({ dir: root, label: '(root)', cmd, suite: 'RSpec', parseOutput: parseRSpecOutput })];
     }
   },
 
-  // ── Dart/Flutter ───────────────────────────────────────────────────────────
+  // ── Flutter/Dart ────────────────────────────────────────────────────────────
   {
     name: 'Flutter/Dart test',
     detect(root) { return fs.existsSync(path.join(root, 'pubspec.yaml')); },
     run(root) {
-      const cmd = commandExists('flutter') ? 'flutter test 2>&1' : (commandExists('dart') ? 'dart test 2>&1' : null);
+      const cmd = commandExists('flutter') ? 'flutter test --reporter expanded' : (commandExists('dart') ? 'dart test --reporter expanded' : null);
       return [runCommand({ dir: root, label: '(root)', cmd, suite: 'Flutter/Dart', parseOutput: parseDartOutput })];
     }
   },
 
-  // ── .NET: dotnet test ──────────────────────────────────────────────────────
+  // ── dotnet test ─────────────────────────────────────────────────────────────
   {
     name: 'dotnet test',
     detect(root) {
-      try {
-        return fs.readdirSync(root).some(f => f.endsWith('.csproj') || f.endsWith('.sln'));
-      } catch { return false; }
+      try { return fs.readdirSync(root).some(f => f.endsWith('.csproj') || f.endsWith('.sln')); }
+      catch { return false; }
+    },
+    run(root) {
+      if (!commandExists('dotnet')) return [{ suite: 'dotnet test (root)', status: 'skipped', passed: 0, failed: 0, skipped: 0, output: 'dotnet not found in PATH.', duration: 0 }];
+      return [runDotnetTest(root)];
+    }
+  },
+
+  // ── C++ / CTest (GoogleTest / Catch2) ───────────────────────────────────────
+  {
+    name: 'CTest (C++)',
+    detect(root) {
+      return (fs.existsSync(path.join(root, 'CMakeLists.txt')) ||
+              fs.existsSync(path.join(root, 'build', 'CTestTestfile.cmake'))) &&
+             hasSourceExt(root, '.cpp');
+    },
+    run(root) {
+      return [runCTest(root)];
+    }
+  },
+
+  // ── DSA / standalone script runner ──────────────────────────────────────────
+  // For projects that have no test framework but have Python/JS/TS files
+  // with assert-based tests, doctest, or unittest.
+  {
+    name: 'DSA / Standalone Tests',
+    detect(root) {
+      // Only kick in if no other test framework is present
+      const hasOtherFramework =
+        fs.existsSync(path.join(root, 'package.json')) ||
+        fs.existsSync(path.join(root, 'go.mod'))       ||
+        fs.existsSync(path.join(root, 'Cargo.toml'))   ||
+        fs.existsSync(path.join(root, 'pom.xml'))      ||
+        fs.existsSync(path.join(root, 'build.gradle')) ||
+        fs.existsSync(path.join(root, 'Gemfile'))      ||
+        fs.existsSync(path.join(root, 'pubspec.yaml'));
+      if (hasOtherFramework) return false;
+
+      // Has Python or JS/TS files with test-like patterns
+      const pyFiles = findFilesWithExt(root, '.py');
+      const jsFiles = [...findFilesWithExt(root, '.js'), ...findFilesWithExt(root, '.ts')];
+      return pyFiles.some(f => hasTestPatterns(f)) || jsFiles.some(f => hasTestPatterns(f));
     },
     run(root) {
-      const cmd = commandExists('dotnet') ? 'dotnet test --logger "console;verbosity=normal" 2>&1' : null;
-      return [runCommand({ dir: root, label: '(root)', cmd, suite: 'dotnet test', parseOutput: parseDotnetOutput })];
+      return runDSATests(root);
     }
   },
 ];
 
-// ─── Core runner ─────────────────────────────────────────────────────────────
+// ─── Core ─────────────────────────────────────────────────────────────────────
 
 function runAllTests(rootDir) {
   const results = [];
-  const activeRunners = RUNNERS.filter(r => r.detect(rootDir));
+  const activeRunners = RUNNERS.filter(r => { try { return r.detect(rootDir); } catch { return false; } });
 
   if (activeRunners.length === 0) {
     return [{
       suite: 'No test framework detected',
-      status: 'skipped',
-      passed: 0, failed: 0, skipped: 0,
-      output: 'No recognized test framework was found in this project.',
+      status: 'skipped', passed: 0, failed: 0, skipped: 0,
+      output: 'No recognized test framework found. Add tests using pytest, Jest, go test, cargo test, JUnit, RSpec, etc.',
       duration: 0,
     }];
   }
 
   for (const runner of activeRunners) {
     try {
-      const suiteResults = runner.run(rootDir);
-      results.push(...suiteResults);
+      results.push(...runner.run(rootDir));
     } catch (err) {
-      results.push({
-        suite: runner.name,
-        status: 'error',
-        passed: 0, failed: 0, skipped: 0,
-        output: '',
-        error: err.message,
-        duration: 0,
-      });
+      results.push({ suite: runner.name, status: 'error', passed: 0, failed: 0, skipped: 0, output: '', error: err.message, duration: 0 });
     }
   }
   return results;
 }
 
-// ─── Jest runner (special: uses JSON reporter) ────────────────────────────────
+// ─── Jest (JSON reporter → structured testCases) ──────────────────────────────
 
 function runJest(dir, label) {
   const start = Date.now();
-  if (!fs.existsSync(path.join(dir, 'node_modules', '.bin', 'jest')) &&
+  if (!fs.existsSync(path.join(dir, 'node_modules', '.bin', 'jest'))    &&
+      !fs.existsSync(path.join(dir, 'node_modules', '.bin', 'jest.cmd')) &&
       !fs.existsSync(path.join(dir, 'node_modules', 'jest'))) {
-    // Try npm test fallback
     const pkg = tryReadJSON(path.join(dir, 'package.json'));
-    if (!pkg?.scripts?.test) {
-      return { suite: `Jest (${label})`, status: 'skipped', passed: 0, failed: 0, skipped: 0, output: 'Jest not installed. Run npm install first.', duration: 0 };
-    }
+    if (!pkg?.scripts?.test) return { suite: `Jest (${label})`, status: 'skipped', passed: 0, failed: 0, skipped: 0, output: 'Jest not installed.', duration: 0 };
   }
 
   const result = spawnSync('npx', ['jest', '--no-coverage', '--json', '--forceExit'], {
-    cwd: dir, encoding: 'utf8', timeout: 120000,
+    cwd: dir, encoding: 'utf8', timeout: 120000, shell: true,
     env: { ...process.env, FORCE_COLOR: '0' }
   });
 
   const duration = Date.now() - start;
   const rawOutput = (result.stdout || '') + (result.stderr || '');
 
-  // Try to parse JSON output
   const jsonStart = rawOutput.indexOf('{');
   const jsonEnd   = rawOutput.lastIndexOf('}');
   if (jsonStart !== -1 && jsonEnd !== -1) {
     try {
-      const jResult = JSON.parse(rawOutput.slice(jsonStart, jsonEnd + 1));
-      const passed  = jResult.numPassedTests  || 0;
-      const failed  = jResult.numFailedTests  || 0;
-      const skipped = jResult.numPendingTests || 0;
-      const status  = failed > 0 ? 'failed' : (passed > 0 ? 'passed' : 'skipped');
-
-      // Build structured per-test case list (LeetCode style)
-      // Jest uses 'assertionResults' per suite (not 'testResults')
+      const jr      = JSON.parse(rawOutput.slice(jsonStart, jsonEnd + 1));
+      const passed  = jr.numPassedTests  || 0;
+      const failed  = jr.numFailedTests  || 0;
+      const skipped = jr.numPendingTests || 0;
       const testCases = [];
-      const lines = [];
-      for (const suite of (jResult.testResults || [])) {
+      for (const suite of (jr.testResults || [])) {
         const relPath = path.relative(dir, suite.testFilePath || suite.name || '');
-        lines.push(`\n  📄 ${relPath}`);
-        const assertions = suite.assertionResults || suite.testResults || [];
-        for (const t of assertions) {
-          const icon = t.status === 'passed' ? '  ✔' : t.status === 'failed' ? '  ✖' : '  ○';
-          lines.push(`${icon} ${t.fullName || t.title}`);
-          if (t.status === 'failed' && t.failureMessages?.length) {
-            lines.push(`       ${t.failureMessages[0].split('\n').slice(0, 3).join('\n       ')}`);
-          }
+        for (const t of (suite.assertionResults || suite.testResults || [])) {
           testCases.push({
             file:     relPath,
             name:     t.fullName || t.title || '(unnamed)',
-            status:   t.status,           // 'passed' | 'failed' | 'pending'
+            status:   t.status,
             duration: t.duration || 0,
             error:    t.status === 'failed' && t.failureMessages?.length
-                        ? t.failureMessages[0].split('\n').slice(0, 6).join('\n')
-                        : null,
+                        ? t.failureMessages[0].split('\n').slice(0, 6).join('\n') : null,
           });
         }
       }
+      return {
+        suite: `Jest (${label})`, status: failed > 0 ? 'failed' : (passed > 0 ? 'passed' : 'skipped'),
+        passed, failed, skipped, duration, testCases,
+        suites: `${jr.numPassedTestSuites}/${jr.numTotalTestSuites} suites passed`,
+        output: buildTextOutput(testCases),
+      };
+    } catch {}
+  }
+  return parseJestTextFallback(rawOutput, label, duration);
+}
+
+// ─── Vitest (JSON reporter → structured testCases) ────────────────────────────
+
+function runVitest(dir, label) {
+  const start = Date.now();
+  const result = spawnSync('npx', ['vitest', 'run', '--reporter=json'], {
+    cwd: dir, encoding: 'utf8', timeout: 120000, shell: true,
+    env: { ...process.env, FORCE_COLOR: '0' }
+  });
+  const duration = Date.now() - start;
+  const rawOutput = (result.stdout || '') + (result.stderr || '');
 
+  // Vitest JSON output
+  const jsonStart = rawOutput.indexOf('{');
+  const jsonEnd   = rawOutput.lastIndexOf('}');
+  if (jsonStart !== -1 && jsonEnd !== -1) {
+    try {
+      const vr = JSON.parse(rawOutput.slice(jsonStart, jsonEnd + 1));
+      const testCases = [];
+      for (const file of (vr.testResults || [])) {
+        const relPath = path.relative(dir, file.name || '');
+        for (const t of (file.assertionResults || [])) {
+          testCases.push({
+            file: relPath, name: t.fullName || t.title || '(unnamed)',
+            status: t.status, duration: t.duration || 0,
+            error: t.status === 'failed' && t.failureMessages?.length ? t.failureMessages[0].split('\n').slice(0, 6).join('\n') : null,
+          });
+        }
+      }
+      const passed  = testCases.filter(t => t.status === 'passed').length;
+      const failed  = testCases.filter(t => t.status === 'failed').length;
+      const skipped = testCases.filter(t => t.status === 'pending').length;
       return {
-        suite: `Jest (${label})`,
-        status,
-        passed, failed, skipped,
-        duration,
-        output: lines.join('\n'),
-        suites: jResult.numPassedTestSuites + '/' + jResult.numTotalTestSuites + ' suites passed',
-        testCases,
+        suite: `Vitest (${label})`, status: failed > 0 ? 'failed' : (passed > 0 ? 'passed' : 'skipped'),
+        passed, failed, skipped, duration, testCases, output: buildTextOutput(testCases),
       };
-    } catch { /* fall through to text parse */ }
+    } catch {}
+  }
+  // Fallback: verbose text
+  return { suite: `Vitest (${label})`, duration, ...parseVitestOutput(rawOutput, result.status === 0) };
+}
+
+// ─── pytest (--tb=line -v → structured testCases) ────────────────────────────
+
+function runPytest(root, base) {
+  const start = Date.now();
+  let output = '';
+  let exitOk = false;
+  try {
+    output = execSync(`${base} -v --tb=short --no-header -rN`, {
+      cwd: root, encoding: 'utf8', timeout: 120000, shell: true,
+      env: { ...process.env, PYTHONUNBUFFERED: '1' }, stdio: 'pipe'
+    });
+    exitOk = true;
+  } catch (err) {
+    output = (err.stdout || '') + (err.stderr || '') + (err.message || '');
+  }
+  const duration = Date.now() - start;
+
+  // Parse individual test lines: "path/test_foo.py::test_bar PASSED"
+  const testCases = [];
+  const lines = output.split('\n');
+  for (const line of lines) {
+    const m = line.match(/^([\w/\\.\-:]+)\s+(PASSED|FAILED|ERROR|SKIPPED|XFAIL|XPASS)/);
+    if (!m) continue;
+    const rawId = m[1];          // e.g. "tests/test_algo.py::TestSort::test_bubble"
+    const verdict = m[2];
+    const parts = rawId.split('::');
+    const file = parts[0];
+    const name = parts.slice(1).join(' > ') || path.basename(file);
+    const status = verdict === 'PASSED' || verdict === 'XPASS' ? 'passed'
+                 : verdict === 'SKIPPED' || verdict === 'XFAIL' ? 'pending'
+                 : 'failed';
+    // Grab error block for failures
+    let error = null;
+    if (status === 'failed') {
+      const errLines = [];
+      let inBlock = false;
+      for (const l of lines) {
+        if (l.includes('FAILED') && l.includes(rawId.split('::')[1] || '')) inBlock = true;
+        if (inBlock && (l.startsWith('E ') || l.startsWith('    E '))) errLines.push(l.trim());
+        if (errLines.length >= 5) break;
+      }
+      if (errLines.length) error = errLines.join('\n');
+    }
+    testCases.push({ file, name, status, duration: 0, error });
+  }
+
+  const passed  = testCases.filter(t => t.status === 'passed').length;
+  const failed  = testCases.filter(t => t.status === 'failed').length;
+  const skipped = testCases.filter(t => t.status === 'pending').length;
+
+  // If we couldn't parse individual tests, fall back to summary line
+  if (testCases.length === 0) {
+    return { suite: 'pytest (root)', duration, ...parsePytestOutput(output, exitOk) };
+  }
+
+  return {
+    suite: 'pytest (root)',
+    status: failed > 0 ? 'failed' : (passed > 0 ? 'passed' : 'skipped'),
+    passed, failed, skipped, duration, testCases, output: buildTextOutput(testCases),
+  };
+}
+
+// ─── Go test (JSON output → structured testCases) ────────────────────────────
+
+function runGoTest(root) {
+  const start = Date.now();
+  let output = '';
+  let exitOk = false;
+  try {
+    output = execSync('go test ./... -v -json', {
+      cwd: root, encoding: 'utf8', timeout: 120000, shell: true,
+      env: { ...process.env }, stdio: 'pipe'
+    });
+    exitOk = true;
+  } catch (err) {
+    output = (err.stdout || '') + (err.stderr || '') + (err.message || '');
+  }
+  const duration = Date.now() - start;
+
+  const testCases = [];
+  const testMap   = {};  // test name → {file, status, output[]}
+
+  for (const line of output.split('\n')) {
+    if (!line.trim().startsWith('{')) continue;
+    try {
+      const ev = JSON.parse(line);
+      if (!ev.Test) continue;
+      const key = `${ev.Package}::${ev.Test}`;
+      if (ev.Action === 'run') {
+        testMap[key] = { file: ev.Package || '', name: ev.Test, status: 'pending', errLines: [] };
+      } else if (ev.Action === 'pass') {
+        if (testMap[key]) testMap[key].status = 'passed';
+      } else if (ev.Action === 'fail') {
+        if (testMap[key]) testMap[key].status = 'failed';
+      } else if (ev.Action === 'skip') {
+        if (testMap[key]) testMap[key].status = 'pending';
+      } else if (ev.Action === 'output' && ev.Output) {
+        if (testMap[key]) testMap[key].errLines.push(ev.Output.trim());
+      }
+    } catch {}
+  }
+
+  for (const tc of Object.values(testMap)) {
+    if (tc.status === 'pending') tc.status = 'failed'; // ran but no result = fail
+    const errorLines = tc.errLines.filter(l => l.startsWith('---') || l.includes('FAIL') || l.includes('Error') || l.includes('got ') || l.includes('want '));
+    testCases.push({
+      file: tc.file, name: tc.name, status: tc.status, duration: 0,
+      error: tc.status === 'failed' && errorLines.length ? errorLines.slice(0, 5).join('\n') : null,
+    });
+  }
+
+  if (testCases.length === 0) {
+    return { suite: 'Go test (root)', duration, ...parseGoTestOutput(output, exitOk) };
+  }
+
+  const passed  = testCases.filter(t => t.status === 'passed').length;
+  const failed  = testCases.filter(t => t.status === 'failed').length;
+  const skipped = testCases.filter(t => t.status === 'pending').length;
+
+  return {
+    suite: 'Go test (root)',
+    status: failed > 0 ? 'failed' : (passed > 0 ? 'passed' : 'skipped'),
+    passed, failed, skipped, duration, testCases, output: buildTextOutput(testCases),
+  };
+}
+
+// ─── Cargo test (--format json → structured testCases) ───────────────────────
+
+function runCargoTest(root) {
+  const start = Date.now();
+  let output = '';
+  let exitOk = false;
+  try {
+    // unstable-options needed for JSON; fall back gracefully
+    output = execSync('cargo test -- -Z unstable-options --format json 2>&1 || cargo test -- --nocapture', {
+      cwd: root, encoding: 'utf8', timeout: 180000, shell: true, stdio: 'pipe',
+      env: { ...process.env, RUST_BACKTRACE: '0' }
+    });
+    exitOk = true;
+  } catch (err) {
+    output = (err.stdout || '') + (err.stderr || '') + (err.message || '');
+  }
+  const duration = Date.now() - start;
+
+  const testCases = [];
+  for (const line of output.split('\n')) {
+    // JSON format: {"type":"test","event":"ok","name":"tests::test_add"}
+    if (line.trim().startsWith('{')) {
+      try {
+        const ev = JSON.parse(line);
+        if (ev.type === 'test') {
+          testCases.push({
+            file: '', name: ev.name || '(unnamed)',
+            status: ev.event === 'ok' ? 'passed' : ev.event === 'ignored' ? 'pending' : 'failed',
+            duration: ev.exec_time ? Math.round(ev.exec_time * 1000) : 0,
+            error: ev.event === 'failed' && ev.stdout ? ev.stdout.split('\n').slice(0, 4).join('\n') : null,
+          });
+        }
+      } catch {}
+    } else {
+      // Text fallback: "test tests::add ... ok" or "test tests::add ... FAILED"
+      const m = line.match(/^test (.+?) \.\.\. (ok|FAILED|ignored)/);
+      if (m && !testCases.find(t => t.name === m[1])) {
+        testCases.push({
+          file: '', name: m[1],
+          status: m[2] === 'ok' ? 'passed' : m[2] === 'ignored' ? 'pending' : 'failed',
+          duration: 0, error: null,
+        });
+      }
+    }
+  }
+
+  if (testCases.length === 0) {
+    return { suite: 'Cargo test (root)', duration, ...parseCargoOutput(output, exitOk) };
+  }
+
+  const passed  = testCases.filter(t => t.status === 'passed').length;
+  const failed  = testCases.filter(t => t.status === 'failed').length;
+  const skipped = testCases.filter(t => t.status === 'pending').length;
+
+  return {
+    suite: 'Cargo test (root)',
+    status: failed > 0 ? 'failed' : (passed > 0 ? 'passed' : 'skipped'),
+    passed, failed, skipped, duration, testCases, output: buildTextOutput(testCases),
+  };
+}
+
+// ─── dotnet test (TRX/verbose → structured testCases) ────────────────────────
+
+function runDotnetTest(root) {
+  const start = Date.now();
+  let output = '';
+  let exitOk = false;
+  try {
+    output = execSync('dotnet test --logger "console;verbosity=detailed"', {
+      cwd: root, encoding: 'utf8', timeout: 120000, shell: true, stdio: 'pipe'
+    });
+    exitOk = true;
+  } catch (err) {
+    output = (err.stdout || '') + (err.stderr || '') + (err.message || '');
+  }
+  const duration = Date.now() - start;
+
+  const testCases = [];
+  for (const line of output.split('\n')) {
+    // "  Passed  TestAdd [< 1 ms]" or "  Failed  TestAdd [...]"
+    const m = line.match(/^\s+(Passed|Failed|Skipped)\s+(.+?)(?:\s+\[.*\])?$/);
+    if (m) {
+      testCases.push({
+        file: '', name: m[2].trim(),
+        status: m[1] === 'Passed' ? 'passed' : m[1] === 'Skipped' ? 'pending' : 'failed',
+        duration: 0, error: null,
+      });
+    }
+  }
+
+  if (testCases.length === 0) {
+    return { suite: 'dotnet test (root)', duration, ...parseDotnetOutput(output, exitOk) };
+  }
+
+  const passed  = testCases.filter(t => t.status === 'passed').length;
+  const failed  = testCases.filter(t => t.status === 'failed').length;
+  const skipped = testCases.filter(t => t.status === 'pending').length;
+
+  return {
+    suite: 'dotnet test (root)', status: failed > 0 ? 'failed' : (passed > 0 ? 'passed' : 'skipped'),
+    passed, failed, skipped, duration, testCases, output: buildTextOutput(testCases),
+  };
+}
+
+// ─── CTest / GoogleTest ───────────────────────────────────────────────────────
+
+function runCTest(root) {
+  const buildDir = fs.existsSync(path.join(root, 'build')) ? path.join(root, 'build') : root;
+  if (!commandExists('ctest')) {
+    return { suite: 'CTest (root)', status: 'skipped', passed: 0, failed: 0, skipped: 0, output: 'ctest not found. Install CMake.', duration: 0 };
+  }
+  const start = Date.now();
+  let output = '';
+  let exitOk = false;
+  try {
+    output = execSync('ctest --output-on-failure', {
+      cwd: buildDir, encoding: 'utf8', timeout: 120000, shell: true, stdio: 'pipe'
+    });
+    exitOk = true;
+  } catch (err) {
+    output = (err.stdout || '') + (err.stderr || '') + (err.message || '');
+  }
+  const duration = Date.now() - start;
+
+  const testCases = [];
+  for (const line of output.split('\n')) {
+    // CTest: "   1/3 Test #1: TestAdd ................. Passed   0.01 sec"
+    const m = line.match(/\s*\d+\/\d+\s+Test\s+#\d+:\s+(.+?)\s+\.+\s+(Passed|Failed|Not Run)/i);
+    if (m) {
+      testCases.push({
+        file: '', name: m[1].trim(),
+        status: m[2].toLowerCase() === 'passed' ? 'passed' : m[2].toLowerCase() === 'not run' ? 'pending' : 'failed',
+        duration: 0, error: null,
+      });
+    }
+    // GoogleTest inline: "[ RUN      ] SortTest.BubbleSort" / "[       OK ]" / "[  FAILED  ]"
+    const gRun  = line.match(/\[ RUN\s+\] (.+)/);
+    const gOk   = line.match(/\[\s+OK\s+\] (.+?)(?:\s+\(|$)/);
+    const gFail = line.match(/\[\s+FAILED\s+\] (.+?)(?:\s+\(|$)/);
+    if (gRun) {
+      testCases.push({ file: '', name: gRun[1].trim(), status: 'pending', duration: 0, error: null });
+    } else if (gOk) {
+      const tc = testCases.findLast?.(t => t.name === gOk[1].trim()) || testCases.find(t => t.name === gOk[1].trim());
+      if (tc) tc.status = 'passed';
+    } else if (gFail) {
+      const tc = testCases.findLast?.(t => t.name === gFail[1].trim()) || testCases.find(t => t.name === gFail[1].trim());
+      if (tc) tc.status = 'failed';
+    }
+  }
+
+  const deduped = [];
+  const seen = new Set();
+  for (const tc of testCases) {
+    if (!seen.has(tc.name)) { seen.add(tc.name); deduped.push(tc); }
   }
 
-  return parseJestTextOutput(rawOutput, label, duration);
+  if (deduped.length === 0) {
+    const passMatch = output.match(/(\d+) tests? passed/i);
+    const failMatch = output.match(/(\d+) tests? failed/i);
+    return { suite: 'CTest (root)', status: exitOk ? 'passed' : 'failed', passed: passMatch ? +passMatch[1] : 0, failed: failMatch ? +failMatch[1] : 0, skipped: 0, duration, output: output.slice(-2000) };
+  }
+
+  const passed  = deduped.filter(t => t.status === 'passed').length;
+  const failed  = deduped.filter(t => t.status === 'failed').length;
+  const skipped = deduped.filter(t => t.status === 'pending').length;
+
+  return { suite: 'CTest (root)', status: failed > 0 ? 'failed' : 'passed', passed, failed, skipped, duration, testCases: deduped, output: buildTextOutput(deduped) };
+}
+
+// ─── DSA / Standalone test runner ────────────────────────────────────────────
+// Runs Python files that use unittest / doctest / bare assert,
+// and JS/TS files that use console.assert or a simple assert pattern.
+
+function runDSATests(root) {
+  const results = [];
+  const pyFiles = findFilesWithExt(root, '.py').filter(f => hasTestPatterns(f));
+  const jsFiles = [...findFilesWithExt(root, '.js'), ...findFilesWithExt(root, '.ts')].filter(f => hasTestPatterns(f));
+
+  // Python: run each file with unittest discover or directly
+  if (pyFiles.length > 0) {
+    const pyCmd = commandExists('python3') ? 'python3' : commandExists('python') ? 'python' : null;
+    for (const f of pyFiles.slice(0, 10)) { // cap at 10 to avoid infinite loops
+      const start = Date.now();
+      let output = '';
+      let exitOk = false;
+      try {
+        output = execSync(`${pyCmd} -m pytest "${f}" -v --tb=short --no-header 2>&1 || ${pyCmd} -m doctest "${f}" -v 2>&1 || ${pyCmd} "${f}" 2>&1`, {
+          cwd: root, encoding: 'utf8', timeout: 30000, shell: true, stdio: 'pipe'
+        });
+        exitOk = true;
+      } catch (err) {
+        output = (err.stdout || '') + (err.stderr || '') + (err.message || '');
+      }
+      const duration = Date.now() - start;
+      const relF = path.relative(root, f);
+      const testCases = parsePythonFileOutput(output, relF);
+      const passed  = testCases.filter(t => t.status === 'passed').length;
+      const failed  = testCases.filter(t => t.status === 'failed').length;
+      if (testCases.length > 0) {
+        results.push({ suite: `Python: ${relF}`, status: failed > 0 ? 'failed' : 'passed', passed, failed, skipped: 0, duration, testCases, output: buildTextOutput(testCases) });
+      } else {
+        const ok = exitOk && !output.toLowerCase().includes('error') && !output.toLowerCase().includes('failed');
+        results.push({ suite: `Python: ${relF}`, status: ok ? 'passed' : 'failed', passed: ok ? 1 : 0, failed: ok ? 0 : 1, skipped: 0, duration, output: output.slice(-1000) });
+      }
+    }
+  }
+
+  // JS: run each file with node directly
+  if (jsFiles.length > 0 && commandExists('node')) {
+    for (const f of jsFiles.slice(0, 10)) {
+      const start = Date.now();
+      let output = '';
+      let exitOk = false;
+      try {
+        output = execSync(`node "${f}"`, { cwd: root, encoding: 'utf8', timeout: 30000, shell: true, stdio: 'pipe' });
+        exitOk = true;
+      } catch (err) {
+        output = (err.stdout || '') + (err.stderr || '') + (err.message || '');
+      }
+      const duration = Date.now() - start;
+      const relF = path.relative(root, f);
+      const testCases = parseJsAssertOutput(output, relF, exitOk);
+      const passed  = testCases.filter(t => t.status === 'passed').length;
+      const failed  = testCases.filter(t => t.status === 'failed').length;
+      if (testCases.length > 0) {
+        results.push({ suite: `Node: ${relF}`, status: failed > 0 ? 'failed' : 'passed', passed, failed, skipped: 0, duration, testCases, output: buildTextOutput(testCases) });
+      } else {
+        const ok = exitOk && !output.toLowerCase().includes('assertionerror') && !output.toLowerCase().includes('error:');
+        results.push({ suite: `Node: ${relF}`, status: ok ? 'passed' : 'failed', passed: ok ? 1 : 0, failed: ok ? 0 : 1, skipped: 0, duration, output: output.slice(-1000) });
+      }
+    }
+  }
+
+  if (results.length === 0) {
+    return [{ suite: 'DSA / Standalone Tests', status: 'skipped', passed: 0, failed: 0, skipped: 0, output: 'No runnable standalone test files found.', duration: 0 }];
+  }
+  return results;
+}
+
+function parsePythonFileOutput(output, filePath) {
+  const testCases = [];
+  for (const line of output.split('\n')) {
+    // pytest: "tests/test_sort.py::test_bubble PASSED"
+    const pm = line.match(/^(.+?::(.+?))\s+(PASSED|FAILED|ERROR|SKIPPED)/);
+    if (pm) {
+      testCases.push({ file: filePath, name: pm[2].trim(), status: pm[3] === 'PASSED' ? 'passed' : pm[3] === 'SKIPPED' ? 'pending' : 'failed', duration: 0, error: null });
+      continue;
+    }
+    // doctest: "Trying: ... ok" or "Failed example:"
+    const dm = line.match(/^Trying:\s+(.+)/);
+    if (dm) { testCases.push({ file: filePath, name: `doctest: ${dm[1].slice(0, 60)}`, status: 'passed', duration: 0, error: null }); }
+    // unittest: "test_add (TestMath) ... ok"
+    const um = line.match(/^(test\w+)\s+\(.+?\)\s+\.\.\.\s+(ok|FAIL|ERROR)/);
+    if (um) { testCases.push({ file: filePath, name: um[1], status: um[2] === 'ok' ? 'passed' : 'failed', duration: 0, error: null }); }
+  }
+  return testCases;
+}
+
+function parseJsAssertOutput(output, filePath, exitOk) {
+  const testCases = [];
+  for (const line of output.split('\n')) {
+    // console.assert or custom: "✔ test_add passed" / "✖ test_add failed"
+    const m1 = line.match(/[✔✓]\s+(.+)/);
+    const m2 = line.match(/[✖✗✘×]\s+(.+)/);
+    if (m1) testCases.push({ file: filePath, name: m1[1].trim(), status: 'passed', duration: 0, error: null });
+    if (m2) testCases.push({ file: filePath, name: m2[1].trim(), status: 'failed', duration: 0, error: null });
+  }
+  return testCases;
 }
 
 // ─── Generic command runner ───────────────────────────────────────────────────
 
 function runCommand({ dir, label, cmd, suite, parseOutput }) {
-  if (!cmd) {
-    return { suite: `${suite} (${label})`, status: 'skipped', passed: 0, failed: 0, skipped: 0, output: `${suite} not installed or not found in PATH.`, duration: 0 };
-  }
+  if (!cmd) return { suite: `${suite} (${label})`, status: 'skipped', passed: 0, failed: 0, skipped: 0, output: `${suite} not installed or not found in PATH.`, duration: 0 };
   const start = Date.now();
   try {
-    const output = execSync(cmd, { cwd: dir, encoding: 'utf8', timeout: 120000, env: { ...process.env, FORCE_COLOR: '0' }, stdio: 'pipe' });
-    const duration = Date.now() - start;
-    return { suite: `${suite} (${label})`, duration, ...parseOutput(output, true) };
+    const output = execSync(cmd, { cwd: dir, encoding: 'utf8', timeout: 120000, shell: true, env: { ...process.env, FORCE_COLOR: '0' }, stdio: 'pipe' });
+    return { suite: `${suite} (${label})`, duration: Date.now() - start, ...parseOutput(output, true) };
   } catch (err) {
-    const duration = Date.now() - start;
     const output = (err.stdout || '') + (err.stderr || '') + (err.message || '');
-    return { suite: `${suite} (${label})`, duration, ...parseOutput(output, false) };
+    return { suite: `${suite} (${label})`, duration: Date.now() - start, ...parseOutput(output, false) };
   }
 }
 
-// ─── Output parsers ───────────────────────────────────────────────────────────
+// ─── Output parsers (text fallback for non-JSON runners) ─────────────────────
+
+function buildTextOutput(testCases) {
+  const byFile = {};
+  for (const tc of testCases) { (byFile[tc.file || ''] = byFile[tc.file || ''] || []).push(tc); }
+  return Object.entries(byFile).map(([file, cases]) =>
+    (file ? `\n  📄 ${file}` : '') + '\n' +
+    cases.map(t => `  ${t.status === 'passed' ? '✔' : t.status === 'failed' ? '✖' : '○'} ${t.name}${t.duration > 0 ? ` (${t.duration}ms)` : ''}`).join('\n')
+  ).join('\n');
+}
 
-function parseJestTextOutput(output, label, duration) {
-  const passMatch = output.match(/(\d+)\s+passed/);
-  const failMatch = output.match(/(\d+)\s+failed/);
-  const skipMatch = output.match(/(\d+)\s+(?:skipped|pending)/);
-  const passed  = passMatch ? parseInt(passMatch[1]) : 0;
-  const failed  = failMatch ? parseInt(failMatch[1]) : 0;
-  const skipped = skipMatch ? parseInt(skipMatch[1]) : 0;
+function parseJestTextFallback(output, label, duration) {
+  const passed  = +(output.match(/(\d+)\s+passed/)?.[1]  || 0);
+  const failed  = +(output.match(/(\d+)\s+failed/)?.[1]  || 0);
+  const skipped = +(output.match(/(\d+)\s+(?:skipped|pending)/)?.[1] || 0);
   return { suite: `Jest (${label})`, status: failed > 0 ? 'failed' : (passed > 0 ? 'passed' : 'unknown'), passed, failed, skipped, duration, output: output.slice(-3000) };
 }
 
 function parsePytestOutput(output, exitOk) {
-  const m = output.match(/(\d+)\s+passed(?:,\s*(\d+)\s+failed)?(?:,\s*(\d+)\s+(?:warning|skipped))?/);
-  const failed  = output.match(/(\d+)\s+failed/)?.[1];
-  const passed  = m?.[1] || '0';
-  const skipped = output.match(/(\d+)\s+(?:skipped|deselected)/)?.[1] || '0';
-  const status  = parseInt(failed || '0') > 0 ? 'failed' : (exitOk ? 'passed' : 'failed');
-  return { status, passed: parseInt(passed), failed: parseInt(failed || '0'), skipped: parseInt(skipped), output: output.slice(-3000) };
+  const failed  = +(output.match(/(\d+)\s+failed/)?.[1]  || 0);
+  const passed  = +(output.match(/(\d+)\s+passed/)?.[1]  || 0);
+  const skipped = +(output.match(/(\d+)\s+(?:skipped|deselected)/)?.[1] || 0);
+  return { status: failed > 0 ? 'failed' : (exitOk ? 'passed' : 'failed'), passed, failed, skipped, output: output.slice(-3000) };
 }
 
 function parseGoTestOutput(output, exitOk) {
@@ -369,78 +802,136 @@ function parseGoTestOutput(output, exitOk) {
 
 function parseCargoOutput(output, exitOk) {
   const m = output.match(/test result:.*?(\d+)\s+passed;\s*(\d+)\s+failed;\s*(\d+)\s+ignored/);
-  return { status: m && parseInt(m[2]) > 0 ? 'failed' : (exitOk ? 'passed' : 'failed'), passed: parseInt(m?.[1] || '0'), failed: parseInt(m?.[2] || '0'), skipped: parseInt(m?.[3] || '0'), output: output.slice(-3000) };
+  return { status: m && +m[2] > 0 ? 'failed' : (exitOk ? 'passed' : 'failed'), passed: +(m?.[1]||0), failed: +(m?.[2]||0), skipped: +(m?.[3]||0), output: output.slice(-3000) };
 }
 
 function parseMavenOutput(output, exitOk) {
   const m = output.match(/Tests run:\s*(\d+),\s*Failures:\s*(\d+),\s*Errors:\s*(\d+),\s*Skipped:\s*(\d+)/);
-  const failed  = m ? parseInt(m[2]) + parseInt(m[3]) : 0;
-  const passed  = m ? parseInt(m[1]) - failed - parseInt(m[4]) : 0;
-  const skipped = m ? parseInt(m[4]) : 0;
-  return { status: failed > 0 ? 'failed' : (exitOk ? 'passed' : 'failed'), passed, failed, skipped, output: output.slice(-3000) };
+  const failed  = m ? +m[2] + +m[3] : 0;
+  const passed  = m ? +m[1] - failed - +m[4] : 0;
+  return { status: failed > 0 ? 'failed' : (exitOk ? 'passed' : 'failed'), passed, failed, skipped: m ? +m[4] : 0, output: output.slice(-3000) };
 }
 
 function parseGradleOutput(output, exitOk) {
   const m = output.match(/(\d+)\s+tests?\s+completed(?:,\s*(\d+)\s+failed)?/);
-  const failed  = m?.[2] ? parseInt(m[2]) : 0;
-  const total   = m ? parseInt(m[1]) : 0;
-  return { status: failed > 0 ? 'failed' : (exitOk ? 'passed' : 'failed'), passed: total - failed, failed, skipped: 0, output: output.slice(-3000) };
+  const failed = m?.[2] ? +m[2] : 0;
+  return { status: failed > 0 ? 'failed' : (exitOk ? 'passed' : 'failed'), passed: m ? +m[1] - failed : 0, failed, skipped: 0, output: output.slice(-3000) };
 }
 
 function parseMochaOutput(output, exitOk) {
-  const passMatch = output.match(/(\d+)\s+passing/);
-  const failMatch = output.match(/(\d+)\s+failing/);
-  const pending   = output.match(/(\d+)\s+pending/);
-  const passed  = passMatch ? parseInt(passMatch[1]) : 0;
-  const failed  = failMatch ? parseInt(failMatch[1]) : 0;
-  const skipped = pending   ? parseInt(pending[1])   : 0;
-  return { status: failed > 0 ? 'failed' : (exitOk ? 'passed' : 'failed'), passed, failed, skipped, output: output.slice(-3000) };
+  const passed  = +(output.match(/(\d+)\s+passing/)?.[1] || 0);
+  const failed  = +(output.match(/(\d+)\s+failing/)?.[1] || 0);
+  const skipped = +(output.match(/(\d+)\s+pending/)?.[1] || 0);
+  // Per-test from mocha spec reporter: "    ✓ should add two numbers" or "    1) should fail"
+  const testCases = [];
+  for (const line of output.split('\n')) {
+    const pass = line.match(/^\s+(?:✓|✔|passing)\s+(.+)/);
+    const fail = line.match(/^\s+\d+\)\s+(.+)/);
+    if (pass) testCases.push({ file: '', name: pass[1].trim(), status: 'passed', duration: 0, error: null });
+    if (fail) testCases.push({ file: '', name: fail[1].trim(), status: 'failed', duration: 0, error: null });
+  }
+  return { status: failed > 0 ? 'failed' : (exitOk ? 'passed' : 'failed'), passed, failed, skipped, testCases: testCases.length ? testCases : undefined, output: output.slice(-3000) };
 }
 
 function parseVitestOutput(output, exitOk) {
-  const passMatch = output.match(/(\d+)\s+(?:test[s]?\s+)?passed/i);
-  const failMatch = output.match(/(\d+)\s+(?:test[s]?\s+)?failed/i);
-  const passed  = passMatch ? parseInt(passMatch[1]) : 0;
-  const failed  = failMatch ? parseInt(failMatch[1]) : 0;
+  const passed = +(output.match(/(\d+)\s+(?:tests?\s+)?passed/i)?.[1] || 0);
+  const failed = +(output.match(/(\d+)\s+(?:tests?\s+)?failed/i)?.[1] || 0);
   return { status: failed > 0 ? 'failed' : (exitOk ? 'passed' : 'failed'), passed, failed, skipped: 0, output: output.slice(-3000) };
 }
 
 function parsePHPUnitOutput(output, exitOk) {
   const m = output.match(/OK\s+\((\d+)\s+tests?/);
   const f = output.match(/FAILURES!\s*\nTests:\s*(\d+),.*?Failures:\s*(\d+)/s);
-  if (f) return { status: 'failed', passed: parseInt(f[1]) - parseInt(f[2]), failed: parseInt(f[2]), skipped: 0, output: output.slice(-3000) };
-  return { status: exitOk ? 'passed' : 'failed', passed: m ? parseInt(m[1]) : 0, failed: 0, skipped: 0, output: output.slice(-3000) };
+  if (f) return { status: 'failed', passed: +f[1] - +f[2], failed: +f[2], skipped: 0, output: output.slice(-3000) };
+  return { status: exitOk ? 'passed' : 'failed', passed: m ? +m[1] : 0, failed: 0, skipped: 0, output: output.slice(-3000) };
 }
 
 function parseRSpecOutput(output, exitOk) {
   const m = output.match(/(\d+)\s+examples?,\s*(\d+)\s+failures?/);
-  return { status: m && parseInt(m[2]) > 0 ? 'failed' : (exitOk ? 'passed' : 'failed'), passed: m ? parseInt(m[1]) - parseInt(m[2]) : 0, failed: m ? parseInt(m[2]) : 0, skipped: 0, output: output.slice(-3000) };
+  // Per-test from RSpec documentation format:
+  // "  TestClass" / "    ✓ does something" / "    ✗ does something (FAILED)"
+  const testCases = [];
+  let currentGroup = '';
+  for (const line of output.split('\n')) {
+    const group = line.match(/^\s{2}(\S.+)$/);
+    const pass  = line.match(/^\s{4}(?:✓|\+)\s+(.+)/);
+    const fail  = line.match(/^\s{4}(?:✗|×|-)\s+(.+)/);
+    if (group && !pass && !fail) currentGroup = group[1].trim();
+    if (pass) testCases.push({ file: '', name: `${currentGroup ? currentGroup + ' ' : ''}${pass[1].trim()}`, status: 'passed', duration: 0, error: null });
+    if (fail) testCases.push({ file: '', name: `${currentGroup ? currentGroup + ' ' : ''}${fail[1].trim()}`, status: 'failed', duration: 0, error: null });
+  }
+  return { status: m && +m[2] > 0 ? 'failed' : (exitOk ? 'passed' : 'failed'), passed: m ? +m[1] - +m[2] : 0, failed: m ? +m[2] : 0, skipped: 0, testCases: testCases.length ? testCases : undefined, output: output.slice(-3000) };
 }
 
 function parseDartOutput(output, exitOk) {
-  const passMatch = output.match(/(\d+) tests? passed/);
-  const failMatch = output.match(/(\d+) tests? failed/);
-  const passed  = passMatch ? parseInt(passMatch[1]) : 0;
-  const failed  = failMatch ? parseInt(failMatch[1]) : 0;
-  return { status: failed > 0 ? 'failed' : (exitOk ? 'passed' : 'failed'), passed, failed, skipped: 0, output: output.slice(-3000) };
+  const passed = +(output.match(/(\d+) tests? passed/)?.[1] || 0);
+  const failed = +(output.match(/(\d+) tests? failed/)?.[1] || 0);
+  const testCases = [];
+  for (const line of output.split('\n')) {
+    const pass = line.match(/^\s*(?:✓|\+)\s+(.+)/);
+    const fail = line.match(/^\s*(?:✗|-)\s+(.+)/);
+    if (pass) testCases.push({ file: '', name: pass[1].trim(), status: 'passed', duration: 0, error: null });
+    if (fail) testCases.push({ file: '', name: fail[1].trim(), status: 'failed', duration: 0, error: null });
+  }
+  return { status: failed > 0 ? 'failed' : (exitOk ? 'passed' : 'failed'), passed, failed, skipped: 0, testCases: testCases.length ? testCases : undefined, output: output.slice(-3000) };
 }
 
 function parseDotnetOutput(output, exitOk) {
   const m = output.match(/Passed!\s+-\s+Failed:\s*(\d+),\s*Passed:\s*(\d+),\s*Skipped:\s*(\d+)/);
-  if (m) return { status: parseInt(m[1]) > 0 ? 'failed' : 'passed', passed: parseInt(m[2]), failed: parseInt(m[1]), skipped: parseInt(m[3]), output: output.slice(-3000) };
-  const f = output.match(/Failed:\s*(\d+)/); const p = output.match(/Passed:\s*(\d+)/);
-  return { status: exitOk ? 'passed' : 'failed', passed: p ? parseInt(p[1]) : 0, failed: f ? parseInt(f[1]) : 0, skipped: 0, output: output.slice(-3000) };
+  if (m) return { status: +m[1] > 0 ? 'failed' : 'passed', passed: +m[2], failed: +m[1], skipped: +m[3], output: output.slice(-3000) };
+  const f = output.match(/Failed:\s*(\d+)/);
+  const p = output.match(/Passed:\s*(\d+)/);
+  return { status: exitOk ? 'passed' : 'failed', passed: p ? +p[1] : 0, failed: f ? +f[1] : 0, skipped: 0, output: output.slice(-3000) };
 }
 
 // ─── Utility helpers ──────────────────────────────────────────────────────────
 
 function tryReadJSON(p) { try { return JSON.parse(fs.readFileSync(p, 'utf8')); } catch { return null; } }
-function allDeps(pkg) { return [...Object.keys(pkg.dependencies || {}), ...Object.keys(pkg.devDependencies || {}), ...Object.keys(pkg.peerDependencies || {})]; }
-function commandExists(cmd) { try { execSync(`which ${cmd} 2>/dev/null || command -v ${cmd} 2>/dev/null`, { encoding: 'utf8' }).trim(); return true; } catch { return false; } }
-function hasBin(dir, bin) { return fs.existsSync(path.join(dir, 'node_modules', '.bin', bin)); }
+function allDeps(pkg) { return [...Object.keys(pkg.dependencies||{}), ...Object.keys(pkg.devDependencies||{}), ...Object.keys(pkg.peerDependencies||{})]; }
+
+function commandExists(cmd) {
+  try {
+    if (IS_WIN) {
+      execSync(`where ${cmd}`, { encoding: 'utf8', stdio: 'pipe' });
+    } else {
+      execSync(`command -v ${cmd}`, { encoding: 'utf8', stdio: 'pipe', shell: '/bin/sh' });
+    }
+    return true;
+  } catch { return false; }
+}
+
+function hasBin(dir, bin) {
+  return fs.existsSync(path.join(dir, 'node_modules', '.bin', bin)) ||
+         fs.existsSync(path.join(dir, 'node_modules', '.bin', bin + '.cmd'));
+}
+
 function hasSourceExt(root, ext) {
   try { return fs.readdirSync(root).some(f => f.endsWith(ext)); } catch { return false; }
 }
+
+function findFilesWithExt(root, ext) {
+  const results = [];
+  const SKIP = new Set(['node_modules', '.git', 'dist', 'build', 'venv', '.venv', '__pycache__']);
+  function walk(dir, depth) {
+    if (depth > 5) return;
+    let entries;
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      if (e.isDirectory() && !SKIP.has(e.name)) walk(path.join(dir, e.name), depth + 1);
+      else if (e.isFile() && e.name.endsWith(ext)) results.push(path.join(dir, e.name));
+    }
+  }
+  walk(root, 0);
+  return results;
+}
+
+function hasTestPatterns(filePath) {
+  try {
+    const src = fs.readFileSync(filePath, 'utf8');
+    return /\b(unittest|pytest|doctest|assert|describe|it\(|test\(|expect\()\b/.test(src);
+  } catch { return false; }
+}
+
 function findSubPackages(root) {
   try {
     return fs.readdirSync(root, { withFileTypes: true })
@@ -449,6 +940,7 @@ function findSubPackages(root) {
       .filter(p => fs.existsSync(p));
   } catch { return []; }
 }
+
 function findSubDirs(root) {
   try {
     return fs.readdirSync(root, { withFileTypes: true })