@duckmind/dm-linux-x64 0.65.4 → 0.65.6

package/extensions/dm-lens/dist/clients/dispatch/lazy.js

@@ -0,0 +1,8 @@
+import { createLazyImport } from "../lazy-import.js";
+const lazyIntegration = createLazyImport(() => import("./integration.js"));
+export function warmDispatchIntegration() {
+  return lazyIntegration.get();
+}
+export function loadDispatchIntegration() {
+  return warmDispatchIntegration();
+}

package/extensions/dm-lens/dist/clients/dispatch/pending-runner-findings.js

@@ -0,0 +1,75 @@
+import { incrementDegradationCount } from "../degradation-ledger.js";
+const pending = [];
+const MAX_PENDING_RUNNER_FINDINGS = 50;
+export function deferRunnerFindings(entry) {
+  const tracked = { ...entry, settled: false };
+  tracked.promise.then((result) => {
+    tracked.result = result;
+    tracked.settled = true;
+  }, (error) => {
+    tracked.result = {
+      status: "failed",
+      diagnostics: [],
+      semantic: "warning",
+      failureKind: "exception",
+      failureMessage: String(error).slice(0, 200)
+    };
+    tracked.settled = true;
+  });
+  pending.push(tracked);
+  if (pending.length > MAX_PENDING_RUNNER_FINDINGS) {
+    const evicted = pending.shift();
+    if (evicted) {
+      incrementDegradationCount({
+        kind: "runner-findings-evicted",
+        subject: `${evicted.runnerId}:${evicted.filePath}`,
+        reason: `pending runner cap ${MAX_PENDING_RUNNER_FINDINGS}`
+      });
+    }
+  }
+}
+export async function drainPendingRunnerFindings(maxWaitMs = 2000) {
+  if (pending.length === 0)
+    return [];
+  const current = pending.splice(0, pending.length);
+  const results = [];
+  if (maxWaitMs === 0)
+    await Promise.resolve();
+  if (maxWaitMs > 0 && current.some((entry) => !entry.settled)) {
+    await new Promise((resolve) => {
+      const timer = setTimeout(resolve, maxWaitMs);
+      timer.unref?.();
+    });
+  }
+  for (const entry of current) {
+    if (entry.settled && entry.result) {
+      results.push({
+        filePath: entry.filePath,
+        cwd: entry.cwd,
+        projectRoot: entry.projectRoot,
+        runnerId: entry.runnerId,
+        markedAtMs: entry.markedAtMs,
+        writeIndex: entry.writeIndex,
+        result: entry.result
+      });
+    } else {
+      pending.push(entry);
+    }
+  }
+  return results;
+}
+export function dropStaleRunnerFindings(entry) {
+  if (!entry.result)
+    return;
+  incrementDegradationCount({
+    kind: "runner-findings-stale",
+    subject: `${entry.runnerId}:${entry.filePath}`,
+    reason: "completed result was older than the latest file edit"
+  });
+}
+export function resetPendingRunnerFindings() {
+  pending.length = 0;
+}
+export function pendingRunnerFindingsSize() {
+  return pending.length;
+}

package/extensions/dm-lens/dist/clients/dispatch/plan.js

@@ -0,0 +1,278 @@
+import { getPrimaryDispatchGroup } from "../language-policy.js";
+function primary(kind) {
+  const group = getPrimaryDispatchGroup(kind, true);
+  if (!group) {
+    throw new Error(`Missing primary dispatch group for ${kind}`);
+  }
+  return group;
+}
+export const LANGUAGE_CAPABILITY_MATRIX = {
+  jsts: {
+    name: "JavaScript/TypeScript Linting",
+    capabilities: ["types", "security", "smells", "format", "lint"],
+    writeGroups: [
+      primary("jsts"),
+      { mode: "all", runnerIds: ["tree-sitter"], filterKinds: ["jsts"] },
+      { mode: "all", runnerIds: ["fact-rules"], filterKinds: ["jsts"] },
+      { mode: "all", runnerIds: ["ast-grep-napi"], filterKinds: ["jsts"] },
+      {
+        mode: "fallback",
+        runnerIds: ["eslint", "oxlint", "biome-check-json"],
+        filterKinds: ["jsts"]
+      }
+    ]
+  },
+  python: {
+    name: "Python Linting",
+    capabilities: ["types", "lint", "smells"],
+    writeGroups: [
+      primary("python"),
+      { mode: "fallback", runnerIds: ["ruff-lint"], filterKinds: ["python"] },
+      { mode: "fallback", runnerIds: ["mypy"], filterKinds: ["python"] },
+      { mode: "all", runnerIds: ["tree-sitter"], filterKinds: ["python"] },
+      { mode: "all", runnerIds: ["fact-rules"], filterKinds: ["python"] }
+    ]
+  },
+  go: {
+    name: "Go Linting",
+    capabilities: ["types", "lint", "smells"],
+    writeGroups: [
+      primary("go"),
+      { mode: "fallback", runnerIds: ["golangci-lint"], filterKinds: ["go"] },
+      { mode: "all", runnerIds: ["tree-sitter"], filterKinds: ["go"] },
+      { mode: "all", runnerIds: ["fact-rules"], filterKinds: ["go"] }
+    ]
+  },
+  rust: {
+    name: "Rust Linting",
+    capabilities: ["types", "lint", "smells"],
+    writeGroups: [
+      primary("rust"),
+      { mode: "all", runnerIds: ["tree-sitter"], filterKinds: ["rust"] },
+      { mode: "all", runnerIds: ["fact-rules"], filterKinds: ["rust"] }
+    ]
+  },
+  ruby: {
+    name: "Ruby Linting",
+    capabilities: ["types", "lint", "smells"],
+    writeGroups: [
+      primary("ruby"),
+      { mode: "fallback", runnerIds: ["rubocop"], filterKinds: ["ruby"] },
+      { mode: "all", runnerIds: ["tree-sitter"], filterKinds: ["ruby"] },
+      { mode: "all", runnerIds: ["fact-rules"], filterKinds: ["ruby"] }
+    ]
+  },
+  cxx: {
+    name: "C/C++ Linting",
+    capabilities: ["types", "lint", "smells"],
+    writeGroups: [
+      primary("cxx"),
+      { mode: "all", runnerIds: ["tree-sitter"], filterKinds: ["cxx"] }
+    ]
+  },
+  cmake: {
+    name: "CMake Processing",
+    capabilities: ["lint"],
+    writeGroups: [
+      primary("cmake"),
+      { mode: "all", runnerIds: ["fact-rules"], filterKinds: ["cmake"] }
+    ]
+  },
+  fish: {
+    name: "Fish Script Formatting",
+    capabilities: ["format"],
+    writeGroups: [primary("fish")]
+  },
+  shell: {
+    name: "Shell Script Linting",
+    capabilities: ["lint", "security", "format"],
+    writeGroups: [
+      primary("shell"),
+      { mode: "all", runnerIds: ["shfmt"], filterKinds: ["shell"] },
+      { mode: "all", runnerIds: ["fact-rules"], filterKinds: ["shell"] }
+    ]
+  },
+  json: {
+    name: "JSON Processing",
+    capabilities: ["format", "lint"],
+    writeGroups: [
+      primary("json"),
+      { mode: "all", runnerIds: ["trivy-config"], filterKinds: ["json"] }
+    ]
+  },
+  markdown: {
+    name: "Markdown Processing",
+    capabilities: ["docs", "format", "lint"],
+    writeGroups: [
+      primary("markdown"),
+      { mode: "all", runnerIds: ["markdownlint"], filterKinds: ["markdown"] }
+    ]
+  },
+  css: {
+    name: "CSS Processing",
+    capabilities: ["format", "lint"],
+    writeGroups: [
+      primary("css"),
+      { mode: "all", runnerIds: ["tree-sitter"], filterKinds: ["css"] },
+      { mode: "all", runnerIds: ["ast-grep-napi"], filterKinds: ["css"] }
+    ]
+  },
+  yaml: {
+    name: "YAML Processing",
+    capabilities: ["format", "lint"],
+    writeGroups: [
+      primary("yaml"),
+      { mode: "all", runnerIds: ["actionlint"], filterKinds: ["yaml"] }
+    ]
+  },
+  "helm-template": {
+    name: "Helm Template Linting",
+    capabilities: ["lint"],
+    writeGroups: [primary("helm-template")]
+  },
+  sql: {
+    name: "SQL Processing",
+    capabilities: ["format", "lint"],
+    writeGroups: [primary("sql")]
+  },
+  html: {
+    name: "HTML Linting",
+    capabilities: ["lint"],
+    writeGroups: [
+      primary("html"),
+      { mode: "all", runnerIds: ["ast-grep-napi"], filterKinds: ["html"] }
+    ]
+  },
+  docker: {
+    name: "Dockerfile Linting",
+    capabilities: ["lint"],
+    writeGroups: [primary("docker")]
+  },
+  php: {
+    name: "PHP Linting",
+    capabilities: ["types", "lint"],
+    writeGroups: [
+      primary("php"),
+      { mode: "all", runnerIds: ["tree-sitter"], filterKinds: ["php"] }
+    ]
+  },
+  powershell: {
+    name: "PowerShell Linting",
+    capabilities: ["lint"],
+    writeGroups: [primary("powershell")]
+  },
+  prisma: {
+    name: "Prisma Schema Linting",
+    capabilities: ["types", "lint"],
+    writeGroups: [primary("prisma")]
+  },
+  csharp: {
+    name: "C# Linting",
+    capabilities: ["types", "lint"],
+    writeGroups: [
+      primary("csharp"),
+      { mode: "all", runnerIds: ["tree-sitter"], filterKinds: ["csharp"] }
+    ]
+  },
+  fsharp: {
+    name: "F# Linting",
+    capabilities: ["types", "lint"],
+    writeGroups: [primary("fsharp")]
+  },
+  java: {
+    name: "Java Linting",
+    capabilities: ["types", "lint"],
+    writeGroups: [primary("java")]
+  },
+  kotlin: {
+    name: "Kotlin Linting",
+    capabilities: ["types", "lint", "format", "smells"],
+    writeGroups: [
+      primary("kotlin"),
+      { mode: "fallback", runnerIds: ["detekt"], filterKinds: ["kotlin"] }
+    ]
+  },
+  swift: {
+    name: "Swift Linting",
+    capabilities: ["types", "lint"],
+    writeGroups: [primary("swift")]
+  },
+  dart: {
+    name: "Dart Linting",
+    capabilities: ["types", "lint"],
+    writeGroups: [primary("dart")]
+  },
+  lua: {
+    name: "Lua Linting",
+    capabilities: ["types", "lint"],
+    writeGroups: [primary("lua")]
+  },
+  zig: {
+    name: "Zig Linting",
+    capabilities: ["types", "lint"],
+    writeGroups: [primary("zig")]
+  },
+  haskell: {
+    name: "Haskell Linting",
+    capabilities: ["types", "lint"],
+    writeGroups: [primary("haskell")]
+  },
+  elixir: {
+    name: "Elixir Linting",
+    capabilities: ["types", "lint"],
+    writeGroups: [primary("elixir")]
+  },
+  gleam: {
+    name: "Gleam Linting",
+    capabilities: ["types", "lint"],
+    writeGroups: [primary("gleam")]
+  },
+  ocaml: {
+    name: "OCaml Linting",
+    capabilities: ["types", "lint"],
+    writeGroups: [primary("ocaml")]
+  },
+  clojure: {
+    name: "Clojure Linting",
+    capabilities: ["types", "lint"],
+    writeGroups: [primary("clojure")]
+  },
+  cue: {
+    name: "CUE Linting",
+    capabilities: ["types", "lint"],
+    writeGroups: [primary("cue")]
+  },
+  terraform: {
+    name: "Terraform Linting",
+    capabilities: ["types", "lint", "security"],
+    writeGroups: [primary("terraform")]
+  },
+  terragrunt: {
+    name: "Terragrunt Linting",
+    capabilities: ["lint", "format"],
+    writeGroups: [primary("terragrunt")]
+  },
+  nix: {
+    name: "Nix Linting",
+    capabilities: ["types", "lint"],
+    writeGroups: [primary("nix")]
+  },
+  toml: {
+    name: "TOML Linting",
+    capabilities: ["lint", "format"],
+    writeGroups: [primary("toml")]
+  }
+};
+function toWritePlan(entry) {
+  return {
+    name: entry.name,
+    groups: [...entry.writeGroups]
+  };
+}
+export const TOOL_PLANS = Object.fromEntries(Object.entries(LANGUAGE_CAPABILITY_MATRIX).map(([kind, entry]) => [
+  kind,
+  toWritePlan(entry)
+]));
+export function getToolPlan(kind) {
+  return TOOL_PLANS[kind];
+}

package/extensions/dm-lens/dist/clients/dispatch/priorities.js

@@ -0,0 +1,14 @@
+export const PRIORITY = {
+  LSP_PRIMARY: 4,
+  LSP_FALLBACK: 5,
+  FORMAT_AND_LINT_PRIMARY: 10,
+  LINT_SECONDARY: 12,
+  STRUCTURAL_ANALYSIS: 14,
+  SPECIALIZED_ANALYSIS: 15,
+  GENERAL_ANALYSIS: 20,
+  YAML_LINT: 22,
+  SQL_LINT: 24,
+  DOC_QUALITY: 30,
+  ARCHITECTURE: 40,
+  DEEP_LANGUAGE_ANALYSIS: 50
+};

package/extensions/dm-lens/dist/clients/dispatch/rule-id-normalize.js

@@ -0,0 +1,42 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getAstGrepRuleSources } from "../sgconfig.js";
+export function deriveRuleIdLanguageSuffixes(ruleRoot) {
+  const suffixes = new Set;
+  const visit = (dir) => {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const entryPath = path.join(dir, entry.name);
+      if (entry.isDirectory())
+        visit(entryPath);
+      else {
+        const match = /-([a-z0-9]+)\.ya?ml$/i.exec(entry.name);
+        if (match)
+          suffixes.add(match[1].toLowerCase());
+      }
+    }
+  };
+  visit(ruleRoot);
+  return suffixes;
+}
+const bundledCodeRabbitRules = getAstGrepRuleSources().find((source) => source.origin === "bundled" && source.tier === "secondary");
+const RULE_ID_LANGUAGE_SUFFIXES = new Set(["js"]);
+if (bundledCodeRabbitRules) {
+  for (const suffix of deriveRuleIdLanguageSuffixes(bundledCodeRabbitRules.dir)) {
+    RULE_ID_LANGUAGE_SUFFIXES.add(suffix);
+  }
+}
+export function normalizeRuleId(ruleId) {
+  const normalized = ruleId.replace(/^ast-grep:/, "");
+  for (const suffix of RULE_ID_LANGUAGE_SUFFIXES) {
+    if (normalized.endsWith(`-${suffix}`)) {
+      return normalized.slice(0, -(suffix.length + 1));
+    }
+  }
+  return normalized;
+}

package/extensions/dm-lens/dist/clients/dispatch/rule-ignores.js

@@ -0,0 +1,21 @@
+import * as path from "node:path";
+import { minimatch } from "../deps/minimatch.js";
+import { buildEffectiveAstGrepCatalog } from "./ast-grep-catalog.js";
+import { isWindowsPath, toPosix } from "../path-utils.js";
+export function isRuleIgnoredForPath(filePath, root, patterns) {
+  if (!patterns || patterns.length === 0)
+    return false;
+  const pathApi = isWindowsPath(root) || isWindowsPath(filePath) ? path.win32 : path.posix;
+  const relative = pathApi.relative(root, filePath);
+  const outsideRoot = relative !== "" && (relative === ".." || relative.startsWith(`..${pathApi.sep}`) || pathApi.isAbsolute(relative));
+  const displayPath = toPosix(outsideRoot ? filePath : relative);
+  return patterns.some((pattern) => (!outsideRoot || !pattern.replaceAll("\\", "/").endsWith("/**")) && minimatch(displayPath, pattern, { dot: true }));
+}
+export function loadRuleIgnorePatterns(root) {
+  const patterns = new Map;
+  for (const [id, { rule }] of buildEffectiveAstGrepCatalog(root).effectiveRules) {
+    if (rule.ignores?.length)
+      patterns.set(id, rule.ignores);
+  }
+  return patterns;
+}

package/extensions/dm-lens/dist/clients/dispatch/rule-policy.js

@@ -0,0 +1,73 @@
+import { normalizeRuleId } from "./rule-id-normalize.js";
+export function evaluateRulePolicy(ruleId, policyMap) {
+  if (!policyMap)
+    return { dropped: false };
+  const raw = ruleId || "";
+  const norm = normalizeRuleId(raw);
+  if (scanList(policyMap, (e) => e.disable, raw, norm).matched) {
+    return { dropped: true };
+  }
+  const select = scanList(policyMap, (e) => e.select, raw, norm);
+  return { dropped: select.sawEntry && !select.matched };
+}
+function scanList(policyMap, pick, raw, norm) {
+  let sawEntry = false;
+  for (const entry of Object.values(policyMap)) {
+    for (const candidate of (entry && pick(entry)) ?? []) {
+      sawEntry = true;
+      if (matchesRule(candidate, raw, norm))
+        return { matched: true, sawEntry };
+    }
+  }
+  return { matched: false, sawEntry };
+}
+function matchesRule(entry, raw, normalized) {
+  if (entry === raw)
+    return true;
+  return normalizeRuleId(entry) === normalized;
+}
+export function applyRulePolicy(diagnostics, policyMap) {
+  if (!policyMap)
+    return diagnostics;
+  let hasFilter = false;
+  for (const rawEntry of Object.values(policyMap)) {
+    if (!rawEntry || typeof rawEntry !== "object" || Array.isArray(rawEntry)) {
+      continue;
+    }
+    const entry = rawEntry;
+    if ((entry.disable?.length ?? 0) > 0 || (entry.select?.length ?? 0) > 0) {
+      hasFilter = true;
+      break;
+    }
+  }
+  if (!hasFilter)
+    return diagnostics;
+  return diagnostics.filter((d) => {
+    const ruleId = d.rule ?? d.code;
+    if (!ruleId)
+      return true;
+    const { dropped } = evaluateRulePolicy(ruleId, policyMap);
+    return !dropped;
+  });
+}
+export function rulePolicyMapFromConfig(rules) {
+  if (!rules)
+    return;
+  let built;
+  for (const [key, rawEntry] of Object.entries(rules)) {
+    if (!rawEntry || typeof rawEntry !== "object" || Array.isArray(rawEntry)) {
+      continue;
+    }
+    const entry = rawEntry;
+    const hasDisable = (entry.disable?.length ?? 0) > 0;
+    const hasSelect = (entry.select?.length ?? 0) > 0;
+    if (!hasDisable && !hasSelect)
+      continue;
+    built ??= {};
+    built[key] = {
+      ...hasDisable ? { disable: entry.disable } : {},
+      ...hasSelect ? { select: entry.select } : {}
+    };
+  }
+  return built;
+}

package/extensions/dm-lens/dist/clients/dispatch/rules/async-noise.js

@@ -0,0 +1,31 @@
+import { isTestFile } from "../../file-utils.js";
+export const asyncNoiseRule = {
+  id: "async-noise",
+  requires: ["file.functionSummaries"],
+  appliesTo(ctx) {
+    return /\.tsx?$/.test(ctx.filePath) && !isTestFile(ctx.filePath);
+  },
+  evaluate(ctx, store) {
+    const summaries = store.getFileFact(ctx.filePath, "file.functionSummaries");
+    if (!summaries)
+      return [];
+    const diagnostics = [];
+    const ASYNC_INTERFACE_PATTERN = /^(on[A-Z]|handle[A-Z]|before[A-Z]|after[A-Z]|setup|teardown|init|dispose|connect|disconnect|open|close|start|stop|run|execute|invoke|dispatch|middleware)/;
+    for (const fn of summaries) {
+      if (fn.isAsync && !fn.hasAwait && !fn.hasReturnAwaitCall && !fn.isPassThroughWrapper && !fn.hasExplicitPromiseReturnType && !ASYNC_INTERFACE_PATTERN.test(fn.name) && fn.statementCount > 1) {
+        diagnostics.push({
+          id: `async-noise:${ctx.filePath}:${fn.line}:${fn.column}`,
+          tool: "fact-rules",
+          filePath: ctx.filePath,
+          line: fn.line,
+          column: fn.column,
+          severity: "warning",
+          semantic: "warning",
+          message: `Async function '${fn.name}' has no await and appears to add async noise`,
+          rule: "async-noise"
+        });
+      }
+    }
+    return diagnostics;
+  }
+};

package/extensions/dm-lens/dist/clients/dispatch/rules/async-unnecessary-wrapper.js

@@ -0,0 +1,27 @@
+export const asyncUnnecessaryWrapperRule = {
+  id: "async-unnecessary-wrapper",
+  requires: ["file.functionSummaries"],
+  appliesTo(ctx) {
+    return /\.tsx?$/.test(ctx.filePath);
+  },
+  evaluate(ctx, store) {
+    const fns = store.getFileFact(ctx.filePath, "file.functionSummaries") ?? [];
+    const diagnostics = [];
+    for (const f of fns) {
+      if (!f.isAsync || !f.isPassThroughWrapper || f.hasAwait)
+        continue;
+      diagnostics.push({
+        id: `async-unnecessary-wrapper:${ctx.filePath}:${f.line}`,
+        tool: "fact-rules",
+        rule: "async-unnecessary-wrapper",
+        filePath: ctx.filePath,
+        line: f.line,
+        column: f.column,
+        severity: "warning",
+        semantic: "warning",
+        message: `'${f.name}' is async but has no await and just forwards to '${f.passThroughTarget}' — the async keyword is unnecessary and wraps the return in an extra Promise`
+      });
+    }
+    return diagnostics;
+  }
+};

package/extensions/dm-lens/dist/clients/dispatch/rules/cors-wildcard.js

@@ -0,0 +1,35 @@
+export const corsWildcardRule = {
+  id: "cors-wildcard",
+  requires: ["file.content"],
+  appliesTo(ctx) {
+    return /\.(tsx?|py|go)$/.test(ctx.filePath);
+  },
+  evaluate(ctx, store) {
+    const content = store.getFileFact(ctx.filePath, "file.content");
+    if (!content)
+      return [];
+    const diagnostics = [];
+    const lines = content.split(`
+`);
+    for (let i = 0;i < lines.length; i++) {
+      const line = lines[i];
+      if (/^\s*(?:\/\/|\*|#|\/)/.test(line))
+        continue;
+      const isWildcard = /["']Access-Control-Allow-Origin["']/.test(line) && /["']\*["']/.test(line) || /origin\s*:\s*["']\*["']/.test(line) || /cors\s*\(/.test(line) && /\*/.test(line) || /(?:allow_origins|origins)\s*=\s*["']\*["']/.test(line) || /(?:allow_origins|origins)\s*=\s*[[(]["']\*["']/.test(line) || /AllowAllOrigins\s*:\s*true/.test(line) || /Allow(?:ed)?Origins[^*\n]{0,60}\*/.test(line);
+      if (isWildcard) {
+        diagnostics.push({
+          id: `cors-wildcard:${ctx.filePath}:${i + 1}`,
+          tool: "fact-rules",
+          rule: "cors-wildcard",
+          filePath: ctx.filePath,
+          line: i + 1,
+          column: 1,
+          severity: "error",
+          semantic: "blocking",
+          message: "CORS wildcard origin (*) allows any website to make credentialed requests — restrict to known origins"
+        });
+      }
+    }
+    return diagnostics;
+  }
+};

package/extensions/dm-lens/dist/clients/dispatch/rules/error-obscuring.js

@@ -0,0 +1,29 @@
+export const errorObscuringRule = {
+  id: "error-obscuring",
+  requires: ["file.tryCatchSummaries"],
+  appliesTo(ctx) {
+    return /\.tsx?$/.test(ctx.filePath);
+  },
+  evaluate(ctx, store) {
+    const summaries = store.getFileFact(ctx.filePath, "file.tryCatchSummaries");
+    if (!summaries)
+      return [];
+    const diagnostics = [];
+    for (const s of summaries) {
+      if (!s.isEmpty && !s.hasRethrow && s.catchParam !== null && !s.bodyText.includes(s.catchParam)) {
+        diagnostics.push({
+          id: `error-obscuring:${ctx.filePath}:${s.line}:${s.column}`,
+          tool: "fact-rules",
+          rule: "error-obscuring",
+          filePath: ctx.filePath,
+          line: s.line,
+          column: s.column,
+          severity: "warning",
+          semantic: "warning",
+          message: `Catch block catches '${s.catchParam}' but never references it — the error is obscured`
+        });
+      }
+    }
+    return diagnostics;
+  }
+};

package/extensions/dm-lens/dist/clients/dispatch/rules/error-swallowing.js

@@ -0,0 +1,29 @@
+export const errorSwallowingRule = {
+  id: "error-swallowing",
+  requires: ["file.tryCatchSummaries"],
+  appliesTo(ctx) {
+    return /\.tsx?$/.test(ctx.filePath);
+  },
+  evaluate(ctx, store) {
+    const summaries = store.getFileFact(ctx.filePath, "file.tryCatchSummaries");
+    if (!summaries)
+      return [];
+    const diagnostics = [];
+    for (const s of summaries) {
+      if (s.isEmpty && !s.isDocumentedLocalFallback && s.boundaryCategory !== "fs") {
+        diagnostics.push({
+          id: `error-swallowing:${ctx.filePath}:${s.line}:${s.column}`,
+          tool: "fact-rules",
+          rule: "error-swallowing",
+          filePath: ctx.filePath,
+          line: s.line,
+          column: s.column,
+          severity: "error",
+          semantic: "blocking",
+          message: `Empty catch block silently swallows errors`
+        });
+      }
+    }
+    return diagnostics;
+  }
+};