@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

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

@@ -0,0 +1,205 @@
+import * as path from "node:path";
+import { incrementDegradationCount } from "../../degradation-ledger.js";
+import { pathsEqual } from "../../path-utils.js";
+import { mapWithConcurrency } from "../../dependency-checker.js";
+import { safeSpawnAsync } from "../../safe-spawn.js";
+import { biomeConfigArgs, getAutofixCapability, getJstsLintPolicyForCwd } from "../../tool-policy.js";
+import { PRIORITY } from "../priorities.js";
+import { resolveRunnerCwd, resolveToolCommandWithInstallFallback } from "./utils/runner-helpers.js";
+import { finishParsedRun } from "./utils/tool-failure.js";
+export function normalizeBiomeSeverity(raw) {
+  switch (raw) {
+    case "error":
+      return "error";
+    case "info":
+      return "info";
+    case "hint":
+      return "hint";
+    case "warning":
+      return "warning";
+    default:
+      return "warning";
+  }
+}
+export function biomeRuleNameFromCategory(category) {
+  if (!category?.startsWith("lint/"))
+    return;
+  const parts = category.split("/");
+  return parts[parts.length - 1] || undefined;
+}
+export function parseBiomeJson(raw, filePath, cwd, fixKindByRule) {
+  try {
+    const result = JSON.parse(raw);
+    const diagnostics = result.diagnostics || [];
+    const autofix = getAutofixCapability("biome");
+    const absTarget = path.resolve(cwd, filePath);
+    return {
+      diagnostics: diagnostics.flatMap((d) => {
+        if (d.location?.path && !pathsEqual(path.resolve(cwd, d.location.path), absTarget))
+          return [];
+        {
+          const ruleName = biomeRuleNameFromCategory(d.category);
+          const fixKind = ruleName ? fixKindByRule?.get(ruleName) : undefined;
+          const isFixable = fixKind === "safe" || fixKind === "unsafe";
+          return [
+            {
+              id: `biome:${d.category}:${d.location.start.line}`,
+              message: d.message,
+              filePath,
+              line: d.location.start.line,
+              column: d.location.start.column,
+              severity: normalizeBiomeSeverity(d.severity),
+              semantic: d.severity === "error" ? "blocking" : "warning",
+              tool: "biome",
+              rule: d.category,
+              fixable: isFixable,
+              autoFixAvailable: fixKind === "safe" && (autofix?.safePipelineAutofix ?? false),
+              fixKind: isFixable && autofix?.fixKind !== "none" ? autofix?.fixKind : undefined
+            }
+          ];
+        }
+      })
+    };
+  } catch (err) {
+    return {
+      diagnostics: [],
+      parseError: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+const biomeFixKindCache = new Map;
+export function _resetBiomeFixKindCacheForTests() {
+  biomeFixKindCache.clear();
+}
+const BIOME_FIX_KIND_PATTERN = /^-\s*Fix:\s*(safe|unsafe)\s*$/m;
+const BIOME_NO_FIX_PATTERN = /^-\s*No fix available\.\s*$/m;
+const EXPLAIN_CONCURRENCY = 4;
+export async function resolveBiomeFixKinds(cmd, cwd, categories) {
+  const resolved = new Map;
+  const ruleNames = new Set;
+  for (const category of categories) {
+    const ruleName = biomeRuleNameFromCategory(category);
+    if (ruleName)
+      ruleNames.add(ruleName);
+  }
+  const toResolve = [];
+  for (const ruleName of ruleNames) {
+    const cacheKey = `${cmd}::${ruleName}`;
+    const cached = biomeFixKindCache.get(cacheKey);
+    if (cached === undefined) {
+      toResolve.push(ruleName);
+    } else {
+      resolved.set(ruleName, cached);
+    }
+  }
+  await mapWithConcurrency(toResolve, EXPLAIN_CONCURRENCY, async (ruleName) => {
+    const cacheKey = `${cmd}::${ruleName}`;
+    const spawned = await safeSpawnAsync(cmd, ["explain", ruleName], {
+      timeout: 1e4,
+      cwd
+    });
+    if (spawned.error || spawned.status !== 0) {
+      incrementDegradationCount({
+        kind: "biome-explain-unavailable",
+        subject: ruleName,
+        reason: spawned.error ? `spawn failed: ${spawned.error}` : `explain exited ${spawned.status}`
+      });
+      resolved.set(ruleName, "none");
+      return;
+    }
+    const stdout = spawned.stdout || "";
+    const fixMatch = stdout.match(BIOME_FIX_KIND_PATTERN);
+    if (fixMatch) {
+      const kind = fixMatch[1] === "safe" ? "safe" : "unsafe";
+      biomeFixKindCache.set(cacheKey, kind);
+      resolved.set(ruleName, kind);
+      return;
+    }
+    if (BIOME_NO_FIX_PATTERN.test(stdout)) {
+      biomeFixKindCache.set(cacheKey, "none");
+      resolved.set(ruleName, "none");
+      return;
+    }
+    incrementDegradationCount({
+      kind: "biome-explain-unavailable",
+      subject: ruleName,
+      reason: "explain output matched neither the Fix nor No-fix pattern"
+    });
+    resolved.set(ruleName, "none");
+  });
+  return resolved;
+}
+const biomeCheckJsonRunner = {
+  id: "biome-check-json",
+  appliesTo: ["jsts"],
+  priority: PRIORITY.FORMAT_AND_LINT_PRIMARY,
+  async run(ctx) {
+    const cwd = resolveRunnerCwd(ctx, "biome");
+    const policy = getJstsLintPolicyForCwd(cwd);
+    if (!policy.hasBiomeConfig && policy.hasExplicitNonBiomeLinter) {
+      return {
+        status: "skipped",
+        diagnostics: [],
+        semantic: "none",
+        skipReason: "configured-non-biome-linter"
+      };
+    }
+    const cmd = await resolveToolCommandWithInstallFallback(cwd, "biome");
+    if (!cmd) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    const configArg = biomeConfigArgs(cwd);
+    const checkResult = await safeSpawnAsync(cmd, [
+      "lint",
+      "--reporter=json",
+      "--no-errors-on-unmatched",
+      ...configArg,
+      ctx.filePath
+    ], { timeout: 30000, cwd });
+    if (checkResult.error) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    let fixKindByRule;
+    if (checkResult.status === 0 || checkResult.status === 1) {
+      let categories = [];
+      try {
+        const preParsed = JSON.parse(checkResult.stdout || "{}");
+        categories = (preParsed.diagnostics || []).map((d) => d.category);
+      } catch {
+        categories = [];
+      }
+      fixKindByRule = await resolveBiomeFixKinds(cmd, cwd, categories);
+    }
+    const parsed = checkResult.status === 0 || checkResult.status === 1 ? parseBiomeJson(checkResult.stdout || "", ctx.filePath, cwd, fixKindByRule) : { diagnostics: [] };
+    if (parsed.parseError) {
+      const raw = checkResult.stdout || checkResult.stderr || "";
+      const preview = raw.replace(/\s+/g, " ").slice(0, 160);
+      const message = "Biome JSON parse failed: " + parsed.parseError + (preview ? " (output preview: " + preview + ")" : "");
+      return {
+        status: "failed",
+        diagnostics: [
+          {
+            id: "biome:parse-error:1",
+            message,
+            filePath: ctx.filePath,
+            line: 1,
+            column: 1,
+            severity: "warning",
+            semantic: "warning",
+            tool: "biome"
+          }
+        ],
+        semantic: "warning",
+        failureKind: "parser_error",
+        failureMessage: message.slice(0, 200)
+      };
+    }
+    return finishParsedRun({
+      tool: "biome",
+      ctx,
+      result: checkResult,
+      diagnostics: parsed.diagnostics
+    });
+  }
+};
+export default biomeCheckJsonRunner;

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

@@ -0,0 +1,190 @@
+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 { probeToolAsync } from "../../tool-probe.js";
+import { resolveRunnerCwd } from "../../tool-cwd.js";
+import { PRIORITY } from "../priorities.js";
+import { createAvailabilityChecker } from "./utils/runner-helpers.js";
+import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
+const compilerCheckers = {
+  clang: createAvailabilityChecker("clang", ".exe"),
+  gcc: createAvailabilityChecker("gcc", ".exe"),
+  cc: createAvailabilityChecker("cc", ".exe"),
+  "clang++": createAvailabilityChecker("clang++", ".exe"),
+  "g++": createAvailabilityChecker("g++", ".exe"),
+  "c++": createAvailabilityChecker("c++", ".exe"),
+  cl: createAvailabilityChecker("cl", ".exe")
+};
+const C_SOURCE_EXTENSIONS = new Set([".c"]);
+const C_HEADER_EXTENSIONS = new Set([".h"]);
+const CPP_SOURCE_EXTENSIONS = new Set([
+  ".c++",
+  ".cc",
+  ".cp",
+  ".cpp",
+  ".cxx",
+  ".c++m",
+  ".cppm",
+  ".cxxm",
+  ".ixx",
+  ".cu",
+  ".hip",
+  ".mm",
+  ".clcpp"
+]);
+const CPP_HEADER_EXTENSIONS = new Set([
+  ".hh",
+  ".hpp",
+  ".hxx",
+  ".inl",
+  ".ipp",
+  ".tpp",
+  ".txx"
+]);
+function headerLooksLikeCpp(absPath) {
+  try {
+    const content = fs.readFileSync(absPath, "utf-8");
+    return /\b(namespace|template|class|constexpr|concept|using)\b|std::|\b(public|private|protected)\s*:/.test(content);
+  } catch {
+    return false;
+  }
+}
+function getGccLikeCandidates(absPath) {
+  const ext = path.extname(absPath).toLowerCase();
+  const cMode = C_SOURCE_EXTENSIONS.has(ext) || C_HEADER_EXTENSIONS.has(ext) && !headerLooksLikeCpp(absPath);
+  const cppMode = CPP_SOURCE_EXTENSIONS.has(ext) || CPP_HEADER_EXTENSIONS.has(ext);
+  if (cMode) {
+    const cArgs = C_HEADER_EXTENSIONS.has(ext) ? ["-x", "c-header", "-fsyntax-only", absPath] : ["-x", "c", "-fsyntax-only", absPath];
+    return [
+      { key: "clang", args: cArgs },
+      { key: "gcc", args: cArgs },
+      { key: "cc", args: cArgs }
+    ];
+  }
+  if (cppMode || ext) {
+    return [
+      { key: "clang++", args: ["-fsyntax-only", absPath] },
+      { key: "g++", args: ["-fsyntax-only", absPath] },
+      { key: "c++", args: ["-fsyntax-only", absPath] }
+    ];
+  }
+  return [];
+}
+async function resolveCompiler(absPath, cwd) {
+  for (const candidate of getGccLikeCandidates(absPath)) {
+    const checker = compilerCheckers[candidate.key];
+    if (await checker.isAvailableAsync(cwd)) {
+      const command = checker.getCommand(cwd) ?? candidate.key;
+      return { command, args: candidate.args, flavor: "gcc" };
+    }
+  }
+  const clChecker = compilerCheckers.cl;
+  const clCmd = clChecker.getCommand(cwd);
+  if (clCmd) {
+    return {
+      command: clCmd,
+      args: ["/nologo", "/Zs", absPath],
+      flavor: "msvc"
+    };
+  }
+  const clProbe = await probeToolAsync("cl", [], { timeout: 5000 });
+  if (!clProbe.error && clProbe.status !== null) {
+    return {
+      command: "cl",
+      args: ["/nologo", "/Zs", absPath],
+      flavor: "msvc"
+    };
+  }
+  return;
+}
+function parseGccLikeOutput(raw, filePath, cwd) {
+  const diagnostics = [];
+  const absTarget = path.resolve(cwd, filePath);
+  for (const line of raw.split(/\r?\n/)) {
+    const match = line.match(/^(.*?):(\d+):(?:(\d+):)?\s*(fatal error|error|warning|note):\s+(.+)$/i);
+    if (!match)
+      continue;
+    const [, sourcePath, lineStr, colStr, severityLabel, message] = match;
+    if (!pathsEqual(path.resolve(cwd, sourcePath.trim()), absTarget))
+      continue;
+    const severity = severityLabel.toLowerCase().includes("error") ? "error" : "warning";
+    diagnostics.push({
+      id: `cpp-check-${severityLabel}-${lineStr}-${colStr || "1"}`,
+      message: message.trim(),
+      filePath,
+      line: Number.parseInt(lineStr, 10) || 1,
+      column: Number.parseInt(colStr || "1", 10) || 1,
+      severity,
+      semantic: "warning",
+      tool: "cpp-check",
+      rule: severityLabel.toLowerCase(),
+      fixable: false
+    });
+  }
+  return diagnostics;
+}
+function parseMsvcOutput(raw, filePath, cwd) {
+  const diagnostics = [];
+  const absTarget = path.resolve(cwd, filePath);
+  for (const line of raw.split(/\r?\n/)) {
+    const match = line.match(/^(.*)\((\d+)(?:,(\d+))?\):\s*(fatal error|error|warning)\s+([A-Z]+\d+):\s+(.+)$/i);
+    if (!match)
+      continue;
+    const [, sourcePath, lineStr, colStr, severityLabel, rule, message] = match;
+    if (!pathsEqual(path.resolve(cwd, sourcePath.trim()), absTarget))
+      continue;
+    const severity = severityLabel.toLowerCase().includes("error") ? "error" : "warning";
+    diagnostics.push({
+      id: `cpp-check-${rule}-${lineStr}-${colStr || "1"}`,
+      message: `[${rule}] ${message.trim()}`,
+      filePath,
+      line: Number.parseInt(lineStr, 10) || 1,
+      column: Number.parseInt(colStr || "1", 10) || 1,
+      severity,
+      semantic: "warning",
+      tool: "cpp-check",
+      rule,
+      fixable: false
+    });
+  }
+  return diagnostics;
+}
+const cppCheckRunner = {
+  id: "cpp-check",
+  appliesTo: ["cxx"],
+  priority: PRIORITY.GENERAL_ANALYSIS,
+  skipTestFiles: false,
+  async run(ctx) {
+    const cwd = resolveRunnerCwd(ctx, "cpp-check");
+    const absPath = path.resolve(cwd, ctx.filePath);
+    const compiler = await resolveCompiler(absPath, cwd);
+    if (!compiler) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    const result = await safeSpawnAsync(compiler.command, compiler.args, {
+      cwd,
+      timeout: 30000
+    });
+    const raw = `${result.stdout ?? ""}
+${result.stderr ?? ""}`.trim();
+    const parsed = parseToolRun("cpp-check", {
+      result,
+      output: raw,
+      exitCodes: { ran: [1, 2] }
+    }, (output) => compiler.flavor === "msvc" ? parseMsvcOutput(output, ctx.filePath, cwd) : parseGccLikeOutput(output, ctx.filePath, cwd));
+    if (parsed.skipped)
+      return parsed.skipped;
+    return finishParsedRun({
+      tool: "cpp-check",
+      ctx,
+      result,
+      diagnostics: parsed.diagnostics,
+      classify: (diagnostics) => ({
+        status: diagnostics.some((d) => d.severity === "error") ? "failed" : "succeeded",
+        semantic: "warning"
+      })
+    });
+  }
+};
+export default cppCheckRunner;

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

@@ -0,0 +1,66 @@
+import * as path from "node:path";
+import * as fs from "node:fs";
+import { safeSpawnAsync } from "../../safe-spawn.js";
+import { resolveRunnerCwd } from "../../tool-cwd.js";
+import { PRIORITY } from "../priorities.js";
+import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
+import { createCwdCachedProbe } from "./utils/runner-helpers.js";
+const CREDO_PROBE_BUDGET_MS = 1e4;
+const probeCredo = createCwdCachedProbe((cwd) => safeSpawnAsync("mix", ["credo", "--version"], {
+  timeout: CREDO_PROBE_BUDGET_MS,
+  cwd
+}), { tool: "credo", budgetMs: CREDO_PROBE_BUDGET_MS });
+export function parseCredoJson(raw, fallbackPath, cwd) {
+  try {
+    const output = JSON.parse(raw);
+    return (output.issues ?? []).map((issue) => ({
+      id: `credo:${issue.check}:${issue.line_no}`,
+      message: `[${issue.check}] ${issue.message}`,
+      filePath: issue.filename && issue.filename.trim() ? path.isAbsolute(issue.filename) ? issue.filename : path.resolve(cwd, issue.filename) : fallbackPath,
+      line: issue.line_no,
+      column: issue.column ?? 1,
+      severity: issue.priority <= 10 ? "error" : "warning",
+      semantic: issue.priority <= 10 ? "blocking" : "warning",
+      tool: "credo",
+      rule: issue.check,
+      fixable: false
+    }));
+  } catch {
+    return [];
+  }
+}
+function hasMixExs(cwd) {
+  return fs.existsSync(path.join(cwd, "mix.exs"));
+}
+const credoRunner = {
+  id: "credo",
+  appliesTo: ["elixir"],
+  priority: PRIORITY.GENERAL_ANALYSIS,
+  skipTestFiles: false,
+  async run(ctx) {
+    const cwd = resolveRunnerCwd(ctx, "credo");
+    if (!hasMixExs(cwd)) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    if (!await probeCredo(cwd)) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    const absPath = path.resolve(cwd, ctx.filePath);
+    const result = await safeSpawnAsync("mix", ["credo", "--format", "json", "--strict", absPath], { timeout: 30000, cwd });
+    const output = `${result.stdout ?? ""}${result.stderr ?? ""}`;
+    const parsed = parseToolRun("credo", {
+      result,
+      output,
+      exitCodes: { ran: [1, 2] }
+    }, (raw) => parseCredoJson(raw, ctx.filePath, cwd));
+    if (parsed.skipped)
+      return parsed.skipped;
+    return finishParsedRun({
+      tool: "credo",
+      ctx,
+      result,
+      diagnostics: parsed.diagnostics
+    });
+  }
+};
+export default credoRunner;

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

@@ -0,0 +1,171 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { safeSpawnAsync } from "../../safe-spawn.js";
+import { pathsEqual } from "../../path-utils.js";
+import { resolveRunnerCwd } from "../../tool-cwd.js";
+import { createAvailabilityChecker, resolveAvailableOrInstall } from "./utils/runner-helpers.js";
+import { spawnFailedWithNoOutput } from "./utils/spawn-outcome.js";
+import { findingsResult } from "../types.js";
+import { PRIORITY } from "../priorities.js";
+const cue = createAvailabilityChecker("cue", ".exe", ["version"]);
+export function parseCueVetOutput(raw) {
+  const errors = [];
+  let current = null;
+  for (const rawLine of raw.split(/\r?\n/)) {
+    if (!rawLine.trim())
+      continue;
+    if (/^\s/.test(rawLine)) {
+      if (current) {
+        const loc = rawLine.trim().match(/^(.+):(\d+):(\d+)$/);
+        if (loc) {
+          current.locations.push({
+            file: loc[1],
+            line: Number.parseInt(loc[2], 10),
+            column: Number.parseInt(loc[3], 10)
+          });
+        }
+      }
+      continue;
+    }
+    if (current)
+      errors.push(current);
+    current = { message: rawLine.replace(/:\s*$/, "").trim(), locations: [] };
+  }
+  if (current)
+    errors.push(current);
+  return errors;
+}
+export function directoryScopeUnavailable(raw) {
+  return /build constraints exclude all CUE files/.test(raw) || /found packages ".+"\s*\(.+\)\s+and\s+".+"\s*\(.+\)\s+in\s+".*"/.test(raw);
+}
+export function hasPackageClause(content) {
+  for (const line of content.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("@"))
+      continue;
+    return /^package\s+[A-Za-z_]\w*\b/.test(trimmed);
+  }
+  return false;
+}
+function locationMatchesFile(location, absTarget, vetCwd) {
+  return pathsEqual(path.resolve(vetCwd, location.file), absTarget);
+}
+function toDiagnostic(id, message, fileName, line, column) {
+  return {
+    id,
+    message: message || "cue vet reported an error",
+    filePath: fileName,
+    line,
+    column,
+    severity: "error",
+    semantic: "blocking",
+    tool: "cue-vet",
+    rule: "vet",
+    fixable: false
+  };
+}
+export function filterToTouchedFile(errors, fileName, vetCwd) {
+  if (errors.length === 0)
+    return;
+  const absTarget = path.resolve(vetCwd, fileName);
+  const withLocation = errors.filter((error) => error.locations.length > 0);
+  const unattributable = errors.filter((error) => error.locations.length === 0);
+  if (withLocation.length === 0)
+    return;
+  const diagnostics = [];
+  for (const error of withLocation) {
+    const match = error.locations.find((location) => locationMatchesFile(location, absTarget, vetCwd));
+    if (!match)
+      continue;
+    diagnostics.push(toDiagnostic(`cue-vet-${diagnostics.length + 1}-${match.line}`, error.message, fileName, match.line, match.column));
+  }
+  for (const error of unattributable) {
+    diagnostics.push(toDiagnostic(`cue-vet-unattributed-${diagnostics.length + 1}`, error.message, fileName, 1, 1));
+  }
+  return diagnostics;
+}
+const cueVetRunner = {
+  id: "cue-vet",
+  appliesTo: ["cue"],
+  priority: PRIORITY.GENERAL_ANALYSIS,
+  skipTestFiles: false,
+  timeoutMs: 30000,
+  async run(ctx) {
+    const cwd = resolveRunnerCwd(ctx, "cue-vet");
+    let cmd = null;
+    if (await cue.isAvailableAsync(cwd)) {
+      cmd = cue.getCommand(cwd);
+    } else {
+      cmd = await resolveAvailableOrInstall(cue, "cue", cwd);
+    }
+    if (!cmd)
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    const absPath = path.resolve(cwd, ctx.filePath);
+    const fileDir = path.dirname(absPath);
+    const fileName = path.basename(absPath);
+    const singleFileArgs = ["vet", "-c=false", `./${fileName}`];
+    let touchedContent = null;
+    try {
+      touchedContent = fs.readFileSync(absPath, "utf8");
+    } catch {
+      touchedContent = null;
+    }
+    const touchedIsPackageLess = touchedContent !== null && !hasPackageClause(touchedContent);
+    let result;
+    if (touchedIsPackageLess) {
+      result = await safeSpawnAsync(cmd, [...singleFileArgs], {
+        cwd: fileDir,
+        timeout: 30000
+      });
+    } else {
+      result = await safeSpawnAsync(cmd, ["vet", "-c=false", "."], {
+        cwd: fileDir,
+        timeout: 30000
+      });
+      if (!spawnFailedWithNoOutput(result, `${result.stdout}${result.stderr}`) && result.status !== 0 && directoryScopeUnavailable(`${result.stdout || ""}${result.stderr || ""}`)) {
+        result = await safeSpawnAsync(cmd, [...singleFileArgs], {
+          cwd: fileDir,
+          timeout: 30000
+        });
+      }
+    }
+    if (spawnFailedWithNoOutput(result, `${result.stdout}${result.stderr}`)) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    if (result.status === 0) {
+      return { status: "succeeded", diagnostics: [], semantic: "none" };
+    }
+    const raw = `${result.stdout || ""}
+${result.stderr || ""}`.trim();
+    const errors = parseCueVetOutput(raw);
+    const filtered = filterToTouchedFile(errors, fileName, fileDir);
+    if (filtered === undefined) {
+      const message = raw.slice(0, 300) || "cue vet exited non-zero";
+      return {
+        status: "failed",
+        diagnostics: [
+          {
+            id: "cue-vet-unparsed",
+            message,
+            filePath: ctx.filePath,
+            line: 1,
+            column: 1,
+            severity: "error",
+            semantic: "blocking",
+            tool: "cue-vet",
+            rule: "vet",
+            fixable: false
+          }
+        ],
+        semantic: "blocking",
+        failureKind: "unconfirmed_output",
+        failureMessage: message.slice(0, 200)
+      };
+    }
+    if (filtered.length === 0) {
+      return { status: "succeeded", diagnostics: [], semantic: "none" };
+    }
+    return findingsResult(filtered, { status: "failed", semantic: "blocking" });
+  }
+};
+export default cueVetRunner;