@duckmind/dm-darwin-x64 0.66.5 → 0.66.7

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

@@ -0,0 +1,23 @@
+import * as path from "node:path";
+export function govulncheckFindingToProjectDiagnostic(cwd, finding) {
+  const frame = finding.trace?.find((f) => f.filename);
+  const filePath = frame?.filename ? path.isAbsolute(frame.filename) ? frame.filename : path.resolve(cwd, frame.filename) : cwd;
+  const fix = finding.fixedVersion ? ` (fixed in ${finding.fixedVersion})` : "";
+  return {
+    filePath,
+    line: frame?.line,
+    severity: "warning",
+    semantic: "warning",
+    tool: "govulncheck",
+    runner: "govulncheck",
+    rule: `govulncheck:${finding.osv}`,
+    code: finding.packageName ?? finding.module,
+    message: `Vulnerability ${finding.osv}: ${finding.summary ?? "reachable vulnerable dependency"}${fix}`,
+    source: "project-scan"
+  };
+}
+export function govulncheckResultToProjectDiagnostics(cwd, result) {
+  if (!result.success || result.findings.length === 0)
+    return [];
+  return result.findings.map((finding) => govulncheckFindingToProjectDiagnostic(cwd, finding));
+}

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

@@ -0,0 +1,28 @@
+import * as path from "node:path";
+function resolveClonePath(cwd, file) {
+  return path.isAbsolute(file) ? file : path.resolve(cwd, file);
+}
+function jscpdCloneToProjectDiagnostics(cwd, clone) {
+  const a = resolveClonePath(cwd, clone.fileA);
+  const b = resolveClonePath(cwd, clone.fileB);
+  const make = (filePath, line, otherFile, otherLine) => ({
+    filePath,
+    line,
+    severity: "warning",
+    semantic: "warning",
+    tool: "jscpd",
+    runner: "jscpd",
+    rule: "jscpd:duplicate",
+    message: `Duplicate code (${clone.lines} lines) — also at ${path.relative(cwd, otherFile)}:${otherLine}`,
+    source: "project-scan"
+  });
+  return [
+    make(a, clone.startA, b, clone.startB),
+    make(b, clone.startB, a, clone.startA)
+  ];
+}
+export function jscpdResultToProjectDiagnostics(cwd, result) {
+  if (!result.success || result.clones.length === 0)
+    return [];
+  return result.clones.flatMap((clone) => jscpdCloneToProjectDiagnostics(cwd, clone));
+}

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

@@ -0,0 +1,45 @@
+import * as path from "node:path";
+function knipIssueFile(cwd, issue) {
+  if (!issue.file)
+    return cwd;
+  return path.isAbsolute(issue.file) ? issue.file : path.resolve(cwd, issue.file);
+}
+function knipIssueMessage(issue) {
+  if (issue.type === "unlisted") {
+    return `Unlisted dependency ${issue.name}`;
+  }
+  if (issue.type === "bin") {
+    return `Unlisted binary ${issue.name}`;
+  }
+  if (issue.type === "export") {
+    return `Unused export ${issue.name}`;
+  }
+  if (issue.type === "enumMember") {
+    return `Unused enum member ${issue.name}`;
+  }
+  if (issue.type === "file") {
+    return `Unused file ${issue.name}`;
+  }
+  if (issue.type === "dependency" || issue.type === "devDependency") {
+    return `Unused ${issue.type} ${issue.name}`;
+  }
+  return `${issue.type}: ${issue.name}`;
+}
+function knipIssueToProjectDiagnostic(cwd, issue) {
+  const blocking = issue.type === "unlisted" || issue.type === "bin";
+  return {
+    filePath: knipIssueFile(cwd, issue),
+    line: issue.line,
+    severity: blocking ? "error" : "warning",
+    semantic: blocking ? "blocking" : "warning",
+    tool: "knip",
+    runner: "knip",
+    rule: `knip:${issue.type}`,
+    code: issue.package,
+    message: knipIssueMessage(issue),
+    source: "project-scan"
+  };
+}
+export function knipIssuesToProjectDiagnostics(cwd, issues) {
+  return issues.map((issue) => knipIssueToProjectDiagnostic(cwd, issue));
+}

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

@@ -0,0 +1,34 @@
+import * as path from "node:path";
+import { compareOrdinal } from "../../string-utils.js";
+function resolveCyclePath(cwd, file) {
+  return path.isAbsolute(file) ? file : path.resolve(cwd, file);
+}
+function cycleMembers(dep) {
+  return dep.path.length > 0 ? dep.path : [dep.file];
+}
+function circularDepToProjectDiagnostics(cwd, dep) {
+  const members = cycleMembers(dep);
+  const rendered = `${members.map((f) => path.basename(f)).join(" → ")} → ${path.basename(members[0] ?? "")}`;
+  return members.map((file) => ({
+    filePath: resolveCyclePath(cwd, file),
+    severity: "warning",
+    semantic: "warning",
+    tool: "madge",
+    runner: "madge",
+    rule: "madge:circular",
+    message: `Part of circular dependency: ${rendered}`,
+    source: "project-scan"
+  }));
+}
+export function circularDepsToProjectDiagnostics(cwd, circular) {
+  const seen = new Set;
+  const out = [];
+  for (const dep of circular) {
+    const key = cycleMembers(dep).map((f) => resolveCyclePath(cwd, f)).sort(compareOrdinal).join("|");
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    out.push(...circularDepToProjectDiagnostics(cwd, dep));
+  }
+  return out;
+}

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

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

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

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

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

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