@duckmind/dm-linux-x64 0.65.4 → 0.65.6

package/extensions/dm-lens/dist/clients/dispatch/runners/rust-clippy.js

@@ -0,0 +1,147 @@
+import { isAbsolute, resolve } from "node:path";
+import { pathsEqual } from "../../path-utils.js";
+import { rustClient } from "../../rust-client.js";
+import { safeSpawnAsync } from "../../safe-spawn.js";
+import { stripAnsi } from "../../sanitize.js";
+import { getLazyInstallAttempt, tryLazyInstall } from "./utils/lazy-installer.js";
+import { describeInstallAttempt, logAvailabilityDecision } from "./utils/availability-policy.js";
+import { PRIORITY } from "../priorities.js";
+import { resolveRunnerCwdWithReason } from "../../tool-cwd.js";
+import { createCwdCachedProbe } from "./utils/runner-helpers.js";
+const CLIPPY_PROBE_BUDGET_MS = 8000;
+let clippyProbeRevision = 0;
+const makeClippyProbe = (cargoExe, flightKeyComponent = cargoExe) => createCwdCachedProbe((cwd) => safeSpawnAsync(cargoExe, ["clippy", "--version"], {
+  timeout: CLIPPY_PROBE_BUDGET_MS,
+  cwd
+}), {
+  tool: "clippy",
+  budgetMs: CLIPPY_PROBE_BUDGET_MS,
+  flightKeyComponent
+});
+const clippyAvailabilityByCargo = new Map;
+function getClippyProbe(cargoExe) {
+  return clippyAvailabilityByCargo.get(cargoExe) ?? refreshClippyProbe(cargoExe);
+}
+function refreshClippyProbe(cargoExe) {
+  const created = makeClippyProbe(cargoExe, `${cargoExe}#refresh-${++clippyProbeRevision}`);
+  clippyAvailabilityByCargo.set(cargoExe, created);
+  return created;
+}
+const rustClippyRunner = {
+  id: "rust-clippy",
+  appliesTo: ["rust"],
+  priority: PRIORITY.SPECIALIZED_ANALYSIS,
+  timeoutMs: 90000,
+  async run(ctx) {
+    const cargoExe = await rustClient.findCargoPathAsync();
+    if (!cargoExe) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    const clippyProbe = getClippyProbe(cargoExe);
+    if (!await clippyProbe(ctx.cwd)) {
+      if (clippyProbe.getVerdict(ctx.cwd).outcome === "transient") {
+        return { status: "skipped", diagnostics: [], semantic: "none" };
+      }
+      await tryLazyInstall("rust-clippy", ctx.cwd);
+      const refreshedProbe = refreshClippyProbe(cargoExe);
+      if (!await refreshedProbe(ctx.cwd)) {
+        const verdict = refreshedProbe.getVerdict(ctx.cwd);
+        logAvailabilityDecision({
+          tool: "rust-clippy",
+          verdict: "unavailable",
+          outcome: verdict.outcome ?? "missing",
+          cause: verdict.cause ?? "not-found",
+          classifiedBy: "caller",
+          evidence: describeInstallAttempt(getLazyInstallAttempt("rust-clippy", ctx.cwd)),
+          elapsedMs: 0,
+          latched: false
+        });
+        return { status: "skipped", diagnostics: [], semantic: "none" };
+      }
+    }
+    const cargoResolution = resolveRunnerCwdWithReason(ctx, "rust-clippy");
+    const cargoDir = cargoResolution.cwd;
+    if (cargoResolution.marker !== "Cargo.toml") {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    const result = await safeSpawnAsync(cargoExe, ["clippy", "--message-format=json", "-q"], {
+      timeout: 60000,
+      cwd: cargoDir
+    });
+    const raw = stripAnsi(result.stdout + result.stderr);
+    if (result.status === 0 && !raw.trim()) {
+      return { status: "succeeded", diagnostics: [], semantic: "none" };
+    }
+    const allDiagnostics = parseClippyOutput(raw, ctx.filePath, cargoDir);
+    if (allDiagnostics.length === 0) {
+      return {
+        status: "failed",
+        diagnostics: [],
+        semantic: "warning",
+        rawOutput: raw.substring(0, 500)
+      };
+    }
+    const absEdited = resolve(ctx.filePath);
+    const diagnostics = allDiagnostics.filter((d) => pathsEqual(resolve(cargoDir, d.filePath), absEdited));
+    const hasErrors = diagnostics.some((d) => d.semantic === "blocking");
+    return {
+      status: hasErrors ? "failed" : "succeeded",
+      diagnostics,
+      semantic: hasErrors ? "blocking" : diagnostics.length > 0 ? "warning" : "none"
+    };
+  }
+};
+export function normalizeClippyLevel(raw) {
+  if (raw === "error")
+    return "error";
+  if (typeof raw === "string" && raw.startsWith("error: internal compiler error")) {
+    return "error";
+  }
+  if (raw === "note")
+    return "hint";
+  if (raw === "help")
+    return "info";
+  return "warning";
+}
+function findMachineApplicableSpan(spans) {
+  return spans.find((s) => typeof s.suggested_replacement === "string" && s.suggestion_applicability === "MachineApplicable");
+}
+export function parseClippyOutput(raw, fallbackPath, cargoDir) {
+  const diagnostics = [];
+  const lines = raw.split(`
+`).filter((l) => l.trim());
+  for (const line of lines) {
+    try {
+      const msg = JSON.parse(line);
+      if (msg.reason !== "compiler-message")
+        continue;
+      const message = msg.message;
+      if (!message)
+        continue;
+      const spans = message.spans ?? [];
+      const span = spans[0];
+      if (!span)
+        continue;
+      const fixableSpan = findMachineApplicableSpan(spans);
+      const rawFile = span.file || span.file_name;
+      const filePath = rawFile ? cargoDir && !isAbsolute(rawFile) ? resolve(cargoDir, rawFile) : rawFile : fallbackPath;
+      const normalizedSeverity = normalizeClippyLevel(message.level);
+      diagnostics.push({
+        id: `clippy-${message.code?.code || "unknown"}`,
+        message: message.message || "Clippy warning",
+        filePath,
+        line: span.line_start || 0,
+        column: span.column_start || 0,
+        severity: normalizedSeverity,
+        semantic: normalizedSeverity === "error" ? "blocking" : "warning",
+        tool: "rust-clippy",
+        rule: message.code?.code,
+        defectClass: "correctness",
+        fixable: fixableSpan !== undefined,
+        fixSuggestion: fixableSpan?.suggested_replacement
+      });
+    } catch {}
+  }
+  return diagnostics;
+}
+export default rustClippyRunner;

package/extensions/dm-lens/dist/clients/dispatch/runners/shellcheck.js

@@ -0,0 +1,111 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { pathsEqual } from "../../path-utils.js";
+import { safeSpawnAsync } from "../../safe-spawn.js";
+import { resolveRunnerCwd } from "../../tool-cwd.js";
+import { PRIORITY } from "../priorities.js";
+import { createAvailabilityChecker, lspPrimaryCoversFile, resolveAvailableOrInstall } from "./utils/runner-helpers.js";
+import { finishParsedRun } from "./utils/tool-failure.js";
+const shellcheck = createAvailabilityChecker("shellcheck", ".exe");
+function findShellcheckConfig(cwd) {
+  const local = path.join(cwd, ".shellcheckrc");
+  if (fs.existsSync(local))
+    return local;
+  let current = path.resolve(cwd);
+  while (true) {
+    const candidate = path.join(current, ".shellcheckrc");
+    if (fs.existsSync(candidate))
+      return candidate;
+    const parent = path.dirname(current);
+    if (parent === current)
+      break;
+    current = parent;
+  }
+  return;
+}
+function parseShellcheckOutput(raw, filePath, cwd) {
+  const diagnostics = [];
+  const absTarget = path.resolve(cwd, filePath);
+  if (!raw.trim()) {
+    return diagnostics;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) {
+      return diagnostics;
+    }
+    for (const item of parsed) {
+      if (!item.message || !item.line)
+        continue;
+      if (!item.file || !pathsEqual(path.resolve(cwd, item.file), absTarget))
+        continue;
+      const severityMap = {
+        error: "error",
+        warning: "warning",
+        info: "info",
+        style: "info"
+      };
+      const severity = severityMap[item.level || "warning"] || "warning";
+      const ruleCode = item.code ? `SC${item.code}` : "unknown";
+      diagnostics.push({
+        id: `shellcheck-${item.line}-${ruleCode}`,
+        message: `[${ruleCode}] ${item.message}`,
+        filePath,
+        line: item.line,
+        column: item.column || 1,
+        severity,
+        semantic: severity === "error" ? "blocking" : "warning",
+        tool: "shellcheck",
+        rule: ruleCode,
+        fixable: !!item.fix,
+        autoFixAvailable: false,
+        fixKind: item.fix ? "suggestion" : undefined
+      });
+    }
+  } catch {
+    return diagnostics;
+  }
+  return diagnostics;
+}
+const shellcheckRunner = {
+  id: "shellcheck",
+  appliesTo: ["shell"],
+  priority: PRIORITY.GENERAL_ANALYSIS,
+  skipTestFiles: false,
+  async run(ctx) {
+    const cwd = resolveRunnerCwd(ctx, "shellcheck");
+    if (lspPrimaryCoversFile(ctx, "bash") && await ctx.hasTool("bash-language-server") && await ctx.hasTool("shellcheck")) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    let cmd = null;
+    if (await shellcheck.isAvailableAsync(cwd)) {
+      cmd = shellcheck.getCommand(cwd);
+    } else {
+      const managed = await resolveAvailableOrInstall(shellcheck, "shellcheck", cwd);
+      if (managed)
+        cmd = managed;
+    }
+    if (!cmd)
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    const shellDialect = "bash";
+    const args = ["--format", "json", "--shell", shellDialect];
+    const configPath = findShellcheckConfig(ctx.cwd);
+    if (!configPath) {
+      args.push("--severity", "info");
+    }
+    args.push(ctx.filePath);
+    const result = await safeSpawnAsync(cmd, args, { cwd, timeout: 15000 });
+    if (result.status === 0 && !result.stdout?.trim()) {
+      return { status: "succeeded", diagnostics: [], semantic: "none" };
+    }
+    const raw = result.stdout + result.stderr;
+    const diagnostics = parseShellcheckOutput(raw, ctx.filePath, cwd);
+    return finishParsedRun({
+      tool: "shellcheck",
+      ctx,
+      result,
+      diagnostics
+    });
+  }
+};
+export default shellcheckRunner;

package/extensions/dm-lens/dist/clients/dispatch/runners/shfmt.js

@@ -0,0 +1,81 @@
+import { safeSpawnAsync } from "../../safe-spawn.js";
+import { findNearestContaining } from "../../path-utils.js";
+import { resolveRunnerCwd } from "../../tool-cwd.js";
+import { PRIORITY } from "../priorities.js";
+import { createAvailabilityChecker, resolveAvailableOrInstall } from "./utils/runner-helpers.js";
+const shfmt = createAvailabilityChecker("shfmt", ".exe");
+function hasEditorConfig(cwd) {
+  return findNearestContaining(cwd, [".editorconfig"]) !== undefined;
+}
+const shfmtRunner = {
+  id: "shfmt",
+  appliesTo: ["shell"],
+  priority: PRIORITY.FORMAT_AND_LINT_PRIMARY,
+  skipTestFiles: false,
+  async run(ctx) {
+    const cwd = resolveRunnerCwd(ctx, "shfmt");
+    let cmd = null;
+    if (await shfmt.isAvailableAsync(cwd)) {
+      cmd = shfmt.getCommand(cwd);
+    } else {
+      const installed = await resolveAvailableOrInstall(shfmt, "shfmt", cwd);
+      if (!installed) {
+        return { status: "skipped", diagnostics: [], semantic: "none" };
+      }
+      cmd = installed;
+    }
+    if (!cmd)
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    const result = await safeSpawnAsync(cmd, ["--diff", ctx.filePath], {
+      timeout: 1e4,
+      cwd
+    });
+    if (result.status === 0) {
+      return { status: "succeeded", diagnostics: [], semantic: "none" };
+    }
+    if ((result.status ?? 2) > 1) {
+      const errMsg = (result.stderr ?? "").split(`
+`)[0].trim();
+      const diagnostics = [
+        {
+          id: `shfmt-parse-${ctx.filePath}`,
+          message: errMsg ? `shfmt parse error: ${errMsg}` : "shfmt: failed to parse shell script",
+          filePath: ctx.filePath,
+          line: 1,
+          column: 1,
+          severity: "error",
+          semantic: "blocking",
+          tool: "shfmt",
+          rule: "shfmt-parse-error"
+        }
+      ];
+      return { status: "failed", diagnostics, semantic: "blocking" };
+    }
+    if (!hasEditorConfig(cwd)) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    const diffOutput = result.stdout ?? result.stderr ?? "";
+    let line = 1;
+    const lineMatch = diffOutput.match(/^@@\s+-(\d+)/m);
+    if (lineMatch)
+      line = Number(lineMatch[1]);
+    const diagnostics = [
+      {
+        id: `shfmt-format-${ctx.filePath}`,
+        message: "Shell script is not formatted — run `shfmt -w` to fix",
+        filePath: ctx.filePath,
+        line,
+        column: 1,
+        severity: "warning",
+        semantic: "warning",
+        tool: "shfmt",
+        rule: "shfmt-unformatted",
+        fixable: true,
+        autoFixAvailable: false,
+        fixKind: "manual"
+      }
+    ];
+    return { status: "succeeded", diagnostics, semantic: "warning" };
+  }
+};
+export default shfmtRunner;

package/extensions/dm-lens/dist/clients/dispatch/runners/spellcheck.js

@@ -0,0 +1,74 @@
+import * as path from "node:path";
+import { pathsEqual } from "../../path-utils.js";
+import { safeSpawnAsync } from "../../safe-spawn.js";
+import { PRIORITY } from "../priorities.js";
+import { createAvailabilityChecker, resolveRunnerCwd } from "./utils/runner-helpers.js";
+import { parseToolRun } from "./utils/tool-failure.js";
+const typos = createAvailabilityChecker("typos", ".exe");
+const TYPOS_EXIT_CODES = { ran: [2] };
+function parseTyposOutput(raw, filePath, cwd) {
+  const diagnostics = [];
+  const absTarget = path.resolve(cwd, filePath);
+  if (!raw.trim()) {
+    return diagnostics;
+  }
+  const lines = raw.trim().split(`
+`).filter((l) => l.trim());
+  for (const line of lines) {
+    try {
+      const parsed = JSON.parse(line);
+      if (!parsed.typo || !parsed.line_num)
+        continue;
+      if (parsed.path && !pathsEqual(path.resolve(cwd, parsed.path), absTarget))
+        continue;
+      const corrections = parsed.corrections?.join(", ") || "no suggestions";
+      const message = `Typo: "${parsed.typo}" → ${corrections}`;
+      diagnostics.push({
+        id: `typos-${parsed.line_num}-${parsed.typo}`,
+        message,
+        filePath,
+        line: parsed.line_num,
+        column: 1,
+        severity: "warning",
+        semantic: "warning",
+        tool: "typos",
+        rule: "typo",
+        fixable: !!parsed.corrections?.length,
+        autoFixAvailable: false,
+        fixKind: parsed.corrections?.length ? "suggestion" : undefined,
+        fixSuggestion: parsed.corrections?.[0]
+      });
+    } catch (err) {}
+  }
+  return diagnostics;
+}
+const spellcheckRunner = {
+  id: "spellcheck",
+  appliesTo: ["markdown"],
+  priority: PRIORITY.DOC_QUALITY,
+  skipTestFiles: false,
+  async run(ctx) {
+    const cwd = resolveRunnerCwd(ctx, "spellcheck/typos");
+    if (!await typos.isAvailableAsync(cwd)) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    const args = ["--format", "json", ctx.filePath];
+    const result = await safeSpawnAsync(typos.getCommand(cwd), args, {
+      cwd,
+      timeout: 15000
+    });
+    const run = parseToolRun("spellcheck", { result, exitCodes: TYPOS_EXIT_CODES }, (out) => parseTyposOutput(out, ctx.filePath, cwd), { parseOutput: `${result.stdout ?? ""}${result.stderr ?? ""}` });
+    if (run.skipped)
+      return run.skipped;
+    const diagnostics = run.diagnostics;
+    if (diagnostics.length === 0) {
+      return { status: "succeeded", diagnostics: [], semantic: "none" };
+    }
+    return {
+      status: "failed",
+      diagnostics,
+      semantic: "warning"
+    };
+  }
+};
+export default spellcheckRunner;

package/extensions/dm-lens/dist/clients/dispatch/runners/spotbugs.js

@@ -0,0 +1,208 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { BoundedLruCache } from "../../bounded-cache.js";
+import { safeSpawnAsync } from "../../safe-spawn.js";
+import { resolveRunnerCwd } from "../../tool-cwd.js";
+import { findCompiledClassesDir } from "../../tool-policy.js";
+import { PRIORITY } from "../priorities.js";
+import { createAvailabilityChecker, resolveAvailableOrInstall } from "./utils/runner-helpers.js";
+const java = createAvailabilityChecker("java", ".exe", ["-version"]);
+const spotbugs = createAvailabilityChecker("spotbugs", ".bat", ["-version"]);
+const MAX_DIAGNOSTICS = 50;
+const MAX_XML_BYTES = 4 * 1024 * 1024;
+const scanCache = new BoundedLruCache(32);
+export function _resetSpotbugsCacheForTests() {
+  scanCache.clear();
+}
+function classesSignature(classesDir) {
+  let count = 0;
+  let newest = 0;
+  const stack = [classesDir];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    if (!dir)
+      break;
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(full);
+      } else if (entry.isFile() && entry.name.endsWith(".class")) {
+        count++;
+        try {
+          const m = fs.statSync(full).mtimeMs;
+          if (m > newest)
+            newest = m;
+        } catch {}
+      }
+    }
+  }
+  return `${count}:${newest}`;
+}
+function mapCategory(category) {
+  switch (category.toUpperCase()) {
+    case "CORRECTNESS":
+    case "MT_CORRECTNESS":
+      return "correctness";
+    case "SECURITY":
+      return "safety";
+    case "PERFORMANCE":
+    case "BAD_PRACTICE":
+    case "STYLE":
+    case "I18N":
+    case "EXPERIMENTAL":
+      return "style";
+    default:
+      return "correctness";
+  }
+}
+function mapSeverity(priority) {
+  switch (priority) {
+    case "1":
+      return "error";
+    case "3":
+      return "info";
+    default:
+      return "warning";
+  }
+}
+function attr(attrs, name) {
+  const m = new RegExp(`\\b${name}="([^"]*)"`).exec(attrs);
+  return m ? m[1] : undefined;
+}
+function firstSentence(text) {
+  const trimmed = text.replace(/\s+/g, " ").trim();
+  const dot = trimmed.indexOf(". ");
+  return (dot > 0 ? trimmed.slice(0, dot + 1) : trimmed).slice(0, 300);
+}
+export function parseSpotbugsXml(raw) {
+  const xml = raw.length > MAX_XML_BYTES ? raw.slice(0, MAX_XML_BYTES) : raw;
+  const diagnostics = [];
+  const blockRe = /<BugInstance\b([^>]*)>([\s\S]*?)<\/BugInstance>/g;
+  let block;
+  let index = 0;
+  while ((block = blockRe.exec(xml)) !== null) {
+    if (diagnostics.length >= MAX_DIAGNOSTICS)
+      break;
+    const headAttrs = block[1];
+    const body = block[2];
+    const type = attr(headAttrs, "type") || "SPOTBUGS";
+    const priority = attr(headAttrs, "priority") || "2";
+    const category = attr(headAttrs, "category") || "CORRECTNESS";
+    let filePath;
+    let line = 1;
+    const slRe = /<SourceLine\b([^>]*?)\/?>/g;
+    let sl;
+    while ((sl = slRe.exec(body)) !== null) {
+      const slAttrs = sl[1];
+      const start = attr(slAttrs, "start");
+      const sourcepath = attr(slAttrs, "sourcepath");
+      const sourcefile = attr(slAttrs, "sourcefile");
+      if (!start || !(sourcepath || sourcefile))
+        continue;
+      filePath = sourcepath || sourcefile;
+      line = Number(start) || 1;
+      if (attr(slAttrs, "primary") === "true")
+        break;
+    }
+    if (!filePath)
+      continue;
+    const longMsgMatch = /<LongMessage>([\s\S]*?)<\/LongMessage>/.exec(body);
+    const shortMsgMatch = /<ShortMessage>([\s\S]*?)<\/ShortMessage>/.exec(body);
+    const longMsg = longMsgMatch ? decodeXmlEntities(longMsgMatch[1].trim()) : "";
+    const shortMsg = shortMsgMatch ? decodeXmlEntities(shortMsgMatch[1].trim()) : "";
+    const message = shortMsg || longMsg || type;
+    const fixSuggestion = longMsg ? firstSentence(longMsg) : undefined;
+    diagnostics.push({
+      id: `spotbugs:${type}:${path.basename(filePath)}:${line}:${index}`,
+      message: `[${type}] ${message}`,
+      filePath,
+      line,
+      column: 1,
+      severity: mapSeverity(priority),
+      semantic: "warning",
+      tool: "spotbugs",
+      rule: type,
+      defectClass: mapCategory(category),
+      fixable: false,
+      autoFixAvailable: false,
+      fixKind: fixSuggestion ? "suggestion" : undefined,
+      fixSuggestion
+    });
+    index++;
+  }
+  return diagnostics;
+}
+function decodeXmlEntities(s) {
+  return s.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+}
+const spotbugsRunner = {
+  id: "spotbugs",
+  appliesTo: ["java", "kotlin"],
+  priority: PRIORITY.DEEP_LANGUAGE_ANALYSIS,
+  async run(ctx) {
+    const cwd = resolveRunnerCwd(ctx, "spotbugs");
+    const classesDir = findCompiledClassesDir(cwd);
+    if (!classesDir) {
+      ctx.log?.("spotbugs: Java project detected but no compiled .class files found — run `mvn compile` / `gradle build` first");
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    if (!await java.isAvailableAsync(cwd)) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    const signature = classesSignature(classesDir);
+    const cached = scanCache.get(classesDir);
+    if (cached && cached.signature === signature) {
+      return {
+        status: "succeeded",
+        diagnostics: cached.diagnostics,
+        semantic: cached.diagnostics.length > 0 ? "warning" : "none"
+      };
+    }
+    const cmd = await resolveAvailableOrInstall(spotbugs, "spotbugs", cwd);
+    if (!cmd)
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    const tmpXml = path.join(os.tmpdir(), `dm-lens-spotbugs-${process.pid}-${Date.now()}.xml`);
+    const result = await safeSpawnAsync(cmd, [
+      "-textui",
+      "-xml:withMessages",
+      "-low",
+      "-longBugCodes",
+      "-output",
+      tmpXml,
+      classesDir
+    ], { cwd, timeout: 120000 });
+    let xml = "";
+    try {
+      xml = fs.readFileSync(tmpXml, "utf8");
+    } catch {
+      if (result.error || (result.status ?? 0) > 1) {
+        return {
+          status: "failed",
+          diagnostics: [],
+          semantic: "none",
+          rawOutput: (result.stderr || "").slice(0, 500)
+        };
+      }
+      return { status: "succeeded", diagnostics: [], semantic: "none" };
+    } finally {
+      try {
+        fs.rmSync(tmpXml, { force: true });
+      } catch {}
+    }
+    const diagnostics = parseSpotbugsXml(xml);
+    scanCache.set(classesDir, { signature, diagnostics });
+    return {
+      status: "succeeded",
+      diagnostics,
+      semantic: diagnostics.length > 0 ? "warning" : "none"
+    };
+  }
+};
+export default spotbugsRunner;