@corbat-tech/coco 2.14.1 → 2.15.0

package/dist/index.js

@@ -3972,6 +3972,18 @@ function trackSubprocess(proc) {
 
 // src/quality/analyzers/coverage.ts
 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");
@@ -4033,6 +4045,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 = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
@@ -4042,29 +4103,53 @@ var CoverageAnalyzer = class {
    */
   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 path40 of possiblePaths) {
+    for (const p5 of possiblePaths) {
       try {
-        await access(path40, constants.R_OK);
-        const content = await readFile(path40, "utf-8");
+        await access(p5, constants.R_OK);
+        const content = await readFile(p5, "utf-8");
         const report = JSON.parse(content);
         return parseCoverageSummary(report);
       } catch {
@@ -4724,7 +4809,7 @@ var BuildVerifier = class {
           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(buildCommand.trim())) {
         return {
           success: false,
@@ -4829,9 +4914,20 @@ var BuildVerifier = class {
     }
   }
   /**
-   * 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(path17.join(this.projectPath, "pom.xml"))) {
+      const wrapper = path17.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(path17.join(this.projectPath, f))) {
+        const wrapper = path17.join(this.projectPath, "gradlew");
+        return await this.fileExists(wrapper) ? "./gradlew classes -q" : "gradle classes -q";
+      }
+    }
     try {
       const packageJsonPath = path17.join(this.projectPath, "package.json");
       const content = await fs16.readFile(packageJsonPath, "utf-8");
@@ -4842,10 +4938,9 @@ var BuildVerifier = class {
       if (packageJson.devDependencies?.typescript || packageJson.dependencies?.typescript) {
         return "npx tsc --noEmit";
       }
-      return null;
     } catch {
-      return null;
     }
+    return null;
   }
   /**
    * Parse errors from build output
@@ -4919,6 +5014,16 @@ var BuildVerifier = class {
 };
 
 // src/quality/analyzers/correctness.ts
+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)?/
@@ -4971,10 +5076,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 = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
@@ -5026,6 +5150,11 @@ var CorrectnessAnalyzer = class {
     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,
@@ -5037,15 +5166,15 @@ var CorrectnessAnalyzer = class {
       });
       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,
@@ -5055,6 +5184,9 @@ var CorrectnessAnalyzer = class {
             return { passed: 0, failed: 0, skipped: 0 };
           }
         }
+        case "maven":
+        case "gradle":
+          return parseMavenOutput(output);
         default:
           return { passed: 0, failed: 0, skipped: 0 };
       }
@@ -7854,9 +7986,31 @@ var QualityEvaluator = class {
     return suggestions;
   }
   /**
-   * Find source files in project
+   * Find source files in project, adapting to the detected language stack.
    */
   async findSourceFiles() {
+    const { access: access10 } = await import('fs/promises');
+    const { join: join18 } = await import('path');
+    let isJava = false;
+    try {
+      await access10(join18(this.projectPath, "pom.xml"));
+      isJava = true;
+    } catch {
+      for (const f of ["build.gradle", "build.gradle.kts"]) {
+        try {
+          await access10(join18(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,
@@ -17482,6 +17636,18 @@ var checkAgentCapabilityTool = defineTool({
 });
 var simpleAgentTools = [spawnSimpleAgentTool, checkAgentCapabilityTool];
 async function detectTestFramework2(cwd) {
+  try {
+    await fs16__default.access(path17__default.join(cwd, "pom.xml"));
+    return "maven";
+  } catch {
+  }
+  for (const gradleFile of ["build.gradle", "build.gradle.kts"]) {
+    try {
+      await fs16__default.access(path17__default.join(cwd, gradleFile));
+      return "gradle";
+    } catch {
+    }
+  }
   try {
     const pkgPath = path17__default.join(cwd, "package.json");
     const pkgContent = await fs16__default.readFile(pkgPath, "utf-8");
@@ -17499,36 +17665,79 @@ async function detectTestFramework2(cwd) {
     return null;
   }
 }
+function toMavenTestFilter(pattern) {
+  const base = path17__default.basename(pattern).replace(/\.java$/, "");
+  return base;
+}
+function toGradleTestFilter(pattern) {
+  const base = path17__default.basename(pattern).replace(/\.java$/, "");
+  return `*${base}`;
+}
+async function mavenExecutable(cwd) {
+  try {
+    await fs16__default.access(path17__default.join(cwd, "mvnw"));
+    return "./mvnw";
+  } catch {
+    return "mvn";
+  }
+}
+async function gradleExecutable(cwd) {
+  try {
+    await fs16__default.access(path17__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: watch2 }) {
+  async execute({ cwd, pattern, coverage, framework, watch: watch2, 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");
@@ -17566,8 +17775,8 @@ Examples:
       const duration = performance.now() - startTime;
       return parseTestResults(
         detectedFramework,
-        result.stdout,
-        result.stderr,
+        result.stdout ?? "",
+        result.stderr ?? "",
         result.exitCode ?? 0,
         duration
       );
@@ -17581,18 +17790,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;
@@ -17649,6 +17877,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).
@@ -17667,11 +17926,23 @@ Examples:
       const coverageLocations = [
         path17__default.join(projectDir, "coverage", "coverage-summary.json"),
         path17__default.join(projectDir, "coverage", "coverage-final.json"),
-        path17__default.join(projectDir, ".nyc_output", "coverage-summary.json")
+        path17__default.join(projectDir, ".nyc_output", "coverage-summary.json"),
+        // Maven JaCoCo
+        path17__default.join(projectDir, "target", "site", "jacoco", "jacoco.csv"),
+        path17__default.join(projectDir, "target", "site", "jacoco-ut", "jacoco.csv"),
+        // Gradle JaCoCo
+        path17__default.join(projectDir, "build", "reports", "jacoco", "test", "jacocoTestReport.csv")
       ];
       for (const location of coverageLocations) {
         try {
           const content = await fs16__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 {
@@ -17685,9 +17956,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);
@@ -17704,25 +17976,41 @@ 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
     });
   }
 });
 var testTools = [runTestsTool, getCoverageTool, runTestFileTool];
 async function detectLinter2(cwd) {
+  try {
+    await fs16__default.access(path17__default.join(cwd, "pom.xml"));
+    return "maven-checkstyle";
+  } catch {
+  }
+  for (const f of ["build.gradle", "build.gradle.kts"]) {
+    try {
+      await fs16__default.access(path17__default.join(cwd, f));
+      return "gradle-checkstyle";
+    } catch {
+    }
+  }
   try {
     const pkgPath = path17__default.join(cwd, "package.json");
     const pkgContent = await fs16__default.readFile(pkgPath, "utf-8");
@@ -17739,21 +18027,60 @@ async function detectLinter2(cwd) {
     return null;
   }
 }
+async function mavenExec(cwd) {
+  try {
+    await fs16__default.access(path17__default.join(cwd, "mvnw"));
+    return "./mvnw";
+  } catch {
+    return "mvn";
+  }
+}
+async function gradleExec(cwd) {
+  try {
+    await fs16__default.access(path17__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 };
+}
 var 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();
@@ -17766,13 +18093,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) {
@@ -17813,7 +18150,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)}`,
@@ -17916,6 +18271,28 @@ Examples:
 });
 async function findSourceFiles(cwd) {
   const { glob: glob17 } = await import('glob');
+  let isJava = false;
+  try {
+    await fs16__default.access(path17__default.join(cwd, "pom.xml"));
+    isJava = true;
+  } catch {
+  }
+  if (!isJava) {
+    for (const f of ["build.gradle", "build.gradle.kts"]) {
+      try {
+        await fs16__default.access(path17__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,
@@ -17933,6 +18310,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) {
@@ -18061,7 +18440,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, {
@@ -18791,7 +19170,205 @@ ${message}
     }
   }
 });
-var buildTools = [runScriptTool, installDepsTool, makeTool, tscTool];
+async function resolveMaven(cwd) {
+  try {
+    await fs16__default.access(path17__default.join(cwd, "mvnw"));
+    return "./mvnw";
+  } catch {
+    return "mvn";
+  }
+}
+async function resolveGradle(cwd) {
+  try {
+    await fs16__default.access(path17__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 text = chunk.toString();
+        stdoutBuffer += text;
+        process.stdout.write(text);
+        heartbeat.activity();
+      });
+      subprocess.stderr?.on("data", (chunk) => {
+        const text = chunk.toString();
+        stderrBuffer += text;
+        process.stderr.write(text);
+        heartbeat.activity();
+      });
+      const result = await subprocess;
+      const buildResult = {
+        success: result.exitCode === 0,
+        stdout: truncateOutput2(stdoutBuffer),
+        stderr: truncateOutput2(stderrBuffer),
+        exitCode: result.exitCode ?? 0,
+        duration: performance.now() - startTime
+      };
+      if (!buildResult.success) {
+        buildResult.hint = getBuildHint(stderrBuffer || stdoutBuffer, "run_maven");
+      }
+      return buildResult;
+    } 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 text = chunk.toString();
+        stdoutBuffer += text;
+        process.stdout.write(text);
+        heartbeat.activity();
+      });
+      subprocess.stderr?.on("data", (chunk) => {
+        const text = chunk.toString();
+        stderrBuffer += text;
+        process.stderr.write(text);
+        heartbeat.activity();
+      });
+      const result = await subprocess;
+      const buildResult = {
+        success: result.exitCode === 0,
+        stdout: truncateOutput2(stdoutBuffer),
+        stderr: truncateOutput2(stderrBuffer),
+        exitCode: result.exitCode ?? 0,
+        duration: performance.now() - startTime
+      };
+      if (!buildResult.success) {
+        buildResult.hint = getBuildHint(stderrBuffer || stdoutBuffer, "run_gradle");
+      }
+      return buildResult;
+    } 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/cli/repl/recommended-permissions.ts
 init_paths();