@corbat-tech/coco 2.14.0 → 2.15.0

package/dist/cli/index.js

@@ -8502,7 +8502,13 @@ function initializeContextManager(session, provider) {
 function updateContextTokens(session, provider, toolRegistry) {
   if (!session.contextManager) return;
   let totalTokens = 0;
-  {
+  if (toolRegistry) {
+    const effectiveMessages = getConversationContext(session, toolRegistry);
+    for (const message of effectiveMessages) {
+      const content = typeof message.content === "string" ? message.content : JSON.stringify(message.content);
+      totalTokens += provider.countTokens(content);
+    }
+  } else {
     totalTokens += provider.countTokens(session.config.agent.systemPrompt);
     for (const message of session.messages) {
       const content = typeof message.content === "string" ? message.content : JSON.stringify(message.content);
@@ -8515,7 +8521,7 @@ async function checkAndCompactContext(session, provider, signal, toolRegistry) {
   if (!session.contextManager) {
     initializeContextManager(session, provider);
   }
-  updateContextTokens(session, provider);
+  updateContextTokens(session, provider, toolRegistry);
   if (!session.contextManager.shouldCompact()) {
     return null;
   }
@@ -10444,6 +10450,18 @@ var init_subprocess_registry = __esm({
   }
 });
 async function detectTestFramework(projectPath) {
+  try {
+    await access(join(projectPath, "pom.xml"), constants.R_OK);
+    return "maven";
+  } catch {
+  }
+  for (const f of ["build.gradle", "build.gradle.kts"]) {
+    try {
+      await access(join(projectPath, f), constants.R_OK);
+      return "gradle";
+    } catch {
+    }
+  }
   try {
     const pkgPath = join(projectPath, "package.json");
     const pkgContent = await readFile(pkgPath, "utf-8");
@@ -10505,6 +10523,55 @@ function parseCoverageSummary(report) {
     }
   };
 }
+function parseJacocoCsv(csv) {
+  const lines = csv.trim().split("\n").slice(1);
+  let lineMissed = 0, lineCovered = 0;
+  let branchMissed = 0, branchCovered = 0;
+  let methodMissed = 0, methodCovered = 0;
+  let instrMissed = 0, instrCovered = 0;
+  for (const line of lines) {
+    const cols = line.split(",");
+    if (cols.length < 13) continue;
+    instrMissed += parseInt(cols[3] ?? "0", 10);
+    instrCovered += parseInt(cols[4] ?? "0", 10);
+    branchMissed += parseInt(cols[5] ?? "0", 10);
+    branchCovered += parseInt(cols[6] ?? "0", 10);
+    lineMissed += parseInt(cols[7] ?? "0", 10);
+    lineCovered += parseInt(cols[8] ?? "0", 10);
+    methodMissed += parseInt(cols[11] ?? "0", 10);
+    methodCovered += parseInt(cols[12] ?? "0", 10);
+  }
+  const pct = (covered, missed) => {
+    const total = covered + missed;
+    return total > 0 ? Math.round(covered / total * 1e3) / 10 : 0;
+  };
+  return {
+    lines: {
+      total: lineCovered + lineMissed,
+      covered: lineCovered,
+      skipped: 0,
+      percentage: pct(lineCovered, lineMissed)
+    },
+    branches: {
+      total: branchCovered + branchMissed,
+      covered: branchCovered,
+      skipped: 0,
+      percentage: pct(branchCovered, branchMissed)
+    },
+    functions: {
+      total: methodCovered + methodMissed,
+      covered: methodCovered,
+      skipped: 0,
+      percentage: pct(methodCovered, methodMissed)
+    },
+    statements: {
+      total: instrCovered + instrMissed,
+      covered: instrCovered,
+      skipped: 0,
+      percentage: pct(instrCovered, instrMissed)
+    }
+  };
+}
 var CoverageAnalyzer;
 var init_coverage = __esm({
   "src/quality/analyzers/coverage.ts"() {
@@ -10518,29 +10585,53 @@ var init_coverage = __esm({
        */
       async analyze() {
         const framework = await detectTestFramework(this.projectPath);
-        const coverageTool = await detectCoverageTool(this.projectPath);
         if (!framework) {
-          throw new Error("No test framework detected (vitest, jest, or mocha)");
+          return this.zeroCoverage();
         }
-        const existingCoverage = await this.readExistingCoverage();
+        const existingCoverage = await this.readExistingCoverage(framework);
         if (existingCoverage) {
           return existingCoverage;
         }
+        if (framework === "maven" || framework === "gradle") {
+          return this.zeroCoverage();
+        }
+        const coverageTool = await detectCoverageTool(this.projectPath);
         return await this.runWithCoverage(framework, coverageTool);
       }
+      /** Return empty coverage metrics (graceful fallback) */
+      zeroCoverage() {
+        const zero = { total: 0, covered: 0, skipped: 0, percentage: 0 };
+        return { lines: zero, branches: zero, functions: zero, statements: zero };
+      }
       /**
-       * Read existing coverage report if available
+       * Read existing coverage report if available.
+       * Supports Node.js (c8/nyc JSON) and JVM (JaCoCo CSV) formats.
        */
-      async readExistingCoverage() {
+      async readExistingCoverage(framework) {
+        if (framework === "maven" || framework === "gradle") {
+          const jacocoPaths = framework === "maven" ? [
+            join(this.projectPath, "target", "site", "jacoco", "jacoco.csv"),
+            join(this.projectPath, "target", "site", "jacoco-ut", "jacoco.csv")
+          ] : [join(this.projectPath, "build", "reports", "jacoco", "test", "jacocoTestReport.csv")];
+          for (const csvPath of jacocoPaths) {
+            try {
+              await access(csvPath, constants.R_OK);
+              const csv = await readFile(csvPath, "utf-8");
+              return parseJacocoCsv(csv);
+            } catch {
+            }
+          }
+          return null;
+        }
         const possiblePaths = [
           join(this.projectPath, "coverage", "coverage-summary.json"),
           join(this.projectPath, ".coverage", "coverage-summary.json"),
           join(this.projectPath, "coverage", "lcov-report", "coverage-summary.json")
         ];
-        for (const path57 of possiblePaths) {
+        for (const p45 of possiblePaths) {
           try {
-            await access(path57, constants.R_OK);
-            const content = await readFile(path57, "utf-8");
+            await access(p45, constants.R_OK);
+            const content = await readFile(p45, "utf-8");
             const report = JSON.parse(content);
             return parseCoverageSummary(report);
           } catch {
@@ -11215,7 +11306,7 @@ var init_build_verifier = __esm({
               stderr: ""
             };
           }
-          const SAFE_BUILD_PATTERN = /^(npm|pnpm|yarn|bun)\s+(run\s+)?[\w:.-]+$|^npx\s+tsc(\s+--[\w-]+)*$/;
+          const SAFE_BUILD_PATTERN = /^(npm|pnpm|yarn|bun)\s+(run\s+)?[\w:.-]+$|^npx\s+tsc(\s+--[\w-]+)*$|^\.(\/|\\)(mvnw|gradlew)(\s+[\w:.-]+)*(\s+-[\w-]+)*$/;
           if (!SAFE_BUILD_PATTERN.test(buildCommand2.trim())) {
             return {
               success: false,
@@ -11320,9 +11411,20 @@ var init_build_verifier = __esm({
         }
       }
       /**
-       * Detect build command from package.json
+       * Detect build command from project build files.
+       * Checks Maven, Gradle, and Node.js in that order.
        */
       async detectBuildCommand() {
+        if (await this.fileExists(path36.join(this.projectPath, "pom.xml"))) {
+          const wrapper = path36.join(this.projectPath, "mvnw");
+          return await this.fileExists(wrapper) ? "./mvnw compile -B -q" : "mvn compile -B -q";
+        }
+        for (const f of ["build.gradle", "build.gradle.kts"]) {
+          if (await this.fileExists(path36.join(this.projectPath, f))) {
+            const wrapper = path36.join(this.projectPath, "gradlew");
+            return await this.fileExists(wrapper) ? "./gradlew classes -q" : "gradle classes -q";
+          }
+        }
         try {
           const packageJsonPath = path36.join(this.projectPath, "package.json");
           const content = await fs34.readFile(packageJsonPath, "utf-8");
@@ -11333,10 +11435,9 @@ var init_build_verifier = __esm({
           if (packageJson.devDependencies?.typescript || packageJson.dependencies?.typescript) {
             return "npx tsc --noEmit";
           }
-          return null;
         } catch {
-          return null;
         }
+        return null;
       }
       /**
        * Parse errors from build output
@@ -11410,6 +11511,16 @@ var init_build_verifier = __esm({
     };
   }
 });
+async function resolveJvmExecutable(projectPath, tool) {
+  const wrapper = tool === "maven" ? "mvnw" : "gradlew";
+  const fallback = tool === "maven" ? "mvn" : "gradle";
+  try {
+    await access(join(projectPath, wrapper));
+    return join(projectPath, wrapper);
+  } catch {
+    return fallback;
+  }
+}
 function parseVitestOutput(stdout) {
   const testsMatch = stdout.match(
     /Tests\s+(?:(\d+)\s+passed)?(?:\s*\|\s*(\d+)\s+failed)?(?:\s*\|\s*(\d+)\s+skipped)?/
@@ -11462,10 +11573,29 @@ function buildTestCommand(framework) {
       return { command: "npx", args: ["jest", "--json"] };
     case "mocha":
       return { command: "npx", args: ["mocha", "--reporter=json"] };
+    case "maven":
+      return { command: "__maven__", args: ["test", "--no-transfer-progress", "-B"] };
+    case "gradle":
+      return { command: "__gradle__", args: ["test"] };
     default:
       return null;
   }
 }
+function parseMavenOutput(output) {
+  let passed = 0, failed = 0, skipped = 0;
+  const pattern = /Tests run:\s*(\d+),\s*Failures:\s*(\d+),\s*Errors:\s*(\d+),\s*Skipped:\s*(\d+)/gi;
+  for (const match of output.matchAll(pattern)) {
+    const total = parseInt(match[1] ?? "0", 10);
+    const failures = parseInt(match[2] ?? "0", 10);
+    const errors = parseInt(match[3] ?? "0", 10);
+    const skip = parseInt(match[4] ?? "0", 10);
+    const f = failures + errors;
+    passed += total - f - skip;
+    failed += f;
+    skipped += skip;
+  }
+  return { passed, failed, skipped };
+}
 var CorrectnessAnalyzer;
 var init_correctness = __esm({
   "src/quality/analyzers/correctness.ts"() {
@@ -11523,6 +11653,11 @@ var init_correctness = __esm({
         if (!cmd) {
           return { passed: 0, failed: 0, skipped: 0 };
         }
+        if (cmd.command === "__maven__") {
+          cmd.command = await resolveJvmExecutable(this.projectPath, "maven");
+        } else if (cmd.command === "__gradle__") {
+          cmd.command = await resolveJvmExecutable(this.projectPath, "gradle");
+        }
         try {
           const proc = execa(cmd.command, cmd.args, {
             cwd: this.projectPath,
@@ -11534,15 +11669,15 @@ var init_correctness = __esm({
           });
           trackSubprocess(proc);
           const result = await proc;
-          const output = result.stdout + "\n" + result.stderr;
+          const output = (result.stdout ?? "") + "\n" + (result.stderr ?? "");
           switch (framework) {
             case "vitest":
               return parseVitestOutput(output);
             case "jest":
-              return parseJestOutput(result.stdout);
+              return parseJestOutput(result.stdout ?? "");
             case "mocha": {
               try {
-                const json2 = JSON.parse(result.stdout);
+                const json2 = JSON.parse(result.stdout ?? "");
                 return {
                   passed: json2.stats?.passes ?? 0,
                   failed: json2.stats?.failures ?? 0,
@@ -11552,6 +11687,9 @@ var init_correctness = __esm({
                 return { passed: 0, failed: 0, skipped: 0 };
               }
             }
+            case "maven":
+            case "gradle":
+              return parseMavenOutput(output);
             default:
               return { passed: 0, failed: 0, skipped: 0 };
           }
@@ -14492,9 +14630,31 @@ var init_evaluator = __esm({
         return suggestions;
       }
       /**
-       * Find source files in project
+       * Find source files in project, adapting to the detected language stack.
        */
       async findSourceFiles() {
+        const { access: access16 } = await import('fs/promises');
+        const { join: join26 } = await import('path');
+        let isJava = false;
+        try {
+          await access16(join26(this.projectPath, "pom.xml"));
+          isJava = true;
+        } catch {
+          for (const f of ["build.gradle", "build.gradle.kts"]) {
+            try {
+              await access16(join26(this.projectPath, f));
+              isJava = true;
+              break;
+            } catch {
+            }
+          }
+        }
+        if (isJava) {
+          return glob("src/main/java/**/*.java", {
+            cwd: this.projectPath,
+            absolute: true
+          });
+        }
         return glob("**/*.{ts,js,tsx,jsx}", {
           cwd: this.projectPath,
           absolute: true,
@@ -14505,6 +14665,18 @@ var init_evaluator = __esm({
   }
 });
 async function detectLinter2(cwd) {
+  try {
+    await fs34__default.access(path36__default.join(cwd, "pom.xml"));
+    return "maven-checkstyle";
+  } catch {
+  }
+  for (const f of ["build.gradle", "build.gradle.kts"]) {
+    try {
+      await fs34__default.access(path36__default.join(cwd, f));
+      return "gradle-checkstyle";
+    } catch {
+    }
+  }
   try {
     const pkgPath = path36__default.join(cwd, "package.json");
     const pkgContent = await fs34__default.readFile(pkgPath, "utf-8");
@@ -14521,6 +14693,44 @@ async function detectLinter2(cwd) {
     return null;
   }
 }
+async function mavenExec(cwd) {
+  try {
+    await fs34__default.access(path36__default.join(cwd, "mvnw"));
+    return "./mvnw";
+  } catch {
+    return "mvn";
+  }
+}
+async function gradleExec(cwd) {
+  try {
+    await fs34__default.access(path36__default.join(cwd, "gradlew"));
+    return "./gradlew";
+  } catch {
+    return "gradle";
+  }
+}
+function parseCheckstyleOutput(stdout, stderr) {
+  const output = stdout + "\n" + stderr;
+  const issues = [];
+  let errors = 0;
+  let warnings = 0;
+  const lineRe = /\[(ERROR|WARN(?:ING)?)\]\s+(.+?):(?:\[(\d+)(?:,(\d+))?\])?\s*(?:\([^)]*\))?\s*(.+)/gi;
+  for (const m of output.matchAll(lineRe)) {
+    const sev = (m[1] ?? "").toUpperCase().startsWith("ERROR") ? "error" : "warning";
+    if (sev === "error") errors++;
+    else warnings++;
+    issues.push({
+      file: m[2]?.trim() ?? "",
+      line: parseInt(m[3] ?? "0", 10),
+      column: parseInt(m[4] ?? "0", 10),
+      severity: sev,
+      message: m[5]?.trim() ?? "",
+      rule: ""
+    });
+  }
+  const score = Math.max(0, 100 - errors * 5 - warnings * 2);
+  return { errors, warnings, fixable: 0, issues, score };
+}
 function parseLintResults(_linter, stdout, _stderr) {
   const issues = [];
   let errors = 0;
@@ -14560,6 +14770,28 @@ function parseLintResults(_linter, stdout, _stderr) {
 }
 async function findSourceFiles(cwd) {
   const { glob: glob17 } = await import('glob');
+  let isJava = false;
+  try {
+    await fs34__default.access(path36__default.join(cwd, "pom.xml"));
+    isJava = true;
+  } catch {
+  }
+  if (!isJava) {
+    for (const f of ["build.gradle", "build.gradle.kts"]) {
+      try {
+        await fs34__default.access(path36__default.join(cwd, f));
+        isJava = true;
+        break;
+      } catch {
+      }
+    }
+  }
+  if (isJava) {
+    return glob17("src/main/java/**/*.java", {
+      cwd,
+      absolute: true
+    });
+  }
   return glob17("src/**/*.{ts,js,tsx,jsx}", {
     cwd,
     absolute: true,
@@ -14577,6 +14809,8 @@ function analyzeFileComplexity(content, file) {
     const line = lines[i] ?? "";
     const funcMatch = line.match(
       /(?:function|async function)\s+(\w+)|(\w+)\s*(?:=|:)\s*(?:async\s*)?\(?.*\)?\s*=>/
+    ) ?? line.match(
+      /(?:public|private|protected|static|final|native|synchronized|abstract)\s+\S+\s+(\w+)\s*\(/
     );
     if (funcMatch && braceDepth === 0) {
       if (currentFunction) {
@@ -14619,19 +14853,20 @@ var init_quality = __esm({
     init_evaluator();
     runLinterTool = defineTool({
       name: "run_linter",
-      description: `Run linter on the codebase (auto-detects eslint, oxlint, or biome).
+      description: `Run linter on the codebase (auto-detects eslint, oxlint, biome for Node.js; checkstyle for Maven/Gradle).
 
 Examples:
 - Lint all: {} \u2192 { "errors": 0, "warnings": 5, "score": 90 }
-- Auto-fix: { "fix": true }
+- Auto-fix (Node.js): { "fix": true }
 - Specific files: { "files": ["src/app.ts", "src/utils.ts"] }
-- Force linter: { "linter": "eslint" }`,
+- Force linter: { "linter": "eslint" }
+- Java project (Maven): automatically runs checkstyle:check if plugin is configured`,
       category: "quality",
       parameters: z.object({
         cwd: z.string().optional().describe("Project directory"),
         files: z.array(z.string()).optional().describe("Specific files to lint"),
-        fix: z.boolean().optional().default(false).describe("Auto-fix issues"),
-        linter: z.string().optional().describe("Linter to use (eslint, oxlint, biome)")
+        fix: z.boolean().optional().default(false).describe("Auto-fix issues (Node.js only)"),
+        linter: z.string().optional().describe("Linter to use (eslint, oxlint, biome, maven-checkstyle, gradle-checkstyle)")
       }),
       async execute({ cwd, files, fix, linter }) {
         const projectDir = cwd ?? process.cwd();
@@ -14644,13 +14879,23 @@ Examples:
             issues: [],
             score: null,
             linter: "none",
-            message: "No linter detected (looked for: eslint, oxlint, biome). Install one or use bash_exec to run a custom linter."
+            message: "No linter detected (looked for: eslint, oxlint, biome for Node.js; checkstyle plugin for Maven/Gradle). Install one or use bash_exec to run a custom linter."
           };
         }
         try {
           const args = [];
           let command = "npx";
           switch (detectedLinter) {
+            case "maven-checkstyle": {
+              command = await mavenExec(projectDir);
+              args.push("checkstyle:check", "--no-transfer-progress", "-q");
+              break;
+            }
+            case "gradle-checkstyle": {
+              command = await gradleExec(projectDir);
+              args.push("checkstyleMain", "--quiet");
+              break;
+            }
             case "oxlint":
               args.push("oxlint");
               if (files && files.length > 0) {
@@ -14691,7 +14936,25 @@ Examples:
             reject: false,
             timeout: 12e4
           });
-          return parseLintResults(detectedLinter, result.stdout, result.stderr);
+          const combinedOutput = (result.stdout ?? "") + (result.stderr ?? "");
+          if ((detectedLinter === "maven-checkstyle" || detectedLinter === "gradle-checkstyle") && /No plugin found|Task.*not found|checkstyle.*not configured/i.test(combinedOutput)) {
+            return {
+              errors: 0,
+              warnings: 0,
+              fixable: 0,
+              issues: [],
+              score: null,
+              linter: "none",
+              message: "Checkstyle plugin not configured in build file. Add maven-checkstyle-plugin (Maven) or checkstyle plugin (Gradle) to enable Java linting."
+            };
+          }
+          if (detectedLinter === "maven-checkstyle" || detectedLinter === "gradle-checkstyle") {
+            return {
+              ...parseCheckstyleOutput(result.stdout ?? "", result.stderr ?? ""),
+              linter: detectedLinter
+            };
+          }
+          return parseLintResults(detectedLinter, result.stdout ?? "", result.stderr ?? "");
         } catch (error) {
           throw new ToolError(
             `Linting failed: ${error instanceof Error ? error.message : String(error)}`,
@@ -15165,7 +15428,18 @@ Examples:
             required,
             suggestions,
             maturity,
-            diff
+            // Include full diff for skill access, but strip raw content from files
+            // to prevent dumping thousands of lines into the LLM tool result.
+            // Skills that need file content can access diff.files[].hunks,
+            // but the serialised output stays lean (stats + file names only).
+            diff: {
+              ...diff,
+              files: diff.files.map((f) => ({
+                ...f,
+                hunks: []
+                // strip raw diff hunks — findings already extracted above
+              }))
+            }
           };
           if (diffWarnings.length > 0) {
             result.warnings = diffWarnings;
@@ -20203,7 +20477,8 @@ async function detectProjectStack(cwd) {
     testingFrameworks = parsed.testingFrameworks;
     languages = parsed.languages;
   } else if (stack === "java") {
-    const parsed = await parsePomXml(cwd);
+    const isGradle = await fileExists2(path36__default.join(cwd, "build.gradle")) || await fileExists2(path36__default.join(cwd, "build.gradle.kts"));
+    const parsed = isGradle ? { dependencies: {}, frameworks: [], buildTools: ["gradle"], testingFrameworks: ["JUnit"] } : await parsePomXml(cwd);
     dependencies = parsed.dependencies;
     frameworks = parsed.frameworks;
     buildTools2 = parsed.buildTools;
@@ -37885,6 +38160,18 @@ init_registry4();
 init_errors();
 init_subprocess_registry();
 async function detectTestFramework2(cwd) {
+  try {
+    await fs34__default.access(path36__default.join(cwd, "pom.xml"));
+    return "maven";
+  } catch {
+  }
+  for (const gradleFile of ["build.gradle", "build.gradle.kts"]) {
+    try {
+      await fs34__default.access(path36__default.join(cwd, gradleFile));
+      return "gradle";
+    } catch {
+    }
+  }
   try {
     const pkgPath = path36__default.join(cwd, "package.json");
     const pkgContent = await fs34__default.readFile(pkgPath, "utf-8");
@@ -37902,36 +38189,79 @@ async function detectTestFramework2(cwd) {
     return null;
   }
 }
+function toMavenTestFilter(pattern) {
+  const base = path36__default.basename(pattern).replace(/\.java$/, "");
+  return base;
+}
+function toGradleTestFilter(pattern) {
+  const base = path36__default.basename(pattern).replace(/\.java$/, "");
+  return `*${base}`;
+}
+async function mavenExecutable(cwd) {
+  try {
+    await fs34__default.access(path36__default.join(cwd, "mvnw"));
+    return "./mvnw";
+  } catch {
+    return "mvn";
+  }
+}
+async function gradleExecutable(cwd) {
+  try {
+    await fs34__default.access(path36__default.join(cwd, "gradlew"));
+    return "./gradlew";
+  } catch {
+    return "gradle";
+  }
+}
 var runTestsTool = defineTool({
   name: "run_tests",
-  description: `Run tests in the project (auto-detects vitest, jest, or mocha).
+  description: `Run tests in the project (auto-detects Maven/Gradle/JUnit, vitest, jest, or mocha).
 
 Examples:
 - Run all tests: {}
 - With coverage: { "coverage": true }
-- Specific pattern: { "pattern": "src/**/*.test.ts" }
-- Specific framework: { "framework": "vitest" }`,
+- Specific pattern (JS): { "pattern": "src/**/*.test.ts" }
+- Specific test class (Java): { "pattern": "**/ItemRestControllerIT.java" }
+- Specific framework: { "framework": "maven" }
+- Maven module: { "framework": "maven", "args": ["-pl", "stock-core"] }`,
   category: "test",
   parameters: z.object({
     cwd: z.string().optional().describe("Project directory"),
-    pattern: z.string().optional().describe("Test file pattern"),
+    pattern: z.string().optional().describe("Test file pattern or class glob"),
     coverage: z.boolean().optional().default(false).describe("Collect coverage"),
-    framework: z.string().optional().describe("Test framework (vitest, jest, mocha)"),
-    watch: z.boolean().optional().default(false).describe("Watch mode")
+    framework: z.string().optional().describe("Test framework (maven, gradle, vitest, jest, mocha)"),
+    watch: z.boolean().optional().default(false).describe("Watch mode"),
+    args: z.array(z.string()).optional().describe("Extra arguments (e.g. Maven -pl module)")
   }),
-  async execute({ cwd, pattern, coverage, framework, watch }) {
+  async execute({ cwd, pattern, coverage, framework, watch, args: extraArgs }) {
     const projectDir = cwd ?? process.cwd();
     const detectedFramework = framework ?? await detectTestFramework2(projectDir);
     if (!detectedFramework) {
-      throw new ToolError("No test framework detected. Install vitest, jest, or mocha.", {
-        tool: "run_tests"
-      });
+      throw new ToolError(
+        "No test framework detected. For Java projects ensure pom.xml or build.gradle exists. For Node.js projects install vitest, jest, or mocha.",
+        { tool: "run_tests" }
+      );
     }
     const startTime = performance.now();
     try {
       const args = [];
       let command = "npx";
       switch (detectedFramework) {
+        case "maven": {
+          command = await mavenExecutable(projectDir);
+          args.push(coverage ? "verify" : "test");
+          if (extraArgs && extraArgs.length > 0) args.push(...extraArgs);
+          if (pattern) args.push(`-Dtest=${toMavenTestFilter(pattern)}`);
+          break;
+        }
+        case "gradle": {
+          command = await gradleExecutable(projectDir);
+          args.push("test");
+          if (extraArgs && extraArgs.length > 0) args.push(...extraArgs);
+          if (pattern) args.push("--tests", toGradleTestFilter(pattern));
+          if (coverage) args.push("jacocoTestReport");
+          break;
+        }
         case "vitest":
           args.push("vitest", "run");
           if (coverage) args.push("--coverage");
@@ -37969,8 +38299,8 @@ Examples:
       const duration = performance.now() - startTime;
       return parseTestResults(
         detectedFramework,
-        result.stdout,
-        result.stderr,
+        result.stdout ?? "",
+        result.stderr ?? "",
         result.exitCode ?? 0,
         duration
       );
@@ -37984,18 +38314,37 @@ Examples:
   }
 });
 function parseTestResults(framework, stdout, stderr, exitCode, duration) {
-  try {
-    const jsonMatch = stdout.match(/\{[\s\S]*\}/);
-    if (jsonMatch) {
-      const json2 = JSON.parse(jsonMatch[0]);
-      if (framework === "vitest" || framework === "jest") {
+  if (framework === "vitest" || framework === "jest") {
+    try {
+      const jsonMatch = stdout.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        const json2 = JSON.parse(jsonMatch[0]);
         return parseJestLikeResults(json2, duration);
       }
+    } catch {
     }
-  } catch {
   }
-  const passMatch = stdout.match(/(\d+)\s*(?:passed|passing)/i);
-  const failMatch = stdout.match(/(\d+)\s*(?:failed|failing)/i);
+  const mavenMatch = stdout.match(
+    /Tests run:\s*(\d+),\s*Failures:\s*(\d+),\s*Errors:\s*(\d+),\s*Skipped:\s*(\d+)/i
+  );
+  if (mavenMatch) {
+    const total = parseInt(mavenMatch[1] ?? "0", 10);
+    const failures = parseInt(mavenMatch[2] ?? "0", 10);
+    const errors = parseInt(mavenMatch[3] ?? "0", 10);
+    const skipped2 = parseInt(mavenMatch[4] ?? "0", 10);
+    const failed2 = failures + errors;
+    return {
+      passed: total - failed2 - skipped2,
+      failed: failed2,
+      skipped: skipped2,
+      total,
+      duration,
+      success: exitCode === 0,
+      failures: failed2 > 0 ? parseFailuresFromOutput(stderr || stdout) : []
+    };
+  }
+  const passMatch = stdout.match(/(\d+)\s*(?:passed|passing|tests\s+run)/i);
+  const failMatch = stdout.match(/(\d+)\s*(?:failed|failing|failures)/i);
   const skipMatch = stdout.match(/(\d+)\s*(?:skipped|pending)/i);
   const passed = passMatch ? parseInt(passMatch[1] ?? "0", 10) : 0;
   const failed = failMatch ? parseInt(failMatch[1] ?? "0", 10) : 0;
@@ -38052,6 +38401,37 @@ function parseFailuresFromOutput(output) {
   }
   return failures;
 }
+function parseJacocoCsvCoverage(csv) {
+  const lines = csv.trim().split("\n").slice(1);
+  if (lines.length === 0) return null;
+  let lineMissed = 0, lineCovered = 0;
+  let branchMissed = 0, branchCovered = 0;
+  let methodMissed = 0, methodCovered = 0;
+  let instrMissed = 0, instrCovered = 0;
+  for (const line of lines) {
+    const cols = line.split(",");
+    if (cols.length < 13) continue;
+    instrMissed += parseInt(cols[3] ?? "0", 10);
+    instrCovered += parseInt(cols[4] ?? "0", 10);
+    branchMissed += parseInt(cols[5] ?? "0", 10);
+    branchCovered += parseInt(cols[6] ?? "0", 10);
+    lineMissed += parseInt(cols[7] ?? "0", 10);
+    lineCovered += parseInt(cols[8] ?? "0", 10);
+    methodMissed += parseInt(cols[11] ?? "0", 10);
+    methodCovered += parseInt(cols[12] ?? "0", 10);
+  }
+  if (lineCovered + lineMissed === 0) return null;
+  const pct = (covered, missed) => {
+    const total = covered + missed;
+    return total > 0 ? Math.round(covered / total * 1e3) / 10 : 0;
+  };
+  return {
+    lines: pct(lineCovered, lineMissed),
+    branches: pct(branchCovered, branchMissed),
+    functions: pct(methodCovered, methodMissed),
+    statements: pct(instrCovered, instrMissed)
+  };
+}
 var getCoverageTool = defineTool({
   name: "get_coverage",
   description: `Get test coverage report (requires running tests with --coverage first).
@@ -38070,11 +38450,23 @@ Examples:
       const coverageLocations = [
         path36__default.join(projectDir, "coverage", "coverage-summary.json"),
         path36__default.join(projectDir, "coverage", "coverage-final.json"),
-        path36__default.join(projectDir, ".nyc_output", "coverage-summary.json")
+        path36__default.join(projectDir, ".nyc_output", "coverage-summary.json"),
+        // Maven JaCoCo
+        path36__default.join(projectDir, "target", "site", "jacoco", "jacoco.csv"),
+        path36__default.join(projectDir, "target", "site", "jacoco-ut", "jacoco.csv"),
+        // Gradle JaCoCo
+        path36__default.join(projectDir, "build", "reports", "jacoco", "test", "jacocoTestReport.csv")
       ];
       for (const location of coverageLocations) {
         try {
           const content = await fs34__default.readFile(location, "utf-8");
+          if (location.endsWith(".csv")) {
+            const result = parseJacocoCsvCoverage(content);
+            if (result) {
+              return { ...result, report: format === "detailed" ? content : void 0 };
+            }
+            continue;
+          }
           const coverage = JSON.parse(content);
           if (coverage.total) {
             return {
@@ -38088,9 +38480,10 @@ Examples:
         } catch {
         }
       }
-      throw new ToolError("Coverage data not found. Run tests with --coverage first.", {
-        tool: "get_coverage"
-      });
+      throw new ToolError(
+        "Coverage data not found. For Maven projects run 'mvn verify' with JaCoCo plugin. For Node.js run tests with --coverage.",
+        { tool: "get_coverage" }
+      );
     } catch (error) {
       if (error instanceof ToolError) throw error;
       const msg = error instanceof Error ? error.message : String(error);
@@ -38107,20 +38500,24 @@ var runTestFileTool = defineTool({
 
 Examples:
 - Single file: { "file": "src/utils.test.ts" }
-- With framework: { "file": "test/app.spec.js", "framework": "jest" }`,
+- Java test: { "file": "**/ItemRestControllerIT.java" }
+- With framework: { "file": "test/app.spec.js", "framework": "jest" }
+- Maven module: { "file": "**/MyTest.java", "args": ["-pl", "my-module"] }`,
   category: "test",
   parameters: z.object({
     cwd: z.string().optional().describe("Project directory"),
-    file: z.string().describe("Test file path"),
-    framework: z.string().optional().describe("Test framework")
+    file: z.string().describe("Test file path or class glob"),
+    framework: z.string().optional().describe("Test framework (maven, gradle, vitest, jest, mocha)"),
+    args: z.array(z.string()).optional().describe("Extra arguments (e.g. Maven -pl module)")
   }),
-  async execute({ cwd, file, framework }) {
+  async execute({ cwd, file, framework, args }) {
     return runTestsTool.execute({
       cwd,
       pattern: file,
       coverage: false,
       framework,
-      watch: false
+      watch: false,
+      args
     });
   }
 });
@@ -40119,7 +40516,7 @@ Examples:
       if (stats.isFile()) {
         filesToSearch = [targetPath];
       } else {
-        const globPattern = include ?? "**/*.{ts,tsx,js,jsx,json,md,txt}";
+        const globPattern = include ?? "**/*.{ts,tsx,js,jsx,java,py,go,rs,json,md,txt}";
         const defaultExclude = ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/coverage/**"];
         const excludePatterns = exclude ?? defaultExclude;
         filesToSearch = await glob(globPattern, {
@@ -40858,7 +41255,205 @@ ${message}
     }
   }
 });
-var buildTools = [runScriptTool, installDepsTool, makeTool, tscTool];
+async function resolveMaven(cwd) {
+  try {
+    await fs34__default.access(path36__default.join(cwd, "mvnw"));
+    return "./mvnw";
+  } catch {
+    return "mvn";
+  }
+}
+async function resolveGradle(cwd) {
+  try {
+    await fs34__default.access(path36__default.join(cwd, "gradlew"));
+    return "./gradlew";
+  } catch {
+    return "gradle";
+  }
+}
+var runMavenTool = defineTool({
+  name: "run_maven",
+  description: `Run a Maven goal (auto-detects ./mvnw wrapper).
+
+Examples:
+- Compile: { "goal": "compile" }
+- Run tests: { "goal": "test" }
+- Package: { "goal": "package" }
+- Skip tests: { "goal": "package", "args": ["-DskipTests"] }
+- Specific module: { "goal": "test", "args": ["-pl", "stock-core"] }
+- Quiet mode: { "goal": "verify", "args": ["-q", "--no-transfer-progress"] }`,
+  category: "build",
+  parameters: z.object({
+    goal: z.string().describe("Maven goal (compile, test, package, verify, clean, install, ...)"),
+    cwd: z.string().optional().describe("Project directory"),
+    args: z.array(z.string()).optional().describe("Additional Maven arguments"),
+    env: z.record(z.string(), z.string()).optional().describe("Environment variables"),
+    timeout: z.number().optional().describe("Timeout in milliseconds")
+  }),
+  async execute({ goal, cwd, args, env: env2, timeout }) {
+    const projectDir = cwd ?? process.cwd();
+    const startTime = performance.now();
+    const timeoutMs = timeout ?? DEFAULT_TIMEOUT_MS4;
+    const { CommandHeartbeat: CommandHeartbeat2 } = await Promise.resolve().then(() => (init_heartbeat(), heartbeat_exports));
+    const heartbeat = new CommandHeartbeat2({
+      onUpdate: (stats) => {
+        if (stats.elapsedSeconds > 10)
+          process.stderr.write(`\r\u23F1\uFE0F  ${stats.elapsedSeconds}s elapsed`);
+      },
+      onWarn: (message) => process.stderr.write(`
+${message}
+`)
+    });
+    try {
+      heartbeat.start();
+      const command = await resolveMaven(projectDir);
+      const cmdArgs = [goal, "--no-transfer-progress", "-B", ...args ?? []];
+      const subprocess = execa(command, cmdArgs, {
+        cwd: projectDir,
+        timeout: timeoutMs,
+        env: { ...process.env, ...env2 },
+        reject: false,
+        buffer: false,
+        maxBuffer: MAX_OUTPUT_SIZE2
+      });
+      let stdoutBuffer = "";
+      let stderrBuffer = "";
+      subprocess.stdout?.on("data", (chunk) => {
+        const text13 = chunk.toString();
+        stdoutBuffer += text13;
+        process.stdout.write(text13);
+        heartbeat.activity();
+      });
+      subprocess.stderr?.on("data", (chunk) => {
+        const text13 = chunk.toString();
+        stderrBuffer += text13;
+        process.stderr.write(text13);
+        heartbeat.activity();
+      });
+      const result = await subprocess;
+      const buildResult2 = {
+        success: result.exitCode === 0,
+        stdout: truncateOutput2(stdoutBuffer),
+        stderr: truncateOutput2(stderrBuffer),
+        exitCode: result.exitCode ?? 0,
+        duration: performance.now() - startTime
+      };
+      if (!buildResult2.success) {
+        buildResult2.hint = getBuildHint(stderrBuffer || stdoutBuffer, "run_maven");
+      }
+      return buildResult2;
+    } catch (error) {
+      if (error.timedOut) {
+        throw new TimeoutError(`Maven goal '${goal}' timed out after ${timeoutMs}ms`, {
+          timeoutMs,
+          operation: `mvn ${goal}`
+        });
+      }
+      throw new ToolError(
+        `Maven failed: ${error instanceof Error ? error.message : String(error)}`,
+        { tool: "run_maven", cause: error instanceof Error ? error : void 0 }
+      );
+    } finally {
+      heartbeat.stop();
+      process.stderr.write("\r                                        \r");
+    }
+  }
+});
+var runGradleTool = defineTool({
+  name: "run_gradle",
+  description: `Run a Gradle task (auto-detects ./gradlew wrapper).
+
+Examples:
+- Build: { "task": "build" }
+- Run tests: { "task": "test" }
+- Assemble: { "task": "assemble" }
+- Skip tests: { "task": "build", "args": ["-x", "test"] }
+- Specific subproject: { "task": ":stock-core:test" }`,
+  category: "build",
+  parameters: z.object({
+    task: z.string().describe("Gradle task (build, test, assemble, clean, check, ...)"),
+    cwd: z.string().optional().describe("Project directory"),
+    args: z.array(z.string()).optional().describe("Additional Gradle arguments"),
+    env: z.record(z.string(), z.string()).optional().describe("Environment variables"),
+    timeout: z.number().optional().describe("Timeout in milliseconds")
+  }),
+  async execute({ task, cwd, args, env: env2, timeout }) {
+    const projectDir = cwd ?? process.cwd();
+    const startTime = performance.now();
+    const timeoutMs = timeout ?? DEFAULT_TIMEOUT_MS4;
+    const { CommandHeartbeat: CommandHeartbeat2 } = await Promise.resolve().then(() => (init_heartbeat(), heartbeat_exports));
+    const heartbeat = new CommandHeartbeat2({
+      onUpdate: (stats) => {
+        if (stats.elapsedSeconds > 10)
+          process.stderr.write(`\r\u23F1\uFE0F  ${stats.elapsedSeconds}s elapsed`);
+      },
+      onWarn: (message) => process.stderr.write(`
+${message}
+`)
+    });
+    try {
+      heartbeat.start();
+      const command = await resolveGradle(projectDir);
+      const cmdArgs = [task, "--console=plain", ...args ?? []];
+      const subprocess = execa(command, cmdArgs, {
+        cwd: projectDir,
+        timeout: timeoutMs,
+        env: { ...process.env, ...env2 },
+        reject: false,
+        buffer: false,
+        maxBuffer: MAX_OUTPUT_SIZE2
+      });
+      let stdoutBuffer = "";
+      let stderrBuffer = "";
+      subprocess.stdout?.on("data", (chunk) => {
+        const text13 = chunk.toString();
+        stdoutBuffer += text13;
+        process.stdout.write(text13);
+        heartbeat.activity();
+      });
+      subprocess.stderr?.on("data", (chunk) => {
+        const text13 = chunk.toString();
+        stderrBuffer += text13;
+        process.stderr.write(text13);
+        heartbeat.activity();
+      });
+      const result = await subprocess;
+      const buildResult2 = {
+        success: result.exitCode === 0,
+        stdout: truncateOutput2(stdoutBuffer),
+        stderr: truncateOutput2(stderrBuffer),
+        exitCode: result.exitCode ?? 0,
+        duration: performance.now() - startTime
+      };
+      if (!buildResult2.success) {
+        buildResult2.hint = getBuildHint(stderrBuffer || stdoutBuffer, "run_gradle");
+      }
+      return buildResult2;
+    } catch (error) {
+      if (error.timedOut) {
+        throw new TimeoutError(`Gradle task '${task}' timed out after ${timeoutMs}ms`, {
+          timeoutMs,
+          operation: `gradle ${task}`
+        });
+      }
+      throw new ToolError(
+        `Gradle failed: ${error instanceof Error ? error.message : String(error)}`,
+        { tool: "run_gradle", cause: error instanceof Error ? error : void 0 }
+      );
+    } finally {
+      heartbeat.stop();
+      process.stderr.write("\r                                        \r");
+    }
+  }
+});
+var buildTools = [
+  runScriptTool,
+  installDepsTool,
+  makeTool,
+  tscTool,
+  runMavenTool,
+  runGradleTool
+];
 
 // src/tools/permissions.ts
 init_registry4();
@@ -47923,11 +48518,21 @@ async function executeAgentTurn(session, userMessage, provider, toolRegistry, op
         break;
       }
     }
-    const inputText = messages.map((m) => typeof m.content === "string" ? m.content : JSON.stringify(m.content)).join("\n");
+    const inputText = messages.map((m) => {
+      if (typeof m.content === "string") return m.content;
+      try {
+        return JSON.stringify(m.content);
+      } catch {
+        return "";
+      }
+    }).join("\n");
     const estimatedInputTokens = provider.countTokens(inputText);
-    const estimatedOutputTokens = provider.countTokens(
-      responseContent + JSON.stringify(collectedToolCalls)
-    );
+    let serializedToolCalls = "";
+    try {
+      serializedToolCalls = JSON.stringify(collectedToolCalls);
+    } catch {
+    }
+    const estimatedOutputTokens = provider.countTokens(responseContent + serializedToolCalls);
     totalInputTokens += estimatedInputTokens;
     totalOutputTokens += estimatedOutputTokens;
     if (collectedToolCalls.length === 0) {
@@ -49419,7 +50024,8 @@ async function startRepl(options = {}) {
           const compactionResult = await checkAndCompactContext(
             session,
             provider,
-            compactAbort.signal
+            compactAbort.signal,
+            toolRegistry
           );
           if (compactionResult?.wasCompacted) {
             usageForDisplay = getContextUsagePercent(session);