@duckmind/dm-linux-x64 0.66.0 → 0.66.2

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

@@ -1,100 +0,0 @@
-import actionlintRunner from "./actionlint.js";
-import astGrepNapiRunner from "./ast-grep-napi.js";
-import biomeCheckJsonRunner from "./biome-check.js";
-import cppCheckRunner from "./cpp-check.js";
-import credoRunner from "./credo.js";
-import cueVetRunner from "./cue-vet.js";
-import dartAnalyzeRunner from "./dart-analyze.js";
-import detektRunner from "./detekt.js";
-import dotnetBuildRunner from "./dotnet-build.js";
-import elixirCheckRunner from "./elixir-check.js";
-import eslintRunner from "./eslint.js";
-import factRulesRunner from "./fact-rules.js";
-import gleamCheckRunner from "./gleam-check.js";
-import goVetRunner from "./go-vet.js";
-import golangciRunner from "./golangci-lint.js";
-import hadolintRunner from "./hadolint.js";
-import helmLintRunner from "./helm-lint.js";
-import helmRenderRunner from "./helm-render.js";
-import htmlhintRunner from "./htmlhint.js";
-import javacRunner from "./javac.js";
-import ktlintRunner from "./ktlint.js";
-import lspRunner from "./lsp.js";
-import markdownlintRunner from "./markdownlint.js";
-import mypyRunner from "./mypy.js";
-import oxlintRunner from "./oxlint.js";
-import phpLintRunner from "./php-lint.js";
-import phpstanRunner from "./phpstan.js";
-import prismaValidateRunner from "./prisma-validate.js";
-import psScriptAnalyzerRunner from "./psscriptanalyzer.js";
-import pyrightRunner from "./pyright.js";
-import rubocopRunner from "./rubocop.js";
-import ruffRunner from "./ruff.js";
-import rustClippyRunner from "./rust-clippy.js";
-import spotbugsRunner from "./spotbugs.js";
-import shellcheckRunner from "./shellcheck.js";
-import fishIndentRunner from "./fish-indent.js";
-import shfmtRunner from "./shfmt.js";
-import spellcheckRunner from "./spellcheck.js";
-import sqlfluffRunner from "./sqlfluff.js";
-import stylelintRunner from "./stylelint.js";
-import swiftlintRunner from "./swiftlint.js";
-import taploRunner from "./taplo.js";
-import terragruntRunner from "./terragrunt.js";
-import tflintRunner from "./tflint.js";
-import trivyConfigRunner from "./trivy-config.js";
-import valeRunner from "./vale.js";
-import treeSitterRunner from "./tree-sitter.js";
-import yamllintRunner from "./yamllint.js";
-import zigCheckRunner from "./zig-check.js";
-export function registerDefaultRunners(registry) {
-  registry.register(lspRunner);
-  registry.register(pyrightRunner);
-  registry.register(biomeCheckJsonRunner);
-  registry.register(astGrepNapiRunner);
-  registry.register(treeSitterRunner);
-  registry.register(ruffRunner);
-  registry.register(shellcheckRunner);
-  registry.register(spotbugsRunner);
-  registry.register(eslintRunner);
-  registry.register(oxlintRunner);
-  registry.register(golangciRunner);
-  registry.register(rubocopRunner);
-  registry.register(spellcheckRunner);
-  registry.register(yamllintRunner);
-  registry.register(actionlintRunner);
-  registry.register(sqlfluffRunner);
-  registry.register(goVetRunner);
-  registry.register(rustClippyRunner);
-  registry.register(markdownlintRunner);
-  registry.register(mypyRunner);
-  registry.register(stylelintRunner);
-  registry.register(swiftlintRunner);
-  registry.register(shfmtRunner);
-  registry.register(fishIndentRunner);
-  registry.register(factRulesRunner);
-  registry.register(htmlhintRunner);
-  registry.register(hadolintRunner);
-  registry.register(helmLintRunner);
-  registry.register(helmRenderRunner);
-  registry.register(valeRunner);
-  registry.register(phpLintRunner);
-  registry.register(psScriptAnalyzerRunner);
-  registry.register(prismaValidateRunner);
-  registry.register(ktlintRunner);
-  registry.register(detektRunner);
-  registry.register(tflintRunner);
-  registry.register(terragruntRunner);
-  registry.register(trivyConfigRunner);
-  registry.register(taploRunner);
-  registry.register(dartAnalyzeRunner);
-  registry.register(javacRunner);
-  registry.register(dotnetBuildRunner);
-  registry.register(cppCheckRunner);
-  registry.register(zigCheckRunner);
-  registry.register(gleamCheckRunner);
-  registry.register(credoRunner);
-  registry.register(elixirCheckRunner);
-  registry.register(phpstanRunner);
-  registry.register(cueVetRunner);
-}

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

@@ -1,82 +0,0 @@
-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 { hasJavaBuildDescriptor } from "../../tool-policy.js";
-import { PRIORITY } from "../priorities.js";
-import { createAvailabilityChecker } from "./utils/runner-helpers.js";
-import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
-const javac = createAvailabilityChecker("javac", ".exe");
-function parseJavacOutput(raw, filePath, cwd) {
-  const diagnostics = [];
-  const lines = raw.split(/\r?\n/);
-  const absTarget = path.resolve(cwd, filePath);
-  for (const line of lines) {
-    const match = line.match(/^(.*?\.java):(\d+):\s+(error|warning):\s+(.+)$/i);
-    if (!match)
-      continue;
-    const [, reportedFile, lineStr, severityLabel, message] = match;
-    if (!pathsEqual(path.resolve(cwd, reportedFile.trim()), absTarget))
-      continue;
-    const severity = severityLabel.toLowerCase() === "error" ? "error" : "warning";
-    const lineNum = Number.parseInt(lineStr, 10) || 1;
-    diagnostics.push({
-      id: `javac-${severity}-${lineNum}-${message}`,
-      message: message.trim(),
-      filePath,
-      line: lineNum,
-      column: 1,
-      severity,
-      semantic: "warning",
-      tool: "javac",
-      rule: "compile",
-      fixable: false
-    });
-  }
-  return diagnostics;
-}
-const javacRunner = {
-  id: "javac",
-  appliesTo: ["java"],
-  priority: PRIORITY.GENERAL_ANALYSIS,
-  skipTestFiles: false,
-  async run(ctx) {
-    const cwd = resolveRunnerCwd(ctx, "javac");
-    const absPath = path.resolve(cwd, ctx.filePath);
-    if (hasJavaBuildDescriptor(path.dirname(absPath), ctx.projectRoot ?? ctx.cwd)) {
-      ctx.log?.("javac: skipped — file is inside a Maven/Gradle project; a classpath-less compile would emit false positives");
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    if (!await javac.isAvailableAsync(cwd)) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    const cmd = javac.getCommand(cwd);
-    if (!cmd) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    const result = await safeSpawnAsync(cmd, ["-Xlint:none", "-proc:none", absPath], {
-      cwd,
-      timeout: 30000
-    });
-    const raw = `${result.stdout ?? ""}
-${result.stderr ?? ""}`.trim();
-    const parsed = parseToolRun("javac", {
-      result,
-      output: raw,
-      exitCodes: { ran: [1, 2] }
-    }, (output) => parseJavacOutput(output, ctx.filePath, cwd));
-    if (parsed.skipped)
-      return parsed.skipped;
-    return finishParsedRun({
-      tool: "javac",
-      ctx,
-      result,
-      diagnostics: parsed.diagnostics,
-      classify: (diagnostics) => ({
-        status: diagnostics.some((d) => d.severity === "error") ? "failed" : "succeeded",
-        semantic: "warning"
-      })
-    });
-  }
-};
-export default javacRunner;

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

@@ -1,93 +0,0 @@
-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 { getAutofixCapability, getLinterPolicyForCwd } from "../../tool-policy.js";
-import { PRIORITY } from "../priorities.js";
-import { createAvailabilityChecker, resolveToolCommandWithInstallFallback } from "./utils/runner-helpers.js";
-import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
-const ktlint = createAvailabilityChecker("ktlint", ".exe");
-const KTLINT_EXIT_CODES = { ran: [1, 2, 3] };
-function normalizeKtlintResults(parsed) {
-  if (Array.isArray(parsed)) {
-    return parsed;
-  }
-  if (parsed && typeof parsed === "object" && Array.isArray(parsed.errors)) {
-    return [parsed];
-  }
-  return null;
-}
-function parseKtlintOutput(raw, filePath, cwd) {
-  try {
-    const parsed = normalizeKtlintResults(JSON.parse(raw));
-    if (!parsed)
-      return null;
-    const autofix = getAutofixCapability("ktlint");
-    const diagnostics = [];
-    const absTarget = path.resolve(cwd, filePath);
-    for (const result of parsed) {
-      if (result.file && !pathsEqual(path.resolve(cwd, result.file), absTarget))
-        continue;
-      for (const err of result.errors ?? []) {
-        diagnostics.push({
-          id: `ktlint-${err.ruleId}-${err.line}-${err.col}`,
-          message: `[${err.ruleId}] ${err.detail}`,
-          filePath,
-          line: err.line,
-          column: err.col,
-          severity: "warning",
-          semantic: "warning",
-          tool: "ktlint",
-          rule: err.ruleId,
-          fixable: true,
-          autoFixAvailable: autofix?.safePipelineAutofix ?? false,
-          fixKind: autofix?.fixKind === "none" ? undefined : autofix?.fixKind
-        });
-      }
-    }
-    return diagnostics;
-  } catch {
-    return null;
-  }
-}
-const ktlintRunner = {
-  id: "ktlint",
-  appliesTo: ["kotlin"],
-  priority: PRIORITY.FORMAT_AND_LINT_PRIMARY,
-  skipTestFiles: false,
-  async run(ctx) {
-    const cwd = resolveRunnerCwd(ctx, "ktlint");
-    const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
-    if (policy && !policy.preferredRunners.includes("ktlint")) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    let cmd = null;
-    if (await ktlint.isAvailableAsync(cwd)) {
-      cmd = ktlint.getCommand(cwd);
-    } else {
-      cmd = await resolveToolCommandWithInstallFallback(cwd, "ktlint");
-    }
-    if (!cmd)
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    const absPath = path.resolve(cwd, ctx.filePath);
-    const result = await safeSpawnAsync(cmd, ["--reporter=json", absPath], {
-      cwd,
-      timeout: 30000
-    });
-    const run = parseToolRun("ktlint", {
-      result,
-      output: `${result.stdout ?? ""}
-${result.stderr ?? ""}`,
-      exitCodes: KTLINT_EXIT_CODES
-    }, (output) => parseKtlintOutput(output, ctx.filePath, cwd) ?? []);
-    if (run.skipped)
-      return run.skipped;
-    return finishParsedRun({
-      tool: "ktlint",
-      ctx,
-      result,
-      diagnostics: run.diagnostics
-    });
-  }
-};
-export default ktlintRunner;

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

@@ -1,206 +0,0 @@
-import { logExtension } from "../../extension-log.js";
-import { getLspCapableKinds } from "../../language-policy.js";
-import { exceedsLspSyncLimits } from "../../lsp/content-limits.js";
-import { touchCoverageGap } from "../../lsp/diagnostic-binding.js";
-import { getLSPService } from "../../lsp/index.js";
-import { LSP_SERVERS } from "../../lsp/server.js";
-import { RUNTIME_CONFIG } from "../../runtime-config.js";
-import { PRIORITY } from "../priorities.js";
-import { resolveRunnerPath } from "../runner-context.js";
-import { convertLspDiagnostics } from "../utils/lsp-diagnostics.js";
-import { demoteInferredProjectDiagnostics } from "../../lsp/inferred-project.js";
-import { enabledAuxiliaryLspServerIds, retagAuxiliaryDiagnostics } from "../auxiliary-lsp.js";
-import { readFileContent } from "./utils.js";
-import { tryWarmAttachedCodeActions, tryWarmAttachedDiagnostics } from "../../warm-attach.js";
-import { contentHash, WARM_CODE_ACTION_LOOKUP_LIMIT } from "../../mcp/ipc.js";
-const LSP_SPAWN_BUDGET_MS = RUNTIME_CONFIG.pipeline.lspSpawnBudgetMs;
-export const LSP_DIAGNOSTICS_WAIT_MS = 2500;
-const MAX_CODE_ACTION_TITLES = 3;
-const LSP_COLD_SPAWN_MARGIN_MS = 5000;
-export const LSP_RUNNER_TIMEOUT_MS = Math.max(LSP_SPAWN_BUDGET_MS, ...LSP_SERVERS.map((server) => server.clientWaitTimeoutMs ?? 0)) + LSP_DIAGNOSTICS_WAIT_MS + LSP_COLD_SPAWN_MARGIN_MS;
-function normalizeActionTitle(title) {
-  return title.replace(/\s+/g, " ").trim();
-}
-function buildCodeActionSuggestion(actions) {
-  if (!actions.length)
-    return;
-  const quickFixes = actions.filter((action) => action.kind?.startsWith("quickfix"));
-  if (!quickFixes.length)
-    return;
-  const titles = Array.from(new Set(quickFixes.map((action) => normalizeActionTitle(action.title)).filter((title) => title.length > 0))).slice(0, MAX_CODE_ACTION_TITLES);
-  if (!titles.length)
-    return;
-  return `LSP quick fixes: ${titles.join("; ")}`;
-}
-const lspRunner = {
-  id: "lsp",
-  appliesTo: getLspCapableKinds(),
-  priority: PRIORITY.LSP_PRIMARY,
-  timeoutMs: LSP_RUNNER_TIMEOUT_MS,
-  async run(ctx) {
-    const diagnosticPath = resolveRunnerPath(ctx.cwd, ctx.filePath);
-    if (ctx.pi.getFlag("no-lsp")) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    const lspService = getLSPService();
-    if (!lspService.supportsLSP(ctx.filePath)) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    let lspDiags = [];
-    let serverFailed = false;
-    let lspClientReady = true;
-    let diagnosticsInconclusive = false;
-    let unconfirmedServerIds = [];
-    let deferredServerIds = [];
-    let usedWarmAttach = false;
-    let failureReason = "";
-    const content = readFileContent(ctx.filePath);
-    if (!content) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    if (exceedsLspSyncLimits(content).tooLarge) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    const auxiliaryServerIds = enabledAuxiliaryLspServerIds((f) => ctx.pi.getFlag(f));
-    try {
-      const attached = await tryWarmAttachedDiagnostics(ctx.filePath, content, Math.max(LSP_SPAWN_BUDGET_MS, LSP_DIAGNOSTICS_WAIT_MS));
-      usedWarmAttach = attached?.available === true;
-      const touched = attached?.available ? {
-        diags: attached.response.diagnostics,
-        ...attached.response.unconfirmedServerIds !== undefined && {
-          unconfirmedServerIds: attached.response.unconfirmedServerIds
-        }
-      } : await lspService.touchFile(ctx.filePath, content, {
-        diagnostics: "document",
-        collectDiagnostics: true,
-        clientScope: auxiliaryServerIds.length > 0 ? "with-auxiliary" : "primary",
-        auxiliaryServerIds,
-        maxClientWaitMs: LSP_SPAWN_BUDGET_MS,
-        maxDiagnosticsWaitMs: LSP_DIAGNOSTICS_WAIT_MS,
-        source: "dispatch-lsp-runner"
-      });
-      if (touched === undefined) {
-        lspClientReady = false;
-      } else {
-        lspDiags = touched.diags;
-        diagnosticsInconclusive = touched.inconclusive === true;
-        unconfirmedServerIds = touchCoverageGap(touched);
-        deferredServerIds = touched.deferredServerIds ?? [];
-      }
-    } catch (err) {
-      serverFailed = true;
-      failureReason = err instanceof Error ? err.message : String(err);
-      if (failureReason.includes("spawn") || failureReason.includes("exited") || failureReason.includes("connection") || failureReason.includes("JSON RPC")) {
-        logExtension({
-          subsystem: "lsp-runner",
-          message: `LSP server failed for ${diagnosticPath}: ${failureReason}`,
-          metadata: { filePath: diagnosticPath }
-        });
-      }
-    }
-    if (serverFailed) {
-      return {
-        status: "failed",
-        failureKind: "server_error",
-        failureMessage: failureReason.slice(0, 200),
-        diagnostics: [
-          {
-            id: `lsp:server-error:0`,
-            message: `LSP server failed: ${failureReason}`,
-            filePath: diagnosticPath,
-            line: 1,
-            column: 1,
-            severity: "error",
-            semantic: "warning",
-            tool: "lsp"
-          }
-        ],
-        semantic: "warning"
-      };
-    }
-    if (!lspClientReady) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    if (diagnosticsInconclusive) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    if (lspDiags.length === 0) {
-      if (deferredServerIds.length > 0) {
-        return {
-          status: "deferred",
-          diagnostics: [],
-          semantic: "none",
-          unconfirmedServerIds: [...unconfirmedServerIds],
-          deferredServerIds: [...deferredServerIds]
-        };
-      }
-      if (unconfirmedServerIds.length > 0) {
-        return {
-          status: "skipped",
-          diagnostics: [],
-          semantic: "none",
-          unconfirmedServerIds: [...unconfirmedServerIds]
-        };
-      }
-      return {
-        status: "succeeded",
-        diagnostics: [],
-        semantic: "none",
-        rawOutput: "no-diagnostics"
-      };
-    }
-    const rawValidLspDiags = lspDiags.filter((d) => d.range?.start?.line !== undefined);
-    const validLspDiags = usedWarmAttach ? rawValidLspDiags : await demoteInferredProjectDiagnostics(rawValidLspDiags, {
-      filePath: diagnosticPath,
-      cwd: ctx.cwd,
-      service: lspService
-    });
-    const fixSuggestionByIndex = new Map;
-    const blockingDiagIndexes = rawValidLspDiags.map((d, idx) => ({ d, idx })).filter(({ d }) => d.severity === 1).slice(0, WARM_CODE_ACTION_LOOKUP_LIMIT);
-    if (usedWarmAttach) {
-      const ranges = blockingDiagIndexes.map(({ d }) => ({
-        start: d.range.start,
-        end: d.range.end ?? d.range.start
-      }));
-      const result = await tryWarmAttachedCodeActions(ctx.filePath, contentHash(content), ranges, LSP_DIAGNOSTICS_WAIT_MS);
-      if (result?.available) {
-        result.response.actions.forEach((actions, responseIndex) => {
-          const diagnosticIndex = blockingDiagIndexes[responseIndex]?.idx;
-          const suggestion = buildCodeActionSuggestion(actions);
-          if (diagnosticIndex !== undefined && suggestion) {
-            fixSuggestionByIndex.set(diagnosticIndex, suggestion);
-          }
-        });
-      }
-    } else {
-      await Promise.all(blockingDiagIndexes.map(async ({ d, idx }) => {
-        try {
-          const start = d.range.start;
-          const end = d.range.end ?? d.range.start;
-          const actions = await lspService.codeAction(ctx.filePath, start.line, start.character, end.line, end.character);
-          const suggestion = buildCodeActionSuggestion(actions);
-          if (suggestion) {
-            fixSuggestionByIndex.set(idx, suggestion);
-          }
-        } catch {}
-      }));
-    }
-    const diagnostics = convertLspDiagnostics(validLspDiags, diagnosticPath, { fixSuggestionByIndex });
-    const keptDiagnostics = retagAuxiliaryDiagnostics(diagnostics, validLspDiags, content, { cwd: ctx.cwd, fileRole: ctx.fileRole });
-    const hasErrors = keptDiagnostics.some((d) => d.semantic === "blocking");
-    const resultSemantic = hasErrors ? "blocking" : keptDiagnostics.length > 0 ? "warning" : "none";
-    return {
-      status: hasErrors ? "failed" : deferredServerIds.length > 0 ? "deferred" : "succeeded",
-      failureKind: hasErrors ? "blocking_diagnostics" : undefined,
-      diagnostics: keptDiagnostics,
-      semantic: resultSemantic,
-      ...unconfirmedServerIds.length > 0 && {
-        unconfirmedServerIds: [...unconfirmedServerIds]
-      },
-      ...deferredServerIds.length > 0 && {
-        deferredServerIds: [...deferredServerIds]
-      }
-    };
-  }
-};
-export default lspRunner;

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

@@ -1,129 +0,0 @@
-import * as path from "node:path";
-import { pathsEqual } from "../../path-utils.js";
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { logRunnerAdvisoryOnce, resolveRunnerCwd } from "../../tool-cwd.js";
-import { getLinterPolicyForCwd, markdownlintConfigArgs } from "../../tool-policy.js";
-import { PRIORITY } from "../priorities.js";
-import { createAvailabilityChecker, resolveToolCommandWithInstallFallback } from "./utils/runner-helpers.js";
-import { parseToolRun } from "./utils/tool-failure.js";
-import { isInSpawnTimeoutCooldown, noteSpawnTimeout } from "../../spawn-timeout-cooldown.js";
-import { finishParsedRun } from "./utils/tool-failure.js";
-const markdownlint = createAvailabilityChecker("markdownlint-cli2", ".cmd", [
-  "--no-globs",
-  "-"
-]);
-const MARKDOWNLINT_EXIT_CODES = { ran: [1] };
-const MARKDOWNLINT_FIXABLE_RULES = new Set([
-  "MD001",
-  "MD004",
-  "MD005",
-  "MD007",
-  "MD009",
-  "MD010",
-  "MD011",
-  "MD012",
-  "MD014",
-  "MD018",
-  "MD019",
-  "MD020",
-  "MD021",
-  "MD022",
-  "MD023",
-  "MD026",
-  "MD027",
-  "MD030",
-  "MD031",
-  "MD032",
-  "MD034",
-  "MD037",
-  "MD038",
-  "MD039",
-  "MD044",
-  "MD047",
-  "MD049",
-  "MD050",
-  "MD053",
-  "MD058"
-]);
-function parseMarkdownlintOutput(raw, filePath, cwd) {
-  const diagnostics = [];
-  const absTarget = path.resolve(cwd, filePath);
-  for (const line of raw.split(/\r?\n/)) {
-    if (!line.trim())
-      continue;
-    const match = line.match(/^(.*?):(\d+)(?::(\d+))?\s+(?:error|warning)?\s*(MD\d+\/[\w/-]+)\s+(.+)$/);
-    if (!match)
-      continue;
-    const [, reported, lineNum, col, ruleCode, message] = match;
-    if (reported && !pathsEqual(path.resolve(cwd, reported), absTarget))
-      continue;
-    const ruleName = ruleCode.split("/")[0];
-    const fixable = MARKDOWNLINT_FIXABLE_RULES.has(ruleName);
-    diagnostics.push({
-      id: `markdownlint-${lineNum}-${ruleName}`,
-      message: `[${ruleCode}] ${message}`,
-      filePath,
-      line: Number(lineNum),
-      column: col ? Number(col) : 1,
-      severity: "warning",
-      semantic: "warning",
-      tool: "markdownlint",
-      rule: ruleName,
-      fixable,
-      fixSuggestion: fixable ? "Run `markdownlint-cli2 --fix` to apply the deterministic auto-correction for this rule." : undefined
-    });
-  }
-  return diagnostics;
-}
-const markdownlintRunner = {
-  id: "markdownlint",
-  appliesTo: ["markdown"],
-  priority: PRIORITY.DOC_QUALITY,
-  skipTestFiles: false,
-  async run(ctx) {
-    const cwd = resolveRunnerCwd(ctx, "markdownlint");
-    const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
-    if (policy && !policy.preferredRunners.includes("markdownlint")) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    let cmd = null;
-    if (await markdownlint.isAvailableAsync(cwd)) {
-      cmd = markdownlint.getCommand(cwd);
-    } else {
-      cmd = await resolveToolCommandWithInstallFallback(cwd, "markdownlint");
-    }
-    if (!cmd)
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    if (isInSpawnTimeoutCooldown(cmd)) {
-      logRunnerAdvisoryOnce(ctx, "markdownlint", cwd, `markdownlint: ${cmd} is cooling down after a spawn timeout — skipping (one bounded failure budget per edit)`);
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    const configArgs = markdownlintConfigArgs(cwd);
-    const result = await safeSpawnAsync(cmd, [...configArgs, ctx.filePath], {
-      timeout: 15000,
-      cwd
-    });
-    if (result.failure === "timeout") {
-      noteSpawnTimeout({
-        tool: "markdownlint",
-        command: cmd,
-        phase: "lint",
-        durationMs: 15000,
-        teardown: result.timeoutTeardown
-      });
-    }
-    const raw = `${result.stdout ?? ""}${result.stderr ?? ""}`;
-    const run = parseToolRun("markdownlint", { result, output: raw, exitCodes: MARKDOWNLINT_EXIT_CODES }, (out) => parseMarkdownlintOutput(out, ctx.filePath, cwd));
-    if (run.skipped)
-      return run.skipped;
-    const diagnostics = run.diagnostics;
-    return finishParsedRun({
-      tool: "markdownlint",
-      ctx,
-      result,
-      diagnostics,
-      classify: () => ({ status: "succeeded", semantic: "warning" })
-    });
-  }
-};
-export default markdownlintRunner;

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

@@ -1,70 +0,0 @@
-import * as path from "node:path";
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { resolveRunnerCwd } from "../../tool-cwd.js";
-import { hasMypyConfig } from "../../tool-policy.js";
-import { PRIORITY } from "../priorities.js";
-import { createAvailabilityChecker, resolveToolCommandWithInstallFallback } from "./utils/runner-helpers.js";
-import { parseToolRun } from "./utils/tool-failure.js";
-import { finishParsedRun } from "./utils/tool-failure.js";
-const mypy = createAvailabilityChecker("mypy", "");
-const MYPY_EXIT_CODES = { ran: [1, 2] };
-export function parseMypyOutput(raw, fallbackPath, cwd) {
-  const diagnostics = [];
-  const linePattern = /^(.+?):(\d+)(?::(\d+))?:\s*(error|warning|note):\s*(.+?)(?:\s+\[([^\]]+)\])?$/gm;
-  for (const match of raw.matchAll(linePattern)) {
-    const [, file, lineNum, col, level, message, errorCode] = match;
-    if (!lineNum || !level || !message)
-      continue;
-    if (level === "note")
-      continue;
-    const severity = level === "error" ? "error" : "warning";
-    const rule = errorCode ?? "mypy";
-    const filePath = file && file.trim() ? path.isAbsolute(file) ? file : path.resolve(cwd, file) : fallbackPath;
-    diagnostics.push({
-      id: `mypy-${lineNum}-${rule}`,
-      message: errorCode ? `[${errorCode}] ${message}` : message,
-      filePath,
-      line: Number(lineNum),
-      column: col ? Number(col) : 1,
-      severity,
-      semantic: severity === "error" ? "blocking" : "warning",
-      tool: "mypy",
-      rule,
-      defectClass: "correctness"
-    });
-  }
-  return diagnostics;
-}
-const mypyRunner = {
-  id: "mypy",
-  appliesTo: ["python"],
-  priority: PRIORITY.GENERAL_ANALYSIS,
-  skipTestFiles: false,
-  async run(ctx) {
-    const cwd = resolveRunnerCwd(ctx, "mypy");
-    if (!hasMypyConfig(cwd)) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    let cmd = null;
-    if (await mypy.isAvailableAsync(cwd)) {
-      cmd = mypy.getCommand(cwd);
-    } else {
-      cmd = await resolveToolCommandWithInstallFallback(cwd, "mypy");
-    }
-    if (!cmd)
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    const result = await safeSpawnAsync(cmd, ["--no-error-summary", "--show-column-numbers", ctx.filePath], { timeout: 30000, cwd });
-    const raw = `${result.stdout ?? ""}${result.stderr ?? ""}`;
-    const run = parseToolRun("mypy", { result, output: result.stdout, exitCodes: MYPY_EXIT_CODES }, (out) => parseMypyOutput(out, ctx.filePath, cwd), { parseOutput: raw });
-    if (run.skipped)
-      return run.skipped;
-    const diagnostics = run.diagnostics;
-    return finishParsedRun({
-      tool: "mypy",
-      ctx,
-      result,
-      diagnostics
-    });
-  }
-};
-export default mypyRunner;