@duckmind/dm-linux-x64 0.65.5 → 0.65.7

package/extensions/dm-lens/clients/dispatch/runners/ruff.js

@@ -6,10 +6,12 @@ import {
   ruffConfigArgs
 } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
+import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
 import { parseRuffOutput } from "./utils/diagnostic-parsers.js";
 import {
   createAvailabilityChecker,
-  resolveAvailableOrInstall
+  resolveAvailableOrInstall,
+  resolveRunnerCwd
 } from "./utils/runner-helpers.js";
 const ruff = createAvailabilityChecker("ruff", ".exe");
 function parseRuffJson(raw, filePath) {
@@ -46,7 +48,7 @@ const ruffRunner = {
   appliesTo: ["python"],
   priority: PRIORITY.FORMAT_AND_LINT_PRIMARY,
   async run(ctx) {
-    const cwd = ctx.cwd || process.cwd();
+    const cwd = resolveRunnerCwd(ctx, "ruff");
     const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
     if (policy && !policy.preferredRunners.includes("ruff-lint")) {
       return { status: "skipped", diagnostics: [], semantic: "none" };
@@ -56,27 +58,20 @@ const ruffRunner = {
       return { status: "skipped", diagnostics: [], semantic: "none" };
     }
     const configArgs = ruffConfigArgs(cwd);
-    const checkResult = await safeSpawnAsync(cmd, ["check", "--output-format", "json", ...configArgs, ctx.filePath], { timeout: 30000 });
+    const checkResult = await safeSpawnAsync(cmd, ["check", "--output-format", "json", ...configArgs, ctx.filePath], { cwd, timeout: 30000 });
     const raw = stripAnsi(checkResult.stdout + checkResult.stderr);
-    const diagnostics = parseRuffJson(checkResult.stdout || "", ctx.filePath);
-    const parsedDiagnostics = diagnostics.length > 0 ? diagnostics : parseRuffOutput(raw, ctx.filePath);
-    if (checkResult.status === 0 && parsedDiagnostics.length === 0) {
-      return { status: "succeeded", diagnostics: [], semantic: "none" };
-    }
-    if (parsedDiagnostics.length === 0) {
-      return {
-        status: "failed",
-        diagnostics: [],
-        semantic: "warning",
-        rawOutput: raw.slice(0, 500)
-      };
-    }
-    const hasErrors = parsedDiagnostics.some((d) => d.severity === "error");
-    return {
-      status: hasErrors ? "failed" : "succeeded",
-      diagnostics: parsedDiagnostics,
-      semantic: hasErrors ? "blocking" : "warning"
-    };
+    const run = parseToolRun("ruff", { result: checkResult, output: raw, exitCodes: { ran: [1, 2] } }, (output) => {
+      const diagnostics = parseRuffJson(output, ctx.filePath);
+      return diagnostics.length > 0 ? diagnostics : parseRuffOutput(output, ctx.filePath, cwd);
+    });
+    if (run.skipped)
+      return run.skipped;
+    return finishParsedRun({
+      tool: "ruff",
+      ctx,
+      result: checkResult,
+      diagnostics: run.diagnostics
+    });
   }
 };
 export default ruffRunner;

package/extensions/dm-lens/clients/dispatch/runners/rust-clippy.js

@@ -1,5 +1,5 @@
-import { dirname, isAbsolute, join, resolve } from "node:path";
-import { findNearestContaining } from "../../path-utils.js";
+import { isAbsolute, resolve } from "node:path";
+import { pathsEqual } from "../../path-utils.js";
 import { rustClient } from "../../rust-client.js";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { stripAnsi } from "../../sanitize.js";
@@ -12,6 +12,7 @@ import {
   logAvailabilityDecision
 } from "./utils/availability-policy.js";
 import { PRIORITY } from "../priorities.js";
+import { resolveRunnerCwdWithReason } from "../../tool-cwd.js";
 import { createCwdCachedProbe } from "./utils/runner-helpers.js";
 const CLIPPY_PROBE_BUDGET_MS = 8000;
 let clippyProbeRevision = 0;
@@ -64,19 +65,19 @@ const rustClippyRunner = {
         return { status: "skipped", diagnostics: [], semantic: "none" };
       }
     }
-    const cargoToml = findCargoToml(ctx.filePath);
-    if (!cargoToml) {
+    const cargoResolution = resolveRunnerCwdWithReason(ctx, "rust-clippy");
+    const cargoDir = cargoResolution.cwd;
+    if (cargoResolution.marker !== "Cargo.toml") {
       return { status: "skipped", diagnostics: [], semantic: "none" };
     }
     const result = await safeSpawnAsync(cargoExe, ["clippy", "--message-format=json", "-q"], {
       timeout: 60000,
-      cwd: cargoToml.replace("Cargo.toml", "")
+      cwd: cargoDir
     });
     const raw = stripAnsi(result.stdout + result.stderr);
     if (result.status === 0 && !raw.trim()) {
       return { status: "succeeded", diagnostics: [], semantic: "none" };
     }
-    const cargoDir = cargoToml.replace("Cargo.toml", "");
     const allDiagnostics = parseClippyOutput(raw, ctx.filePath, cargoDir);
     if (allDiagnostics.length === 0) {
       return {
@@ -87,7 +88,7 @@ const rustClippyRunner = {
       };
     }
     const absEdited = resolve(ctx.filePath);
-    const diagnostics = allDiagnostics.filter((d) => resolve(d.filePath) === absEdited);
+    const diagnostics = allDiagnostics.filter((d) => pathsEqual(resolve(cargoDir, d.filePath), absEdited));
     const hasErrors = diagnostics.some((d) => d.semantic === "blocking");
     return {
       status: hasErrors ? "failed" : "succeeded",
@@ -96,10 +97,6 @@ const rustClippyRunner = {
     };
   }
 };
-function findCargoToml(filePath) {
-  const dir = findNearestContaining(dirname(filePath), ["Cargo.toml"]);
-  return dir ? join(dir, "Cargo.toml") : undefined;
-}
 export function normalizeClippyLevel(raw) {
   if (raw === "error")
     return "error";

package/extensions/dm-lens/clients/dispatch/runners/shellcheck.js

@@ -1,6 +1,8 @@
 import * as fs from "node:fs";
 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 { PRIORITY } from "../priorities.js";
 import {
   createAvailabilityChecker,
@@ -25,8 +27,9 @@ function findShellcheckConfig(cwd) {
   }
   return;
 }
-function parseShellcheckOutput(raw, filePath) {
+function parseShellcheckOutput(raw, filePath, cwd) {
   const diagnostics = [];
+  const absTarget = path.resolve(cwd, filePath);
   if (!raw.trim()) {
     return diagnostics;
   }
@@ -38,6 +41,8 @@ function parseShellcheckOutput(raw, filePath) {
     for (const item of parsed) {
       if (!item.message || !item.line)
         continue;
+      if (!item.file || !pathsEqual(path.resolve(cwd, item.file), absTarget))
+        continue;
       const severityMap = {
         error: "error",
         warning: "warning",
@@ -72,7 +77,7 @@ const shellcheckRunner = {
   priority: PRIORITY.GENERAL_ANALYSIS,
   skipTestFiles: false,
   async run(ctx) {
-    const cwd = ctx.cwd || process.cwd();
+    const cwd = resolveRunnerCwd(ctx, "shellcheck");
     if (lspPrimaryCoversFile(ctx, "bash") && await ctx.hasTool("bash-language-server") && await ctx.hasTool("shellcheck")) {
       return { status: "skipped", diagnostics: [], semantic: "none" };
     }
@@ -93,12 +98,12 @@ const shellcheckRunner = {
       args.push("--severity", "info");
     }
     args.push(ctx.filePath);
-    const result = await safeSpawnAsync(cmd, args, { timeout: 15000 });
+    const result = await safeSpawnAsync(cmd, args, { cwd, timeout: 15000 });
     if (result.status === 0 && !result.stdout?.trim()) {
       return { status: "succeeded", diagnostics: [], semantic: "none" };
     }
     const raw = result.stdout + result.stderr;
-    const diagnostics = parseShellcheckOutput(raw, ctx.filePath);
+    const diagnostics = parseShellcheckOutput(raw, ctx.filePath, cwd);
     return finishParsedRun({
       tool: "shellcheck",
       ctx,

package/extensions/dm-lens/clients/dispatch/runners/shfmt.js

@@ -1,6 +1,6 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
 import { safeSpawnAsync } from "../../safe-spawn.js";
+import { findNearestContaining } from "../../path-utils.js";
+import { resolveRunnerCwd } from "../../tool-cwd.js";
 import { PRIORITY } from "../priorities.js";
 import {
   createAvailabilityChecker,
@@ -8,16 +8,7 @@ import {
 } from "./utils/runner-helpers.js";
 const shfmt = createAvailabilityChecker("shfmt", ".exe");
 function hasEditorConfig(cwd) {
-  let current = path.resolve(cwd);
-  while (true) {
-    if (fs.existsSync(path.join(current, ".editorconfig")))
-      return true;
-    const parent = path.dirname(current);
-    if (parent === current)
-      break;
-    current = parent;
-  }
-  return false;
+  return findNearestContaining(cwd, [".editorconfig"]) !== undefined;
 }
 const shfmtRunner = {
   id: "shfmt",
@@ -25,7 +16,7 @@ const shfmtRunner = {
   priority: PRIORITY.FORMAT_AND_LINT_PRIMARY,
   skipTestFiles: false,
   async run(ctx) {
-    const cwd = ctx.cwd || process.cwd();
+    const cwd = resolveRunnerCwd(ctx, "shfmt");
     let cmd = null;
     if (await shfmt.isAvailableAsync(cwd)) {
       cmd = shfmt.getCommand(cwd);

package/extensions/dm-lens/clients/dispatch/runners/spellcheck.js

@@ -1,11 +1,17 @@
+import * as path from "node:path";
+import { pathsEqual } from "../../path-utils.js";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { PRIORITY } from "../priorities.js";
-import { createAvailabilityChecker } from "./utils/runner-helpers.js";
+import {
+  createAvailabilityChecker,
+  resolveRunnerCwd
+} from "./utils/runner-helpers.js";
 import { parseToolRun } from "./utils/tool-failure.js";
 const typos = createAvailabilityChecker("typos", ".exe");
 const TYPOS_EXIT_CODES = { ran: [2] };
-function parseTyposOutput(raw, filePath) {
+function parseTyposOutput(raw, filePath, cwd) {
   const diagnostics = [];
+  const absTarget = path.resolve(cwd, filePath);
   if (!raw.trim()) {
     return diagnostics;
   }
@@ -16,6 +22,8 @@ function parseTyposOutput(raw, filePath) {
       const parsed = JSON.parse(line);
       if (!parsed.typo || !parsed.line_num)
         continue;
+      if (parsed.path && !pathsEqual(path.resolve(cwd, parsed.path), absTarget))
+        continue;
       const corrections = parsed.corrections?.join(", ") || "no suggestions";
       const message = `Typo: "${parsed.typo}" → ${corrections}`;
       diagnostics.push({
@@ -43,14 +51,16 @@ const spellcheckRunner = {
   priority: PRIORITY.DOC_QUALITY,
   skipTestFiles: false,
   async run(ctx) {
-    if (!await typos.isAvailableAsync(ctx.cwd || process.cwd())) {
+    const cwd = resolveRunnerCwd(ctx, "spellcheck/typos");
+    if (!await typos.isAvailableAsync(cwd)) {
       return { status: "skipped", diagnostics: [], semantic: "none" };
     }
     const args = ["--format", "json", ctx.filePath];
-    const result = await safeSpawnAsync(typos.getCommand(ctx.cwd || process.cwd()), args, {
+    const result = await safeSpawnAsync(typos.getCommand(cwd), args, {
+      cwd,
       timeout: 15000
     });
-    const run = parseToolRun("spellcheck", { result, exitCodes: TYPOS_EXIT_CODES }, (out) => parseTyposOutput(out, ctx.filePath), { parseOutput: `${result.stdout ?? ""}${result.stderr ?? ""}` });
+    const run = parseToolRun("spellcheck", { result, exitCodes: TYPOS_EXIT_CODES }, (out) => parseTyposOutput(out, ctx.filePath, cwd), { parseOutput: `${result.stdout ?? ""}${result.stderr ?? ""}` });
     if (run.skipped)
       return run.skipped;
     const diagnostics = run.diagnostics;

package/extensions/dm-lens/clients/dispatch/runners/spotbugs.js

@@ -3,6 +3,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { BoundedLruCache } from "../../bounded-cache.js";
 import { safeSpawnAsync } from "../../safe-spawn.js";
+import { resolveRunnerCwd } from "../../tool-cwd.js";
 import { findCompiledClassesDir } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
 import {
@@ -149,7 +150,7 @@ const spotbugsRunner = {
   appliesTo: ["java", "kotlin"],
   priority: PRIORITY.DEEP_LANGUAGE_ANALYSIS,
   async run(ctx) {
-    const cwd = ctx.cwd || process.cwd();
+    const cwd = resolveRunnerCwd(ctx, "spotbugs");
     const classesDir = findCompiledClassesDir(cwd);
     if (!classesDir) {
       ctx.log?.("spotbugs: Java project detected but no compiled .class files found — run `mvn compile` / `gradle build` first");

package/extensions/dm-lens/clients/dispatch/runners/sqlfluff.js

@@ -1,4 +1,7 @@
+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, hasSqlfluffConfig } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
 import {
@@ -49,7 +52,7 @@ const SQLFLUFF_FIXABLE_RULES = new Set([
   "ST01",
   "ST02"
 ]);
-function parseSqlfluffOutput(raw, filePath) {
+function parseSqlfluffOutput(raw, filePath, cwd) {
   if (!raw.trim())
     return [];
   try {
@@ -57,7 +60,10 @@ function parseSqlfluffOutput(raw, filePath) {
     if (!Array.isArray(parsed))
       return [];
     const diagnostics = [];
+    const absTarget = path.resolve(cwd, filePath);
     for (const item of parsed) {
+      if (item.filepath && !pathsEqual(path.resolve(cwd, item.filepath), absTarget))
+        continue;
       for (const v of item.violations ?? []) {
         if (!v.description)
           continue;
@@ -91,14 +97,14 @@ const sqlfluffRunner = {
   priority: PRIORITY.SQL_LINT,
   skipTestFiles: false,
   async run(ctx) {
-    const cwd = ctx.cwd || process.cwd();
+    const cwd = resolveRunnerCwd(ctx, "sqlfluff");
     const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
     if (policy && !policy.preferredRunners.includes("sqlfluff")) {
       return { status: "skipped", diagnostics: [], semantic: "none" };
     }
     const hasConfig = hasSqlfluffConfig(cwd);
     if (!hasConfig) {
-      ctx.log("sqlfluff: no config detected, using ANSI dialect defaults");
+      logRunnerAdvisoryOnce(ctx, "sqlfluff", cwd, "sqlfluff: no config detected, using ANSI dialect defaults");
     }
     let cmd = null;
     if (await sqlfluff.isAvailableAsync(cwd)) {
@@ -117,7 +123,7 @@ const sqlfluffRunner = {
       timeout: 20000,
       cwd
     });
-    const run = parseToolRun("sqlfluff", { result, exitCodes: SQLFLUFF_EXIT_CODES }, (out) => parseSqlfluffOutput(out, ctx.filePath), { parseOutput: result.stdout ?? "" });
+    const run = parseToolRun("sqlfluff", { result, exitCodes: SQLFLUFF_EXIT_CODES }, (out) => parseSqlfluffOutput(out, ctx.filePath, cwd), { parseOutput: result.stdout ?? "" });
     if (run.skipped)
       return run.skipped;
     const diagnostics = run.diagnostics;

package/extensions/dm-lens/clients/dispatch/runners/stylelint.js

@@ -1,5 +1,7 @@
 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,
   hasStylelintConfig
@@ -50,11 +52,14 @@ const STYLELINT_FIXABLE_RULES = new Set([
   "string-quotes",
   "value-no-vendor-prefix"
 ]);
-function parseStylelintJson(raw, filePath) {
+function parseStylelintJson(raw, filePath, cwd) {
   try {
     const results = JSON.parse(raw);
     const diagnostics = [];
+    const absTarget = path.resolve(cwd, filePath);
     for (const result of results) {
+      if (result.source && !pathsEqual(path.resolve(cwd, result.source), absTarget))
+        continue;
       for (const w of result.warnings) {
         const severity = w.severity === "error" ? "error" : "warning";
         const fixable = STYLELINT_FIXABLE_RULES.has(w.rule);
@@ -84,7 +89,7 @@ const stylelintRunner = {
   priority: PRIORITY.FORMAT_AND_LINT_PRIMARY,
   skipTestFiles: false,
   async run(ctx) {
-    const cwd = ctx.cwd || process.cwd();
+    const cwd = resolveRunnerCwd(ctx, "stylelint");
     const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
     if (policy && !policy.preferredRunners.includes("stylelint")) {
       return { status: "skipped", diagnostics: [], semantic: "none" };
@@ -92,7 +97,7 @@ const stylelintRunner = {
     const fileDir = path.dirname(path.resolve(cwd, ctx.filePath));
     const hasConfig = hasStylelintConfig(fileDir) || hasStylelintConfig(cwd);
     if (!hasConfig) {
-      ctx.log("stylelint: no config detected, running with default rules");
+      logRunnerAdvisoryOnce(ctx, "stylelint", cwd, "stylelint: no config detected, running with default rules");
     }
     let cmd = null;
     if (await stylelint.isAvailableAsync(cwd)) {
@@ -104,7 +109,7 @@ const stylelintRunner = {
       return { status: "skipped", diagnostics: [], semantic: "none" };
     const result = await safeSpawnAsync(cmd, ["--formatter", "json", ctx.filePath], { timeout: 20000, cwd });
     const raw = stylelintReport(result.stdout, result.stderr);
-    const run = parseToolRun("stylelint", { result, output: raw, exitCodes: STYLELINT_EXIT_CODES }, (out) => parseStylelintJson(out, ctx.filePath));
+    const run = parseToolRun("stylelint", { result, output: raw, exitCodes: STYLELINT_EXIT_CODES }, (out) => parseStylelintJson(out, ctx.filePath, cwd));
     if (run.skipped)
       return run.skipped;
     const diagnostics = run.diagnostics;

package/extensions/dm-lens/clients/dispatch/runners/swiftlint.js

@@ -1,5 +1,7 @@
 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 { PRIORITY } from "../priorities.js";
 import {
   createAvailabilityChecker,
@@ -64,10 +66,11 @@ const SWIFTLINT_FIXABLE_RULES = new Set([
   "void_return",
   "yoda_condition"
 ]);
-function parseSwiftLintOutput(raw, filePath) {
+function parseSwiftLintOutput(raw, filePath, cwd) {
   const diagnostics = [];
   if (!raw.trim())
     return diagnostics;
+  const absTarget = path.resolve(cwd, filePath);
   try {
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed))
@@ -75,6 +78,8 @@ function parseSwiftLintOutput(raw, filePath) {
     for (const item of parsed) {
       if (!item.reason)
         continue;
+      if (item.file && !pathsEqual(path.resolve(cwd, item.file), absTarget))
+        continue;
       const severityMap = {
         error: "error",
         warning: "warning",
@@ -109,7 +114,7 @@ const swiftlintRunner = {
   priority: PRIORITY.GENERAL_ANALYSIS,
   skipTestFiles: false,
   async run(ctx) {
-    const cwd = ctx.cwd || process.cwd();
+    const cwd = resolveRunnerCwd(ctx, "swiftlint");
     let cmd = null;
     if (await swiftlint.isAvailableAsync(cwd)) {
       cmd = swiftlint.getCommand(cwd);
@@ -119,7 +124,10 @@ const swiftlintRunner = {
     if (!cmd)
       return { status: "skipped", diagnostics: [], semantic: "none" };
     const result = await safeSpawnAsync(cmd, ["--reporter", "json", path.resolve(cwd, ctx.filePath)], { cwd, timeout: 15000 });
-    const run = parseToolRun("swiftlint", { result }, (out) => parseSwiftLintOutput(out, ctx.filePath));
+    const run = parseToolRun("swiftlint", {
+      result,
+      exitCodes: { ran: [1, 2] }
+    }, (out) => parseSwiftLintOutput(out, ctx.filePath, cwd));
     if (run.skipped)
       return run.skipped;
     const diagnostics = run.diagnostics;

package/extensions/dm-lens/clients/dispatch/runners/taplo.js

@@ -1,6 +1,9 @@
 import * as path from "node:path";
+import { pathsEqual } from "../../path-utils.js";
 import { findLocalBinUpwards } from "../../package-manager.js";
+import { stripAnsi } from "../../sanitize.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 {
@@ -13,10 +16,11 @@ const taplo = createAvailabilityChecker("taplo", ".exe");
 const TAPLO_EXIT_CODES = { ran: [1] };
 const HEADER_PATTERN = /^\s*(error|warning):(.*)$/;
 const LOCATION_LEAD = "┌─";
-const LOCATION_PATTERN = /:(\d+):(\d+)$/;
-export function parseTaploOutput(raw, filePath) {
+const LOCATION_PATTERN = /^\s*┌─\s+(.+?):(\d+):(\d+)$/;
+export function parseTaploOutput(raw, filePath, cwd) {
   const diagnostics = [];
-  const lines = (raw ?? "").split(/\r?\n/);
+  const absTarget = path.resolve(cwd, filePath);
+  const lines = stripAnsi(raw ?? "").split(/\r?\n/);
   for (let i = 0;i < lines.length; i++) {
     const header = HEADER_PATTERN.exec(lines[i].trimEnd());
     if (!header)
@@ -33,8 +37,10 @@ export function parseTaploOutput(raw, filePath) {
       const location = LOCATION_PATTERN.exec(lines[j].trimEnd());
       if (!location)
         continue;
-      line = Number.parseInt(location[1], 10) || 1;
-      column = Number.parseInt(location[2], 10) || 1;
+      if (!pathsEqual(path.resolve(cwd, location[1].trim()), absTarget))
+        continue;
+      line = Number.parseInt(location[2], 10) || 1;
+      column = Number.parseInt(location[3], 10) || 1;
       break;
     }
     if (line === null)
@@ -61,7 +67,7 @@ const taploRunner = {
   priority: PRIORITY.FORMAT_AND_LINT_PRIMARY,
   skipTestFiles: false,
   async run(ctx) {
-    const cwd = ctx.cwd || process.cwd();
+    const cwd = resolveRunnerCwd(ctx, "taplo");
     const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
     if (policy && !policy.preferredRunners.includes("taplo")) {
       return { status: "skipped", diagnostics: [], semantic: "none" };
@@ -82,7 +88,7 @@ const taploRunner = {
     const absPath = path.resolve(cwd, ctx.filePath);
     const result = await safeSpawnAsync(cmd, ["check", "--colors", "never", absPath], { cwd, timeout: 15000 });
     const raw = result.stderr?.trim() ? result.stderr : result.stdout ?? "";
-    const run = parseToolRun("taplo", { result, output: raw, exitCodes: TAPLO_EXIT_CODES }, (out) => parseTaploOutput(out, ctx.filePath), { skipWhenParsedNothing: true });
+    const run = parseToolRun("taplo", { result, output: raw, exitCodes: TAPLO_EXIT_CODES }, (out) => parseTaploOutput(out, ctx.filePath, cwd), { skipWhenParsedNothing: true });
     if (run.skipped)
       return run.skipped;
     const diagnostics = run.diagnostics;

package/extensions/dm-lens/clients/dispatch/runners/terragrunt.js

@@ -1,5 +1,6 @@
 import * as path from "node:path";
 import { safeSpawnAsync } from "../../safe-spawn.js";
+import { resolveRunnerCwd } from "../../tool-cwd.js";
 import { pathsEqual } from "../../path-utils.js";
 import { getLinterPolicyForCwd } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
@@ -74,7 +75,7 @@ const terragruntRunner = {
   priority: PRIORITY.GENERAL_ANALYSIS,
   skipTestFiles: false,
   async run(ctx) {
-    const cwd = ctx.cwd || process.cwd();
+    const cwd = resolveRunnerCwd(ctx, "terragrunt");
     const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
     if (policy && !policy.preferredRunners.includes("terragrunt"))
       return SKIPPED;

package/extensions/dm-lens/clients/dispatch/runners/tflint.js

@@ -1,5 +1,7 @@
 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 { findNearestDirWithAnyBasename } from "../../workspace-topology.js";
 import { PRIORITY } from "../priorities.js";
@@ -17,24 +19,29 @@ function findTflintConfig(fileDir) {
   const dir = findNearestDirWithAnyBasename(fileDir, [TFLINT_CONFIG]);
   return dir ? path.join(dir, TFLINT_CONFIG) : null;
 }
-function parseTflintOutput(raw, filePath) {
+function parseTflintOutput(raw, filePath, toolCwd) {
   try {
     const parsed = JSON.parse(raw);
     const issues = parsed.issues ?? [];
-    return issues.map((issue) => {
+    const absTarget = path.resolve(toolCwd, filePath);
+    return issues.flatMap((issue) => {
+      if (issue.range?.filename && !pathsEqual(path.resolve(toolCwd, issue.range.filename), absTarget))
+        return [];
       const severity = issue.rule.severity === "error" ? "error" : "warning";
-      return {
-        id: `tflint-${issue.rule.name}-${issue.range.start.line}`,
-        message: `[${issue.rule.name}] ${issue.message}`,
-        filePath,
-        line: issue.range.start.line,
-        column: issue.range.start.column,
-        severity,
-        semantic: severity === "error" ? "blocking" : "warning",
-        tool: "tflint",
-        rule: issue.rule.name,
-        fixable: false
-      };
+      return [
+        {
+          id: `tflint-${issue.rule.name}-${issue.range.start.line}`,
+          message: `[${issue.rule.name}] ${issue.message}`,
+          filePath,
+          line: issue.range.start.line,
+          column: issue.range.start.column,
+          severity,
+          semantic: severity === "error" ? "blocking" : "warning",
+          tool: "tflint",
+          rule: issue.rule.name,
+          fixable: false
+        }
+      ];
     });
   } catch {
     return [];
@@ -46,7 +53,7 @@ const tflintRunner = {
   priority: PRIORITY.GENERAL_ANALYSIS,
   skipTestFiles: false,
   async run(ctx) {
-    const cwd = ctx.cwd || process.cwd();
+    const cwd = resolveRunnerCwd(ctx, "tflint");
     const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
     if (policy && !policy.preferredRunners.includes("tflint")) {
       return { status: "skipped", diagnostics: [], semantic: "none" };
@@ -75,7 +82,10 @@ const tflintRunner = {
       cwd: fileDir,
       timeout: 30000
     });
-    const run = parseToolRun("tflint", { result }, (out) => parseTflintOutput(out, ctx.filePath));
+    const run = parseToolRun("tflint", {
+      result,
+      exitCodes: { ran: [1, 2] }
+    }, (out) => parseTflintOutput(out, absPath, fileDir));
     if (run.skipped)
       return run.skipped;
     const diagnostics = run.diagnostics;

package/extensions/dm-lens/clients/dispatch/runners/tree-sitter.js

@@ -1,6 +1,6 @@
 import * as path from "node:path";
 import { RuleCache } from "../../cache/rule-cache.js";
-import { minimatch } from "../../deps/minimatch.js";
+import { isRuleIgnoredForPath } from "../rule-ignores.js";
 import { isTestFile } from "../../file-utils.js";
 import {
   buildOrUpdateGraph,
@@ -282,17 +282,6 @@ function getTotalLinesChanged(ranges) {
   return ranges.reduce((total, r) => total + (r.end - r.start + 1), 0);
 }
 const ENTITY_EXTRACTION_LINE_THRESHOLD = 5;
-function relativeForIgnoreGlob(filePath, root) {
-  const rel = path.relative(root, filePath);
-  const normalized = (rel.startsWith("..") ? filePath : rel).split(path.sep).join("/");
-  return normalized;
-}
-function matchesIgnorePaths(filePath, root, patterns) {
-  if (!patterns || patterns.length === 0)
-    return false;
-  const rel = relativeForIgnoreGlob(filePath, root);
-  return patterns.some((pattern) => minimatch(rel, pattern, { dot: true }));
-}
 const treeSitterRunner = {
   id: "tree-sitter",
   appliesTo: [
@@ -394,7 +383,7 @@ const treeSitterRunner = {
     }
     const fileIsTest = isTestFile(filePath);
     const ignoreRoot = ctx.projectRoot ?? ctx.cwd;
-    const effectiveQueries = (ctx.blockingOnly ? languageQueries.filter((q) => q.inline_tier !== "review") : languageQueries).filter((q) => !(fileIsTest && q.skip_test_files) && !matchesIgnorePaths(filePath, ignoreRoot, q.ignore_paths));
+    const effectiveQueries = (ctx.blockingOnly ? languageQueries.filter((q) => q.inline_tier !== "review") : languageQueries).filter((q) => !(fileIsTest && q.skip_test_files) && !isRuleIgnoredForPath(filePath, ignoreRoot, q.ignore_paths));
     logTreeSitter({
       phase: "queries_loaded",
       filePath,
@@ -498,6 +487,16 @@ const treeSitterRunner = {
       } catch {}
     }
     if (diagnostics.length === 0) {
+      if (!isTreeSitterWasmAborted() && !client.getLanguage(languageId)) {
+        logTreeSitter({
+          phase: "runner_skip",
+          filePath,
+          languageId,
+          reason: "grammar_unavailable",
+          status: "skipped"
+        });
+        return { status: "skipped", diagnostics: [], semantic: "none" };
+      }
       logTreeSitter({
         phase: "runner_complete",
         filePath,