@duckmind/dm-linux-x64 0.66.0 → 0.66.2

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

@@ -1,147 +0,0 @@
-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

@@ -1,111 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

@@ -1,208 +0,0 @@
-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;