@duckmind/dm-linux-x64 0.65.8 → 0.66.2

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

@@ -1,99 +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, hasEslintConfig } from "../../tool-policy.js";
-import { PRIORITY } from "../priorities.js";
-import { createCwdCachedProbe, resolveToolCommand } from "./utils/runner-helpers.js";
-import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
-const ESLINT_PROBE_BUDGET_MS = 5000;
-function makeEslintProbe(cmd) {
-  return createCwdCachedProbe((cwd) => safeSpawnAsync(cmd, ["--version"], {
-    timeout: ESLINT_PROBE_BUDGET_MS,
-    cwd
-  }), {
-    tool: "eslint",
-    budgetMs: ESLINT_PROBE_BUDGET_MS,
-    flightKeyComponent: cmd
-  });
-}
-const eslintAvailabilityByCmd = new Map;
-function getEslintProbe(cmd) {
-  const existing = eslintAvailabilityByCmd.get(cmd);
-  if (existing)
-    return existing;
-  const created = makeEslintProbe(cmd);
-  eslintAvailabilityByCmd.set(cmd, created);
-  return created;
-}
-function parseEslintJson(raw, filePath, cwd) {
-  try {
-    const results = JSON.parse(raw);
-    const autofix = getAutofixCapability("eslint");
-    const diagnostics = [];
-    const absTarget = path.resolve(cwd, filePath);
-    for (const fileResult of results) {
-      if (fileResult.filePath && !pathsEqual(path.resolve(cwd, fileResult.filePath), absTarget))
-        continue;
-      for (const msg of fileResult.messages) {
-        const severity = msg.severity === 2 ? "error" : "warning";
-        diagnostics.push({
-          id: `eslint:${msg.ruleId ?? "unknown"}:${msg.line}`,
-          message: msg.ruleId ? `${msg.ruleId}: ${msg.message}` : msg.message,
-          filePath,
-          line: msg.line ?? 1,
-          column: msg.column ?? 1,
-          severity,
-          semantic: severity === "error" ? "blocking" : "warning",
-          tool: "eslint",
-          rule: msg.ruleId ?? undefined,
-          fixable: !!msg.fix,
-          autoFixAvailable: !!msg.fix && (autofix?.safePipelineAutofix ?? false),
-          fixKind: !!msg.fix && autofix?.fixKind !== "none" ? autofix?.fixKind : undefined
-        });
-      }
-    }
-    return { diagnostics };
-  } catch (err) {
-    return {
-      diagnostics: [],
-      parseError: err instanceof Error ? err.message : String(err)
-    };
-  }
-}
-const eslintRunner = {
-  id: "eslint",
-  appliesTo: ["jsts"],
-  priority: PRIORITY.LINT_SECONDARY,
-  async run(ctx) {
-    const cwd = resolveRunnerCwd(ctx, "eslint");
-    const userHasConfig = hasEslintConfig(cwd);
-    if (!userHasConfig) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    const cmd = resolveToolCommand(cwd, "eslint") ?? "eslint";
-    if (!await getEslintProbe(cmd)(cwd)) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    const result = await safeSpawnAsync(cmd, ["--format", "json", "--no-error-on-unmatched-pattern", ctx.filePath], { timeout: 30000, cwd });
-    const stdout = result.stdout ?? "";
-    let raw = stdout;
-    if (raw.length === 0 && result.status !== 0) {
-      raw = result.stderr || "";
-    }
-    const parsed = parseToolRun("eslint", {
-      result,
-      output: raw,
-      exitCodes: { ran: [1, 2] }
-    }, (rawOutput) => parseEslintJson(rawOutput, ctx.filePath, cwd).diagnostics);
-    if (parsed.skipped)
-      return parsed.skipped;
-    return finishParsedRun({
-      tool: "eslint",
-      ctx,
-      result,
-      diagnostics: parsed.diagnostics
-    });
-  }
-};
-export default eslintRunner;

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

@@ -1,20 +0,0 @@
-import { PRIORITY } from "../priorities.js";
-import { evaluateRules } from "../fact-rule-runner.js";
-const factRulesRunner = {
-  id: "fact-rules",
-  appliesTo: ["jsts", "python", "go", "rust", "ruby", "shell", "cmake"],
-  priority: PRIORITY.GENERAL_ANALYSIS + 1,
-  async run(ctx) {
-    const diagnostics = evaluateRules(ctx);
-    if (diagnostics.length === 0) {
-      return { status: "succeeded", diagnostics: [], semantic: "none" };
-    }
-    const hasBlocking = diagnostics.some((d) => d.semantic === "blocking" || d.severity === "error");
-    return {
-      status: hasBlocking ? "failed" : "succeeded",
-      diagnostics,
-      semantic: hasBlocking ? "blocking" : "warning"
-    };
-  }
-};
-export default factRulesRunner;

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

@@ -1,65 +0,0 @@
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { resolveRunnerCwd } from "../../tool-cwd.js";
-import { PRIORITY } from "../priorities.js";
-import { createAvailabilityChecker } from "./utils/runner-helpers.js";
-const fishIndent = createAvailabilityChecker("fish_indent");
-const fishIndentRunner = {
-  id: "fish-indent",
-  appliesTo: ["fish"],
-  priority: PRIORITY.FORMAT_AND_LINT_PRIMARY,
-  skipTestFiles: false,
-  async run(ctx) {
-    const cwd = resolveRunnerCwd(ctx, "fish-indent");
-    const available = await fishIndent.isAvailableAsync(cwd);
-    if (!available)
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    const cmd = fishIndent.getCommand(cwd);
-    if (!cmd)
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    const result = await safeSpawnAsync(cmd, ["--check", ctx.filePath], {
-      timeout: 1e4,
-      cwd
-    });
-    if (result.status === 0) {
-      return { status: "succeeded", diagnostics: [], semantic: "none" };
-    }
-    const stderrLine = (result.stderr ?? "").split(`
-`).find((l) => l.trim());
-    if (stderrLine) {
-      const lineMatch = stderrLine.match(/\(line\s+(\d+)\)/);
-      const line = lineMatch ? Number(lineMatch[1]) : 1;
-      const diagnostics = [
-        {
-          id: `fish-indent-parse-${ctx.filePath}`,
-          message: `fish_indent: ${stderrLine.trim()}`,
-          filePath: ctx.filePath,
-          line,
-          column: 1,
-          severity: "error",
-          semantic: "blocking",
-          tool: "fish-indent",
-          rule: "fish-indent-parse-error"
-        }
-      ];
-      return { status: "failed", diagnostics, semantic: "blocking" };
-    }
-    const diagnostics = [
-      {
-        id: `fish-indent-format-${ctx.filePath}`,
-        message: "Fish script is not formatted — run `fish_indent -w` to fix",
-        filePath: ctx.filePath,
-        line: 1,
-        column: 1,
-        severity: "warning",
-        semantic: "warning",
-        tool: "fish-indent",
-        rule: "fish-indent-unformatted",
-        fixable: true,
-        autoFixAvailable: false,
-        fixKind: "manual"
-      }
-    ];
-    return { status: "succeeded", diagnostics, semantic: "warning" };
-  }
-};
-export default fishIndentRunner;

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

@@ -1,107 +0,0 @@
-import * as path from "node:path";
-import { pathsEqual } from "../../path-utils.js";
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { stripAnsi } from "../../sanitize.js";
-import { resolveRunnerCwd } from "../../tool-cwd.js";
-import { createAvailabilityChecker } from "./utils/runner-helpers.js";
-import { PRIORITY } from "../priorities.js";
-const gleam = createAvailabilityChecker("gleam", ".exe");
-const GLEAM_LOCUS = /^\s*┌─\s+(.+?):(\d+):(\d+)$/;
-const GLEAM_HEADER = /^\s*(error|warning):\s*(.+?)\s*$/;
-const GLEAM_LABEL = /^\s*│\s*\^+\s*(.*?)\s*$/;
-function gleamBlocks(lines) {
-  const blocks = [];
-  for (const line of lines) {
-    const header = line.match(GLEAM_HEADER);
-    if (header)
-      blocks.push({ header, body: [] });
-    else
-      blocks.at(-1)?.body.push(line);
-  }
-  return blocks;
-}
-function gleamMessage(title, body) {
-  const labels = body.flatMap((line) => line.match(GLEAM_LABEL)?.[1]?.trim() || []);
-  return labels.length > 0 ? `${title} — ${labels.join(" ")}` : title;
-}
-function parseGleamOutput(raw, filePath, cwd) {
-  const diagnostics = [];
-  const absTarget = path.resolve(cwd, filePath);
-  const lines = stripAnsi(raw).split(/\r?\n/);
-  for (const { header, body } of gleamBlocks(lines)) {
-    const severity = header[1] === "warning" ? "warning" : "error";
-    const title = `${header[1]}: ${header[2]}`;
-    const location = body.find((line) => GLEAM_LOCUS.test(line))?.match(GLEAM_LOCUS);
-    if (!location)
-      continue;
-    const [, sourcePath, lineStr, colStr] = location;
-    if (!pathsEqual(path.resolve(cwd, sourcePath.trim()), absTarget))
-      continue;
-    diagnostics.push({
-      id: `gleam-check-${lineStr}-${colStr}`,
-      message: gleamMessage(title, body),
-      filePath,
-      line: Number.parseInt(lineStr, 10) || 1,
-      column: Number.parseInt(colStr, 10) || 1,
-      severity,
-      semantic: severity === "error" ? "blocking" : "warning",
-      tool: "gleam",
-      rule: "gleam-check",
-      fixable: false
-    });
-  }
-  return diagnostics;
-}
-function firstOutputLine(result) {
-  return `${result.stderr || ""}
-${result.stdout || ""}`.trim().split(/\r?\n/, 1)[0].slice(0, 200);
-}
-const gleamCheckRunner = {
-  id: "gleam-check",
-  appliesTo: ["gleam"],
-  priority: PRIORITY.GENERAL_ANALYSIS,
-  skipTestFiles: false,
-  async run(ctx) {
-    const cwd = resolveRunnerCwd(ctx, "gleam-check");
-    if (!await gleam.isAvailableAsync(cwd)) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    const cmd = gleam.getCommand(cwd);
-    const result = await safeSpawnAsync(cmd, ["check"], {
-      cwd,
-      timeout: 30000
-    });
-    if (result.error && !result.stdout && !result.stderr) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    const diagnostics = parseGleamOutput(`${result.stderr || ""}
-${result.stdout || ""}`, ctx.filePath, cwd);
-    if (diagnostics.length === 0) {
-      if (result.status && result.status !== 0) {
-        return {
-          status: "failed",
-          diagnostics: [
-            {
-              id: "gleam-check-nonzero-no-diagnostics",
-              message: firstOutputLine(result) || "gleam check exited non-zero without structured diagnostics",
-              filePath: ctx.filePath,
-              severity: "error",
-              semantic: "blocking",
-              tool: "gleam",
-              rule: "gleam-check",
-              fixable: false
-            }
-          ],
-          semantic: "blocking"
-        };
-      }
-      return { status: "succeeded", diagnostics: [], semantic: "none" };
-    }
-    return {
-      status: "failed",
-      diagnostics,
-      semantic: "blocking"
-    };
-  }
-};
-export default gleamCheckRunner;

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

@@ -1,51 +0,0 @@
-import { relative, resolve, sep, posix } from "node:path";
-import { goClient } from "../../go-client.js";
-import { pathsEqual } from "../../path-utils.js";
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { resolveRunnerCwd } from "../../tool-cwd.js";
-import { stripAnsi } from "../../sanitize.js";
-import { skipUnlessToolRan } from "./utils/tool-failure.js";
-import { parseGoVetOutput } from "./utils/diagnostic-parsers.js";
-import { PRIORITY } from "../priorities.js";
-const goVetRunner = {
-  id: "go-vet",
-  appliesTo: ["go"],
-  priority: PRIORITY.SPECIALIZED_ANALYSIS,
-  timeoutMs: 40000,
-  async run(ctx) {
-    const goExe = await goClient.findGoPathAsync();
-    if (!goExe) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    const cwd = resolveRunnerCwd(ctx, "go-vet");
-    const fileRel = relative(cwd, ctx.filePath).split(sep).join(posix.sep);
-    const pkgPath = fileRel.startsWith("../") ? "." : fileRel.includes("/") ? "./" + fileRel.slice(0, fileRel.lastIndexOf("/")) : ".";
-    const result = await safeSpawnAsync(goExe, ["vet", pkgPath], {
-      timeout: 30000,
-      cwd
-    });
-    const raw = stripAnsi(result.stdout + result.stderr);
-    const parsableLines = raw.split(`
-`).filter((line) => /^.+?:\d+:\d+:/.test(line)).join(`
-`);
-    const skipped = skipUnlessToolRan("go-vet", {
-      result,
-      output: parsableLines
-    });
-    if (skipped)
-      return skipped;
-    if (result.status === 0 && !raw.trim()) {
-      return { status: "succeeded", diagnostics: [], semantic: "none" };
-    }
-    const absTarget = resolve(ctx.filePath);
-    const relevant = raw.split(`
-`).filter((line) => {
-      const m = line.match(/^(.+?):(\d+):(\d+):\s*(.+)/);
-      return m != null && pathsEqual(resolve(cwd, m[1].trim()), absTarget);
-    }).join(`
-`);
-    const diagnostics = parseGoVetOutput(relevant, ctx.filePath, cwd);
-    return diagnostics.length > 0 ? { status: "failed", diagnostics, semantic: "warning" } : { status: "succeeded", diagnostics: [], semantic: "none" };
-  }
-};
-export default goVetRunner;

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

@@ -1,89 +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 { getLinterPolicyForCwd, hasGolangciConfig } from "../../tool-policy.js";
-import { PRIORITY } from "../priorities.js";
-import { createAvailabilityChecker, resolveAvailableOrInstall } from "./utils/runner-helpers.js";
-import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
-const golangci = createAvailabilityChecker("golangci-lint", ".exe");
-function describeReplacement(replacement) {
-  if (!replacement)
-    return;
-  if (replacement.Inline?.NewString !== undefined) {
-    return `Replace with: ${replacement.Inline.NewString}`;
-  }
-  if (replacement.NeedOnlyDelete)
-    return "Delete this code";
-  if (replacement.NewLines && replacement.NewLines.length > 0) {
-    const preview = replacement.NewLines[0].trim();
-    const hint = replacement.NewLines.length > 1 ? ` (+${replacement.NewLines.length - 1} more lines)` : "";
-    return `Replace with: ${preview}${hint}`;
-  }
-  return "Apply golangci-lint suggested fix";
-}
-function parseGolangciJson(raw, filePath, cwd) {
-  try {
-    const output = JSON.parse(raw);
-    if (!output.Issues)
-      return [];
-    const absFile = path.resolve(cwd, filePath);
-    return output.Issues.filter((issue) => pathsEqual(path.resolve(cwd, issue.Pos.Filename), absFile)).map((issue) => {
-      const severity = issue.Severity === "error" ? "error" : "warning";
-      const fixSuggestion = describeReplacement(issue.Replacement);
-      return {
-        id: `golangci:${issue.FromLinter}:${issue.Pos.Line}`,
-        message: `${issue.FromLinter}: ${issue.Text}`,
-        filePath,
-        line: issue.Pos.Line,
-        column: issue.Pos.Column,
-        severity,
-        semantic: severity === "error" ? "blocking" : "warning",
-        tool: "golangci-lint",
-        rule: issue.FromLinter,
-        defectClass: "correctness",
-        fixable: Boolean(issue.Replacement),
-        fixSuggestion
-      };
-    });
-  } catch {
-    return [];
-  }
-}
-
-export { parseGolangciJson };
-const golangciRunner = {
-  id: "golangci-lint",
-  appliesTo: ["go"],
-  priority: PRIORITY.GENERAL_ANALYSIS,
-  timeoutMs: 90000,
-  async run(ctx) {
-    const cwd = resolveRunnerCwd(ctx, "golangci-lint");
-    const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
-    if (policy && !policy.preferredRunners.includes("golangci-lint")) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    if (!hasGolangciConfig(cwd)) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    const cmd = await resolveAvailableOrInstall(golangci, "golangci-lint", cwd);
-    if (!cmd)
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    const result = await safeSpawnAsync(cmd, ["run", "--out-format=json", ctx.filePath], { timeout: 60000, cwd });
-    const raw = (result.stdout ?? "").length > 0 ? result.stdout ?? "" : result.status !== 0 ? result.stderr || "" : "";
-    const parsed = parseToolRun("golangci-lint", {
-      result,
-      output: raw,
-      exitCodes: { ran: [1, 2, 3, 4, 5] }
-    }, (raw) => parseGolangciJson(raw, ctx.filePath, cwd));
-    if (parsed.skipped)
-      return parsed.skipped;
-    return finishParsedRun({
-      tool: "golangci-lint",
-      ctx,
-      result,
-      diagnostics: parsed.diagnostics
-    });
-  }
-};
-export default golangciRunner;

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

@@ -1,83 +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 { getLinterPolicyForCwd } 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 hadolint = createAvailabilityChecker("hadolint", ".exe");
-function parseHadolintOutput(raw, filePath, cwd) {
-  try {
-    const parsed = JSON.parse(raw);
-    if (!Array.isArray(parsed))
-      return [];
-    const absTarget = path.resolve(cwd, filePath);
-    return parsed.flatMap((item) => {
-      if (item.file && !pathsEqual(path.resolve(cwd, item.file), absTarget))
-        return [];
-      const severity = item.level === "error" ? "error" : "warning";
-      return [
-        {
-          id: `hadolint-${item.code}-${item.line}`,
-          message: `[${item.code}] ${item.message}`,
-          filePath,
-          line: item.line,
-          column: item.column ?? 1,
-          severity,
-          semantic: severity === "error" ? "blocking" : "warning",
-          tool: "hadolint",
-          rule: item.code,
-          fixable: false
-        }
-      ];
-    });
-  } catch {
-    return [];
-  }
-}
-const hadolintRunner = {
-  id: "hadolint",
-  appliesTo: ["docker"],
-  priority: PRIORITY.GENERAL_ANALYSIS,
-  skipTestFiles: false,
-  async run(ctx) {
-    const cwd = resolveRunnerCwd(ctx, "hadolint");
-    const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
-    if (policy && !policy.preferredRunners.includes("hadolint")) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    let cmd = null;
-    if (await hadolint.isAvailableAsync(cwd)) {
-      cmd = hadolint.getCommand(cwd);
-    } else {
-      cmd = await resolveToolCommandWithInstallFallback(cwd, "hadolint");
-    }
-    if (!cmd) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    const result = await safeSpawnAsync(cmd, ["--format", "json", "--no-fail", path.resolve(cwd, ctx.filePath)], { cwd });
-    const run = parseToolRun("hadolint", {
-      result,
-      exitCodes: { ran: [1, 2] }
-    }, (out) => parseHadolintOutput(out, ctx.filePath, cwd));
-    if (run.skipped)
-      return run.skipped;
-    const diagnostics = run.diagnostics;
-    return finishParsedRun({
-      tool: "hadolint",
-      ctx,
-      result,
-      diagnostics,
-      classify: (diagnostics) => {
-        const hasErrors = diagnostics.some((d) => d.severity === "error");
-        return {
-          status: "failed",
-          semantic: hasErrors ? "blocking" : "warning"
-        };
-      }
-    });
-  }
-};
-export default hadolintRunner;

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

@@ -1,144 +0,0 @@
-import * as path from "node:path";
-import { PathKeyedMap } from "../../path-keyed-map.js";
-import { normalizeMapKey } from "../../path-utils.js";
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { truncatedByOutputCap } from "../../spawn-output-cap.js";
-import { resolveRunnerCwd } from "../../tool-cwd.js";
-import { findNearestDirWithMarker } from "../../workspace-topology.js";
-import { PRIORITY } from "../priorities.js";
-import { createAvailabilityChecker, resolveAvailableOrInstall } from "./utils/runner-helpers.js";
-const helm = createAvailabilityChecker("helm", ".exe");
-const inFlightByChartRoot = new PathKeyedMap(normalizeMapKey);
-const HELM_LINT_TIMEOUT_MS = 30000;
-const MAX_HELM_LINT_OUTPUT_BYTES = 8 * 1024 * 1024;
-const SKIPPED = {
-  status: "skipped",
-  diagnostics: [],
-  semantic: "none"
-};
-function isWithin(root, candidate) {
-  const relative = path.relative(normalizeMapKey(root), normalizeMapKey(candidate));
-  return relative === "" || !relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative);
-}
-function diagnosticLocation(message, chartRoot) {
-  const location = message.match(/(?:^|\s)([^:\r\n]+\.(?:ya?ml|tpl|json))(?::(\d+))?(?::\d+)?(?::|\s)/i);
-  if (!location) {
-    return { filePath: path.join(chartRoot, "Chart.yaml"), message };
-  }
-  const candidate = path.resolve(chartRoot, location[1]);
-  return {
-    filePath: isWithin(chartRoot, candidate) ? candidate : path.join(chartRoot, "Chart.yaml"),
-    line: location[2] ? Number(location[2]) : undefined,
-    message
-  };
-}
-export function parseHelmLintOutput(raw, chartRoot) {
-  const diagnostics = [];
-  for (const line of raw.split(/\r?\n/)) {
-    const match = line.trim().match(/^\[(INFO|WARNING|ERROR)\]\s*(.+)$/);
-    if (!match) {
-      const last = diagnostics[diagnostics.length - 1];
-      if (last && /^\s+\S/.test(line)) {
-        last.message += `
-${line.trim()}`;
-      }
-      continue;
-    }
-    const level = match[1];
-    const location = diagnosticLocation(match[2].trim(), chartRoot);
-    const severity = level === "ERROR" ? "error" : level === "WARNING" ? "warning" : "info";
-    diagnostics.push({
-      id: `helm-lint-${diagnostics.length + 1}-${level.toLowerCase()}`,
-      message: location.message,
-      filePath: location.filePath,
-      line: location.line,
-      column: 1,
-      severity,
-      semantic: severity === "error" ? "blocking" : "warning",
-      tool: "helm-lint",
-      rule: level.toLowerCase(),
-      fixable: false
-    });
-  }
-  return diagnostics;
-}
-function failedResult(kind, message) {
-  return {
-    status: "failed",
-    diagnostics: [],
-    semantic: "warning",
-    failureKind: kind,
-    failureMessage: message.slice(0, 200)
-  };
-}
-async function lintChart(chartRoot, cwd) {
-  const cmd = await resolveAvailableOrInstall(helm, "helm", cwd);
-  if (!cmd) {
-    const outcome = helm.getOutcome(cwd);
-    return {
-      status: "failed",
-      diagnostics: [],
-      semantic: "warning",
-      failureKind: "unavailable",
-      failureMessage: `helm unavailable (${outcome ?? "unknown"})`
-    };
-  }
-  const result = await safeSpawnAsync(cmd, ["lint", chartRoot], {
-    cwd,
-    timeout: HELM_LINT_TIMEOUT_MS,
-    deadlineAt: Date.now() + HELM_LINT_TIMEOUT_MS,
-    resourceLabel: "helm-lint",
-    maxOutputBytes: MAX_HELM_LINT_OUTPUT_BYTES
-  });
-  if (truncatedByOutputCap(result)) {
-    return failedResult("parser_error", "helm lint output was truncated before parsing completed");
-  }
-  const output = [result.stdout, result.stderr].filter(Boolean).join(`
-`);
-  const diagnostics = parseHelmLintOutput(output, chartRoot);
-  const typedFailure = result.spawnFailure?.kind;
-  if (typedFailure) {
-    const failureKind = typedFailure === "tool-not-found" ? "unavailable" : typedFailure === "timeout" ? "timeout" : typedFailure === "killed" && result.failure === "aborted" ? "aborted" : "server_error";
-    return failedResult(failureKind, result.error?.message || `helm lint ${typedFailure}`);
-  }
-  if (result.failure) {
-    return failedResult(result.failure === "timeout" ? "timeout" : result.failure, result.error?.message || `helm lint ${result.failure}`);
-  }
-  const hasErrorDiagnostic = diagnostics.some((diagnostic) => diagnostic.severity === "error");
-  if (result.status !== 0 && !hasErrorDiagnostic) {
-    return failedResult(output.trim() ? "parser_error" : "server_error", output.trim() || "helm lint exited without an error diagnostic");
-  }
-  return {
-    status: "succeeded",
-    diagnostics,
-    semantic: diagnostics.some((item) => item.severity === "error") ? "blocking" : diagnostics.length > 0 ? "warning" : "none"
-  };
-}
-const helmLintRunner = {
-  id: "helm-lint",
-  appliesTo: ["yaml", "helm-template"],
-  priority: PRIORITY.GENERAL_ANALYSIS,
-  skipTestFiles: false,
-  timeoutMs: 35000,
-  async run(ctx) {
-    const cwd = resolveRunnerCwd(ctx, "helm");
-    const workspaceRoot = path.resolve(ctx.projectRoot ?? ctx.cwd);
-    const startDir = path.dirname(path.resolve(ctx.filePath));
-    const discovered = findNearestDirWithMarker(startDir, "chartYamlPath");
-    if (!discovered)
-      return SKIPPED;
-    const chartRoot = path.resolve(discovered);
-    if (!isWithin(workspaceRoot, chartRoot))
-      return SKIPPED;
-    const existing = inFlightByChartRoot.get(chartRoot);
-    if (existing)
-      return existing;
-    const promise = lintChart(chartRoot, cwd).finally(() => {
-      if (inFlightByChartRoot.get(chartRoot) === promise)
-        inFlightByChartRoot.delete(chartRoot);
-    });
-    inFlightByChartRoot.set(chartRoot, promise);
-    return promise;
-  }
-};
-export default helmLintRunner;