@nolans01/agent-validator 0.1.0 → 0.2.0

package/dist/index.js

@@ -97,11 +97,20 @@ async function resolveFileList(options) {
   }
   return resolved;
 }
+var DEFAULT_EXCLUDE = [
+  "**/node_modules/**",
+  "**/vendor/**",
+  "**/venv/**",
+  "**/.venv/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/coverage/**",
+  "**/.git/**"
+];
 async function resolveDirectory(options) {
   const dirs = options.targets ?? ["."];
   const patterns = dirs.map((d) => `${d}/**/*`);
-  const defaultExclude = ["**/node_modules/**", "**/dist/**", "**/.git/**"];
-  const ignore = [...defaultExclude, ...options.exclude ?? []];
+  const ignore = [...DEFAULT_EXCLUDE, ...options.exclude ?? []];
   return glob(patterns, {
     cwd: options.workdir,
     nodir: true,
@@ -248,6 +257,101 @@ function buildMypyWhy(severity, code) {
   return parts.join(" ");
 }
 
+// src/adapters/ruby-syntax.ts
+import { execa as execa5 } from "execa";
+
+// src/utils.ts
+function chunk(arr, size) {
+  if (size <= 0) return [arr];
+  const chunks = [];
+  for (let i = 0; i < arr.length; i += size) {
+    chunks.push(arr.slice(i, i + size));
+  }
+  return chunks;
+}
+
+// src/adapters/ruby-syntax.ts
+var RUBY_SYNTAX_LINE = /^(.*?):(\d+):.*(?:syntax error|unterminated|unexpected)/i;
+var RubySyntaxAdapter = class {
+  name = "ruby";
+  supportedLanguages = ["ruby"];
+  async isAvailable() {
+    return isBinaryAvailable("ruby");
+  }
+  async run(files, config) {
+    const findings = [];
+    for (const batch of chunk(files, 8)) {
+      const results = await Promise.all(batch.map(async (file) => ({
+        file,
+        result: await execa5("ruby", ["-c", file], {
+          cwd: config.workdir,
+          reject: false
+        })
+      })));
+      for (const { file, result } of results) {
+        if (result.exitCode === 0) continue;
+        findings.push(buildSyntaxFinding(file, `${result.stderr}
+${result.stdout}`));
+      }
+    }
+    return { findings };
+  }
+};
+function buildSyntaxFinding(file, output) {
+  const relevantLine = output.split("\n").find((line) => RUBY_SYNTAX_LINE.test(line));
+  const match = relevantLine ? RUBY_SYNTAX_LINE.exec(relevantLine) : null;
+  return {
+    file: match?.[1] || file,
+    line: match ? Number.parseInt(match[2], 10) : 0,
+    severity: "blocker",
+    metric: "ruby_syntax",
+    message: relevantLine?.trim() || `Ruby could not parse ${file}`,
+    why: "Ruby files must parse successfully before Rails can load the application.",
+    suggestion: "Fix the reported Ruby syntax error.",
+    metadata: { source: "ruby" }
+  };
+}
+
+// src/adapters/zeitwerk.ts
+import fs3 from "fs";
+import path4 from "path";
+import { execa as execa6 } from "execa";
+var ZeitwerkAdapter = class {
+  name = "zeitwerk";
+  supportedLanguages = ["ruby"];
+  isRailsProject(workdir) {
+    return fs3.existsSync(path4.join(workdir, "Gemfile")) && fs3.existsSync(path4.join(workdir, "config", "application.rb"));
+  }
+  async isAvailable() {
+    return isBinaryAvailable("bundle");
+  }
+  async run(_files, config) {
+    const result = await execa6("bundle", ["exec", "rails", "zeitwerk:check"], {
+      cwd: config.workdir,
+      env: { RAILS_ENV: "test" },
+      reject: false
+    });
+    if (result.exitCode === 0) return { findings: [] };
+    const detail = lastOutputLine(`${result.stderr}
+${result.stdout}`);
+    return {
+      findings: [{
+        file: "config/application.rb",
+        line: 0,
+        severity: "blocker",
+        metric: "rails_zeitwerk",
+        message: detail ? `Rails Zeitwerk check failed: ${detail}` : "Rails Zeitwerk check failed",
+        why: "Rails must boot and autoload application constants consistently.",
+        suggestion: "Run RAILS_ENV=test bundle exec rails zeitwerk:check in the project environment.",
+        metadata: { source: "zeitwerk", exitCode: result.exitCode }
+      }]
+    };
+  }
+};
+function lastOutputLine(output) {
+  return output.split("\n").map((line) => line.trim()).filter(Boolean).at(-1)?.slice(0, 500);
+}
+
 // src/scorer.ts
 function calculateComplexityScore(input) {
   if (input.totalFunctions === 0) return 100;
@@ -318,7 +422,7 @@ function calculateTestQualityScore(input) {
 }
 function overallStatus(results) {
   if (results.some((r) => r.status === "fail")) return "fail";
-  if (results.some((r) => r.status === "warn")) return "warn";
+  if (results.some((r) => r.status === "warn" || r.status === "skip")) return "warn";
   return "pass";
 }
 
@@ -331,11 +435,14 @@ var DEFAULT_COMPLEXITY = {
 };
 var DEFAULT_SECURITY = {
   semgrepRules: ["p/security-audit", "p/secrets"],
-  gitleaksEnabled: true
+  gitleaksEnabled: true,
+  brakemanEnabled: true
 };
 var DEFAULT_TYPE_SAFETY = {
   strict: false,
-  mypyEnabled: true
+  mypyEnabled: true,
+  rubySyntaxEnabled: true,
+  railsZeitwerkEnabled: true
 };
 var DEFAULT_JSCPD_EXCLUDE = [
   "**/test/**",
@@ -391,6 +498,8 @@ var TypeSafetyGate = class {
   name = "type_safety";
   tsc = new TscAdapter();
   mypy = new MypyAdapter();
+  ruby = new RubySyntaxAdapter();
+  zeitwerk = new ZeitwerkAdapter();
   async run(ctx) {
     const start = Date.now();
     const config = ctx.config.typeSafety ?? DEFAULT_TYPE_SAFETY;
@@ -400,6 +509,9 @@ var TypeSafetyGate = class {
     if (ctx.language === "python" && config.mypyEnabled) {
       return this.runMypy(ctx, config, start);
     }
+    if (ctx.language === "ruby" && config.rubySyntaxEnabled !== false) {
+      return this.runRuby(ctx, config, start);
+    }
     const suggestion = ctx.language === "python" ? "Enable mypyEnabled in profile or install mypy: pip install mypy" : "No type checker supported for this language yet.";
     return toolMissingResult(this.name, start, `No type checker available for language: ${ctx.language}`, suggestion);
   }
@@ -440,6 +552,44 @@ var TypeSafetyGate = class {
     const result = await this.mypy.run(files, adapterConfig);
     return this.buildResult(result.findings, start);
   }
+  async runRuby(ctx, config, start) {
+    if (!await this.ruby.isAvailable()) {
+      return toolMissingResult(
+        this.name,
+        start,
+        "Ruby is not installed in the validation environment",
+        "Run the validator from the project Ruby/Docker environment."
+      );
+    }
+    const files = this.getFiles(ctx, this.ruby);
+    if (files.length === 0) return this.emptyResult(start);
+    const adapterConfig = { workdir: ctx.workdir, thresholds: {} };
+    const syntaxResult = await this.ruby.run(files, adapterConfig);
+    const findings = [...syntaxResult.findings];
+    if (findings.length > 0) return this.buildResult(findings, start);
+    if (config.railsZeitwerkEnabled !== false && this.zeitwerk.isRailsProject(ctx.workdir)) {
+      if (await this.zeitwerk.isAvailable()) {
+        const zeitwerkResult = await this.zeitwerk.run(files, adapterConfig);
+        findings.push(...zeitwerkResult.findings);
+      } else {
+        findings.push({
+          file: "Gemfile",
+          line: 0,
+          severity: "warning",
+          metric: "rails_check_skipped",
+          message: "Rails Zeitwerk check was skipped because Bundler is unavailable",
+          why: "Ruby syntax alone does not verify that Rails can boot and autoload constants.",
+          suggestion: "Run the validator inside the project Docker image with Bundler available.",
+          metadata: { source: "zeitwerk" }
+        });
+      }
+    }
+    const result = this.buildResult(findings, start);
+    if (findings.some((finding) => finding.metric === "rails_check_skipped") && result.status === "pass") {
+      result.status = "warn";
+    }
+    return result;
+  }
   buildResult(findings, start) {
     const score = calculateTypeSafetyScore({ findings });
     const status = deriveStatus(score, findings);
@@ -448,19 +598,7 @@ var TypeSafetyGate = class {
 };
 
 // src/adapters/lizard.ts
-import { execa as execa5 } from "execa";
-
-// src/utils.ts
-function chunk(arr, size) {
-  if (size <= 0) return [arr];
-  const chunks = [];
-  for (let i = 0; i < arr.length; i += size) {
-    chunks.push(arr.slice(i, i + size));
-  }
-  return chunks;
-}
-
-// src/adapters/lizard.ts
+import { execa as execa7 } from "execa";
 var LizardAdapter = class {
   name = "lizard";
   supportedLanguages = [
@@ -481,7 +619,7 @@ var LizardAdapter = class {
     const allFindings = [];
     let totalFunctions = 0;
     for (const batch of chunk(files, 50)) {
-      const result = await execa5("lizard", [...batch, "--csv"], {
+      const result = await execa7("lizard", [...batch, "--csv"], {
         cwd: config.workdir,
         reject: false
       });
@@ -641,7 +779,7 @@ var ComplexityGate = class {
 };
 
 // src/adapters/semgrep.ts
-import { execa as execa6 } from "execa";
+import { execa as execa8 } from "execa";
 var SemgrepAdapter = class {
   name = "semgrep";
   supportedLanguages = [
@@ -663,15 +801,17 @@ var SemgrepAdapter = class {
     const allFindings = [];
     for (const batch of chunk(files, 50)) {
       const configArgs = rules.flatMap((r) => ["--config", r]);
-      const result = await execa6(
+      const result = await execa8(
         "semgrep",
         [...configArgs, "--json", ...batch],
         { cwd: config.workdir, reject: false }
       );
-      if (result.stdout) {
-        const parsed = parseSemgrepJson(result.stdout);
-        allFindings.push(...parsed);
+      const parsed = parseSemgrepJson(result.stdout || "");
+      if (!parsed || ![0, 1].includes(result.exitCode ?? -1) || parsed.errors.length > 0) {
+        allFindings.push(toolErrorFinding(result.exitCode));
+        continue;
       }
+      allFindings.push(...parsed.findings);
     }
     return { findings: allFindings };
   }
@@ -681,12 +821,12 @@ function parseSemgrepJson(json) {
   try {
     output = JSON.parse(json);
   } catch {
-    return [];
+    return null;
   }
   if (!output.results || !Array.isArray(output.results)) {
-    return [];
+    return null;
   }
-  return output.results.map((r) => ({
+  const findings = output.results.map((r) => ({
     file: r.path,
     line: r.start.line,
     end_line: r.end.line,
@@ -703,6 +843,19 @@ function parseSemgrepJson(json) {
       source: "semgrep"
     }
   }));
+  return { findings, errors: Array.isArray(output.errors) ? output.errors : [] };
+}
+function toolErrorFinding(exitCode) {
+  return {
+    file: "",
+    line: 0,
+    severity: "blocker",
+    metric: "security_tool_error",
+    message: "Semgrep failed or produced an invalid report",
+    why: "A failed security scan cannot be interpreted as having no vulnerabilities.",
+    suggestion: "Run Semgrep directly and verify network access, rules, and JSON output.",
+    metadata: { source: "semgrep", exitCode }
+  };
 }
 function mapSeverity(severity) {
   switch (severity) {
@@ -731,7 +884,10 @@ function buildWhy2(result) {
 }
 
 // src/adapters/gitleaks.ts
-import { execa as execa7 } from "execa";
+import { execa as execa9 } from "execa";
+import fs4 from "fs";
+import os from "os";
+import path5 from "path";
 var GitleaksAdapter = class {
   name = "gitleaks";
   supportedLanguages = [
@@ -746,19 +902,32 @@ var GitleaksAdapter = class {
   async isAvailable() {
     return isBinaryAvailable("gitleaks");
   }
-  async run(files, config) {
-    const result = await execa7(
-      "gitleaks",
-      ["detect", "--source", config.workdir, "--no-git", "-f", "json", "--report-path", "/dev/stdout"],
-      { cwd: config.workdir, reject: false }
-    );
-    if (!result.stdout || result.stdout.trim() === "") {
-      return { findings: [] };
+  async run(_files, config) {
+    const reportDirectory = fs4.mkdtempSync(path5.join(os.tmpdir(), "validator-gitleaks-"));
+    const reportPath = path5.join(reportDirectory, "report.json");
+    try {
+      const result = await execa9(
+        "gitleaks",
+        ["detect", "--source", config.workdir, "--no-git", "-f", "json", "--report-path", reportPath],
+        { cwd: config.workdir, reject: false }
+      );
+      const output = fs4.existsSync(reportPath) ? fs4.readFileSync(reportPath, "utf8") : result.stdout;
+      if ((!output || output.trim() === "") && result.exitCode === 0) {
+        return { findings: [] };
+      }
+      const allLeaks = parseGitleaksJson(output);
+      if (!allLeaks || ![0, 1].includes(result.exitCode ?? -1)) {
+        return { findings: [toolErrorFinding2(result.exitCode)] };
+      }
+      return {
+        findings: allLeaks.map((finding) => ({
+          ...finding,
+          file: path5.isAbsolute(finding.file) ? path5.relative(config.workdir, finding.file) : finding.file
+        }))
+      };
+    } finally {
+      fs4.rmSync(reportDirectory, { recursive: true, force: true });
     }
-    const allLeaks = parseGitleaksJson(result.stdout);
-    const fileSet = new Set(files);
-    const filtered = allLeaks.filter((f) => fileSet.has(f.file));
-    return { findings: filtered };
   }
 };
 function parseGitleaksJson(json) {
@@ -766,10 +935,10 @@ function parseGitleaksJson(json) {
   try {
     leaks = JSON.parse(json);
   } catch {
-    return [];
+    return null;
   }
   if (!Array.isArray(leaks)) {
-    return [];
+    return null;
   }
   return leaks.map((leak) => ({
     file: leak.File,
@@ -788,21 +957,112 @@ function parseGitleaksJson(json) {
     }
   }));
 }
+function toolErrorFinding2(exitCode) {
+  return {
+    file: "",
+    line: 0,
+    severity: "blocker",
+    metric: "security_tool_error",
+    message: "Gitleaks failed or produced an invalid report",
+    why: "A failed secret scan cannot be interpreted as having no exposed credentials.",
+    suggestion: "Run Gitleaks directly and verify its configuration and JSON output.",
+    metadata: { source: "gitleaks", exitCode }
+  };
+}
+
+// src/adapters/brakeman.ts
+import fs5 from "fs";
+import path6 from "path";
+import { execa as execa10 } from "execa";
+var BrakemanAdapter = class {
+  name = "brakeman";
+  supportedLanguages = ["ruby"];
+  isRailsProject(workdir) {
+    return fs5.existsSync(path6.join(workdir, "Gemfile")) && fs5.existsSync(path6.join(workdir, "config", "application.rb"));
+  }
+  async isAvailable() {
+    return isBinaryAvailable("brakeman");
+  }
+  async run(_files, config) {
+    const result = await execa10(
+      "brakeman",
+      ["--format", "json", "--quiet", "--no-exit-on-warn"],
+      { cwd: config.workdir, reject: false }
+    );
+    const report = parseReport(result.stdout || "");
+    if (!report || result.exitCode !== 0 || report.errors?.length) {
+      return { findings: [toolErrorFinding3(result.exitCode)] };
+    }
+    return { findings: report.warnings.map(toFinding) };
+  }
+};
+function parseReport(output) {
+  try {
+    const report = JSON.parse(output);
+    return Array.isArray(report.warnings) ? report : null;
+  } catch {
+    return null;
+  }
+}
+function toFinding(warning) {
+  return {
+    file: warning.file,
+    line: warning.line ?? 0,
+    severity: warning.confidence === "High" ? "blocker" : warning.confidence === "Medium" ? "warning" : "info",
+    metric: "rails_security",
+    message: warning.message,
+    why: `${warning.warning_type} detected by Brakeman's ${warning.check_name} check.`,
+    suggestion: "Review the affected Rails code and apply the mitigation recommended by Brakeman.",
+    metadata: {
+      source: "brakeman",
+      warningCode: warning.warning_code,
+      fingerprint: warning.fingerprint,
+      confidence: warning.confidence
+    }
+  };
+}
+function toolErrorFinding3(exitCode) {
+  return {
+    file: "",
+    line: 0,
+    severity: "blocker",
+    metric: "security_tool_error",
+    message: "Brakeman failed or produced an invalid report",
+    why: "A failed Rails security scan cannot be interpreted as having no vulnerabilities.",
+    suggestion: "Run brakeman --format json --no-exit-on-warn directly and fix the reported execution error.",
+    metadata: { source: "brakeman", exitCode }
+  };
+}
 
 // src/gates/security.ts
 var SecurityGate = class {
   name = "security";
   semgrep = new SemgrepAdapter();
   gitleaks = new GitleaksAdapter();
+  brakeman = new BrakemanAdapter();
   async run(ctx) {
     const start = Date.now();
     const securityConfig = ctx.config.security ?? DEFAULT_SECURITY;
     const semgrepAvailable = await this.semgrep.isAvailable();
     const gitleaksAvailable = securityConfig.gitleaksEnabled ? await this.gitleaks.isAvailable() : false;
-    if (!semgrepAvailable && !gitleaksAvailable) {
-      return toolMissingResult(this.name, start, "Neither semgrep nor gitleaks is installed", "Install with: pip install semgrep OR brew install gitleaks");
+    const brakemanApplicable = ctx.language === "ruby" && securityConfig.brakemanEnabled !== false && this.brakeman.isRailsProject(ctx.workdir);
+    const brakemanAvailable = brakemanApplicable ? await this.brakeman.isAvailable() : false;
+    if (!semgrepAvailable && !gitleaksAvailable && !brakemanAvailable) {
+      return toolMissingResult(this.name, start, "No security tools are installed", "Install Semgrep, Gitleaks, or Brakeman.");
     }
     const allFindings = [];
+    if (brakemanApplicable && !brakemanAvailable) {
+      allFindings.push({
+        file: "Gemfile",
+        line: 0,
+        severity: "info",
+        metric: "rails_security_skipped",
+        message: "Brakeman is not installed; Rails-specific security checks were skipped",
+        why: "Generic security rules do not cover all Rails-specific vulnerability patterns.",
+        suggestion: "Install Brakeman or use the Rails validator image.",
+        metadata: { source: "brakeman" }
+      });
+    }
     if (semgrepAvailable) {
       const supportedFiles = ctx.files.filter((f) => this.semgrep.supportedLanguages.includes(f.language)).map((f) => f.relativePath);
       if (supportedFiles.length > 0) {
@@ -823,15 +1083,23 @@ var SecurityGate = class {
       });
       allFindings.push(...result.findings);
     }
+    if (brakemanAvailable) {
+      const result = await this.brakeman.run([], {
+        workdir: ctx.workdir,
+        thresholds: {}
+      });
+      allFindings.push(...result.findings);
+    }
     const score = calculateSecurityScore({ findings: allFindings });
-    const status = deriveStatus(score, allFindings);
+    const derivedStatus = deriveStatus(score, allFindings);
+    const status = allFindings.some((finding) => finding.metric === "rails_security_skipped") && derivedStatus === "pass" ? "warn" : derivedStatus;
     const duration_ms = Date.now() - start;
     return { gate: this.name, score, status, duration_ms, findings: allFindings };
   }
 };
 
 // src/adapters/madge.ts
-import { execa as execa8 } from "execa";
+import { execa as execa11 } from "execa";
 function parseCycles(stdout) {
   if (!stdout.trim()) return null;
   try {
@@ -863,7 +1131,7 @@ var MadgeAdapter = class {
   }
   async run(files, config) {
     if (files.length === 0) return { findings: [] };
-    const result = await execa8("madge", ["--circular", "--json", config.workdir], {
+    const result = await execa11("madge", ["--circular", "--json", config.workdir], {
       cwd: config.workdir,
       reject: false
     });
@@ -876,10 +1144,10 @@ var MadgeAdapter = class {
 };
 
 // src/adapters/jscpd.ts
-import { execa as execa9 } from "execa";
-import fs3 from "fs";
-import os from "os";
-import path4 from "path";
+import { execa as execa12 } from "execa";
+import fs6 from "fs";
+import os2 from "os";
+import path7 from "path";
 function buildArgs(config, tmpDir) {
   const minLines = config.minLines ?? 5;
   const minTokens = config.minTokens ?? 50;
@@ -901,9 +1169,9 @@ function buildArgs(config, tmpDir) {
   args.push(config.workdir);
   return args;
 }
-function parseReport(reportPath) {
-  if (!fs3.existsSync(reportPath)) return null;
-  const raw = fs3.readFileSync(reportPath, "utf-8");
+function parseReport2(reportPath) {
+  if (!fs6.existsSync(reportPath)) return null;
+  const raw = fs6.readFileSync(reportPath, "utf-8");
   try {
     const report = JSON.parse(raw);
     if (!report.duplicates || !Array.isArray(report.duplicates)) return null;
@@ -913,8 +1181,8 @@ function parseReport(reportPath) {
   }
 }
 function cloneToFinding(clone, workdir) {
-  const firstRel = path4.relative(workdir, clone.firstFile.name);
-  const secondRel = path4.relative(workdir, clone.secondFile.name);
+  const firstRel = path7.relative(workdir, clone.firstFile.name);
+  const secondRel = path7.relative(workdir, clone.secondFile.name);
   return {
     file: firstRel,
     line: clone.firstFile.startLoc.line,
@@ -942,28 +1210,28 @@ var JscpdAdapter = class {
   async run(files, config) {
     if (files.length === 0) return { findings: [] };
     const jscpdConfig = config;
-    const tmpDir = fs3.mkdtempSync(path4.join(os.tmpdir(), "jscpd-"));
+    const tmpDir = fs6.mkdtempSync(path7.join(os2.tmpdir(), "jscpd-"));
     try {
       const args = buildArgs(jscpdConfig, tmpDir);
-      await execa9("jscpd", args, { cwd: config.workdir, reject: false });
-      const report = parseReport(path4.join(tmpDir, "jscpd-report.json"));
+      await execa12("jscpd", args, { cwd: config.workdir, reject: false });
+      const report = parseReport2(path7.join(tmpDir, "jscpd-report.json"));
       if (!report) return { findings: [] };
       const fileSet = new Set(files);
       return {
         findings: report.duplicates.filter((clone) => {
-          const firstRel = path4.relative(config.workdir, clone.firstFile.name);
-          const secondRel = path4.relative(config.workdir, clone.secondFile.name);
+          const firstRel = path7.relative(config.workdir, clone.firstFile.name);
+          const secondRel = path7.relative(config.workdir, clone.secondFile.name);
           return fileSet.has(firstRel) || fileSet.has(secondRel);
         }).map((clone) => cloneToFinding(clone, config.workdir))
       };
     } finally {
-      fs3.rmSync(tmpDir, { recursive: true, force: true });
+      fs6.rmSync(tmpDir, { recursive: true, force: true });
     }
   }
 };
 
 // src/adapters/knip.ts
-import { execa as execa10 } from "execa";
+import { execa as execa13 } from "execa";
 function collectUnusedFiles(report, fileSet) {
   if (!report.files || !Array.isArray(report.files)) return [];
   return report.files.filter((file) => fileSet.has(file)).map((file) => ({
@@ -1019,7 +1287,7 @@ var KnipAdapter = class {
   }
   async run(files, config) {
     if (files.length === 0) return { findings: [] };
-    const result = await execa10("knip", ["--reporter", "json"], {
+    const result = await execa13("knip", ["--reporter", "json"], {
       cwd: config.workdir,
       reject: false
     });
@@ -1101,9 +1369,9 @@ var ArchitectureGate = class {
 };
 
 // src/adapters/stryker.ts
-import { execa as execa11 } from "execa";
-import fs4 from "fs";
-import path5 from "path";
+import { execa as execa14 } from "execa";
+import fs7 from "fs";
+import path8 from "path";
 
 // src/adapters/mutation-shared.ts
 function scoreSeverity(score) {
@@ -1119,7 +1387,7 @@ function timeoutResult(tool, timeout) {
     findings: [{
       file: "",
       line: 0,
-      severity: "info",
+      severity: "blocker",
       metric: "mutation_timeout",
       message: tool + " timed out after " + timeout + "ms",
       why: "Mutation testing exceeded the configured timeout.",
@@ -1217,16 +1485,16 @@ function survivorToFinding(file, mutant) {
 }
 function findReportPath(workdir) {
   const candidates = [
-    path5.join(workdir, "reports", "mutation", "mutation.json"),
-    path5.join(workdir, "reports", "mutation.json")
+    path8.join(workdir, "reports", "mutation", "mutation.json"),
+    path8.join(workdir, "reports", "mutation.json")
   ];
-  return candidates.find((p) => fs4.existsSync(p));
+  return candidates.find((p) => fs7.existsSync(p));
 }
 function readReport(workdir) {
   const reportPath = findReportPath(workdir);
   if (!reportPath) return null;
   try {
-    const raw = fs4.readFileSync(reportPath, "utf-8");
+    const raw = fs7.readFileSync(reportPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -1257,8 +1525,8 @@ var StrykerAdapter = class {
   supportedLanguages = ["typescript", "javascript"];
   async isAvailable(workdir) {
     if (workdir) {
-      const localBin = path5.join(workdir, "node_modules", ".bin", "stryker");
-      if (fs4.existsSync(localBin)) return true;
+      const localBin = path8.join(workdir, "node_modules", ".bin", "stryker");
+      if (fs7.existsSync(localBin)) return true;
     }
     return await isBinaryAvailable("stryker");
   }
@@ -1274,10 +1542,10 @@ var StrykerAdapter = class {
   async executeStryker(files, config, timeout) {
     const mutatePattern = files.join(",");
     const args = ["run", "--reporters", "json", "--mutate", mutatePattern];
-    const useNpx = fs4.existsSync(path5.join(config.workdir, "node_modules", ".bin", "stryker"));
+    const useNpx = fs7.existsSync(path8.join(config.workdir, "node_modules", ".bin", "stryker"));
     const command = useNpx ? "npx" : "stryker";
     const execArgs = useNpx ? ["stryker", ...args] : args;
-    const result = await execa11(command, execArgs, {
+    const result = await execa14(command, execArgs, {
       cwd: config.workdir,
       reject: false,
       timeout
@@ -1287,7 +1555,7 @@ var StrykerAdapter = class {
 };
 
 // src/adapters/mutmut.ts
-import { execa as execa12 } from "execa";
+import { execa as execa15 } from "execa";
 function matchToResult(match) {
   const classname = match[1];
   const name = match[2];
@@ -1361,13 +1629,13 @@ var MutmutAdapter = class {
   }
   async executeMutmut(files, config, timeout) {
     const pathsToMutate = files.join(",");
-    const runResult = await execa12("mutmut", ["run", `--paths-to-mutate=${pathsToMutate}`, "--CI", "--no-progress"], {
+    const runResult = await execa15("mutmut", ["run", `--paths-to-mutate=${pathsToMutate}`, "--CI", "--no-progress"], {
       cwd: config.workdir,
       reject: false,
       timeout
     });
     if (runResult.timedOut) return null;
-    const xmlResult = await execa12("mutmut", ["junitxml"], {
+    const xmlResult = await execa15("mutmut", ["junitxml"], {
       cwd: config.workdir,
       reject: false
     });
@@ -1395,8 +1663,10 @@ var MutmutAdapter = class {
 };
 
 // src/adapters/mutant.ts
-import { execa as execa13 } from "execa";
-var RESULT_LINE_RE = /^(alive|killed|timeout):(.+):(.+):(\d+)/;
+import { execa as execa16 } from "execa";
+import fs8 from "fs";
+import path9 from "path";
+var RESULT_LINE_RE = /^(alive|evil|killed|timeout):(.+):([^:]+\.rb):(\d+)(?::.*)?$/;
 var COVERAGE_RE = /Coverage:\s+([\d.]+)%/;
 function parseOutput(stdout) {
   const entries = [];
@@ -1405,7 +1675,7 @@ function parseOutput(stdout) {
     const resultMatch = RESULT_LINE_RE.exec(line);
     if (resultMatch) {
       entries.push({
-        status: resultMatch[1],
+        status: resultMatch[1] === "evil" ? "alive" : resultMatch[1],
         subject: resultMatch[2],
         file: resultMatch[3],
         line: parseInt(resultMatch[4], 10)
@@ -1440,7 +1710,7 @@ function groupByFile2(entries) {
   const fileStats = /* @__PURE__ */ new Map();
   for (const [file, g] of groups) {
     const total = g.killed + g.survived + g.timeout;
-    const score = total > 0 ? (g.killed + g.timeout) / total * 100 : 100;
+    const score = total > 0 ? g.killed / total * 100 : 100;
     fileStats.set(file, { killed: g.killed, survived: g.survived, timeout: g.timeout, total, score, survivors: g.survivors });
   }
   return fileStats;
@@ -1468,7 +1738,7 @@ function processEntries(opts) {
   let totalMutants = 0;
   for (const [file, stats] of fileStatsMap) {
     if (!fileSet.has(file)) continue;
-    totalKilled += stats.killed + stats.timeout;
+    totalKilled += stats.killed;
     totalMutants += stats.total;
     if (stats.score < opts.threshold) {
       findings.push(fileStatsToFinding(file, stats, opts.threshold));
@@ -1481,31 +1751,154 @@ function processEntries(opts) {
 var MutantAdapter = class {
   name = "mutant";
   supportedLanguages = ["ruby"];
-  async isAvailable() {
-    return isBinaryAvailable("mutant");
+  async isAvailable(workdir = process.cwd()) {
+    if (!fs8.existsSync(path9.join(workdir, "Gemfile"))) {
+      return isBinaryAvailable("mutant");
+    }
+    try {
+      const result = await execa16("bundle", ["exec", "mutant", "--version"], {
+        cwd: workdir,
+        reject: false
+      });
+      return result.exitCode === 0;
+    } catch {
+      return false;
+    }
   }
   async run(files, config) {
     if (files.length === 0) return { findings: [], mutationScore: 100 };
     const timeout = config.timeout ?? 3e5;
     const threshold = config.mutationScoreThreshold ?? 80;
     const maxSurvivorFindings = config.maxSurvivorFindings ?? 5;
-    const stdout = await this.executeMutant(config.workdir, timeout);
-    if (stdout === null) return timeoutResult("mutant", timeout);
-    if (!stdout.trim()) return { findings: [], mutationScore: 100 };
-    const { entries, overallScore } = parseOutput(stdout);
-    if (entries.length === 0 && overallScore === null) return { findings: [], mutationScore: 100 };
+    if (!config.usage) {
+      return toolError(
+        "Mutant requires an explicit usage policy",
+        "Set --mutant-usage opensource or --mutant-usage commercial according to the project license."
+      );
+    }
+    let execution;
+    try {
+      execution = await this.executeMutant(files, config.workdir, timeout, config.usage);
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : "unknown execution error";
+      return toolError(`Mutant could not start: ${detail}`, "Verify Bundler, Mutant, and the project test environment.");
+    }
+    if (execution.timedOut) return timeoutResult("mutant", timeout);
+    const stdout = execution.stdout;
+    if (!stdout.trim()) {
+      return toolError("Mutant produced no report", "Run Mutant through the project bundle and verify its RSpec integration.");
+    }
+    if (![0, 1].includes(execution.exitCode ?? -1)) {
+      return toolError(
+        `Mutant failed with exit code ${execution.exitCode ?? "unknown"}`,
+        "Run Mutant directly and fix its bundle, licence, Rails, or RSpec configuration."
+      );
+    }
+    const parsed = parseOutput(stdout);
+    const entries = parsed.entries.map((entry) => ({
+      ...entry,
+      file: path9.isAbsolute(entry.file) ? path9.relative(config.workdir, entry.file) : entry.file
+    }));
+    const { overallScore } = parsed;
+    if (entries.length === 0 && overallScore === null) {
+      return toolError("Mutant output could not be parsed", "Check the installed Mutant version and its command output.");
+    }
     return processEntries({ entries, overallScore, files, threshold, maxSurvivorFindings });
   }
-  async executeMutant(workdir, timeout) {
-    const result = await execa13("mutant", ["run", "--include", "lib", "--use", "rspec"], {
+  async executeMutant(files, workdir, timeout, usage) {
+    const bundled = fs8.existsSync(path9.join(workdir, "Gemfile"));
+    const command = bundled ? "bundle" : "mutant";
+    const roots = [...new Set(files.map((file) => file.split("/")[0]).filter((root) => root === "app" || root === "lib"))];
+    const railsArgs = fs8.existsSync(path9.join(workdir, "config", "environment.rb")) ? ["--require", "./config/environment"] : [];
+    const mutantArgs = [
+      "run",
+      "--usage",
+      usage,
+      ...roots.flatMap((root) => ["--include", root]),
+      ...railsArgs,
+      "--integration",
+      "rspec",
+      "--jobs",
+      "1",
+      "--",
+      ...files.map((file) => `source:${file}`)
+    ];
+    const args = bundled ? ["exec", "mutant", ...mutantArgs] : mutantArgs;
+    const result = await execa16(command, args, {
       cwd: workdir,
+      env: { RAILS_ENV: "test", CI: "true" },
       reject: false,
       timeout
     });
-    if (result.timedOut) return null;
-    return result.stdout || "";
+    return { stdout: result.stdout || "", timedOut: result.timedOut, exitCode: result.exitCode };
+  }
+};
+function toolError(message, suggestion) {
+  return {
+    findings: [{
+      file: "",
+      line: 0,
+      severity: "blocker",
+      metric: "mutation_tool_error",
+      message,
+      why: "A failed mutation test cannot be treated as a perfect mutation score.",
+      suggestion,
+      metadata: { source: "mutant" }
+    }],
+    mutationScore: 0
+  };
+}
+
+// src/adapters/test-command.ts
+import { execaCommand } from "execa";
+var TestCommandAdapter = class {
+  name = "test-command";
+  supportedLanguages = ["typescript", "javascript", "python", "ruby", "go", "rust"];
+  async isAvailable() {
+    return true;
+  }
+  async run(_files, config) {
+    let result;
+    try {
+      result = await execaCommand(config.command, {
+        cwd: config.workdir,
+        env: { CI: "true" },
+        reject: false,
+        timeout: config.timeout
+      });
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : "unknown execution error";
+      return this.failure(`Test command could not start: ${detail}`, "test_command_failed");
+    }
+    if (result.timedOut) {
+      return this.failure(`Test command timed out after ${config.timeout}ms`, "test_command_timeout");
+    }
+    if (result.exitCode !== 0) {
+      const detail = diagnosticLine(result.stderr) ?? diagnosticLine(result.stdout);
+      const message = detail ? `Test command failed with exit code ${result.exitCode}: ${detail}` : `Test command failed with exit code ${result.exitCode}`;
+      return this.failure(message, "test_command_failed");
+    }
+    return { findings: [], mutationScore: 100 };
+  }
+  failure(message, metric) {
+    const finding = {
+      file: "",
+      line: 0,
+      severity: "blocker",
+      metric,
+      message,
+      why: "The project-defined test suite must complete successfully.",
+      suggestion: "Run the configured test command directly and inspect its full logs.",
+      metadata: { source: "test-command" }
+    };
+    return { findings: [finding], mutationScore: 0 };
   }
 };
+function diagnosticLine(output) {
+  const lines = output.split("\n").map((line) => line.trim()).filter((line) => line && !/^=+$/.test(line));
+  const errorLine = lines.find((line) => /error|failed|cannot|denied|no such file|docker:/i.test(line));
+  return (errorLine ?? lines.at(-1))?.slice(0, 500);
+}
 
 // src/gates/test-quality.ts
 var TestQualityGate = class {
@@ -1513,16 +1906,18 @@ var TestQualityGate = class {
   stryker = new StrykerAdapter();
   mutmut = new MutmutAdapter();
   mutant = new MutantAdapter();
+  testCommand = new TestCommandAdapter();
   async run(ctx) {
     const start = Date.now();
     const config = ctx.config.testQuality ?? DEFAULT_TEST_QUALITY;
     const available = await this.checkAvailability(config, ctx);
-    if (!available.stryker && !available.mutmut && !available.mutant) {
+    if (!available.stryker && !available.mutmut && !available.mutant && !available.testCommand) {
       return toolMissingResult(this.name, start, "No mutation testing tools available", "Install: npm i -D @stryker-mutator/core | pip install mutmut | gem install mutant");
     }
-    const { findings, mutationScore } = await this.collectFindings(available, config, ctx);
+    const { findings, mutationScore, mutationRan } = await this.collectFindings(available, config, ctx);
     const score = calculateTestQualityScore({ mutationScore });
-    const status = deriveStatus(score, findings);
+    const hasBlocker = findings.some((finding) => finding.severity === "blocker");
+    const status = !mutationRan && available.testCommand && !hasBlocker ? "warn" : score < config.mutationScoreThreshold ? "fail" : deriveStatus(score, findings);
     return { gate: this.name, score, status, duration_ms: Date.now() - start, findings };
   }
   async checkAvailability(config, ctx) {
@@ -1532,13 +1927,13 @@ var TestQualityGate = class {
     return {
       stryker: config.strykerEnabled && tsOrJs ? await this.stryker.isAvailable(ctx.workdir) : false,
       mutmut: config.mutmutEnabled && isPython ? await this.mutmut.isAvailable() : false,
-      mutant: config.mutantEnabled && isRuby ? await this.mutant.isAvailable() : false
+      mutant: config.mutantEnabled && isRuby && (!config.testCommand || Boolean(config.mutantUsage)) ? await this.mutant.isAvailable(ctx.workdir) : false,
+      testCommand: Boolean(config.testCommand)
     };
   }
   async collectFindings(available, config, ctx) {
     const allFindings = [];
-    let totalScore = 0;
-    let adapterCount = 0;
+    const scores = [];
     const adapters = [
       { available: available.stryker, adapter: this.stryker },
       { available: available.mutmut, adapter: this.mutmut },
@@ -1550,13 +1945,33 @@ var TestQualityGate = class {
       if (result) {
         allFindings.push(...result.findings);
         if (!result.timedOut) {
-          totalScore += result.mutationScore;
-          adapterCount++;
+          scores.push(result.mutationScore);
         }
       }
     }
-    const mutationScore = adapterCount > 0 ? totalScore / adapterCount : 100;
-    return { findings: allFindings, mutationScore };
+    if (available.testCommand && config.testCommand) {
+      const result = await this.testCommand.run(ctx.files.map((file) => file.relativePath), {
+        workdir: ctx.workdir,
+        thresholds: {},
+        command: config.testCommand,
+        timeout: config.timeout
+      });
+      allFindings.push(...result.findings);
+      if (result.findings.length === 0 && scores.length === 0) {
+        allFindings.push({
+          file: "",
+          line: 0,
+          severity: "info",
+          metric: "mutation_not_run",
+          message: "Project tests passed, but mutation testing was not run",
+          why: "A passing test suite does not measure whether tests detect behavioral changes.",
+          suggestion: "Configure Mutant in the project bundle to obtain a mutation score.",
+          metadata: { source: "test-command" }
+        });
+      }
+    }
+    const mutationScore = scores.length > 0 ? Math.min(...scores) : 0;
+    return { findings: allFindings, mutationScore, mutationRan: scores.length > 0 };
   }
   async runAdapter(adapter, ctx, config) {
     const files = ctx.files.filter((f) => adapter.supportedLanguages.includes(f.language)).map((f) => f.relativePath);
@@ -1566,7 +1981,8 @@ var TestQualityGate = class {
       thresholds: {},
       timeout: config.timeout,
       mutationScoreThreshold: config.mutationScoreThreshold,
-      maxSurvivorFindings: config.maxSurvivorFindings
+      maxSurvivorFindings: config.maxSurvivorFindings,
+      usage: config.mutantUsage
     });
   }
 };
@@ -1702,7 +2118,8 @@ function getProfile(name) {
 
 // src/reporter.ts
 import chalk from "chalk";
-function reportText(results, meta) {
+import { stripVTControlCharacters } from "util";
+function reportText(results, meta, options = {}) {
   const lines = [];
   lines.push(chalk.bold("=== VALIDATOR REPORT ==="));
   lines.push(`Files analyzed: ${meta.filesAnalyzed} (mode: ${meta.mode})`);
@@ -1734,7 +2151,8 @@ function reportText(results, meta) {
   lines.push(
     `RESULT: ${overall.toUpperCase()} (${blockerCount} blockers, ${warnCount} warnings)`
   );
-  return lines.join("\n");
+  const report = lines.join("\n");
+  return options.ansi === false ? stripVTControlCharacters(report) : report;
 }
 function reportJson(results, meta) {
   const allFindings = results.flatMap((r) => r.findings);
@@ -1752,7 +2170,11 @@ function reportJson(results, meta) {
     },
     gates: Object.fromEntries(results.map((r) => [r.gate, r]))
   };
-  return JSON.stringify(report, null, 2);
+  return JSON.stringify(
+    report,
+    (_key, value) => typeof value === "string" ? stripVTControlCharacters(value) : value,
+    2
+  );
 }
 function statusIcon(status) {
   switch (status) {
@@ -1771,8 +2193,20 @@ function statusIcon(status) {
 
 // src/index.ts
 async function validate(options) {
+  if (options.testTimeout !== void 0 && (!Number.isInteger(options.testTimeout) || options.testTimeout <= 0)) {
+    throw new Error("testTimeout must be a positive integer");
+  }
   const workdir = options.workdir ?? process.cwd();
-  const profile = getProfile(options.profile ?? "default");
+  const selectedProfile = getProfile(options.profile ?? "default");
+  const profile = options.testCommand || options.testTimeout || options.mutantUsage ? {
+    ...selectedProfile,
+    testQuality: {
+      ...selectedProfile.testQuality,
+      testCommand: options.testCommand,
+      timeout: options.testTimeout ?? selectedProfile.testQuality.timeout,
+      mutantUsage: options.mutantUsage
+    }
+  } : selectedProfile;
   const gateNames = options.gates ?? getAllGateNames();
   const files = await resolveFiles({
     mode: options.mode,
@@ -1780,6 +2214,7 @@ async function validate(options) {
     base: options.base,
     head: options.head,
     staged: options.staged,
+    exclude: options.exclude,
     workdir
   });
   const language = detectPrimaryLanguage(files);