@duckmind/dm-linux-x64 0.65.8 → 0.66.2

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

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

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

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

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