@duckmind/dm-linux-x64 0.65.5 → 0.65.6

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

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

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

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

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

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

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

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

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