@duckmind/dm-linux-x64 0.65.5 → 0.65.6

package/extensions/dm-lens/dist/clients/dispatch/runners/tflint.js

@@ -0,0 +1,104 @@
+import * as path from "node:path";
+import { pathsEqual } from "../../path-utils.js";
+import { safeSpawnAsync } from "../../safe-spawn.js";
+import { resolveRunnerCwd } from "../../tool-cwd.js";
+import { getLinterPolicyForCwd } from "../../tool-policy.js";
+import { findNearestDirWithAnyBasename } from "../../workspace-topology.js";
+import { PRIORITY } from "../priorities.js";
+import { createAvailabilityChecker, resolveAvailableOrInstall } from "./utils/runner-helpers.js";
+import { parseToolRun } from "./utils/tool-failure.js";
+import { finishParsedRun } from "./utils/tool-failure.js";
+const tflint = createAvailabilityChecker("tflint", ".exe");
+const TFLINT_CONFIG = ".tflint.hcl";
+function findTflintConfig(fileDir) {
+  if (process.env.TFLINT_CONFIG_FILE)
+    return null;
+  const dir = findNearestDirWithAnyBasename(fileDir, [TFLINT_CONFIG]);
+  return dir ? path.join(dir, TFLINT_CONFIG) : null;
+}
+function parseTflintOutput(raw, filePath, toolCwd) {
+  try {
+    const parsed = JSON.parse(raw);
+    const issues = parsed.issues ?? [];
+    const absTarget = path.resolve(toolCwd, filePath);
+    return issues.flatMap((issue) => {
+      if (issue.range?.filename && !pathsEqual(path.resolve(toolCwd, issue.range.filename), absTarget))
+        return [];
+      const severity = issue.rule.severity === "error" ? "error" : "warning";
+      return [
+        {
+          id: `tflint-${issue.rule.name}-${issue.range.start.line}`,
+          message: `[${issue.rule.name}] ${issue.message}`,
+          filePath,
+          line: issue.range.start.line,
+          column: issue.range.start.column,
+          severity,
+          semantic: severity === "error" ? "blocking" : "warning",
+          tool: "tflint",
+          rule: issue.rule.name,
+          fixable: false
+        }
+      ];
+    });
+  } catch {
+    return [];
+  }
+}
+const tflintRunner = {
+  id: "tflint",
+  appliesTo: ["terraform"],
+  priority: PRIORITY.GENERAL_ANALYSIS,
+  skipTestFiles: false,
+  async run(ctx) {
+    const cwd = resolveRunnerCwd(ctx, "tflint");
+    const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
+    if (policy && !policy.preferredRunners.includes("tflint")) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    let cmd = null;
+    if (await tflint.isAvailableAsync(cwd)) {
+      cmd = tflint.getCommand(cwd);
+    } else {
+      const managed = await resolveAvailableOrInstall(tflint, "tflint", cwd);
+      if (managed)
+        cmd = managed;
+    }
+    if (!cmd)
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    const absPath = path.resolve(cwd, ctx.filePath);
+    const fileDir = path.dirname(absPath);
+    const args = [
+      "--format=json",
+      "--no-color",
+      `--filter=${path.basename(absPath)}`
+    ];
+    const configPath = findTflintConfig(fileDir);
+    if (configPath)
+      args.push(`--config=${configPath}`);
+    const result = await safeSpawnAsync(cmd, args, {
+      cwd: fileDir,
+      timeout: 30000
+    });
+    const run = parseToolRun("tflint", {
+      result,
+      exitCodes: { ran: [1, 2] }
+    }, (out) => parseTflintOutput(out, absPath, fileDir));
+    if (run.skipped)
+      return run.skipped;
+    const diagnostics = run.diagnostics;
+    return finishParsedRun({
+      tool: "tflint",
+      ctx,
+      result,
+      diagnostics,
+      classify: (diagnostics) => {
+        const hasErrors = diagnostics.some((d) => d.severity === "error");
+        return {
+          status: hasErrors ? "failed" : "succeeded",
+          semantic: hasErrors ? "blocking" : "warning"
+        };
+      }
+    });
+  }
+};
+export default tflintRunner;

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

@@ -0,0 +1,516 @@
+import * as path from "node:path";
+import { RuleCache } from "../../cache/rule-cache.js";
+import { isRuleIgnoredForPath } from "../rule-ignores.js";
+import { isTestFile } from "../../file-utils.js";
+import { buildOrUpdateGraph, computeImpactCascade, recordEntitySnapshotDiff } from "../../review-graph/service.js";
+import { getSharedTreeSitterClient, isTreeSitterWasmAborted, markTreeSitterWasmAborted, resolveTreeSitterLanguage } from "../../tree-sitter-shared.js";
+import { logTreeSitter } from "../../tree-sitter-logger.js";
+import { isDisabledQueryFilePath, queriesForLanguage, queryLoader, ruleFilesForLanguage, ruleSourceLanguages } from "../../tree-sitter-query-loader.js";
+import { classifyDefect } from "../diagnostic-taxonomy.js";
+import { PRIORITY } from "../priorities.js";
+const blastCooldownByFile = new Map;
+const BLAST_COOLDOWN_MS = 5000;
+function runBlastRadiusInBackground(cwd, filePath, languageId, facts) {
+  (async () => {
+    try {
+      const graph = await buildOrUpdateGraph(cwd, [filePath], facts);
+      const impact = computeImpactCascade(graph, filePath, cwd);
+      logTreeSitter({
+        phase: "blast_radius",
+        filePath,
+        languageId,
+        metadata: {
+          changedSymbols: impact.changedSymbols,
+          neighborFiles: impact.neighborFiles,
+          directImporters: impact.directImporters,
+          directCallers: impact.directCallers,
+          riskFlags: impact.riskFlags
+        }
+      });
+    } catch {}
+  })();
+}
+const JSTS_SHARED_ENTITY_QUERIES = [
+  {
+    id: "entity-jsts-function",
+    kind: "function",
+    query: "(function_declaration name: (identifier) @NAME)"
+  },
+  {
+    id: "entity-jsts-method",
+    kind: "method",
+    query: "(method_definition name: (property_identifier) @NAME)"
+  },
+  {
+    id: "entity-jsts-arrow",
+    kind: "function",
+    query: "(lexical_declaration (variable_declarator name: (identifier) @NAME value: [(arrow_function) (function_expression)]))"
+  }
+];
+const TS_STRUCTURAL_ENTITY_QUERIES = [
+  {
+    id: "entity-ts-interface",
+    kind: "interface",
+    query: "(interface_declaration name: (type_identifier) @NAME)"
+  },
+  {
+    id: "entity-ts-type",
+    kind: "type",
+    query: "(type_alias_declaration name: (type_identifier) @NAME)"
+  },
+  {
+    id: "entity-ts-enum",
+    kind: "enum",
+    query: "(enum_declaration name: (identifier) @NAME)"
+  }
+];
+const ENTITY_QUERIES = {
+  typescript: [
+    {
+      id: "entity-ts-class",
+      kind: "class",
+      query: "(class_declaration name: (type_identifier) @NAME)"
+    },
+    ...JSTS_SHARED_ENTITY_QUERIES,
+    ...TS_STRUCTURAL_ENTITY_QUERIES
+  ],
+  javascript: [
+    {
+      id: "entity-js-class",
+      kind: "class",
+      query: "(class_declaration name: (identifier) @NAME)"
+    },
+    ...JSTS_SHARED_ENTITY_QUERIES
+  ],
+  python: [
+    {
+      id: "entity-py-function",
+      kind: "function",
+      query: "(function_definition name: (identifier) @NAME)"
+    },
+    {
+      id: "entity-py-class",
+      kind: "class",
+      query: "(class_definition name: (identifier) @NAME)"
+    }
+  ],
+  go: [
+    {
+      id: "entity-go-function",
+      kind: "function",
+      query: "(function_declaration name: (identifier) @NAME)"
+    },
+    {
+      id: "entity-go-method",
+      kind: "method",
+      query: "(method_declaration name: (field_identifier) @NAME)"
+    },
+    {
+      id: "entity-go-type",
+      kind: "type",
+      query: "(type_spec name: (type_identifier) @NAME)"
+    }
+  ],
+  rust: [
+    {
+      id: "entity-rs-function",
+      kind: "function",
+      query: "(function_item name: (identifier) @NAME)"
+    },
+    {
+      id: "entity-rs-struct",
+      kind: "struct",
+      query: "(struct_item name: (type_identifier) @NAME)"
+    },
+    {
+      id: "entity-rs-enum",
+      kind: "enum",
+      query: "(enum_item name: (type_identifier) @NAME)"
+    },
+    {
+      id: "entity-rs-trait",
+      kind: "trait",
+      query: "(trait_item name: (type_identifier) @NAME)"
+    },
+    {
+      id: "entity-rs-type",
+      kind: "type",
+      query: "(type_item name: (type_identifier) @NAME)"
+    }
+  ],
+  ruby: [
+    {
+      id: "entity-rb-method",
+      kind: "method",
+      query: "(method name: (identifier) @NAME)"
+    },
+    {
+      id: "entity-rb-singleton-method",
+      kind: "method",
+      query: "(singleton_method name: (identifier) @NAME)"
+    },
+    {
+      id: "entity-rb-class",
+      kind: "class",
+      query: "(class name: (constant) @NAME)"
+    },
+    {
+      id: "entity-rb-module",
+      kind: "module",
+      query: "(module name: (constant) @NAME)"
+    }
+  ],
+  c: [
+    {
+      id: "entity-c-function",
+      kind: "function",
+      query: "(function_definition declarator: (function_declarator declarator: (identifier) @NAME))"
+    },
+    {
+      id: "entity-c-typedef",
+      kind: "type",
+      query: "(type_definition declarator: (type_identifier) @NAME)"
+    },
+    {
+      id: "entity-c-struct",
+      kind: "struct",
+      query: "(struct_specifier name: (type_identifier) @NAME)"
+    },
+    {
+      id: "entity-c-enum",
+      kind: "enum",
+      query: "(enum_specifier name: (type_identifier) @NAME)"
+    }
+  ],
+  cpp: [
+    {
+      id: "entity-cpp-function",
+      kind: "function",
+      query: "(function_definition declarator: (function_declarator declarator: (identifier) @NAME))"
+    },
+    {
+      id: "entity-cpp-class",
+      kind: "class",
+      query: "(class_specifier name: (type_identifier) @NAME)"
+    },
+    {
+      id: "entity-cpp-struct",
+      kind: "struct",
+      query: "(struct_specifier name: (type_identifier) @NAME)"
+    },
+    {
+      id: "entity-cpp-namespace",
+      kind: "namespace",
+      query: "(namespace_definition name: (namespace_identifier) @NAME)"
+    }
+  ]
+};
+async function extractEntitySnapshot(client, filePath, languageId, contentOverride) {
+  const defs = ENTITY_QUERIES[languageId] ?? [];
+  const snapshot = new Map;
+  for (const def of defs) {
+    const matches = await client.runQueryOnFile({
+      id: def.id,
+      name: def.id,
+      severity: "info",
+      category: "entity",
+      language: languageId,
+      message: "",
+      query: def.query,
+      metavars: ["NAME"],
+      has_fix: false,
+      filePath: ""
+    }, filePath, languageId, { maxResults: 200 }, contentOverride);
+    for (const match of matches) {
+      const name = match.captures.NAME?.trim();
+      if (!name)
+        continue;
+      const key = `${def.kind}:${name}`;
+      snapshot.set(key, `${match.line}:${match.matchedText.slice(0, 400)}`);
+    }
+  }
+  return snapshot;
+}
+const SILENT_ERROR_QUERY_IDS = new Set([
+  "empty-catch",
+  "python-empty-except",
+  "ruby-empty-rescue",
+  "go-bare-error",
+  "no-discarded-error"
+]);
+function defaultFixSuggestion(defectClass, ruleId) {
+  if (defectClass === "silent-error") {
+    return "Handle the error path explicitly: add logging/telemetry and rethrow or return a typed error result.";
+  }
+  if (defectClass === "secrets") {
+    return "Move secret material to environment/secret manager and read it at runtime.";
+  }
+  if (defectClass === "injection") {
+    return "Replace dynamic execution/string interpolation with parameterized or allowlisted operations.";
+  }
+  if (defectClass === "async-misuse") {
+    return "Restructure async flow to handle errors and sequencing deterministically (await/try-catch or explicit concurrency control).";
+  }
+  if (ruleId.includes("unwrap")) {
+    return "Replace unwrap() with explicit error handling (match/if-let) or propagate with ?.";
+  }
+  return "Refactor this pattern to a safer, explicit form matching project conventions.";
+}
+function isLineInModifiedRanges(line, ranges) {
+  if (!ranges || ranges.length === 0)
+    return true;
+  return ranges.some((r) => line >= r.start && line <= r.end);
+}
+function getTotalLinesChanged(ranges) {
+  if (!ranges || ranges.length === 0)
+    return 0;
+  return ranges.reduce((total, r) => total + (r.end - r.start + 1), 0);
+}
+const ENTITY_EXTRACTION_LINE_THRESHOLD = 5;
+const treeSitterRunner = {
+  id: "tree-sitter",
+  appliesTo: [
+    "jsts",
+    "python",
+    "go",
+    "rust",
+    "ruby",
+    "cxx",
+    "csharp",
+    "php",
+    "css"
+  ],
+  priority: PRIORITY.STRUCTURAL_ANALYSIS,
+  skipTestFiles: false,
+  async run(ctx) {
+    const client = getSharedTreeSitterClient();
+    logTreeSitter({ phase: "runner_start", filePath: ctx.filePath });
+    if (!client || !client.isAvailable()) {
+      logTreeSitter({
+        phase: "runner_skip",
+        filePath: ctx.filePath,
+        reason: isTreeSitterWasmAborted() ? "wasm_aborted" : "client_unavailable",
+        status: "skipped"
+      });
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    const initialized = await client.init();
+    if (!initialized) {
+      logTreeSitter({
+        phase: "runner_skip",
+        filePath: ctx.filePath,
+        reason: "client_init_failed",
+        status: "skipped"
+      });
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    const filePath = ctx.filePath;
+    const ext = path.extname(filePath).toLowerCase();
+    const languageId = resolveTreeSitterLanguage(filePath);
+    if (!languageId) {
+      logTreeSitter({
+        phase: "runner_skip",
+        filePath: ctx.filePath,
+        reason: `unsupported_extension:${ext}`,
+        status: "skipped"
+      });
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    let languageQueries = [];
+    const cache = new RuleCache(languageId, ctx.cwd);
+    const ruleFiles = ruleFilesForLanguage(languageId, ctx.cwd);
+    const cached = cache.get(ruleFiles);
+    let cacheHit = false;
+    if (cached) {
+      cacheHit = true;
+      languageQueries = cached.queries.map((q) => ({
+        ...q,
+        has_fix: q.has_fix ?? false,
+        filePath: q.filePath ?? ""
+      })).filter((q) => !isDisabledQueryFilePath(q.filePath));
+    } else {
+      await queryLoader.loadQueries(ctx.cwd, { force: true });
+      languageQueries = queriesForLanguage(new Map(ruleSourceLanguages(languageId).map((lang) => [
+        lang,
+        queryLoader.getQueriesForLanguage(lang)
+      ])), languageId);
+      cache.set(ruleFiles, languageQueries.map((q) => ({
+        id: q.id,
+        name: q.name,
+        severity: q.severity,
+        language: q.language,
+        message: q.message,
+        query: q.query,
+        metavars: q.metavars,
+        post_filter: q.post_filter,
+        post_filter_params: q.post_filter_params,
+        defect_class: q.defect_class,
+        inline_tier: q.inline_tier,
+        skip_test_files: q.skip_test_files,
+        ignore_paths: q.ignore_paths,
+        has_fix: q.has_fix,
+        fix_action: q.fix_action,
+        filePath: q.filePath
+      })));
+    }
+    if (languageQueries.length === 0) {
+      logTreeSitter({
+        phase: "runner_complete",
+        filePath,
+        languageId,
+        status: "succeeded",
+        diagnostics: 0,
+        blocking: 0,
+        queryCount: 0,
+        effectiveQueryCount: 0
+      });
+      return { status: "succeeded", diagnostics: [], semantic: "none" };
+    }
+    const fileIsTest = isTestFile(filePath);
+    const ignoreRoot = ctx.projectRoot ?? ctx.cwd;
+    const effectiveQueries = (ctx.blockingOnly ? languageQueries.filter((q) => q.inline_tier !== "review") : languageQueries).filter((q) => !(fileIsTest && q.skip_test_files) && !isRuleIgnoredForPath(filePath, ignoreRoot, q.ignore_paths));
+    logTreeSitter({
+      phase: "queries_loaded",
+      filePath,
+      languageId,
+      queryCount: languageQueries.length,
+      effectiveQueryCount: effectiveQueries.length,
+      cacheHit,
+      metadata: { blockingOnly: !!ctx.blockingOnly }
+    });
+    const contentFromFacts = ctx.facts.getFileFact(filePath, "file.content");
+    const contentOverride = contentFromFacts !== undefined && contentFromFacts !== null ? contentFromFacts : undefined;
+    const diagnostics = [];
+    try {
+      const found = await client.runQueriesOnFile(effectiveQueries, filePath, languageId, { maxResults: 10 }, contentOverride);
+      for (const { queryDef: query, match } of found) {
+        const { line, column } = match;
+        const isSeverityBlocking = query.severity === "error" || query.inline_tier === "blocking" || SILENT_ERROR_QUERY_IDS.has(query.id);
+        if (ctx.blockingOnly && isSeverityBlocking && !isLineInModifiedRanges(line, ctx.modifiedRanges)) {
+          continue;
+        }
+        const semantic = query.severity === "error" ? "blocking" : query.severity === "warning" ? "warning" : "none";
+        const defectClass = query.defect_class ?? classifyDefect(query.id, "tree-sitter", query.message);
+        const suggestion = query.has_fix && query.fix_action ? `${query.fix_action} this statement` : semantic === "blocking" ? defaultFixSuggestion(defectClass, query.id) : undefined;
+        const hasSuggestedFix = !!query.has_fix;
+        diagnostics.push({
+          id: `tree-sitter:${query.id}:${line}`,
+          message: query.message.replace(/\{\{(\w+)\}\}/g, (_, name) => match.captures[name]?.trim() ?? `{{${name}}}`),
+          filePath,
+          line,
+          column,
+          severity: query.severity,
+          semantic,
+          tool: "tree-sitter",
+          rule: query.id,
+          defectClass,
+          fixable: hasSuggestedFix,
+          autoFixAvailable: false,
+          fixKind: hasSuggestedFix ? "suggestion" : undefined,
+          fixSuggestion: suggestion,
+          matchedText: match.matchedText || undefined,
+          astNodeType: match.nodeType || undefined
+        });
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.includes("Aborted") || msg.includes("abort()")) {
+        markTreeSitterWasmAborted();
+        logTreeSitter({
+          phase: "query_error",
+          filePath,
+          languageId,
+          error: "wasm_aborted_fatal",
+          metadata: { queryIds: effectiveQueries.map((q) => q.id) }
+        });
+      } else {
+        logTreeSitter({
+          phase: "query_error",
+          filePath,
+          languageId,
+          error: msg,
+          metadata: { queryIds: effectiveQueries.map((q) => q.id) }
+        });
+      }
+    }
+    const totalLinesChanged = getTotalLinesChanged(ctx.modifiedRanges);
+    const skipEntityExtraction = ctx.modifiedRanges != null && ctx.modifiedRanges.length > 0 && totalLinesChanged < ENTITY_EXTRACTION_LINE_THRESHOLD;
+    if (!skipEntityExtraction) {
+      try {
+        const snapshot = await extractEntitySnapshot(client, filePath, languageId, contentOverride);
+        const diff = recordEntitySnapshotDiff(ctx.facts, filePath, snapshot);
+        const changedEntityKeys = [
+          ...diff.added,
+          ...diff.modified,
+          ...diff.removed
+        ];
+        if (changedEntityKeys.length > 0) {
+          logTreeSitter({
+            phase: "entity_diff",
+            filePath,
+            languageId,
+            metadata: {
+              added: diff.added,
+              modified: diff.modified,
+              removed: diff.removed,
+              totalChanged: changedEntityKeys.length
+            }
+          });
+          const lastBlast = blastCooldownByFile.get(filePath) ?? 0;
+          if (Date.now() - lastBlast < BLAST_COOLDOWN_MS) {
+            logTreeSitter({
+              phase: "blast_radius",
+              filePath,
+              languageId,
+              metadata: { skipped: "cooldown", cooldownMs: BLAST_COOLDOWN_MS }
+            });
+          } else {
+            blastCooldownByFile.set(filePath, Date.now());
+            runBlastRadiusInBackground(ctx.cwd, filePath, languageId, ctx.facts);
+          }
+        }
+      } catch {}
+    }
+    if (diagnostics.length === 0) {
+      if (!isTreeSitterWasmAborted() && !client.getLanguage(languageId)) {
+        logTreeSitter({
+          phase: "runner_skip",
+          filePath,
+          languageId,
+          reason: "grammar_unavailable",
+          status: "skipped"
+        });
+        return { status: "skipped", diagnostics: [], semantic: "none" };
+      }
+      logTreeSitter({
+        phase: "runner_complete",
+        filePath,
+        languageId,
+        status: "succeeded",
+        diagnostics: 0,
+        blocking: 0,
+        queryCount: languageQueries.length,
+        effectiveQueryCount: effectiveQueries.length
+      });
+      return { status: "succeeded", diagnostics: [], semantic: "none" };
+    }
+    const hasBlocking = diagnostics.some((d) => d.semantic === "blocking");
+    const blockingCount = diagnostics.filter((d) => d.semantic === "blocking").length;
+    logTreeSitter({
+      phase: "runner_complete",
+      filePath,
+      languageId,
+      status: hasBlocking ? "failed" : "succeeded",
+      diagnostics: diagnostics.length,
+      blocking: blockingCount,
+      queryCount: languageQueries.length,
+      effectiveQueryCount: effectiveQueries.length
+    });
+    return {
+      status: hasBlocking ? "failed" : "succeeded",
+      diagnostics,
+      semantic: hasBlocking ? "blocking" : "warning"
+    };
+  }
+};
+export default treeSitterRunner;