@duckmind/dm-linux-x64 0.65.4 → 0.65.6

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

@@ -0,0 +1,151 @@
+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 } from "./utils/runner-helpers.js";
+import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
+import { PRIORITY } from "../priorities.js";
+const dart = createAvailabilityChecker("dart", ".exe");
+const flutter = createAvailabilityChecker("flutter", ".bat");
+const DART_FIXABLE_RULES = new Set([
+  "prefer_const_constructors",
+  "prefer_const_constructors_in_immutables",
+  "prefer_const_declarations",
+  "prefer_const_literals_to_create_immutables",
+  "prefer_final_fields",
+  "prefer_final_in_for_each",
+  "prefer_final_locals",
+  "prefer_final_parameters",
+  "unnecessary_const",
+  "unnecessary_final",
+  "unnecessary_new",
+  "avoid_init_to_null",
+  "avoid_null_checks_in_equality_operators",
+  "avoid_returning_null_for_void",
+  "null_closures",
+  "prefer_if_null_operators",
+  "prefer_null_aware_operators",
+  "unnecessary_null_aware_assignments",
+  "unnecessary_null_in_if_null_operators",
+  "prefer_adjacent_string_concatenation",
+  "prefer_interpolation_to_compose_strings",
+  "prefer_single_quotes",
+  "unnecessary_brace_in_string_interps",
+  "unnecessary_string_escapes",
+  "unnecessary_string_interpolations",
+  "use_raw_strings",
+  "use_string_buffers",
+  "prefer_collection_literals",
+  "prefer_contains",
+  "prefer_for_elements_to_map_fromiterable",
+  "prefer_inlined_adds",
+  "prefer_int_literals",
+  "prefer_iterable_whereType",
+  "prefer_is_empty",
+  "prefer_is_not_empty",
+  "prefer_is_not_operator",
+  "prefer_spread_collections",
+  "use_collection_literals_when_possible",
+  "omit_local_variable_types",
+  "prefer_expression_function_bodies",
+  "prefer_function_declarations_over_variables",
+  "prefer_generic_function_type_aliases",
+  "prefer_typing_uninitialized_variables",
+  "prefer_void_to_null",
+  "type_init_formals",
+  "use_function_type_syntax_for_parameters",
+  "avoid_redundant_argument_values",
+  "avoid_unused_constructor_parameters",
+  "empty_catches",
+  "empty_constructor_bodies",
+  "unnecessary_lambdas",
+  "unnecessary_overrides",
+  "unnecessary_parenthesis",
+  "unnecessary_this",
+  "combinators_ordering",
+  "directives_ordering",
+  "prefer_relative_imports",
+  "sort_child_properties_last",
+  "slash_for_doc_comments",
+  "sized_box_for_whitespace",
+  "use_decorated_box",
+  "use_full_hex_values_for_flutter_colors",
+  "use_key_in_widget_constructors",
+  "use_named_constants",
+  "use_super_parameters",
+  "prefer_conditional_assignment",
+  "prefer_equal_for_default_values",
+  "prefer_initializing_formals",
+  "avoid_void_async",
+  "unawaited_futures",
+  "use_rethrow_when_possible"
+]);
+function parseDartMachineOutput(raw, filePath, cwd) {
+  const diagnostics = [];
+  const absTarget = path.resolve(cwd, filePath);
+  for (const line of raw.split(/\r?\n/)) {
+    if (!line.trim())
+      continue;
+    const parts = line.split("|");
+    if (parts.length < 8)
+      continue;
+    const [severityStr, , code, file, lineStr, colStr, , ...messageParts] = parts;
+    const message = messageParts.join("|").trim();
+    const lineNum = parseInt(lineStr, 10);
+    const colNum = parseInt(colStr, 10);
+    if (!pathsEqual(path.resolve(cwd, file?.trim() ?? ""), absTarget))
+      continue;
+    const severity = severityStr?.trim().toLowerCase() === "error" ? "error" : "warning";
+    const ruleId = code?.trim() ?? "dart";
+    const fixable = DART_FIXABLE_RULES.has(ruleId);
+    diagnostics.push({
+      id: `dart-${ruleId}-${lineNum}-${colNum}`,
+      message: `[${ruleId}] ${message}`,
+      filePath,
+      line: lineNum || 1,
+      column: colNum || 1,
+      severity,
+      semantic: severity === "error" ? "blocking" : "warning",
+      tool: "dart",
+      rule: ruleId,
+      defectClass: "style",
+      fixable,
+      fixSuggestion: fixable ? "Run `dart fix --apply` to apply the deterministic auto-correction for this rule." : undefined
+    });
+  }
+  return diagnostics;
+}
+const dartAnalyzeRunner = {
+  id: "dart-analyze",
+  appliesTo: ["dart"],
+  priority: PRIORITY.GENERAL_ANALYSIS,
+  skipTestFiles: false,
+  async run(ctx) {
+    const cwd = resolveRunnerCwd(ctx, "dart-analyze");
+    const absPath = path.resolve(cwd, ctx.filePath);
+    const dartAvailable = await dart.isAvailableAsync(cwd);
+    const flutterAvailable = !dartAvailable && await flutter.isAvailableAsync(cwd);
+    if (!dartAvailable && !flutterAvailable) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    const cmd = dartAvailable ? dart.getCommand(cwd) : flutter.getCommand(cwd);
+    const args = dartAvailable ? ["analyze", "--format=machine", absPath] : ["analyze", "--machine", absPath];
+    const result = await safeSpawnAsync(cmd, args, { cwd, timeout: 30000 });
+    const raw = (result.stderr || "") + (result.stdout || "");
+    const parsed = parseToolRun("dart-analyze", {
+      result,
+      output: raw,
+      exitCodes: { ran: [1, 2] }
+    }, (out) => parseDartMachineOutput(out, ctx.filePath, cwd));
+    if (parsed.skipped)
+      return parsed.skipped;
+    return finishParsedRun({
+      tool: "dart-analyze",
+      ctx,
+      result,
+      diagnostics: parsed.diagnostics
+    });
+  }
+};
+export default dartAnalyzeRunner;
+export { parseDartMachineOutput, DART_FIXABLE_RULES };

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

@@ -0,0 +1,157 @@
+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 { getLinterPolicyForCwd } from "../../tool-policy.js";
+import { PRIORITY } from "../priorities.js";
+import { createAvailabilityChecker } from "./utils/runner-helpers.js";
+import { parseToolRun } from "./utils/tool-failure.js";
+const detekt = createAvailabilityChecker("detekt", ".bat");
+const DETEKT_CONFIG_CANDIDATES = [
+  "detekt.yml",
+  ".detekt.yml",
+  path.join("config", "detekt", "detekt.yml"),
+  path.join("detekt", "detekt.yml")
+];
+const DETEKT_FIXABLE_RULES = new Set([
+  "AnnotationOnSeparateLine",
+  "AnnotationSpacing",
+  "ArgumentListWrapping",
+  "BlockCommentInitialStarAlignment",
+  "ChainWrapping",
+  "CommentSpacing",
+  "CommentWrapping",
+  "EnumEntryNameCase",
+  "Filename",
+  "FinalNewline",
+  "ImportOrdering",
+  "Indentation",
+  "MaximumLineLength",
+  "ModifierListSpacing",
+  "ModifierOrdering",
+  "MultiLineIfElse",
+  "NoBlankLineBeforeRbrace",
+  "NoBlankLinesInChainedMethodCalls",
+  "NoConsecutiveBlankLines",
+  "NoEmptyClassBody",
+  "NoEmptyFirstLineInMethodBlock",
+  "NoLineBreakAfterElse",
+  "NoLineBreakBeforeAssignment",
+  "NoMultipleSpaces",
+  "NoSemicolons",
+  "NoTrailingSpaces",
+  "NoUnitReturn",
+  "NoUnusedImports",
+  "NoWildcardImports",
+  "PackageName",
+  "ParameterListWrapping",
+  "SpacingAroundAngleBrackets",
+  "SpacingAroundColon",
+  "SpacingAroundComma",
+  "SpacingAroundCurly",
+  "SpacingAroundDot",
+  "SpacingAroundDoubleColon",
+  "SpacingAroundKeyword",
+  "SpacingAroundOperators",
+  "SpacingAroundParens",
+  "SpacingAroundRangeOperator",
+  "SpacingAroundUnaryOperator",
+  "SpacingBetweenDeclarationsWithAnnotations",
+  "SpacingBetweenDeclarationsWithComments",
+  "StringTemplate",
+  "TrailingCommaOnCallSite",
+  "TrailingCommaOnDeclarationSite",
+  "TypeArgumentListSpacing",
+  "TypeParameterListSpacing",
+  "UnnecessaryParenthesesBeforeTrailingLambda",
+  "Wrapping",
+  "OptionalUnit",
+  "OptionalAbstractKeyword",
+  "ProtectedMemberInFinalClass",
+  "UnnecessaryParentheses",
+  "UnusedImports",
+  "UnusedPrivateClass",
+  "RedundantVisibilityModifierRule"
+]);
+export function findDetektConfig(cwd) {
+  for (const candidate of DETEKT_CONFIG_CANDIDATES) {
+    const full = path.join(cwd, candidate);
+    if (fs.existsSync(full))
+      return full;
+  }
+  return;
+}
+function parseDetektOutput(raw, filePath, cwd) {
+  const diagnostics = [];
+  const pattern = /^(.+?):(\d+):(\d+): (error|warning): (.+?)(?:\s+\[([^\]]+)\])?$/gm;
+  const absTarget = path.resolve(cwd, filePath);
+  for (const match of raw.matchAll(pattern)) {
+    const [, file, lineStr, colStr, level, message, rule] = match;
+    if (!pathsEqual(path.resolve(cwd, file.trim()), absTarget))
+      continue;
+    const severity = level === "error" ? "error" : "warning";
+    const lineNum = Number.parseInt(lineStr, 10);
+    const colNum = Number.parseInt(colStr, 10);
+    const ruleId = rule ?? "detekt";
+    const fixable = rule ? DETEKT_FIXABLE_RULES.has(rule) : false;
+    diagnostics.push({
+      id: `detekt-${ruleId}-${lineNum}-${colNum}`,
+      message: rule ? `[${rule}] ${message}` : message,
+      filePath,
+      line: lineNum,
+      column: colNum,
+      severity,
+      semantic: severity === "error" ? "blocking" : "warning",
+      tool: "detekt",
+      rule: ruleId,
+      defectClass: "style",
+      fixable,
+      fixSuggestion: fixable ? "Run `detekt --auto-correct` to apply the deterministic auto-correction for this rule." : undefined
+    });
+  }
+  return diagnostics;
+}
+const detektRunner = {
+  id: "detekt",
+  appliesTo: ["kotlin"],
+  priority: PRIORITY.GENERAL_ANALYSIS,
+  timeoutMs: 90000,
+  skipTestFiles: false,
+  async run(ctx) {
+    const cwd = resolveRunnerCwd(ctx, "detekt");
+    const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
+    if (policy && !policy.preferredRunners.includes("detekt")) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    const configPath = findDetektConfig(cwd);
+    if (!configPath) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    const cmd = await detekt.isAvailableAsync(cwd) ? detekt.getCommand(cwd) : null;
+    if (!cmd)
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    const absPath = path.resolve(cwd, ctx.filePath);
+    const result = await safeSpawnAsync(cmd, ["--input", absPath, "--config", configPath], { cwd, timeout: 60000 });
+    const raw = `${result.stdout ?? ""}${result.stderr ?? ""}`;
+    const run = parseToolRun("detekt", {
+      result,
+      output: raw,
+      exitCodes: { ran: [1, 2] }
+    }, (out) => parseDetektOutput(out, ctx.filePath, cwd));
+    if (run.skipped)
+      return run.skipped;
+    const diagnostics = run.diagnostics;
+    if (diagnostics.length === 0) {
+      return { status: "succeeded", diagnostics: [], semantic: "none" };
+    }
+    const hasErrors = diagnostics.some((d) => d.severity === "error");
+    return {
+      status: hasErrors ? "failed" : "succeeded",
+      diagnostics,
+      semantic: hasErrors ? "blocking" : "warning"
+    };
+  }
+};
+export default detektRunner;
+export { DETEKT_FIXABLE_RULES, parseDetektOutput };

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

@@ -0,0 +1,157 @@
+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 { PRIORITY } from "../priorities.js";
+import { createAvailabilityChecker } from "./utils/runner-helpers.js";
+import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
+const dotnet = createAvailabilityChecker("dotnet", ".exe");
+function findProjectTarget(cwd) {
+  const entries = fs.readdirSync(cwd);
+  const solution = entries.find((entry) => /\.(sln|slnx)$/i.test(entry));
+  if (solution)
+    return solution;
+  return entries.find((entry) => /\.(csproj)$/i.test(entry));
+}
+function isDotnetRuleId(value) {
+  if (value.length < 2)
+    return false;
+  let sawDigit = false;
+  for (const char of value) {
+    const code = char.charCodeAt(0);
+    const isLetter = code >= 65 && code <= 90 || code >= 97 && code <= 122;
+    const isDigit = code >= 48 && code <= 57;
+    if (isDigit) {
+      sawDigit = true;
+      continue;
+    }
+    if (!isLetter || sawDigit)
+      return false;
+  }
+  return sawDigit;
+}
+function parseDotnetDiagnosticLine(line) {
+  const lower = line.toLowerCase();
+  const fileEnd = lower.lastIndexOf(".cs(");
+  if (fileEnd < 0)
+    return null;
+  const reportedFile = line.slice(0, fileEnd + 3).trim();
+  let cursor = fileEnd + 4;
+  const lineStart = cursor;
+  while (cursor < line.length && line.charCodeAt(cursor) >= 48 && line.charCodeAt(cursor) <= 57) {
+    cursor += 1;
+  }
+  if (cursor === lineStart || line[cursor] !== ",")
+    return null;
+  const lineStr = line.slice(lineStart, cursor);
+  cursor += 1;
+  const colStart = cursor;
+  while (cursor < line.length && line.charCodeAt(cursor) >= 48 && line.charCodeAt(cursor) <= 57) {
+    cursor += 1;
+  }
+  if (cursor === colStart || line.slice(cursor, cursor + 3) !== "): ")
+    return null;
+  const colStr = line.slice(colStart, cursor);
+  cursor += 3;
+  const tailLower = line.slice(cursor).toLowerCase();
+  let severityLabel;
+  if (tailLower.startsWith("error ")) {
+    severityLabel = "error";
+    cursor += "error ".length;
+  } else if (tailLower.startsWith("warning ")) {
+    severityLabel = "warning";
+    cursor += "warning ".length;
+  } else {
+    return null;
+  }
+  const colon = line.indexOf(":", cursor);
+  if (colon < 0)
+    return null;
+  const rule = line.slice(cursor, colon).trim();
+  if (!isDotnetRuleId(rule))
+    return null;
+  let message = line.slice(colon + 1).trim();
+  if (message.endsWith("]")) {
+    const projectSuffix = message.lastIndexOf(" [");
+    if (projectSuffix >= 0)
+      message = message.slice(0, projectSuffix).trimEnd();
+  }
+  return { reportedFile, lineStr, colStr, severityLabel, rule, message };
+}
+function parseDotnetBuildOutput(raw, filePath, cwd) {
+  const diagnostics = [];
+  const absTarget = path.resolve(cwd, filePath);
+  for (const line of raw.split(/\r?\n/)) {
+    const parsed = parseDotnetDiagnosticLine(line);
+    if (!parsed)
+      continue;
+    const { reportedFile, lineStr, colStr, severityLabel, rule, message } = parsed;
+    if (!pathsEqual(path.resolve(cwd, reportedFile), absTarget))
+      continue;
+    const severity = severityLabel.toLowerCase() === "error" ? "error" : "warning";
+    const lineNum = Number.parseInt(lineStr, 10) || 1;
+    const colNum = Number.parseInt(colStr, 10) || 1;
+    diagnostics.push({
+      id: `dotnet-build-${rule}-${lineNum}-${colNum}`,
+      message: `[${rule}] ${message.trim()}`,
+      filePath,
+      line: lineNum,
+      column: colNum,
+      severity,
+      semantic: severity === "error" ? "blocking" : "warning",
+      tool: "dotnet-build",
+      rule,
+      fixable: false
+    });
+  }
+  return diagnostics;
+}
+const dotnetBuildRunner = {
+  id: "dotnet-build",
+  appliesTo: ["csharp"],
+  priority: PRIORITY.GENERAL_ANALYSIS,
+  timeoutMs: 90000,
+  skipTestFiles: false,
+  async run(ctx) {
+    const cwd = resolveRunnerCwd(ctx, "dotnet-build");
+    if (!await dotnet.isAvailableAsync(cwd)) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    const cmd = dotnet.getCommand(cwd);
+    if (!cmd) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    const target = findProjectTarget(cwd);
+    if (!target) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    const result = await safeSpawnAsync(cmd, ["build", target, "--nologo", "--verbosity", "minimal"], {
+      cwd,
+      timeout: 60000
+    });
+    const raw = `${result.stdout ?? ""}
+${result.stderr ?? ""}`.trim();
+    const parsed = parseToolRun("dotnet-build", {
+      result,
+      output: raw,
+      exitCodes: { ran: [1, 2] }
+    }, (output) => parseDotnetBuildOutput(output, ctx.filePath, cwd));
+    if (parsed.skipped)
+      return parsed.skipped;
+    return finishParsedRun({
+      tool: "dotnet-build",
+      ctx,
+      result,
+      diagnostics: parsed.diagnostics,
+      classify: (diagnostics) => {
+        const hasErrors = diagnostics.some((d) => d.severity === "error");
+        return {
+          status: hasErrors ? "failed" : "succeeded",
+          semantic: hasErrors ? "blocking" : "warning"
+        };
+      }
+    });
+  }
+};
+export default dotnetBuildRunner;

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

@@ -0,0 +1,153 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getProjectDataDir } from "../../file-utils.js";
+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 } from "./utils/runner-helpers.js";
+import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
+const mix = createAvailabilityChecker("mix", ".bat");
+const elixirc = createAvailabilityChecker("elixirc", ".bat");
+function hasMixExs(cwd) {
+  return fs.existsSync(path.join(cwd, "mix.exs"));
+}
+const ELIXIR_SNIPPET_LOCATION = /└─\s+(.+?):(\d+)(?::(\d+))?(?::|$)/;
+function parseElixirOutput(raw, filePath, cwd = process.cwd()) {
+  const diagnostics = [];
+  const resolvedTarget = path.resolve(cwd, filePath);
+  const lines = raw.split(/\r?\n/);
+  const matchesTarget = (sourcePath) => pathsEqual(path.resolve(cwd, sourcePath.trim()), resolvedTarget);
+  for (let index = 0;index < lines.length; index++) {
+    const line = lines[index];
+    if (line.length > 2000)
+      continue;
+    const syntax = line.match(/^\*\* \(([^)]+)\)\s+(.+?):(\d+):(?:(\d+):)?\s*(.+)$/);
+    if (syntax) {
+      const [, kind, sourcePath, lineStr, colStr, message] = syntax;
+      if (!matchesTarget(sourcePath))
+        continue;
+      diagnostics.push({
+        id: `elixir-check-${kind}-${lineStr}-${colStr || "1"}`,
+        message: `[${kind}] ${message.trim()}`,
+        filePath,
+        line: Number.parseInt(lineStr, 10) || 1,
+        column: Number.parseInt(colStr || "1", 10) || 1,
+        severity: "error",
+        semantic: "blocking",
+        tool: "elixir-check",
+        rule: kind,
+        fixable: false
+      });
+      continue;
+    }
+    const header = line.match(/^\s*(error|warning):\s+(.+)$/);
+    if (!header)
+      continue;
+    const [, severityLabel, message] = header;
+    const severity = severityLabel === "error" ? "error" : "warning";
+    let located = false;
+    for (let lookahead = index + 1;lookahead < lines.length && lookahead <= index + 12; lookahead++) {
+      const next = lines[lookahead];
+      if (/^\s*(error|warning):\s+/.test(next))
+        break;
+      const snippet = next.match(ELIXIR_SNIPPET_LOCATION);
+      if (snippet) {
+        const [, sourcePath, lineStr, colStr] = snippet;
+        if (matchesTarget(sourcePath)) {
+          diagnostics.push({
+            id: `elixir-check-${severity}-${lineStr}-${colStr || "1"}`,
+            message: severity === "error" ? `[error] ${message.trim()}` : message.trim(),
+            filePath,
+            line: Number.parseInt(lineStr, 10) || 1,
+            column: Number.parseInt(colStr || "1", 10) || 1,
+            severity,
+            semantic: severity === "error" ? "blocking" : "warning",
+            tool: "elixir-check",
+            rule: severity === "error" ? "error" : "warning",
+            fixable: false
+          });
+        }
+        located = true;
+        break;
+      }
+    }
+    if (located)
+      continue;
+    const location = lines[index + 1]?.match(/^\s+(.+?):(\d+):(?:(\d+):)?$/);
+    if (!location)
+      continue;
+    const [, sourcePath, lineStr, colStr] = location;
+    if (!matchesTarget(sourcePath))
+      continue;
+    diagnostics.push({
+      id: `elixir-check-${severity}-${lineStr}-${colStr || "1"}`,
+      message: severity === "error" ? `[error] ${message.trim()}` : message.trim(),
+      filePath,
+      line: Number.parseInt(lineStr, 10) || 1,
+      column: Number.parseInt(colStr || "1", 10) || 1,
+      severity,
+      semantic: severity === "error" ? "blocking" : "warning",
+      tool: "elixir-check",
+      rule: severity === "error" ? "error" : "warning",
+      fixable: false
+    });
+  }
+  return diagnostics;
+}
+const elixirCheckRunner = {
+  id: "elixir-check",
+  appliesTo: ["elixir"],
+  priority: PRIORITY.GENERAL_ANALYSIS,
+  skipTestFiles: false,
+  async run(ctx) {
+    const cwd = resolveRunnerCwd(ctx, "elixir-check");
+    const absPath = path.resolve(cwd, ctx.filePath);
+    let command;
+    let args = [];
+    if (hasMixExs(cwd) && await mix.isAvailableAsync(cwd)) {
+      command = "mix";
+      args = ["compile", "--warnings-as-errors"];
+    } else if (await elixirc.isAvailableAsync(cwd)) {
+      const outDir = path.join(getProjectDataDir(cwd), "elixir-check");
+      fs.mkdirSync(outDir, { recursive: true });
+      command = "elixirc";
+      args = ["-o", outDir, absPath];
+    }
+    if (!command) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    const result = await safeSpawnAsync(command, args, {
+      cwd,
+      timeout: 30000
+    });
+    const raw = `${result.stderr || ""}
+${result.stdout || ""}`;
+    const hasProjectContext = command === "mix";
+    const parsed = parseToolRun("elixir-check", {
+      result,
+      output: raw,
+      exitCodes: { ran: [1, 2] }
+    }, (out) => parseElixirOutput(out, ctx.filePath, cwd).map((d) => hasProjectContext ? d : {
+      ...d,
+      semantic: "warning"
+    }));
+    if (parsed.skipped)
+      return parsed.skipped;
+    return finishParsedRun({
+      tool: "elixir-check",
+      ctx,
+      result,
+      diagnostics: parsed.diagnostics,
+      classify: (diagnostics) => {
+        const hasBlocking = diagnostics.some((d) => d.semantic === "blocking");
+        return {
+          status: hasBlocking ? "failed" : "succeeded",
+          semantic: hasBlocking ? "blocking" : "warning"
+        };
+      }
+    });
+  }
+};
+export default elixirCheckRunner;
+export { parseElixirOutput };