@duckmind/dm-linux-x64 0.65.8 → 0.66.2

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

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

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

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

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

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

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

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

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

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

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

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

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