@duckmind/dm-linux-x64 0.63.9 → 0.64.2

package/extensions/dm-lens/clients/dispatch/facts/import-facts.js

@@ -0,0 +1,171 @@
+import { logLatency } from "../../latency-logger.js";
+import { isJstsFactFile } from "../../file-kinds.js";
+import {
+  childrenOfType,
+  firstChildOfType,
+  withFactTree,
+  walk
+} from "./tree-sitter-facts.js";
+function stripQuotes(raw) {
+  return raw.replace(/^["'`]+|["'`]+$/g, "");
+}
+function parseStaticImport(node, moduleType) {
+  const sourceNode = firstChildOfType(node, "string");
+  if (!sourceNode)
+    return null;
+  const source = stripQuotes(sourceNode.text);
+  const clause = firstChildOfType(node, "import_clause");
+  if (!clause) {
+    return { source, names: [], moduleType };
+  }
+  const entry = { source, names: [], moduleType };
+  for (const child of clause.children ?? []) {
+    if (!child)
+      continue;
+    if (child.type === "identifier") {
+      entry.defaultName = child.text;
+    } else if (child.type === "namespace_import") {
+      const id = firstChildOfType(child, "identifier");
+      if (id)
+        entry.namespace = id.text;
+    } else if (child.type === "named_imports") {
+      for (const spec of childrenOfType(child, "import_specifier")) {
+        const ids = childrenOfType(spec, "identifier");
+        const local = ids.length ? ids[ids.length - 1].text : undefined;
+        if (local)
+          entry.names.push(local);
+      }
+    }
+  }
+  return entry;
+}
+function parseReExport(node) {
+  const sourceNode = firstChildOfType(node, "string");
+  if (!sourceNode)
+    return null;
+  const source = stripQuotes(sourceNode.text);
+  const clause = firstChildOfType(node, "export_clause");
+  if (!clause) {
+    return { source, names: [] };
+  }
+  const names = [];
+  for (const spec of childrenOfType(clause, "export_specifier")) {
+    const ids = childrenOfType(spec, "identifier");
+    const name = ids.length ? ids[ids.length - 1].text : undefined;
+    if (name)
+      names.push(name);
+  }
+  return { source, names };
+}
+export const importFactProvider = {
+  id: "fact.file.imports",
+  provides: ["file.imports", "file.reexports", "file.importFactsCoverage"],
+  requires: ["file.content"],
+  appliesTo(ctx) {
+    return isJstsFactFile(ctx.filePath);
+  },
+  async run(ctx, store) {
+    const content = store.getFileFact(ctx.filePath, "file.content");
+    const setEmpty = (complete = false) => {
+      store.setFileFact(ctx.filePath, "file.imports", []);
+      store.setFileFact(ctx.filePath, "file.reexports", []);
+      store.setFileFact(ctx.filePath, "file.importFactsCoverage", complete ? "complete" : "unavailable");
+    };
+    if (content == null) {
+      setEmpty();
+      return;
+    }
+    const parsed = await withFactTree(ctx.filePath, content, (root) => {
+      let hasEsm = false;
+      let hasCjs = false;
+      const importNodes = [];
+      const reExportNodes = [];
+      for (const child of root.children ?? []) {
+        if (!child)
+          continue;
+        if (child.type === "import_statement") {
+          hasEsm = true;
+          importNodes.push(child);
+        } else if (child.type === "export_statement") {
+          const isReExport = Boolean(firstChildOfType(child, "string"));
+          if (isReExport || firstChildOfType(child, "export_clause")) {
+            hasEsm = true;
+          }
+          if (isReExport)
+            reExportNodes.push(child);
+        }
+      }
+      const dynamicRaw = [];
+      walk(root, (node) => {
+        if (node.type === "call_expression") {
+          const callee = node.children?.[0];
+          const args = firstChildOfType(node, "arguments");
+          const strArg = args ? firstChildOfType(args, "string") : undefined;
+          if (!strArg)
+            return;
+          const source = stripQuotes(strArg.text);
+          if (callee?.type === "import") {
+            dynamicRaw.push({ source, kind: "import" });
+          } else if (callee?.type === "identifier" && callee.text === "require") {
+            dynamicRaw.push({ source, kind: "require" });
+            hasCjs = true;
+          }
+        } else if (node.type === "member_expression") {
+          const obj = node.children?.[0];
+          if (obj?.type === "identifier" && obj.text === "module") {
+            const prop = firstChildOfType(node, "property_identifier");
+            if (prop?.text === "exports")
+              hasCjs = true;
+          }
+        }
+      });
+      const moduleType = hasEsm && !hasCjs ? "esm" : hasCjs && !hasEsm ? "cjs" : hasEsm || hasCjs ? "esm" : "unknown";
+      const imports = [];
+      for (const node of importNodes) {
+        const entry = parseStaticImport(node, moduleType);
+        if (entry)
+          imports.push(entry);
+      }
+      let dynamicCount = 0;
+      for (const d of dynamicRaw) {
+        if (d.kind === "import") {
+          imports.push({
+            source: d.source,
+            names: [],
+            isDynamic: true,
+            moduleType
+          });
+        } else {
+          imports.push({ source: d.source, names: [], moduleType: "cjs" });
+        }
+        dynamicCount++;
+      }
+      store.setFileFact(ctx.filePath, "file.imports", imports);
+      const reexports = [];
+      for (const node of reExportNodes) {
+        const r = parseReExport(node);
+        if (r)
+          reexports.push(r);
+      }
+      store.setFileFact(ctx.filePath, "file.reexports", reexports);
+      if (dynamicCount > 0 || reexports.length > 0) {
+        logLatency({
+          type: "call_graph_facts",
+          filePath: ctx.filePath,
+          durationMs: 0,
+          metadata: {
+            moduleType,
+            staticImports: imports.length - dynamicCount,
+            dynamicImports: dynamicCount,
+            reexports: reexports.length,
+            starReexports: reexports.filter((r) => r.names.length === 0).length
+          }
+        });
+      }
+    });
+    if (!parsed.parsed)
+      setEmpty();
+    else
+      store.setFileFact(ctx.filePath, "file.importFactsCoverage", "complete");
+  }
+};

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

@@ -0,0 +1,24 @@
+import {
+  childrenOfType,
+  firstChildOfType,
+  withTreeSitterRoot,
+  walk
+} from "../../tree-sitter-shared.js";
+
+export { childrenOfType, firstChildOfType, walk };
+export const withFactTree = withTreeSitterRoot;
+export async function extractFactsFromTree(ctx, store, defaults, extract, coverageFact) {
+  const writeAll = (facts, complete) => {
+    for (const key of Object.keys(defaults)) {
+      store.setFileFact(ctx.filePath, key, facts[key] ?? defaults[key]);
+    }
+    if (coverageFact) {
+      store.setFileFact(ctx.filePath, coverageFact, complete ? "complete" : "unavailable");
+    }
+  };
+  const content = store.getFileFact(ctx.filePath, "file.content");
+  if (content == null)
+    return writeAll(defaults, false);
+  const parsed = await withFactTree(ctx.filePath, content, (root) => extract(root, content));
+  writeAll(parsed.parsed ? parsed.value : defaults, parsed.parsed);
+}

package/extensions/dm-lens/clients/dispatch/facts/try-catch-facts.js

@@ -0,0 +1,99 @@
+import {
+  extractFactsFromTree,
+  firstChildOfType,
+  walk
+} from "./tree-sitter-facts.js";
+function hasAssignmentExpression(node) {
+  if (!node)
+    return false;
+  let found = false;
+  walk(node, (n) => {
+    if (n.type === "assignment_expression")
+      found = true;
+  });
+  return found;
+}
+function isOnlyWhitespaceOrComments(text) {
+  let stripped = text.replace(/\/\*[\s\S]*?\*\//g, "");
+  stripped = stripped.replace(/\/\/[^\n]*/g, "");
+  return stripped.trim().length === 0;
+}
+const DEFAULT_VALUE_PATTERN = /\breturn\s+(null|undefined|false|true|0|""|''|``|\[\]|\{\}|new\s+\w+\(\))/;
+const STRUCTURED_ERROR_PATTERN = /\breturn\s+\{[^}]*(?:success\s*:\s*false|error\s*:)/;
+const EXPLAINING_COMMENT_PATTERN = /(?:\/\/\s*\S.{3,}|\/\*\s*\S[\s\S]{3,}?\*\/)/;
+const FS_PROBE_PATTERN = /\b(?:existsSync|statSync|lstatSync|readFileSync|accessSync)\b/;
+const DB_PATTERN = /\b(?:query|execute|findOne|findMany|findById|insert|update|delete|select|prisma\.|knex\.|sequelize\.)/;
+const NETWORK_PATTERN = /\b(?:fetch|axios|http\.|https\.|request\.|got\.|undici\.)/;
+const FS_PATTERN = /\b(?:readFileSync?|writeFileSync?|appendFileSync?|readdirSync?|mkdirSync?|statSync?|unlinkSync?|existsSync|accessSync?|copyFileSync?|renameSync?)\b/;
+const PROCESS_PATTERN = /\b(?:spawn|exec|execSync|spawnSync|child_process\.)\b/;
+function detectBoundaryCategory(tryText) {
+  if (DB_PATTERN.test(tryText))
+    return "db";
+  if (NETWORK_PATTERN.test(tryText))
+    return "network";
+  if (FS_PATTERN.test(tryText))
+    return "fs";
+  if (PROCESS_PATTERN.test(tryText))
+    return "process";
+  return "none";
+}
+function detectTryResolvesLocalValues(tryText) {
+  const hasAwait = /\bawait\b/.test(tryText);
+  const hasIO = DB_PATTERN.test(tryText) || NETWORK_PATTERN.test(tryText) || FS_PATTERN.test(tryText) || PROCESS_PATTERN.test(tryText);
+  return !hasAwait && !hasIO;
+}
+export const tryCatchFactProvider = {
+  id: "tryCatchFacts",
+  provides: ["file.tryCatchSummaries"],
+  requires: ["file.content"],
+  appliesTo(ctx) {
+    return /\.tsx?$/.test(ctx.filePath);
+  },
+  async run(ctx, store) {
+    await extractFactsFromTree(ctx, store, { "file.tryCatchSummaries": [] }, (root) => {
+      const summaries = [];
+      walk(root, (node) => {
+        if (node.type !== "try_statement")
+          return;
+        const tryBlock = firstChildOfType(node, "statement_block");
+        const catchClause = firstChildOfType(node, "catch_clause");
+        if (!tryBlock || !catchClause)
+          return;
+        const tryText = tryBlock.text;
+        const tryResolvesLocalValues = detectTryResolvesLocalValues(tryText);
+        const boundaryCategory = detectBoundaryCategory(tryText);
+        const paramNode = firstChildOfType(catchClause, "identifier");
+        const catchParam = paramNode ? paramNode.text : null;
+        const catchBody = firstChildOfType(catchClause, "statement_block");
+        const bodyText = catchBody ? catchBody.text.replace(/^\{/, "").replace(/\}$/, "").trim() : "";
+        const isEmpty = isOnlyWhitespaceOrComments(bodyText);
+        const hasRethrow = /\bthrow\b/.test(bodyText);
+        const hasLogging = /\bconsole\.(log|warn|error)\b/.test(bodyText) || /\blogger\./.test(bodyText);
+        const catchReturnsDefault = DEFAULT_VALUE_PATTERN.test(bodyText);
+        const catchReturnsStructuredError = STRUCTURED_ERROR_PATTERN.test(bodyText);
+        const isDocumentedLocalFallback = EXPLAINING_COMMENT_PATTERN.test(bodyText);
+        const catchHasFallbackAssignment = hasAssignmentExpression(catchBody);
+        const catchLogsOnly = hasLogging && !hasRethrow && !catchReturnsDefault && !catchReturnsStructuredError && !/\b(?:set|update|notify|emit|dispatch|resolve|reject)\b/.test(bodyText);
+        const isFilesystemExistenceProbe = boundaryCategory === "fs" && FS_PROBE_PATTERN.test(tryText) && catchReturnsDefault;
+        summaries.push({
+          line: catchClause.startPosition.row + 1,
+          column: catchClause.startPosition.column + 1,
+          catchParam,
+          bodyText,
+          isEmpty,
+          hasRethrow,
+          hasLogging,
+          catchLogsOnly,
+          catchReturnsDefault,
+          catchReturnsStructuredError,
+          isDocumentedLocalFallback,
+          catchHasFallbackAssignment,
+          tryResolvesLocalValues,
+          isFilesystemExistenceProbe,
+          boundaryCategory
+        });
+      });
+      return { "file.tryCatchSummaries": summaries };
+    });
+  }
+};

package/extensions/dm-lens/clients/dispatch/indent-detect.js

@@ -0,0 +1,27 @@
+const DEFAULT_INDENTATION = { style: "space", width: 2 };
+export function detectIndentation(content) {
+  const lines = content.split(/\r?\n/);
+  const tabs = lines.filter((line) => /^\t+\S/.test(line)).length;
+  const spaceCounts = lines.map((line) => line.match(/^ +(?=\S)/)?.[0].length ?? 0).filter((count) => count > 0);
+  if (tabs === 0 && spaceCounts.length === 0)
+    return DEFAULT_INDENTATION;
+  if (tabs > spaceCounts.length)
+    return { style: "tab", width: 1 };
+  if (spaceCounts.length > tabs) {
+    const counts = new Map;
+    for (const count of spaceCounts) {
+      for (const other of spaceCounts) {
+        if (other > count) {
+          const delta = other - count;
+          counts.set(delta, (counts.get(delta) ?? 0) + 1);
+        }
+      }
+    }
+    const inferredWidth = [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0] - b[0])[0]?.[0] ?? Math.min(...spaceCounts);
+    return { style: "space", width: inferredWidth <= 8 ? inferredWidth : 2 };
+  }
+  return DEFAULT_INDENTATION;
+}
+export function hasDetectableIndentation(content) {
+  return /^(?:\t+| {1,})\S/m.test(content);
+}

package/extensions/dm-lens/clients/dispatch/inline-suppressions.js

@@ -0,0 +1,33 @@
+import { normalizeRuleId } from "./rule-id-normalize.js";
+const SUPPRESS_RE = /(?:\/\/|#)\s*dm-lens-ignore:\s*(.+)/;
+export function applyInlineSuppressions(diagnostics, content) {
+  if (!content || !diagnostics.length)
+    return diagnostics;
+  const suppressed = new Set;
+  const lines = content.split(`
+`);
+  for (let i = 0;i < lines.length; i++) {
+    const m = SUPPRESS_RE.exec(lines[i]);
+    if (!m)
+      continue;
+    const rules = m[1].split(",").map((r) => r.trim()).filter(Boolean);
+    const suppressedLine = i + 1;
+    const nextLine = i + 2;
+    for (const ruleId of rules) {
+      for (const key of new Set([ruleId, normalizeRuleId(ruleId)])) {
+        suppressed.add(`${suppressedLine}:${key}`);
+        suppressed.add(`${nextLine}:${key}`);
+      }
+    }
+  }
+  if (suppressed.size === 0)
+    return diagnostics;
+  return diagnostics.filter((d) => {
+    const rawId = d.rule ?? d.id ?? "";
+    const line = d.line ?? 1;
+    if (suppressed.has(`${line}:${rawId}`))
+      return false;
+    const normId = normalizeRuleId(rawId);
+    return normId === rawId || !suppressed.has(`${line}:${normId}`);
+  });
+}