@duckmind/dm-linux-x64 0.65.8 → 0.66.2

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

@@ -1,136 +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, hasSqlfluffConfig } 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 sqlfluff = createAvailabilityChecker("sqlfluff", ".exe");
-const SQLFLUFF_EXIT_CODES = { ran: [1] };
-
-export { hasSqlfluffConfig };
-const SQLFLUFF_FIXABLE_RULES = new Set([
-  "LT01",
-  "LT02",
-  "LT03",
-  "LT04",
-  "LT05",
-  "LT06",
-  "LT07",
-  "LT08",
-  "LT09",
-  "LT10",
-  "LT11",
-  "LT12",
-  "LT13",
-  "CP01",
-  "CP02",
-  "CP03",
-  "CP04",
-  "CP05",
-  "AL01",
-  "AL05",
-  "AL06",
-  "AL07",
-  "AL08",
-  "AL09",
-  "CV01",
-  "CV02",
-  "CV06",
-  "CV07",
-  "CV10",
-  "CV11",
-  "RF02",
-  "RF04",
-  "RF05",
-  "RF06",
-  "ST01",
-  "ST02"
-]);
-function parseSqlfluffOutput(raw, filePath, cwd) {
-  if (!raw.trim())
-    return [];
-  try {
-    const parsed = JSON.parse(raw);
-    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;
-        const code = v.code ?? "SQL";
-        const fixable = SQLFLUFF_FIXABLE_RULES.has(code);
-        diagnostics.push({
-          id: `sqlfluff-${v.line_no ?? 1}-${v.line_pos ?? 1}-${code}`,
-          message: `[${code}] ${v.description}`,
-          filePath,
-          line: v.line_no ?? 1,
-          column: v.line_pos ?? 1,
-          severity: "warning",
-          semantic: "warning",
-          tool: "sqlfluff",
-          rule: code,
-          fixable,
-          fixSuggestion: fixable ? "Run `sqlfluff fix` to apply the deterministic auto-correction for this rule." : undefined
-        });
-      }
-    }
-    return diagnostics;
-  } catch {
-    return [];
-  }
-}
-
-export { parseSqlfluffOutput };
-const sqlfluffRunner = {
-  id: "sqlfluff",
-  appliesTo: ["sql"],
-  priority: PRIORITY.SQL_LINT,
-  skipTestFiles: false,
-  async run(ctx) {
-    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) {
-      logRunnerAdvisoryOnce(ctx, "sqlfluff", cwd, "sqlfluff: no config detected, using ANSI dialect defaults");
-    }
-    let cmd = null;
-    if (await sqlfluff.isAvailableAsync(cwd)) {
-      cmd = sqlfluff.getCommand(cwd);
-    } else {
-      cmd = await resolveToolCommandWithInstallFallback(cwd, "sqlfluff");
-    }
-    if (!cmd)
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    const args = ["lint", "--format", "json"];
-    if (!hasConfig) {
-      args.push("--dialect", "ansi");
-    }
-    args.push(ctx.filePath);
-    const result = await safeSpawnAsync(cmd, args, {
-      timeout: 20000,
-      cwd
-    });
-    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;
-    return finishParsedRun({
-      tool: "sqlfluff",
-      ctx,
-      result,
-      diagnostics,
-      classify: () => ({ status: "failed", semantic: "warning" })
-    });
-  }
-};
-export default sqlfluffRunner;

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

@@ -1,118 +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, hasStylelintConfig } 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 stylelint = createAvailabilityChecker("stylelint", ".cmd");
-const STYLELINT_EXIT_CODES = { ran: [1, 2] };
-export function stylelintReport(stdout, stderr) {
-  for (const stream of [stdout, stderr]) {
-    if (stream?.trimStart().startsWith("["))
-      return stream;
-  }
-  return "";
-}
-const STYLELINT_FIXABLE_RULES = new Set([
-  "block-no-empty",
-  "color-hex-length",
-  "declaration-block-no-duplicate-properties",
-  "declaration-block-no-redundant-longhand-properties",
-  "declaration-block-no-shorthand-property-overrides",
-  "declaration-block-single-line-max-declarations",
-  "font-family-name-quotes",
-  "function-url-quotes",
-  "length-zero-no-unit",
-  "media-feature-name-no-vendor-prefix",
-  "no-descending-specificity",
-  "no-duplicate-at-import-rules",
-  "no-duplicate-selectors",
-  "no-empty-source",
-  "no-eol-whitespace",
-  "no-extra-semicolons",
-  "no-invalid-double-slash-comments",
-  "no-missing-end-of-source-newline",
-  "number-leading-zero",
-  "number-no-trailing-zeros",
-  "property-no-vendor-prefix",
-  "selector-attribute-quotes",
-  "selector-no-vendor-prefix",
-  "selector-pseudo-element-colon-notation",
-  "selector-type-case",
-  "shorthand-property-no-redundant-values",
-  "string-quotes",
-  "value-no-vendor-prefix"
-]);
-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);
-        diagnostics.push({
-          id: `stylelint-${w.line}-${w.rule}`,
-          message: `[${w.rule}] ${w.text.replace(/\s*\(stylelint.*?\)$/, "")}`,
-          filePath,
-          line: w.line,
-          column: w.column,
-          severity,
-          semantic: severity === "error" ? "blocking" : "warning",
-          tool: "stylelint",
-          rule: w.rule,
-          fixable,
-          fixSuggestion: fixable ? "Run `stylelint --fix` to apply the deterministic auto-correction for this rule." : undefined
-        });
-      }
-    }
-    return diagnostics;
-  } catch {
-    return [];
-  }
-}
-const stylelintRunner = {
-  id: "stylelint",
-  appliesTo: ["css"],
-  priority: PRIORITY.FORMAT_AND_LINT_PRIMARY,
-  skipTestFiles: false,
-  async run(ctx) {
-    const cwd = resolveRunnerCwd(ctx, "stylelint");
-    const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
-    if (policy && !policy.preferredRunners.includes("stylelint")) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    const fileDir = path.dirname(path.resolve(cwd, ctx.filePath));
-    const hasConfig = hasStylelintConfig(fileDir) || hasStylelintConfig(cwd);
-    if (!hasConfig) {
-      logRunnerAdvisoryOnce(ctx, "stylelint", cwd, "stylelint: no config detected, running with default rules");
-    }
-    let cmd = null;
-    if (await stylelint.isAvailableAsync(cwd)) {
-      cmd = stylelint.getCommand(cwd);
-    } else {
-      cmd = await resolveToolCommandWithInstallFallback(cwd, "stylelint");
-    }
-    if (!cmd)
-      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, cwd));
-    if (run.skipped)
-      return run.skipped;
-    const diagnostics = run.diagnostics;
-    return finishParsedRun({
-      tool: "stylelint",
-      ctx,
-      result,
-      diagnostics
-    });
-  }
-};
-export default stylelintRunner;

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

@@ -1,143 +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 { PRIORITY } from "../priorities.js";
-import { createAvailabilityChecker, resolveToolCommandWithInstallFallback } from "./utils/runner-helpers.js";
-import { parseToolRun } from "./utils/tool-failure.js";
-const swiftlint = createAvailabilityChecker("swiftlint", ".exe");
-const SWIFTLINT_FIXABLE_RULES = new Set([
-  "closing_brace",
-  "colon",
-  "comma",
-  "comma_inheritance",
-  "control_statement",
-  "duplicate_imports",
-  "empty_collection_literal",
-  "empty_enum_arguments",
-  "empty_parameters",
-  "empty_parentheses_with_trailing_closure",
-  "empty_string",
-  "explicit_init",
-  "file_header",
-  "joined_default_parameter",
-  "legacy_constant",
-  "legacy_constructor",
-  "legacy_hashing",
-  "legacy_nsgeometry_functions",
-  "mark",
-  "modifier_order",
-  "no_extension_access_modifier",
-  "no_space_in_method_call",
-  "number_separator",
-  "opening_brace",
-  "operator_usage_whitespace",
-  "prefer_zero_over_explicit_init",
-  "private_over_fileprivate",
-  "protocol_property_accessors_order",
-  "redundant_discardable_let",
-  "redundant_nil_coalescing",
-  "redundant_objc_attribute",
-  "redundant_optional_initialization",
-  "redundant_string_enum_value",
-  "redundant_type_annotation",
-  "redundant_void_return",
-  "return_arrow_whitespace",
-  "self_in_property_initialization",
-  "shorthand_operator",
-  "sorted_imports",
-  "statement_position",
-  "trailing_comma",
-  "trailing_newline",
-  "trailing_semicolon",
-  "trailing_whitespace",
-  "unneeded_break_in_switch",
-  "unneeded_parentheses_in_closure_argument",
-  "unused_capture_list",
-  "vertical_parameter_alignment",
-  "vertical_whitespace",
-  "vertical_whitespace_between_cases",
-  "vertical_whitespace_closing_braces",
-  "vertical_whitespace_opening_braces",
-  "void_function_in_ternary",
-  "void_return",
-  "yoda_condition"
-]);
-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))
-      return diagnostics;
-    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",
-        info: "info"
-      };
-      const severity = severityMap[item.severity?.toLowerCase() ?? ""] ?? "warning";
-      const ruleId = item.rule_id ?? "swiftlint";
-      const fixable = SWIFTLINT_FIXABLE_RULES.has(ruleId);
-      diagnostics.push({
-        id: `swiftlint-${item.line}-${ruleId}`,
-        message: `[${ruleId}] ${item.reason}`,
-        filePath,
-        line: item.line ?? 1,
-        column: item.character ?? 1,
-        severity,
-        semantic: severity === "error" ? "blocking" : "warning",
-        tool: "swiftlint",
-        rule: ruleId,
-        defectClass: "style",
-        fixable,
-        fixSuggestion: fixable ? "Run `swiftlint --fix` to apply the deterministic auto-correction for this rule." : undefined
-      });
-    }
-  } catch {
-    return diagnostics;
-  }
-  return diagnostics;
-}
-const swiftlintRunner = {
-  id: "swiftlint",
-  appliesTo: ["swift"],
-  priority: PRIORITY.GENERAL_ANALYSIS,
-  skipTestFiles: false,
-  async run(ctx) {
-    const cwd = resolveRunnerCwd(ctx, "swiftlint");
-    let cmd = null;
-    if (await swiftlint.isAvailableAsync(cwd)) {
-      cmd = swiftlint.getCommand(cwd);
-    } else {
-      cmd = await resolveToolCommandWithInstallFallback(cwd, "swiftlint");
-    }
-    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,
-      exitCodes: { ran: [1, 2] }
-    }, (out) => parseSwiftLintOutput(out, ctx.filePath, cwd));
-    if (run.skipped)
-      return run.skipped;
-    const diagnostics = run.diagnostics;
-    if (diagnostics.length === 0) {
-      return { status: "succeeded", diagnostics: [], semantic: "none" };
-    }
-    const hasBlocking = diagnostics.some((d) => d.semantic === "blocking");
-    return {
-      status: hasBlocking ? "failed" : "succeeded",
-      diagnostics,
-      semantic: hasBlocking ? "blocking" : "warning"
-    };
-  }
-};
-export default swiftlintRunner;
-export { parseSwiftLintOutput, SWIFTLINT_FIXABLE_RULES };

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

@@ -1,97 +0,0 @@
-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 { createAvailabilityChecker, lspPrimaryCoversFile, resolveToolCommandWithInstallFallback } from "./utils/runner-helpers.js";
-import { parseToolRun } from "./utils/tool-failure.js";
-const taplo = createAvailabilityChecker("taplo", ".exe");
-const TAPLO_EXIT_CODES = { ran: [1] };
-const HEADER_PATTERN = /^\s*(error|warning):(.*)$/;
-const LOCATION_LEAD = "┌─";
-const LOCATION_PATTERN = /^\s*┌─\s+(.+?):(\d+):(\d+)$/;
-export function parseTaploOutput(raw, filePath, cwd) {
-  const diagnostics = [];
-  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)
-      continue;
-    const severityWord = header[1];
-    const summary = header[2].trim();
-    if (!summary)
-      continue;
-    let line = null;
-    let column = 1;
-    for (let j = i + 1;j < Math.min(i + 4, lines.length); j++) {
-      if (!lines[j].includes(LOCATION_LEAD))
-        continue;
-      const location = LOCATION_PATTERN.exec(lines[j].trimEnd());
-      if (!location)
-        continue;
-      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)
-      continue;
-    const severity = severityWord === "warning" ? "warning" : "error";
-    diagnostics.push({
-      id: `taplo-${severity}-${line}-${column}`,
-      message: summary,
-      filePath,
-      line,
-      column,
-      severity,
-      semantic: severity === "error" ? "blocking" : "warning",
-      tool: "taplo",
-      rule: `taplo/${severity}`,
-      fixable: false
-    });
-  }
-  return diagnostics;
-}
-const taploRunner = {
-  id: "taplo",
-  appliesTo: ["toml"],
-  priority: PRIORITY.FORMAT_AND_LINT_PRIMARY,
-  skipTestFiles: false,
-  async run(ctx) {
-    const cwd = resolveRunnerCwd(ctx, "taplo");
-    const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
-    if (policy && !policy.preferredRunners.includes("taplo")) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    if (lspPrimaryCoversFile(ctx, "toml") && await ctx.hasTool("taplo")) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    let cmd = findLocalBinUpwards("taplo", cwd) ?? null;
-    if (!cmd) {
-      if (await taplo.isAvailableAsync(cwd)) {
-        cmd = taplo.getCommand(cwd);
-      } else {
-        cmd = await resolveToolCommandWithInstallFallback(cwd, "taplo");
-      }
-    }
-    if (!cmd)
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    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, cwd), { skipWhenParsedNothing: true });
-    if (run.skipped)
-      return run.skipped;
-    const diagnostics = run.diagnostics;
-    if (diagnostics.length === 0) {
-      return { status: "succeeded", diagnostics: [], semantic: "none" };
-    }
-    return { status: "failed", diagnostics, semantic: "blocking" };
-  }
-};
-export default taploRunner;

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

@@ -1,110 +0,0 @@
-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";
-import { createAvailabilityChecker, resolveAvailableOrInstall } from "./utils/runner-helpers.js";
-import { spawnFailedWithNoOutput } from "./utils/spawn-outcome.js";
-import { finishParsedRun } from "./utils/tool-failure.js";
-const terragrunt = createAvailabilityChecker("terragrunt", ".exe");
-function normalizeSeverity(raw) {
-  if (typeof raw === "number")
-    return raw === 1 ? "error" : "warning";
-  if (typeof raw === "string" && raw.toLowerCase() === "error")
-    return "error";
-  return "warning";
-}
-function toRawDiagnostics(parsed) {
-  if (Array.isArray(parsed))
-    return parsed;
-  if (!parsed || typeof parsed !== "object")
-    return [];
-  const invalidFiles = parsed.invalid_files;
-  if (!Array.isArray(invalidFiles))
-    return [];
-  return invalidFiles.flatMap((f) => Array.isArray(f?.diagnostics) ? f.diagnostics : []);
-}
-export function parseTerragruntOutput(raw, filePath, absPath = path.resolve(filePath)) {
-  if (!raw.trim())
-    return [];
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    return [];
-  }
-  const unitDir = path.dirname(absPath);
-  const diagnostics = [];
-  for (const d of toRawDiagnostics(parsed)) {
-    if (!d || typeof d !== "object")
-      continue;
-    const diagFile = d.range?.filename;
-    if (diagFile && !pathsEqual(path.resolve(unitDir, diagFile), absPath))
-      continue;
-    const line = d.range?.start?.line ?? 1;
-    const column = d.range?.start?.column ?? 1;
-    const severity = normalizeSeverity(d.severity);
-    const message = d.summary ?? d.detail ?? "terragrunt hcl validate error";
-    const idMessage = message.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 80);
-    diagnostics.push({
-      id: `terragrunt-hclvalidate-${line}-${column}-${idMessage}`,
-      message,
-      filePath,
-      line,
-      column,
-      severity,
-      semantic: severity === "error" ? "blocking" : "warning",
-      tool: "terragrunt",
-      fixable: false
-    });
-  }
-  return diagnostics;
-}
-const SKIPPED = {
-  status: "skipped",
-  diagnostics: [],
-  semantic: "none"
-};
-const terragruntRunner = {
-  id: "terragrunt",
-  appliesTo: ["terragrunt"],
-  priority: PRIORITY.GENERAL_ANALYSIS,
-  skipTestFiles: false,
-  async run(ctx) {
-    const cwd = resolveRunnerCwd(ctx, "terragrunt");
-    const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
-    if (policy && !policy.preferredRunners.includes("terragrunt"))
-      return SKIPPED;
-    let cmd = null;
-    if (await terragrunt.isAvailableAsync(cwd)) {
-      cmd = terragrunt.getCommand(cwd);
-    } else {
-      const managed = await resolveAvailableOrInstall(terragrunt, "terragrunt", cwd);
-      if (managed)
-        cmd = managed;
-    }
-    if (!cmd)
-      return SKIPPED;
-    const absPath = path.resolve(cwd, ctx.filePath);
-    const fileDir = path.dirname(absPath);
-    const result = await safeSpawnAsync(cmd, ["hcl", "validate", "--json", "--non-interactive"], { cwd: fileDir, timeout: 30000 });
-    if (spawnFailedWithNoOutput(result))
-      return SKIPPED;
-    const diagnostics = parseTerragruntOutput(result.stdout || "", ctx.filePath, absPath);
-    return finishParsedRun({
-      tool: "terragrunt",
-      ctx,
-      result,
-      diagnostics,
-      classify: (diagnostics) => {
-        const hasErrors = diagnostics.some((d) => d.severity === "error");
-        return {
-          status: hasErrors ? "failed" : "succeeded",
-          semantic: hasErrors ? "blocking" : "warning"
-        };
-      }
-    });
-  }
-};
-export default terragruntRunner;