@duckmind/dm-linux-x64 0.65.8 → 0.66.2

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

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

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