@duckmind/dm-linux-x64 0.66.0 → 0.66.2

package/extensions/dm-lens/dist/clients/project-diagnostics/runner-adapters/opengrep.js

@@ -1,32 +0,0 @@
-import * as path from "node:path";
-function severityFor(raw) {
-  switch (raw.toUpperCase()) {
-    case "ERROR":
-      return { severity: "error", blocking: true };
-    case "INFO":
-      return { severity: "info", blocking: false };
-    default:
-      return { severity: "warning", blocking: false };
-  }
-}
-function opengrepFindingToProjectDiagnostic(cwd, finding) {
-  const { severity, blocking } = severityFor(finding.severity);
-  const cweSuffix = finding.cwe?.length ? ` (${finding.cwe[0]})` : "";
-  return {
-    filePath: path.isAbsolute(finding.path) ? finding.path : path.resolve(cwd, finding.path),
-    line: finding.startLine,
-    column: finding.startCol,
-    severity,
-    semantic: blocking ? "blocking" : "warning",
-    tool: "opengrep",
-    runner: "opengrep",
-    rule: `opengrep:${finding.checkId}`,
-    message: `${finding.message}${cweSuffix}`,
-    source: "project-scan"
-  };
-}
-export function opengrepResultToProjectDiagnostics(cwd, result) {
-  if (!result.success || result.findings.length === 0)
-    return [];
-  return result.findings.map((finding) => opengrepFindingToProjectDiagnostic(cwd, finding));
-}

package/extensions/dm-lens/dist/clients/project-diagnostics/runner-adapters/runner-findings.js

@@ -1,79 +0,0 @@
-import { isRunnerErrorResult } from "../../test-runner-client.js";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { advisoryPathKey, validateAdvisoryProvenance } from "../../advisory-provenance.js";
-function failureMessage(failure) {
-  const firstLine = failure.message.split(`
-`)[0]?.slice(0, 300) ?? "";
-  return firstLine ? `${failure.name}: ${firstLine}` : failure.name;
-}
-const LOCATION_LINE_COL_RE = /:(\d+)(?::(\d+))?$/;
-function parseLocation(location) {
-  if (!location)
-    return {};
-  const match = LOCATION_LINE_COL_RE.exec(location);
-  if (!match)
-    return {};
-  return {
-    line: Number.parseInt(match[1], 10),
-    ...match[2] ? { column: Number.parseInt(match[2], 10) } : {}
-  };
-}
-function testResultToProjectDiagnostics(result, stale = false) {
-  if (result.failed === 0 && !result.error)
-    return [];
-  const stalePrefix = stale ? "[stale — from a prior turn] " : "";
-  if (result.failures.length > 0) {
-    return result.failures.map((failure) => ({
-      filePath: result.file,
-      ...parseLocation(failure.location),
-      severity: "error",
-      semantic: "blocking",
-      tool: "test-runner",
-      runner: result.runner,
-      rule: `test:${result.runner}`,
-      message: `${stalePrefix}${failureMessage(failure)}`,
-      source: "project-scan"
-    }));
-  }
-  if (isRunnerErrorResult(result)) {
-    return [
-      {
-        filePath: result.file,
-        severity: "info",
-        semantic: "none",
-        tool: "test-runner",
-        runner: result.runner,
-        rule: `test:${result.runner}`,
-        message: `${stalePrefix}Test run error: ${result.error}`,
-        source: "project-scan"
-      }
-    ];
-  }
-  return [
-    {
-      filePath: result.file,
-      severity: "error",
-      semantic: "blocking",
-      tool: "test-runner",
-      runner: result.runner,
-      rule: `test:${result.runner}`,
-      message: `${stalePrefix}${result.failed} test(s) failed${result.error ? ` (runner also reported: ${result.error})` : ""}`,
-      source: "project-scan"
-    }
-  ];
-}
-export function testRunnerFindingsToProjectDiagnostics(cache, cwd, runtime) {
-  if (!cache.results || cache.results.length === 0)
-    return [];
-  const validation = cwd ? validateAdvisoryProvenance(cache, cwd, runtime) : { status: "unknown", reasons: ["validation-context-missing"] };
-  const root = cwd ?? process.cwd();
-  const missingKeys = new Set((cache.provenance?.files ?? []).filter((file) => !fs.existsSync(path.resolve(root, file.path))).map((file) => advisoryPathKey(file.path, root)));
-  const historical = cache.superseded === true || cache.stale === true || validation.status !== "current";
-  return cache.results.filter((result) => !missingKeys.has(advisoryPathKey(result.file, root))).flatMap((result) => testResultToProjectDiagnostics(result, historical)).map((diagnostic) => historical ? {
-    ...diagnostic,
-    severity: "info",
-    semantic: "none",
-    message: diagnostic.message.startsWith("[stale") ? diagnostic.message : `[historical — re-run to confirm] ${diagnostic.message}`
-  } : diagnostic);
-}

package/extensions/dm-lens/dist/clients/project-diagnostics/runner-adapters/trivy.js

@@ -1,41 +0,0 @@
-import * as path from "node:path";
-export function trivyFindingToProjectDiagnostic(cwd, finding) {
-  const filePath = finding.target ? path.isAbsolute(finding.target) ? finding.target : path.resolve(cwd, finding.target) : cwd;
-  const version = finding.installedVersion ? `@${finding.installedVersion}` : "";
-  const fix = finding.fixedVersion ? ` (fixed in ${finding.fixedVersion})` : "";
-  return {
-    filePath,
-    severity: "warning",
-    semantic: "warning",
-    tool: "trivy",
-    runner: "trivy",
-    rule: `trivy:${finding.vulnerabilityId}`,
-    code: finding.pkgName,
-    message: `${finding.severity} vulnerability ${finding.vulnerabilityId} in ${finding.pkgName}${version}${fix}`,
-    source: "project-scan"
-  };
-}
-export function trivySecretFindingToProjectDiagnostic(cwd, finding) {
-  return {
-    filePath: path.isAbsolute(finding.file) ? finding.file : path.resolve(cwd, finding.file),
-    line: finding.line,
-    severity: "error",
-    semantic: "blocking",
-    tool: "trivy",
-    runner: "trivy",
-    rule: `trivy-secret:${finding.ruleId}`,
-    message: `Potential secret: ${finding.title || finding.ruleId}`,
-    source: "project-scan"
-  };
-}
-function trivySecretsToProjectDiagnostics(cwd, secrets) {
-  return secrets.map((finding) => trivySecretFindingToProjectDiagnostic(cwd, finding));
-}
-export function trivyResultToProjectDiagnostics(cwd, result) {
-  if (!result.success)
-    return [];
-  return [
-    ...(result.findings ?? []).map((finding) => trivyFindingToProjectDiagnostic(cwd, finding)),
-    ...trivySecretsToProjectDiagnostics(cwd, result.secrets ?? [])
-  ];
-}

package/extensions/dm-lens/dist/clients/project-diagnostics/scanner.js

@@ -1,349 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { createDispatchContext } from "../dispatch/dispatcher.js";
-import { evaluateRules } from "../dispatch/fact-rule-runner.js";
-import { runProviders } from "../dispatch/fact-runner.js";
-import { FactStore } from "../dispatch/fact-store.js";
-import { canHandle as astGrepCanHandle, getLang as astGrepGetLang, evaluateAstGrepRules, loadSg } from "../dispatch/runners/ast-grep-napi.js";
-import { detectFileKind } from "../file-kinds.js";
-import { isTestFile } from "../file-utils.js";
-import { isAtOrAboveHomeDir } from "../path-utils.js";
-import { getProjectDiagnosticsScannerMaxFiles } from "../project-scale.js";
-import { captureReviewGraphStructuralIr } from "../review-graph/builder.js";
-import { publishReviewGraphFileIr, reviewGraphIrContentHash } from "../review-graph/shared-extraction-ir.js";
-import { collectSourceFilesWithBudgetAsync } from "../source-filter.js";
-import { logTreeSitter, logTreeSitterCacheStats } from "../tree-sitter-logger.js";
-import { queriesForLanguage, queryLoader } from "../tree-sitter-query-loader.js";
-import { EXT_TO_LANG, getSharedTreeSitterClient, isTreeSitterWasmAborted } from "../tree-sitter-shared.js";
-import { PROJECT_DIAGNOSTICS_CACHE_VERSION, saveProjectDiagnosticsSnapshot } from "./cache.js";
-import { hashDiagnosticContent } from "../lsp/diagnostic-binding.js";
-import"../dispatch/integration.js";
-const AST_GREP_MAX_FILE_BYTES = 1024 * 1024;
-const AST_GREP_SCAN_MAX_MATCHES_PER_RULE = 25;
-const AST_GREP_SCAN_MAX_DIAGNOSTICS_PER_FILE = 100;
-const FACT_RULE_EXTENSIONS = new Set([
-  ".ts",
-  ".tsx",
-  ".js",
-  ".jsx",
-  ".mjs",
-  ".cjs"
-]);
-export const TREE_SITTER_EXT_TO_LANG = EXT_TO_LANG;
-function normalizeSeverity(severity) {
-  if (severity === "error" || severity === "warning" || severity === "hint") {
-    return severity;
-  }
-  return severity === "info" ? "info" : "warning";
-}
-function normalizeSemantic(diagnostic) {
-  if (diagnostic.semantic === "blocking")
-    return "blocking";
-  if (diagnostic.semantic === "warning")
-    return "warning";
-  return "none";
-}
-function fromDispatchDiagnostic(diagnostic, runner) {
-  return {
-    filePath: path.resolve(diagnostic.filePath),
-    line: diagnostic.line,
-    column: diagnostic.column,
-    severity: normalizeSeverity(diagnostic.severity),
-    semantic: normalizeSemantic(diagnostic),
-    tool: diagnostic.tool,
-    runner,
-    rule: diagnostic.rule,
-    code: diagnostic.code,
-    message: diagnostic.message,
-    source: "project-scan"
-  };
-}
-async function scanFileMajorRules(cwd, files, signal) {
-  const client = getSharedTreeSitterClient();
-  client?.ensureTreeCacheCapacity(files.length);
-  const treeSitterReady = !!client && client.isAvailable() && await client.init();
-  const queryMap = treeSitterReady ? await queryLoader.loadQueries(cwd) : undefined;
-  const facts = new FactStore("project-diagnostics-scanner");
-  const pi = { getFlag: () => {
-    return;
-  } };
-  const treeSitter = [];
-  const factRules = [];
-  const astGrep = [];
-  const fingerprints = {};
-  const sgModule = await loadSg();
-  let phaseOneFilesScanned = 0;
-  let astGrepFilesScanned = 0;
-  let astGrepDurationMs = 0;
-  let filesScanned = 0;
-  let wasmAborted = isTreeSitterWasmAborted();
-  const ruleCoverage = new Map;
-  const hasTreeSitterRules = (langId) => {
-    if (!queryMap || !client)
-      return false;
-    const memo = ruleCoverage.get(langId);
-    if (memo !== undefined)
-      return memo;
-    const covered = queriesForLanguage(queryMap, langId).length > 0;
-    ruleCoverage.set(langId, covered);
-    return covered;
-  };
-  const scanTreeSitterFile = async (filePath, langId, content) => {
-    if (!queryMap || !langId || !client || content === null)
-      return;
-    const queries = queriesForLanguage(queryMap, langId);
-    try {
-      const found = await client.runQueriesOnFile(queries, filePath, langId, { maxResults: 50 }, content);
-      for (const { queryDef: query, match } of found) {
-        treeSitter.push({
-          filePath,
-          line: match.line ?? 1,
-          column: match.column,
-          severity: query.severity === "error" ? "error" : query.severity,
-          semantic: query.inline_tier === "blocking" || query.severity === "error" ? "blocking" : "warning",
-          tool: "tree-sitter",
-          runner: "tree-sitter",
-          rule: query.id,
-          message: query.message,
-          source: "project-scan"
-        });
-      }
-    } catch {}
-  };
-  const scanFactRulesFile = async (filePath, content) => {
-    facts.dropFileFacts(filePath);
-    facts.setFileFact(filePath, "file.content", content);
-    const ctx = createDispatchContext(filePath, cwd, pi, facts, false);
-    try {
-      await runProviders(ctx);
-      for (const diagnostic of evaluateRules(ctx)) {
-        factRules.push(fromDispatchDiagnostic(diagnostic, "fact-rules"));
-      }
-    } catch {}
-  };
-  const scanAstGrepFile = (filePath, content, lang) => {
-    const startedAt = Date.now();
-    try {
-      const rootNode = lang.parse(content).root();
-      const fileDiagnostics = evaluateAstGrepRules(filePath, rootNode, cwd, detectFileKind(filePath), {
-        maxMatchesPerRule: AST_GREP_SCAN_MAX_MATCHES_PER_RULE,
-        maxTotalDiagnostics: AST_GREP_SCAN_MAX_DIAGNOSTICS_PER_FILE,
-        content,
-        sgModule
-      });
-      for (const diagnostic of fileDiagnostics) {
-        astGrep.push(fromDispatchDiagnostic(diagnostic, "ast-grep-napi"));
-      }
-    } catch {} finally {
-      astGrepFilesScanned++;
-      astGrepDurationMs += Date.now() - startedAt;
-    }
-  };
-  const scan = async () => {
-    for (const filePath of files) {
-      if (signal?.aborted || isTreeSitterWasmAborted()) {
-        wasmAborted ||= isTreeSitterWasmAborted();
-        break;
-      }
-      if (isTestFile(filePath))
-        continue;
-      const ext = path.extname(filePath);
-      const grammarId = TREE_SITTER_EXT_TO_LANG[ext];
-      const langId = grammarId && hasTreeSitterRules(grammarId) ? grammarId : undefined;
-      const factEligible = FACT_RULE_EXTENSIONS.has(ext);
-      let astGrepLang;
-      if (sgModule && astGrepCanHandle(filePath)) {
-        try {
-          if (fs.statSync(filePath).size <= AST_GREP_MAX_FILE_BYTES) {
-            astGrepLang = astGrepGetLang(filePath, sgModule);
-          }
-        } catch {}
-      }
-      if (!langId && !factEligible && !astGrepLang)
-        continue;
-      if (langId || factEligible)
-        phaseOneFilesScanned++;
-      let content;
-      let contentBytes;
-      try {
-        const buf = fs.readFileSync(filePath);
-        contentBytes = buf.length;
-        content = buf.toString("utf-8");
-      } catch {
-        content = null;
-        contentBytes = undefined;
-      }
-      const rowsBeforeFile = treeSitter.length + factRules.length + astGrep.length;
-      try {
-        await scanTreeSitterFile(filePath, langId, content);
-        if (isTreeSitterWasmAborted()) {
-          wasmAborted = true;
-          break;
-        }
-        if (factEligible) {
-          await scanFactRulesFile(filePath, content);
-          if (isTreeSitterWasmAborted()) {
-            wasmAborted = true;
-            break;
-          }
-        }
-        let graphIr;
-        if (content !== null) {
-          try {
-            graphIr = await captureReviewGraphStructuralIr(filePath, cwd, content, facts);
-          } catch {
-            graphIr = { complete: false };
-          }
-          if (isTreeSitterWasmAborted()) {
-            wasmAborted = true;
-            break;
-          }
-        }
-        if (signal?.aborted) {
-          astGrep.length = 0;
-          break;
-        }
-        if (astGrepLang && content !== null) {
-          scanAstGrepFile(filePath, content, astGrepLang);
-        }
-        if (signal?.aborted)
-          break;
-        if (content !== null && graphIr?.complete && graphIr.structural) {
-          publishReviewGraphFileIr(cwd, {
-            filePath,
-            contentHash: reviewGraphIrContentHash(content),
-            ...graphIr
-          });
-        }
-        if (content !== null && contentBytes !== undefined && treeSitter.length + factRules.length + astGrep.length > rowsBeforeFile) {
-          fingerprints[filePath] = {
-            sizeBytes: contentBytes,
-            contentHash: hashDiagnosticContent(content)
-          };
-        }
-        filesScanned++;
-      } finally {
-        facts.dropFileFacts(filePath);
-      }
-    }
-    if (wasmAborted) {
-      astGrep.length = 0;
-    }
-  };
-  if (!client) {
-    await scan();
-    return {
-      treeSitter,
-      factRules,
-      astGrep,
-      filesScanned,
-      wasmAborted,
-      fingerprints
-    };
-  }
-  const startedAt = Date.now();
-  await client.withParseCacheMeasurement(scan, (stats) => {
-    logTreeSitterCacheStats({
-      scope: "project_diagnostics_scan",
-      filePath: cwd,
-      fileCount: phaseOneFilesScanned,
-      durationMs: Date.now() - startedAt - astGrepDurationMs,
-      stats,
-      astGrep: {
-        durationMs: astGrepDurationMs,
-        fileCount: astGrepFilesScanned
-      }
-    });
-  });
-  return {
-    treeSitter,
-    factRules,
-    astGrep,
-    filesScanned,
-    wasmAborted,
-    fingerprints
-  };
-}
-export async function scanProjectDiagnostics(options) {
-  const cwd = path.resolve(options.cwd);
-  const { signal } = options;
-  if (!options.files && isAtOrAboveHomeDir(cwd, options.homeDir)) {
-    return {
-      version: PROJECT_DIAGNOSTICS_CACHE_VERSION,
-      cwd,
-      tier: options.tier,
-      scannedAt: new Date().toISOString(),
-      diagnostics: [],
-      filesScanned: 0,
-      runners: [],
-      unsafeRoot: true
-    };
-  }
-  const maxFiles = Math.max(1, options.maxFiles ?? getProjectDiagnosticsScannerMaxFiles(cwd));
-  const collected = options.files ? { files: options.files.slice(0, maxFiles), entryBudgetExceeded: false } : await collectSourceFilesWithBudgetAsync(cwd, {
-    maxFiles,
-    maxScanEntries: options.maxScanEntries,
-    includeGenerated: options.includeGenerated === true
-  });
-  const files = collected.files;
-  const runners = [];
-  const diagnostics = [];
-  let fileFingerprints = {};
-  let wasmAborted = false;
-  let filesScanned = files.length;
-  if (!signal?.aborted) {
-    const scanned = await scanFileMajorRules(cwd, files, signal);
-    diagnostics.push(...scanned.treeSitter, ...scanned.factRules);
-    runners.push("tree-sitter", "fact-rules");
-    wasmAborted = scanned.wasmAborted;
-    if (wasmAborted)
-      filesScanned = scanned.filesScanned;
-    if (!signal?.aborted && !wasmAborted) {
-      diagnostics.push(...scanned.astGrep);
-      runners.push("ast-grep-napi");
-    }
-    const rowFiles = new Set(diagnostics.map((d) => d.filePath));
-    fileFingerprints = Object.fromEntries(Object.entries(scanned.fingerprints).filter(([file]) => rowFiles.has(file)));
-  }
-  const snapshot = {
-    version: PROJECT_DIAGNOSTICS_CACHE_VERSION,
-    cwd,
-    tier: options.tier,
-    scannedAt: new Date().toISOString(),
-    diagnostics,
-    filesScanned,
-    runners,
-    fileFingerprints
-  };
-  if (collected.entryBudgetExceeded)
-    snapshot.scanTruncated = true;
-  if (collected.generatedOrArtifactSkips) {
-    snapshot.generatedFileSkips = collected.generatedOrArtifactSkips;
-  }
-  if (collected.generatedNameOnlySkips) {
-    snapshot.generatedNameOnlySkips = collected.generatedNameOnlySkips;
-  }
-  if (collected.generatedDirSkips) {
-    snapshot.generatedDirSkips = collected.generatedDirSkips;
-  }
-  if (wasmAborted) {
-    snapshot.scanTruncated = true;
-    snapshot.treeSitterStatus = "wasm_aborted_restart_required";
-    logTreeSitter({
-      phase: "runner_skip",
-      filePath: cwd,
-      status: "aborted",
-      reason: "wasm_aborted_mid_scan",
-      metadata: {
-        scope: "project_diagnostics_scan",
-        filesScanned,
-        totalFiles: files.length,
-        abortPoint: filesScanned + 1
-      }
-    });
-  }
-  if (signal?.aborted || options.files || wasmAborted)
-    return snapshot;
-  saveProjectDiagnosticsSnapshot(cwd, snapshot);
-  return snapshot;
-}

package/extensions/dm-lens/dist/clients/project-diagnostics/types.js

@@ -1 +0,0 @@
-export {};