@duckmind/dm-darwin-x64 0.66.4 → 0.66.6

package/extensions/dm-lens/dist/clients/tree-sitter-logger.js

@@ -0,0 +1,77 @@
+import * as path from "node:path";
+import { isTestMode } from "./env-utils.js";
+import { getGlobalDmLensLogDir } from "./probe-home-state.js";
+import { createNdjsonLogger } from "./ndjson-logger.js";
+import { getMaxLogSizeMB } from "./log-cleanup.js";
+import { normalizeLoggedPath } from "./path-utils.js";
+const TREE_SITTER_LOG_DIR = getGlobalDmLensLogDir();
+const TREE_SITTER_LOG_FILE = path.join(TREE_SITTER_LOG_DIR, "tree-sitter.log");
+const writer = createNdjsonLogger({
+  filePath: TREE_SITTER_LOG_FILE,
+  maxBytes: getMaxLogSizeMB() * 1024 * 1024
+});
+const CACHE_COUNTER_KEYS = [
+  "lookups",
+  "hits",
+  "misses",
+  "coldMisses",
+  "capacityMisses",
+  "contentChangedMisses",
+  "mtimeMisses",
+  "statFailedMisses",
+  "sets",
+  "replacements",
+  "evictions",
+  "clears",
+  "ghostHistoryDrops",
+  "parserInvocations",
+  "parserDurationMs",
+  "parserFailures"
+];
+export function logTreeSitter(entry) {
+  if (isTestMode()) {
+    return;
+  }
+  writer.log({
+    ts: new Date().toISOString(),
+    ...entry,
+    filePath: normalizeLoggedPath(entry.filePath)
+  });
+}
+export function logTreeSitterCacheStats(options) {
+  const delta = Object.fromEntries(CACHE_COUNTER_KEYS.map((key) => [key, options.stats[key]]));
+  logTreeSitter({
+    phase: "cache_stats",
+    filePath: options.filePath,
+    durationMs: options.durationMs,
+    metadata: {
+      scope: options.scope,
+      fileCount: options.fileCount,
+      hitRate: delta.lookups > 0 ? delta.hits / delta.lookups : null,
+      delta,
+      resident: {
+        size: options.stats.size,
+        maxSize: options.stats.maxSize,
+        totalBytes: options.stats.totalBytes,
+        totalLines: options.stats.totalLines
+      },
+      astGrep: options.astGrep
+    }
+  });
+}
+export function logTreeSitterDiagnostic(entry) {
+  logTreeSitter({
+    phase: "diagnostic",
+    filePath: entry.filePath ?? "<tree-sitter>",
+    ...entry.languageId ? { languageId: entry.languageId } : {},
+    status: entry.level ?? "error",
+    reason: entry.message,
+    metadata: { subsystem: entry.subsystem, ...entry.metadata }
+  });
+}
+export function getTreeSitterLogPath() {
+  return TREE_SITTER_LOG_FILE;
+}
+export function flushTreeSitterLog() {
+  return writer.flush();
+}

package/extensions/dm-lens/dist/clients/tree-sitter-navigator.js

@@ -0,0 +1,198 @@
+export class TreeSitterNavigator {
+  findParent(node, type) {
+    let current = node.parent;
+    const types = Array.isArray(type) ? type : [type];
+    while (current) {
+      if (types.includes(current.type)) {
+        return current;
+      }
+      current = current.parent;
+    }
+    return null;
+  }
+  isInside(node, type) {
+    return this.findParent(node, type) !== null;
+  }
+  getAncestors(node) {
+    const ancestors = [];
+    let current = node.parent;
+    while (current) {
+      ancestors.push(current);
+      current = current.parent;
+    }
+    return ancestors;
+  }
+  isInTestBlock(node) {
+    const testPatterns = [
+      "call_expression"
+    ];
+    let current = node.parent;
+    while (current) {
+      if (testPatterns.includes(current.type)) {
+        const callName = this.getCallName(current);
+        if (callName && /^\b(it|describe|test|before|after|beforeEach|afterEach)\b/.test(callName)) {
+          return true;
+        }
+      }
+      current = current.parent;
+    }
+    return false;
+  }
+  getCallName(node) {
+    if (node.type !== "call_expression")
+      return null;
+    const func = node.children[0];
+    if (!func)
+      return null;
+    if (func.type === "identifier") {
+      return func.text;
+    }
+    if (func.type === "member_expression") {
+      const parts = [];
+      for (const child of func.children) {
+        if (child.type === "identifier" || child.type === "property_identifier") {
+          parts.push(child.text);
+        }
+      }
+      return parts.join(".");
+    }
+    return null;
+  }
+  isInTryCatch(node) {
+    return this.isInside(node, ["try_statement", "begin", "rescue"]);
+  }
+  isInLoop(node) {
+    return this.isInside(node, [
+      "for_statement",
+      "while_statement",
+      "do_statement",
+      "for_in_statement",
+      "for_of_statement"
+    ]);
+  }
+  isInAsyncContext(node) {
+    const functionTypes = [
+      "function_declaration",
+      "function_expression",
+      "arrow_function",
+      "method_definition"
+    ];
+    let current = node.parent;
+    while (current) {
+      if (functionTypes.includes(current.type)) {
+        if (current.children?.some((c) => c.text === "async")) {
+          return true;
+        }
+      }
+      current = current.parent;
+    }
+    return false;
+  }
+  getScopeChain(node) {
+    const chain = [];
+    let current = node.parent;
+    while (current) {
+      if ([
+        "function_declaration",
+        "function_expression",
+        "arrow_function",
+        "method_definition",
+        "block",
+        "statement_block"
+      ].includes(current.type)) {
+        const name = this.getNodeName(current);
+        if (name) {
+          chain.push(name);
+        } else {
+          chain.push(`<${current.type}>`);
+        }
+      }
+      current = current.parent;
+    }
+    return chain;
+  }
+  getNodeName(node) {
+    for (const child of node.children || []) {
+      if (child.type === "identifier" && child.isNamed) {
+        return child.text;
+      }
+    }
+    if (node.type === "method_definition") {
+      const nameNode = node.children?.find((c) => c.type === "property_identifier");
+      return nameNode?.text || null;
+    }
+    return null;
+  }
+  isShadowed(node, varName) {
+    let current = node.parent;
+    while (current) {
+      if (["variable_declaration", "lexical_declaration"].includes(current.type)) {
+        const declarator = current.children?.find((c) => c.type === "variable_declarator");
+        if (declarator) {
+          const idNode = declarator.children?.find((c) => c.type === "identifier");
+          if (idNode?.text === varName) {
+            return true;
+          }
+        }
+      }
+      if ([
+        "function_declaration",
+        "function_expression",
+        "arrow_function",
+        "method_definition"
+      ].includes(current.type)) {
+        const params = current.children?.find((c) => c.type === "formal_parameters");
+        if (params) {
+          for (const param of params.children || []) {
+            if (param.type === "identifier" && param.text === varName) {
+              return true;
+            }
+          }
+        }
+      }
+      current = current.parent;
+    }
+    return false;
+  }
+  getScopeContext(node) {
+    const ancestors = this.getAncestors(node);
+    const functionDepth = ancestors.filter((a) => [
+      "function_declaration",
+      "function_expression",
+      "arrow_function",
+      "method_definition"
+    ].includes(a.type)).length;
+    return {
+      isTestBlock: this.isInTestBlock(node),
+      isLoop: this.isInLoop(node),
+      isAsync: this.isInAsyncContext(node),
+      functionDepth,
+      scopeChain: this.getScopeChain(node)
+    };
+  }
+  getSiblings(node) {
+    if (!node.parent)
+      return [];
+    return node.parent.children?.filter((c) => c !== node) || [];
+  }
+  getPreviousSibling(node) {
+    if (!node.parent)
+      return null;
+    const siblings = node.parent.children || [];
+    const index = siblings.indexOf(node);
+    if (index > 0) {
+      return siblings[index - 1];
+    }
+    return null;
+  }
+  getNextSibling(node) {
+    if (!node.parent)
+      return null;
+    const siblings = node.parent.children || [];
+    const index = siblings.indexOf(node);
+    if (index >= 0 && index < siblings.length - 1) {
+      return siblings[index + 1];
+    }
+    return null;
+  }
+}

package/extensions/dm-lens/dist/clients/tree-sitter-query-loader.js

@@ -0,0 +1,389 @@
+import { logTreeSitterDiagnostic } from "./tree-sitter-logger.js";
+import * as fs from "node:fs";
+import * as crypto from "node:crypto";
+import * as path from "node:path";
+import { classifyBundledResourceDir, reportBundledResourceDirHealth } from "./bundled-resource-health.js";
+import { getDegradationLedgerGeneration, recordDegradationOnce } from "./degradation-ledger.js";
+import yaml from "./deps/js-yaml.js";
+import { resolvePackagePath } from "./package-root.js";
+import { getUserRuleRoot, ruleCorpusFingerprintForCycle } from "./custom-rule-locations.js";
+import { compareOrdinal } from "./string-utils.js";
+export const BUNDLED_QUERIES_ROOT = resolvePackagePath(import.meta.url, "rules", "tree-sitter-queries");
+let cachedBundledQueriesRootHealth;
+let cachedBundledQueriesRootHealthGeneration;
+export function getBundledQueriesRootHealth() {
+  const generation = getDegradationLedgerGeneration();
+  if (cachedBundledQueriesRootHealth === undefined || cachedBundledQueriesRootHealthGeneration !== generation) {
+    cachedBundledQueriesRootHealthGeneration = generation;
+    cachedBundledQueriesRootHealth = classifyBundledResourceDir(BUNDLED_QUERIES_ROOT);
+  }
+  return cachedBundledQueriesRootHealth;
+}
+export function _resetBundledQueriesRootHealthForTests() {
+  cachedBundledQueriesRootHealth = undefined;
+  cachedBundledQueriesRootHealthGeneration = undefined;
+}
+export function isDisabledQueryDirectoryName(name) {
+  return name.endsWith("-disabled");
+}
+export function getQueryLanguageKey(directoryName) {
+  return isDisabledQueryDirectoryName(directoryName) ? directoryName.slice(0, -"-disabled".length) : directoryName;
+}
+const TYPESCRIPT_RULE_HEIRS = new Set(["tsx"]);
+export function ruleSourceLanguages(languageId) {
+  return TYPESCRIPT_RULE_HEIRS.has(languageId) ? [languageId, "typescript"] : [languageId];
+}
+export function ruleFilesForLanguage(languageId, rootDir = process.cwd()) {
+  const resolvedRoot = path.resolve(rootDir);
+  const files = new Set;
+  for (const lang of ruleSourceLanguages(languageId)) {
+    for (const dir of [
+      path.join(resolvedRoot, "rules", "tree-sitter-queries", lang),
+      path.join(getUserRuleRoot(), "tree-sitter-queries", lang),
+      path.join(BUNDLED_QUERIES_ROOT, lang)
+    ]) {
+      if (!fs.existsSync(dir))
+        continue;
+      for (const f of fs.readdirSync(dir)) {
+        if (f.endsWith(".yml"))
+          files.add(path.join(dir, f));
+      }
+    }
+  }
+  if (files.size === 0) {
+    const health = getBundledQueriesRootHealth();
+    if (health.status !== "healthy") {
+      reportBundledResourceDirHealth("tree-sitter-queries-dir-missing", BUNDLED_QUERIES_ROOT, health, "bundled tree-sitter query rules");
+    }
+  }
+  return [...files];
+}
+export function computeRuleFilesFingerprint(ruleFiles) {
+  const hash = crypto.createHash("sha256");
+  for (const file of [...ruleFiles].sort(compareOrdinal)) {
+    const resolved = path.resolve(file);
+    if (!fs.existsSync(resolved))
+      continue;
+    const stat = fs.statSync(resolved);
+    hash.update(`${file}:${stat.mtimeMs}:${stat.size}`);
+    if (resolved !== BUNDLED_QUERIES_ROOT && !resolved.startsWith(BUNDLED_QUERIES_ROOT + path.sep)) {
+      hash.update(fs.readFileSync(resolved));
+    }
+  }
+  return hash.digest("hex").slice(0, 16);
+}
+function computeMutableRuleFingerprint(rootDir) {
+  const files = [];
+  for (const queriesDir of [
+    path.join(path.resolve(rootDir), "rules", "tree-sitter-queries"),
+    path.join(getUserRuleRoot(), "tree-sitter-queries")
+  ]) {
+    if (!fs.existsSync(queriesDir))
+      continue;
+    let languages;
+    try {
+      languages = fs.readdirSync(queriesDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const language of languages) {
+      if (!language.isDirectory())
+        continue;
+      let names;
+      try {
+        names = fs.readdirSync(path.join(queriesDir, language.name));
+      } catch {
+        continue;
+      }
+      for (const name of names) {
+        if (name.endsWith(".yml")) {
+          files.push(path.join(queriesDir, language.name, name));
+        }
+      }
+    }
+  }
+  const hash = crypto.createHash("sha256");
+  for (const filePath of files.sort(compareOrdinal)) {
+    hash.update(filePath);
+    hash.update("\x00");
+    let content;
+    try {
+      content = fs.readFileSync(filePath, "utf-8");
+    } catch {
+      hash.update("missing");
+      hash.update("\x00");
+      continue;
+    }
+    hash.update(content);
+    hash.update("\x00");
+  }
+  return hash.digest("hex").slice(0, 16);
+}
+export function queriesForLanguage(queries, languageId) {
+  const enabled = (langId) => (queries.get(langId) ?? []).filter((q) => !isDisabledQueryFilePath(q.filePath));
+  return ruleSourceLanguages(languageId).flatMap((langId) => enabled(langId));
+}
+function str(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? String(value) : undefined;
+}
+export function isDisabledQueryFilePath(filePath) {
+  const normalized = filePath.replaceAll("\\", "/");
+  const parts = normalized.split("/").filter(Boolean);
+  const parent = parts.length >= 2 ? parts[parts.length - 2] : "";
+  return isDisabledQueryDirectoryName(parent);
+}
+
+export class TreeSitterQueryLoader {
+  queries = new Map;
+  loaded = false;
+  loadedRoot = null;
+  loadedRuleFingerprint = null;
+  verbose;
+  parseFailures = new Map;
+  parseFailuresReplayedGeneration;
+  constructor(verbose = false) {
+    this.verbose = verbose;
+  }
+  dbg(msg) {
+    if (this.verbose) {
+      logTreeSitterDiagnostic({
+        subsystem: "query-loader",
+        level: "debug",
+        message: msg
+      });
+    }
+  }
+  recordQueryParseFailure(filePath, reason) {
+    this.parseFailures.set(filePath, reason);
+    recordDegradationOnce({
+      kind: "tree-sitter-query-parse-failed",
+      subject: filePath,
+      reason
+    });
+  }
+  replayQueryParseFailures() {
+    const generation = getDegradationLedgerGeneration();
+    if (this.parseFailuresReplayedGeneration === generation)
+      return;
+    this.parseFailuresReplayedGeneration = generation;
+    for (const [filePath, reason] of this.parseFailures) {
+      recordDegradationOnce({
+        kind: "tree-sitter-query-parse-failed",
+        subject: filePath,
+        reason
+      });
+    }
+  }
+  async loadQueries(rootDir = process.cwd(), options = {}) {
+    const resolvedRoot = path.resolve(rootDir);
+    const ruleFingerprint = ruleCorpusFingerprintForCycle("tree-sitter", resolvedRoot, computeMutableRuleFingerprint, options.force);
+    if (!options.force && this.loaded && this.loadedRoot === resolvedRoot && this.loadedRuleFingerprint === ruleFingerprint) {
+      this.replayQueryParseFailures();
+      return this.queries;
+    }
+    this.queries.clear();
+    this.parseFailures.clear();
+    this.loaded = false;
+    const queryDirs = [
+      ...new Set([
+        path.join(resolvedRoot, "rules", "tree-sitter-queries"),
+        path.join(getUserRuleRoot(), "tree-sitter-queries"),
+        resolvePackagePath(import.meta.url, "rules", "tree-sitter-queries")
+      ])
+    ];
+    for (const queriesDir of queryDirs) {
+      if (!fs.existsSync(queriesDir)) {
+        this.dbg(`Queries directory not found: ${queriesDir}`);
+        continue;
+      }
+      const languageDirs = fs.readdirSync(queriesDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+      for (const lang of languageDirs) {
+        const langDir = path.join(queriesDir, lang);
+        const languageKey = getQueryLanguageKey(lang);
+        const queryFiles = fs.readdirSync(langDir).filter((f) => f.endsWith(".yml"));
+        const langQueries = this.queries.get(languageKey) ?? [];
+        for (const file of queryFiles) {
+          const filePath = path.join(langDir, file);
+          const query = this.parseQueryFile(filePath, languageKey);
+          if (query) {
+            if (!langQueries.some((existing) => existing.id === query.id)) {
+              langQueries.push(query);
+            }
+          }
+        }
+        if (langQueries.length > 0) {
+          this.queries.set(languageKey, langQueries);
+          this.dbg(`Loaded ${langQueries.length} queries for ${languageKey}`);
+        }
+      }
+    }
+    this.loaded = true;
+    this.loadedRoot = resolvedRoot;
+    this.loadedRuleFingerprint = ruleFingerprint;
+    this.parseFailuresReplayedGeneration = getDegradationLedgerGeneration();
+    return this.queries;
+  }
+  parseQueryFile(filePath, language) {
+    try {
+      const content = fs.readFileSync(filePath, "utf-8");
+      const parsed = this.parseYaml(content);
+      const id = str(parsed.id);
+      const query = typeof parsed.query === "string" ? parsed.query : undefined;
+      if (!id || !query) {
+        this.dbg(`Invalid query file: ${filePath}`);
+        this.recordQueryParseFailure(filePath, !id ? `'id' is missing or not a scalar (got ${typeof parsed.id})` : `'query' is missing or not a string (got ${typeof parsed.query})`);
+        return null;
+      }
+      return {
+        id,
+        name: str(parsed.name) || id,
+        severity: this.parseSeverity(parsed.severity),
+        category: str(parsed.category) || "general",
+        language: str(parsed.language) || language,
+        message: str(parsed.message) || `Pattern: ${id}`,
+        description: str(parsed.description) || undefined,
+        query,
+        metavars: Array.isArray(parsed.metavars) ? parsed.metavars.map(String) : this.extractMetavars(query),
+        post_filter: str(parsed.post_filter) || undefined,
+        post_filter_params: parsed.post_filter_params,
+        defect_class: str(parsed.defect_class) || undefined,
+        inline_tier: str(parsed.inline_tier) || undefined,
+        skip_test_files: parsed.skip_test_files === true,
+        ignore_paths: Array.isArray(parsed.ignore_paths) ? parsed.ignore_paths.map(String) : undefined,
+        predicates: Array.isArray(parsed.predicates) ? parsed.predicates.map((p) => ({
+          type: p.type,
+          var: p.var,
+          value: p.value
+        })) : undefined,
+        tags: Array.isArray(parsed.tags) ? parsed.tags.map(String) : undefined,
+        cwe: Array.isArray(parsed.cwe) ? parsed.cwe.map(String) : undefined,
+        owasp: Array.isArray(parsed.owasp) ? parsed.owasp.map(String) : undefined,
+        confidence: str(parsed.confidence) || undefined,
+        has_fix: parsed.has_fix === true || parsed.has_fix === "true",
+        fix_action: str(parsed.fix_action) || undefined,
+        filePath
+      };
+    } catch (err) {
+      this.dbg(`Failed to parse ${filePath}: ${err}`);
+      this.recordQueryParseFailure(filePath, err instanceof Error ? err.message : String(err));
+      return null;
+    }
+  }
+  parseYaml(content) {
+    return yaml.load(content);
+  }
+  parseSeverity(value) {
+    if (value === "error")
+      return "error";
+    if (value === "warning")
+      return "warning";
+    if (value === "info")
+      return "info";
+    return "warning";
+  }
+  extractMetavars(query) {
+    const matches = query.match(/@([A-Z_][A-Z0-9_]*)/g);
+    if (!matches)
+      return [];
+    return [...new Set(matches.map((m) => m.slice(1)))];
+  }
+  getQueriesForLanguage(language) {
+    const all = this.queries.get(language) || [];
+    return all.filter((q) => !isDisabledQueryFilePath(q.filePath));
+  }
+  getQueryById(id) {
+    for (const langQueries of this.queries.values()) {
+      const query = langQueries.find((q) => q.id === id);
+      if (query)
+        return query;
+    }
+    return;
+  }
+  findMatchingQuery(pattern, language) {
+    const langQueries = this.getQueriesForLanguage(language);
+    for (const query of langQueries) {
+      if (pattern.includes(query.id))
+        return query;
+      switch (query.id) {
+        case "empty-catch":
+          if (pattern.includes("empty-catch") || pattern.includes("catch {}"))
+            return query;
+          break;
+        case "debugger-statement":
+          if (pattern.includes("debugger"))
+            return query;
+          break;
+        case "await-in-loop":
+          if (pattern.includes("await-in-loop") || pattern.includes("await"))
+            return query;
+          break;
+        case "hardcoded-secrets":
+          if (pattern.includes("hardcoded") || pattern.includes("api_key") || pattern.includes("password"))
+            return query;
+          break;
+        case "dangerously-set-inner-html":
+          if (pattern.includes("dangerously") || pattern.includes("innerHTML"))
+            return query;
+          break;
+        case "nested-ternary":
+          if (pattern.includes("ternary") || pattern.includes("? :"))
+            return query;
+          break;
+        case "no-eval":
+          if (pattern.includes("eval") && !pattern.includes("console"))
+            return query;
+          break;
+        case "deep-promise-chain":
+          if (pattern.includes(".then") && pattern.includes(".catch"))
+            return query;
+          break;
+        case "console-statement":
+          if (pattern.includes("console") && !pattern.includes("test"))
+            return query;
+          break;
+        case "long-parameter-list":
+          if (pattern.includes("PARAMS"))
+            return query;
+          break;
+        case "bare-except":
+          if (pattern.includes("bare-except") || pattern.includes("except:"))
+            return query;
+          break;
+        case "mutable-default-arg":
+          if (pattern.includes("mutable") || pattern.includes("default"))
+            return query;
+          break;
+        case "wildcard-import":
+          if (pattern.includes("wildcard") || pattern.includes("import *"))
+            return query;
+          break;
+        case "eval-exec":
+          if (pattern.includes("eval") || pattern.includes("exec"))
+            return query;
+          break;
+        case "is-vs-equals":
+          if (pattern.includes("is") || pattern.includes("equals"))
+            return query;
+          break;
+        case "unreachable-except":
+          if (pattern.includes("unreachable") || pattern.includes("except"))
+            return query;
+          break;
+      }
+    }
+    return;
+  }
+  getAllQueries() {
+    const all = [];
+    for (const queries of this.queries.values()) {
+      all.push(...queries);
+    }
+    return all;
+  }
+  async reload() {
+    this.queries.clear();
+    this.loaded = false;
+    await this.loadQueries();
+  }
+}
+export const queryLoader = new TreeSitterQueryLoader;