@duckmind/dm-linux-x64 0.65.8 → 0.66.2

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

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

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

@@ -1,318 +0,0 @@
-import { logTreeSitterDiagnostic } from "./tree-sitter-logger.js";
-import * as fs from "node:fs";
-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";
-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(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 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;
-  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);
-    if (!options.force && this.loaded && this.loadedRoot === resolvedRoot) {
-      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"),
-        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) {
-            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.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;

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

@@ -1,87 +0,0 @@
-import { notifyUserDegradation } from "./user-notify.js";
-import * as path from "node:path";
-import { TreeSitterClient } from "./tree-sitter-client.js";
-import { EXTENSION_TO_GRAMMAR } from "./language-registry.js";
-import { logTreeSitter } from "./tree-sitter-logger.js";
-let _shared = null;
-let _wasmAborted = false;
-let _wasmAbortedAt;
-export function getSharedTreeSitterClient() {
-  if (_wasmAborted)
-    return null;
-  _shared ??= new TreeSitterClient(false, markTreeSitterWasmAborted);
-  return _shared;
-}
-export function isTreeSitterWasmAborted() {
-  return _wasmAborted;
-}
-export function resetTreeSitterClientLoadState() {
-  _shared?.resetLoadStateForSession();
-}
-export function getTreeSitterRuntimeStatus() {
-  return {
-    available: !_wasmAborted,
-    wasmAborted: _wasmAborted,
-    recovery: _wasmAborted ? "restart_required" : "not_required",
-    ..._wasmAbortedAt ? { abortedAt: _wasmAbortedAt } : {}
-  };
-}
-export function markTreeSitterWasmAborted() {
-  if (_wasmAborted)
-    return;
-  _wasmAborted = true;
-  _wasmAbortedAt = new Date().toISOString();
-  _shared = null;
-  notifyUserDegradation("dm-lens: tree-sitter WASM runtime aborted; structural analysis is disabled " + "for this process. Restart the dm-lens extension/MCP server to recover.", "error");
-  logTreeSitter({
-    phase: "runtime_abort",
-    filePath: process.cwd(),
-    status: "degraded",
-    reason: "wasm_aborted_restart_required",
-    metadata: { abortedAt: _wasmAbortedAt }
-  });
-}
-export function _resetSharedTreeSitterClientForTests() {
-  _shared = null;
-  _wasmAborted = false;
-  _wasmAbortedAt = undefined;
-}
-export const EXT_TO_LANG = EXTENSION_TO_GRAMMAR;
-export function resolveTreeSitterLanguage(filePath) {
-  return EXT_TO_LANG[path.extname(filePath).toLowerCase()];
-}
-export const COMPLEXITY_LANGUAGE_IDS = [
-  "typescript",
-  "tsx",
-  "javascript",
-  "python",
-  "go",
-  "rust"
-];
-export function isComplexityLanguageId(languageId) {
-  return COMPLEXITY_LANGUAGE_IDS.includes(languageId);
-}
-export function isComplexitySupportedFile(filePath) {
-  const languageId = resolveTreeSitterLanguage(filePath);
-  return languageId !== undefined && isComplexityLanguageId(languageId);
-}
-export async function withTreeSitterRoot(filePath, content, consume) {
-  const languageId = resolveTreeSitterLanguage(filePath);
-  const client = getSharedTreeSitterClient();
-  if (!languageId || !client || !await client.init())
-    return { parsed: false };
-  return client.withParsedTree(filePath, languageId, content, (tree) => consume(tree.rootNode));
-}
-export function childrenOfType(node, type) {
-  return (node.children ?? []).filter((c) => c && c.type === type);
-}
-export function firstChildOfType(node, type) {
-  return (node.children ?? []).find((c) => c && c.type === type);
-}
-export function walk(node, visit) {
-  visit(node);
-  for (const child of node.children ?? []) {
-    if (child)
-      walk(child, visit);
-  }
-}