@duckmind/dm-linux-x64 0.65.8 → 0.66.2

package/extensions/dm-lens/dist/clients/project-report.js

@@ -1,527 +0,0 @@
-import * as path from "node:path";
-import { normalizeMapKey, toProjectRelativePath } from "./path-utils.js";
-import { loadProjectSnapshotWithoutWordIndex } from "./project-snapshot.js";
-import { formatReviewGraphRevisionDriftNote } from "./review-graph/revision-drift.js";
-const DEFAULT_LIMIT = 10;
-const STALE_THRESHOLD_MS = 15 * 60000;
-const LOW_COVERAGE_THRESHOLD = 0.8;
-const DEAD_WEIGHT_DISCLAIMER = "Low confidence: dynamic imports, runtime registration, and test-only " + "reachability all produce false positives here — verify with a real " + "usage search (symbol_search/grep) before deleting anything listed.";
-function clampLimit(limit) {
-  return Math.max(1, Math.floor(limit ?? DEFAULT_LIMIT));
-}
-function toDisplayPath(p, projectRoot) {
-  return toProjectRelativePath(p, projectRoot);
-}
-export function _toDisplayPathForTests(p, projectRoot) {
-  return toDisplayPath(p, projectRoot);
-}
-function suggestedNext(displayPath) {
-  return { tool: "module_report", path: displayPath };
-}
-function normalizeFocus(focus) {
-  return (focus ?? "").toLowerCase().split(/[^a-z0-9_.]+/).map((part) => part.trim()).filter((part) => part.length >= 3).slice(0, 8);
-}
-function focusScore(text, terms) {
-  if (terms.length === 0)
-    return 0;
-  const haystack = text.toLowerCase();
-  return terms.reduce((score, term) => score + (haystack.includes(term) ? 6 : 0), 0);
-}
-function buildFileDegrees(graph) {
-  const fanIn = new Map;
-  const fanOut = new Map;
-  for (const edge of graph.edges) {
-    if (edge.kind !== "imports")
-      continue;
-    if (edge.from === edge.to)
-      continue;
-    const fromNode = graph.nodes.get(edge.from);
-    const toNode = graph.nodes.get(edge.to);
-    if (!fromNode || fromNode.kind !== "file")
-      continue;
-    if (!toNode || toNode.kind !== "file")
-      continue;
-    let outSet = fanOut.get(edge.from);
-    if (!outSet) {
-      outSet = new Set;
-      fanOut.set(edge.from, outSet);
-    }
-    outSet.add(edge.to);
-    let inSet = fanIn.get(edge.to);
-    if (!inSet) {
-      inSet = new Set;
-      fanIn.set(edge.to, inSet);
-    }
-    inSet.add(edge.from);
-  }
-  return { fanIn, fanOut };
-}
-function computeTrust(graph, cwd, drift) {
-  const filesCovered = graph.fileNodes.size;
-  const snapshot = loadProjectSnapshotWithoutWordIndex(cwd);
-  const snapshotFileCount = snapshot ? Object.keys(snapshot.files).length : 0;
-  const persistedTotal = graph.persistCoverage?.totalFiles ?? 0;
-  const filesTotal = Math.max(filesCovered, snapshotFileCount, persistedTotal);
-  const coverage = filesTotal > 0 ? filesCovered / filesTotal : 1;
-  let exact = 0;
-  let imp = 0;
-  let receiverType = 0;
-  let nameOnly = 0;
-  for (const edge of graph.edges) {
-    if (edge.kind !== "calls" && edge.kind !== "references")
-      continue;
-    switch (edge.resolution) {
-      case "exact":
-        exact += 1;
-        break;
-      case "import":
-        imp += 1;
-        break;
-      case "receiver-type":
-        receiverType += 1;
-        break;
-      case "name-only":
-        nameOnly += 1;
-        break;
-      default:
-        break;
-    }
-  }
-  const sampleSize = exact + imp + receiverType + nameOnly;
-  const frac = (n) => sampleSize > 0 ? n / sampleSize : 0;
-  const ageMs = Date.now() - Date.parse(graph.builtAt);
-  const stale = Number.isFinite(ageMs) && ageMs > STALE_THRESHOLD_MS;
-  const lowCoverage = coverage < LOW_COVERAGE_THRESHOLD || graph.persistCoverage?.partial === true;
-  const notes = [];
-  if (drift)
-    notes.push(formatReviewGraphRevisionDriftNote(drift));
-  if (stale) {
-    const ageMin = Math.round(ageMs / 60000);
-    notes.push(`Graph is stale: built ${ageMin}m ago. Sections below may miss recent edits — run dmlens_rebuild or re-analyze to refresh.`);
-  }
-  if (lowCoverage) {
-    if (graph.persistCoverage?.partial) {
-      const p = graph.persistCoverage;
-      const totalFiles = p.totalFiles ?? filesCovered;
-      const persistedFiles = p.persistedFiles ?? filesCovered;
-      if (p.sourceFilesTruncated) {
-        notes.push(`Partial source walk: at least ${totalFiles} source files were represented before the visited-entry budget stopped enumeration; ${persistedFiles} files are in this graph.`);
-      } else {
-        notes.push(`Partial persisted graph: ${p.persistedNodes}/${p.totalNodes} nodes, ${p.persistedEdges}/${p.totalEdges} edges, and ${persistedFiles}/${totalFiles} files were retained under the ${p.cap}-element cap — whole subsystems may be invisible below.`);
-      }
-    } else {
-      notes.push(`Low coverage: only ${filesCovered}/${filesTotal} project files (${Math.round(coverage * 100)}%) are in the graph — whole subsystems may be invisible below.`);
-    }
-  }
-  return {
-    graphBuiltAt: graph.builtAt,
-    filesCovered,
-    filesTotal,
-    coverage,
-    resolution: {
-      exact: frac(exact),
-      import: frac(imp),
-      receiverType: frac(receiverType),
-      nameOnly: frac(nameOnly),
-      sampleSize
-    },
-    stale,
-    ...drift ? { revisionDrift: drift } : {},
-    lowCoverage,
-    persistCoverage: graph.persistCoverage?.partial ? graph.persistCoverage : undefined,
-    notes
-  };
-}
-function roleFor(graph, filePath) {
-  const symbolIds = graph.symbolNodesByFile.get(filePath) ?? [];
-  const scored = [];
-  for (const symbolId of symbolIds) {
-    const node = graph.nodes.get(symbolId);
-    if (!node || !node.exported || !node.symbolName)
-      continue;
-    const refs = (graph.edgesByTo.get(symbolId) ?? []).filter((e) => e.kind === "calls" || e.kind === "references").length;
-    scored.push({ name: node.qualifiedName ?? node.symbolName, refs });
-  }
-  scored.sort((a, b) => b.refs - a.refs);
-  const top = scored.slice(0, 3).filter((s) => s.refs > 0);
-  return top.length > 0 ? top.map((s) => s.name).join(", ") : undefined;
-}
-async function computeHubs(graph, degrees, cwd, limit, focusTerms) {
-  const { computeTransitiveImpact } = await import("./review-graph/query.js");
-  const ranked = [...graph.fileNodes.entries()].map(([filePath, fileNodeId]) => ({
-    filePath,
-    fileNodeId,
-    fanIn: degrees.fanIn.get(fileNodeId)?.size ?? 0
-  })).filter((f) => f.fanIn > 0).sort((a, b) => {
-    const focusDelta = focusScore(a.filePath, focusTerms) - focusScore(b.filePath, focusTerms);
-    if (focusDelta !== 0)
-      return -focusDelta;
-    return b.fanIn - a.fanIn || a.filePath.localeCompare(b.filePath);
-  }).slice(0, limit);
-  return ranked.map((f) => {
-    const impact = computeTransitiveImpact(graph, f.filePath, { maxDepth: 3 });
-    const display = toDisplayPath(f.filePath, cwd);
-    return {
-      file: display,
-      fanIn: f.fanIn,
-      blastRadius: impact.hits.length,
-      role: roleFor(graph, f.filePath),
-      suggestedNext: suggestedNext(display)
-    };
-  });
-}
-function computeEntryPoints(graph, degrees, cwd, limit, focusTerms) {
-  const candidates = [...graph.fileNodes.entries()].map(([filePath, fileNodeId]) => ({
-    filePath,
-    fanIn: degrees.fanIn.get(fileNodeId)?.size ?? 0,
-    fanOut: degrees.fanOut.get(fileNodeId)?.size ?? 0
-  })).filter((f) => f.fanIn === 0 && f.fanOut > 0).sort((a, b) => {
-    const focusDelta = focusScore(a.filePath, focusTerms) - focusScore(b.filePath, focusTerms);
-    if (focusDelta !== 0)
-      return -focusDelta;
-    return b.fanOut - a.fanOut || a.filePath.localeCompare(b.filePath);
-  });
-  const entryPointFiles = new Set(candidates.map((c) => c.filePath));
-  const entryPoints = candidates.slice(0, limit).map((f) => {
-    const display = toDisplayPath(f.filePath, cwd);
-    return {
-      file: display,
-      fanIn: f.fanIn,
-      fanOut: f.fanOut,
-      suggestedNext: suggestedNext(display)
-    };
-  });
-  return { entryPoints, entryPointFiles };
-}
-const DOMINANCE_THRESHOLD = 0.4;
-function directoryClusters(filePaths, cwd) {
-  const segmentsOf = (filePath) => toDisplayPath(filePath, cwd).split("/").filter(Boolean);
-  const topCounts = new Map;
-  const perFileSegments = new Map;
-  for (const filePath of filePaths) {
-    const segments = segmentsOf(filePath);
-    perFileSegments.set(filePath, segments);
-    const top = segments.length > 1 ? segments[0] : "(root)";
-    topCounts.set(top, (topCounts.get(top) ?? 0) + 1);
-  }
-  const total = filePaths.length || 1;
-  const dominant = new Set([...topCounts.entries()].filter(([, count]) => count / total >= DOMINANCE_THRESHOLD).map(([seg]) => seg));
-  const clusterOf = new Map;
-  for (const filePath of filePaths) {
-    const segments = perFileSegments.get(filePath) ?? [];
-    if (segments.length <= 1) {
-      clusterOf.set(filePath, "(root)");
-      continue;
-    }
-    const top = segments[0];
-    if (dominant.has(top) && segments.length > 2) {
-      clusterOf.set(filePath, `${segments[0]}/${segments[1]}`);
-    } else {
-      clusterOf.set(filePath, top);
-    }
-  }
-  return clusterOf;
-}
-function tarjanSCCs(nodes, adjacency) {
-  let index = 0;
-  const indices = new Map;
-  const lowlink = new Map;
-  const onStack = new Set;
-  const stack = [];
-  const sccs = [];
-  function strongConnect(v) {
-    indices.set(v, index);
-    lowlink.set(v, index);
-    index += 1;
-    stack.push(v);
-    onStack.add(v);
-    for (const w of adjacency.get(v) ?? []) {
-      if (!indices.has(w)) {
-        strongConnect(w);
-        lowlink.set(v, Math.min(lowlink.get(v), lowlink.get(w)));
-      } else if (onStack.has(w)) {
-        lowlink.set(v, Math.min(lowlink.get(v), indices.get(w)));
-      }
-    }
-    if (lowlink.get(v) === indices.get(v)) {
-      const scc = [];
-      let w;
-      do {
-        w = stack.pop();
-        onStack.delete(w);
-        scc.push(w);
-      } while (w !== v);
-      sccs.push(scc);
-    }
-  }
-  for (const v of nodes) {
-    if (!indices.has(v))
-      strongConnect(v);
-  }
-  return sccs;
-}
-function computeSubsystems(graph, cwd, limit) {
-  const filePaths = [...graph.fileNodes.keys()];
-  const clusterOf = directoryClusters(filePaths, cwd);
-  const fileNodeIdToCluster = new Map;
-  for (const [filePath, nodeId] of graph.fileNodes) {
-    const cluster = clusterOf.get(filePath);
-    if (cluster)
-      fileNodeIdToCluster.set(nodeId, cluster);
-  }
-  const edgeCounts = new Map;
-  for (const edge of graph.edges) {
-    if (edge.kind !== "imports")
-      continue;
-    const fromCluster = fileNodeIdToCluster.get(edge.from);
-    const toCluster = fileNodeIdToCluster.get(edge.to);
-    if (!fromCluster || !toCluster || fromCluster === toCluster)
-      continue;
-    const key = `${fromCluster}|${toCluster}`;
-    edgeCounts.set(key, (edgeCounts.get(key) ?? 0) + 1);
-  }
-  const directories = [...new Set(clusterOf.values())].sort((a, b) => a.localeCompare(b));
-  const edges = [...edgeCounts.entries()].map(([key, count]) => {
-    const [from, to] = key.split("|");
-    return { from, to, count };
-  }).sort((a, b) => b.count - a.count || a.from.localeCompare(b.from));
-  const seenPairs = new Set;
-  const violations = [];
-  for (const edge of edges) {
-    const pairKey = [edge.from, edge.to].sort((a, b) => a.localeCompare(b)).join("|");
-    if (seenPairs.has(pairKey))
-      continue;
-    const reverseKey = `${edge.to}|${edge.from}`;
-    const reverseCount = edgeCounts.get(reverseKey);
-    if (reverseCount === undefined || reverseCount === edge.count)
-      continue;
-    seenPairs.add(pairKey);
-    if (edge.count < reverseCount) {
-      violations.push({
-        from: edge.from,
-        to: edge.to,
-        count: edge.count,
-        dominantCount: reverseCount
-      });
-    } else {
-      violations.push({
-        from: edge.to,
-        to: edge.from,
-        count: reverseCount,
-        dominantCount: edge.count
-      });
-    }
-  }
-  violations.sort((a, b) => b.count - a.count || a.from.localeCompare(b.from));
-  const adjacency = new Map;
-  for (const dir of directories)
-    adjacency.set(dir, new Set);
-  for (const edge of edges) {
-    adjacency.get(edge.from)?.add(edge.to);
-  }
-  const sccs = tarjanSCCs(directories, adjacency).filter((scc) => scc.length > 1);
-  const cycles = sccs.map((scc) => {
-    const members = new Set(scc);
-    let edgeCount = 0;
-    for (const edge of edges) {
-      if (members.has(edge.from) && members.has(edge.to))
-        edgeCount += edge.count;
-    }
-    return { dirs: [...scc].sort((a, b) => a.localeCompare(b)), edgeCount };
-  }).sort((a, b) => b.edgeCount - a.edgeCount);
-  return {
-    directories,
-    edges: edges.slice(0, limit),
-    cycles: cycles.slice(0, limit),
-    violations: violations.slice(0, limit)
-  };
-}
-function computeRiskHotspots(graph, degrees, cwd, limit, focusTerms) {
-  const ranked = [...graph.fileNodes.entries()].map(([filePath, fileNodeId]) => {
-    const symbolIds = graph.symbolNodesByFile.get(filePath) ?? [];
-    let maxComplexity = 0;
-    for (const symbolId of symbolIds) {
-      const complexity = graph.nodes.get(symbolId)?.metadata?.cyclomaticComplexity;
-      if (typeof complexity === "number" && complexity > maxComplexity) {
-        maxComplexity = complexity;
-      }
-    }
-    const fanIn = degrees.fanIn.get(fileNodeId)?.size ?? 0;
-    return { filePath, fanIn, maxComplexity, score: fanIn * maxComplexity };
-  }).filter((f) => f.score > 0).sort((a, b) => {
-    const focusDelta = focusScore(a.filePath, focusTerms) - focusScore(b.filePath, focusTerms);
-    if (focusDelta !== 0)
-      return -focusDelta;
-    return b.score - a.score || a.filePath.localeCompare(b.filePath);
-  }).slice(0, limit);
-  return ranked.map((f) => {
-    const display = toDisplayPath(f.filePath, cwd);
-    return {
-      file: display,
-      fanIn: f.fanIn,
-      maxComplexity: f.maxComplexity,
-      score: f.score,
-      suggestedNext: suggestedNext(display)
-    };
-  });
-}
-function computeDeadWeight(graph, degrees, entryPointFiles, cwd, limit) {
-  const candidates = [...graph.fileNodes.entries()].filter(([filePath, nodeId]) => {
-    if (entryPointFiles.has(filePath))
-      return false;
-    const fanIn = degrees.fanIn.get(nodeId)?.size ?? 0;
-    return fanIn === 0;
-  }).map(([filePath, fileNodeId]) => ({
-    filePath,
-    fanOut: degrees.fanOut.get(fileNodeId)?.size ?? 0
-  })).sort((a, b) => a.fanOut - b.fanOut || a.filePath.localeCompare(b.filePath)).slice(0, limit);
-  return {
-    files: candidates.map((f) => {
-      const display = toDisplayPath(f.filePath, cwd);
-      return { file: display, suggestedNext: suggestedNext(display) };
-    }),
-    disclaimer: DEAD_WEIGHT_DISCLAIMER
-  };
-}
-const inFlightGraphBuilds = new Set;
-export function _resetProjectReportBuildGuardForTests() {
-  inFlightGraphBuilds.clear();
-}
-function triggerBackgroundGraphBuild(cwd, deps) {
-  const key = normalizeMapKey(path.resolve(cwd));
-  if (inFlightGraphBuilds.has(key))
-    return "already_running";
-  const deduped = deps.isGraphBuildInFlight(key, []);
-  inFlightGraphBuilds.add(key);
-  const build = deps.buildOrUpdateGraph(key, [], new deps.FactStore).catch(() => {});
-  build.finally(() => inFlightGraphBuilds.delete(key));
-  return deduped ? "already_running" : "started";
-}
-export async function projectReport(cwd, options) {
-  const limit = clampLimit(options?.limit);
-  const focusTerms = normalizeFocus(options?.focus);
-  const view = options?.view;
-  const { getCachedReviewGraph, getReviewGraphSizeSkipVerdict, getLastReviewGraphBuildAttempt, buildOrUpdateGraph, isGraphBuildInFlight, getReviewGraphRevisionDrift } = await import("./review-graph/builder.js");
-  let graph;
-  try {
-    graph = getCachedReviewGraph(cwd);
-  } catch {
-    graph = undefined;
-  }
-  if (!graph) {
-    let sizeSkip;
-    try {
-      sizeSkip = getReviewGraphSizeSkipVerdict(cwd);
-    } catch {
-      sizeSkip = undefined;
-    }
-    if (sizeSkip) {
-      const lastBuildAttempt = getLastReviewGraphBuildAttempt(cwd);
-      return {
-        available: false,
-        hint: `review graph disabled: project has more than ${sizeSkip.maxFileCount} files (cap ${sizeSkip.maxFileCount}) — raise maxProjectFiles in .dm-lens.json ` + "or set DM_LENS_REVIEW_GRAPH_MAX_FILES; for CI/cron, run npx dm-lens build-graph after configuring the cap",
-        ...lastBuildAttempt ? { lastBuildAttempt } : {},
-        ...view ? { view } : {}
-      };
-    }
-    const previousAttempt = getLastReviewGraphBuildAttempt(cwd);
-    const { FactStore } = await import("./dispatch/fact-store.js");
-    const trigger = triggerBackgroundGraphBuild(cwd, {
-      buildOrUpdateGraph,
-      isGraphBuildInFlight,
-      FactStore
-    });
-    const started = trigger === "started";
-    const lastBuildAttempt = started ? getLastReviewGraphBuildAttempt(cwd) ?? previousAttempt : previousAttempt;
-    const terminal = previousAttempt?.outcome === "failed" || previousAttempt?.outcome === "skipped";
-    const cause = terminal ? `Review graph unavailable: ${previousAttempt?.reason ?? previousAttempt?.outcome}. ` : "";
-    return {
-      available: false,
-      hint: started ? terminal ? `${cause}A retry was started.` : "No review graph cached for this workspace yet — a build was kicked off in the background; retry this call shortly." : `${cause}A build is already running for this workspace; retry this call shortly.`,
-      ...lastBuildAttempt ? { lastBuildAttempt } : {},
-      ...view ? { view } : {}
-    };
-  }
-  const degrees = buildFileDegrees(graph);
-  const trust = computeTrust(graph, cwd, getReviewGraphRevisionDrift(cwd));
-  const hubs = await computeHubs(graph, degrees, cwd, limit, focusTerms);
-  const { entryPoints, entryPointFiles } = computeEntryPoints(graph, degrees, cwd, limit, focusTerms);
-  const subsystems = computeSubsystems(graph, cwd, limit);
-  const riskHotspots = computeRiskHotspots(graph, degrees, cwd, limit, focusTerms);
-  const deadWeight = computeDeadWeight(graph, degrees, entryPointFiles, cwd, limit);
-  const lastBuildAttempt = getLastReviewGraphBuildAttempt(cwd);
-  return {
-    available: true,
-    ...lastBuildAttempt ? { lastBuildAttempt } : {},
-    ...view ? { view } : {},
-    trust,
-    hubs,
-    entryPoints,
-    subsystems,
-    riskHotspots,
-    deadWeight
-  };
-}
-function fmtPct(n) {
-  return `${Math.round(n * 100)}%`;
-}
-export function renderCompactProjectReport(report) {
-  if (!report.available) {
-    return `project_report — unavailable${report.hint ? `: ${report.hint}` : ""}`;
-  }
-  const lines = [];
-  if (report.lastBuildAttempt?.reason) {
-    lines.push(`! build: ${report.lastBuildAttempt.reason}`);
-  }
-  const t = report.trust;
-  if (t) {
-    lines.push(`TRUST: built ${t.graphBuiltAt} — ${t.filesCovered}/${t.filesTotal} files (${fmtPct(t.coverage)} coverage)` + (t.resolution.sampleSize > 0 ? ` — resolution: exact ${fmtPct(t.resolution.exact)}, import ${fmtPct(t.resolution.import)}, receiver-type ${fmtPct(t.resolution.receiverType)}, name-only ${fmtPct(t.resolution.nameOnly)}` : " — no resolution-tagged edges yet"));
-    for (const note of t.notes)
-      lines.push(`  ! ${note}`);
-  }
-  if (report.hubs?.length) {
-    lines.push("HUBS:");
-    for (const h of report.hubs) {
-      const role = h.role ? ` — ${h.role}` : "";
-      lines.push(`  ${h.file}${role}; ${h.fanIn} importer(s), blastRadius ${h.blastRadius}`);
-    }
-  }
-  if (report.entryPoints?.length) {
-    lines.push("ENTRY POINTS:");
-    for (const e of report.entryPoints) {
-      lines.push(`  ${e.file}; fan-out ${e.fanOut}`);
-    }
-  }
-  if (report.subsystems) {
-    const s = report.subsystems;
-    lines.push(`SUBSYSTEMS: ${s.directories.length} directories, ${s.edges.length} cross-dir edge group(s)`);
-    if (s.cycles.length > 0) {
-      lines.push("  CYCLES:");
-      for (const c of s.cycles) {
-        lines.push(`    ${c.dirs.join(" <-> ")} (${c.edgeCount} edges)`);
-      }
-    }
-    if (s.violations.length > 0) {
-      lines.push("  LAYERING VIOLATIONS:");
-      for (const v of s.violations) {
-        lines.push(`    ${v.from} -> ${v.to} (${v.count} edge(s), against the dominant ${v.to} -> ${v.from} direction, ${v.dominantCount} edge(s))`);
-      }
-    }
-  }
-  if (report.riskHotspots?.length) {
-    lines.push("RISK HOTSPOTS:");
-    for (const r of report.riskHotspots) {
-      lines.push(`  ${r.file}; fan-in ${r.fanIn} × max complexity ${r.maxComplexity} = ${r.score}`);
-    }
-  }
-  if (report.deadWeight) {
-    lines.push(`DEAD WEIGHT (${report.deadWeight.disclaimer}):`);
-    for (const d of report.deadWeight.files) {
-      lines.push(`  ${d.file}`);
-    }
-    if (report.deadWeight.files.length === 0)
-      lines.push("  (none found)");
-  }
-  return lines.join(`
-`);
-}

package/extensions/dm-lens/dist/clients/project-scale.js

@@ -1,60 +0,0 @@
-import { lazyEnvNumber, toPositiveFinite } from "./env-utils.js";
-import { loadDmLensProjectConfig } from "./project-lens-config.js";
-export const DEFAULT_PROJECT_SCALE_BASE = 2000;
-const _envBase = lazyEnvNumber("DM_LENS_MAX_PROJECT_FILES", DEFAULT_PROJECT_SCALE_BASE);
-export function _resetProjectScaleBaseForTests() {
-  _envBase._resetForTests();
-}
-export function getProjectScaleBase(cwd) {
-  if (cwd) {
-    const config = loadDmLensProjectConfig(cwd);
-    const configBase = toPositiveFinite(config.maxProjectFiles);
-    if (configBase > 0)
-      return Math.floor(configBase);
-  }
-  return _envBase.get();
-}
-export const PROJECT_SCALE_RATIOS = {
-  projectDiagnosticsScanner: 0.25,
-  reviewGraph: 0.5,
-  startupScan: 1,
-  jscpd: 3,
-  wordIndex: 3
-};
-export function deriveBudget(ratio, cwd) {
-  return Math.max(1, Math.round(getProjectScaleBase(cwd) * ratio));
-}
-export function getProjectDiagnosticsScannerMaxFiles(cwd) {
-  return deriveBudget(PROJECT_SCALE_RATIOS.projectDiagnosticsScanner, cwd);
-}
-export const REVIEW_GRAPH_LINEAR_CEILING_BASE = 4000;
-export const REVIEW_GRAPH_TAPER_SCALE = 8000;
-export const REVIEW_GRAPH_HARD_CEILING = 5000;
-export function taperedReviewGraphMaxFiles(base) {
-  const linearValue = base * PROJECT_SCALE_RATIOS.reviewGraph;
-  if (base <= REVIEW_GRAPH_LINEAR_CEILING_BASE) {
-    return Math.max(1, Math.round(linearValue));
-  }
-  const boundaryValue = REVIEW_GRAPH_LINEAR_CEILING_BASE * PROJECT_SCALE_RATIOS.reviewGraph;
-  const excess = base - REVIEW_GRAPH_LINEAR_CEILING_BASE;
-  const taperedExtra = (REVIEW_GRAPH_HARD_CEILING - boundaryValue) * (excess / (excess + REVIEW_GRAPH_TAPER_SCALE));
-  return Math.max(1, Math.round(boundaryValue + taperedExtra));
-}
-export function getReviewGraphMaxFilesDerived(cwd) {
-  if (cwd) {
-    const config = loadDmLensProjectConfig(cwd);
-    const configOverride = config.reviewGraph?.maxFiles;
-    if (configOverride !== undefined)
-      return configOverride;
-  }
-  return taperedReviewGraphMaxFiles(getProjectScaleBase(cwd));
-}
-export function getStartupScanMaxSourceFilesDerived(cwd) {
-  return deriveBudget(PROJECT_SCALE_RATIOS.startupScan, cwd);
-}
-export function getJscpdMaxEntriesDerived(cwd) {
-  return deriveBudget(PROJECT_SCALE_RATIOS.jscpd, cwd);
-}
-export function getWordIndexMaxFilesDerived(cwd) {
-  return deriveBudget(PROJECT_SCALE_RATIOS.wordIndex, cwd);
-}

package/extensions/dm-lens/dist/clients/project-scan-policy.js

@@ -1,4 +0,0 @@
-import { collectSourceFilesWithBudgetAsync } from "./source-filter.js";
-export function collectProjectSourceFilesWithBudgetAsync(rootDir, options) {
-  return collectSourceFilesWithBudgetAsync(rootDir, options);
-}

package/extensions/dm-lens/dist/clients/project-snapshot-fingerprint.js

@@ -1,39 +0,0 @@
-import { createHash } from "node:crypto";
-export function fingerprintProjectSnapshotJson(json, generatedAt) {
-  const marker = `"generatedAt":${JSON.stringify(generatedAt)}`;
-  let markerIndex = -1;
-  let depth = 0;
-  let inString = false;
-  let escaped = false;
-  for (let index = 0;index < json.length; index++) {
-    const char = json[index];
-    if (inString) {
-      if (escaped)
-        escaped = false;
-      else if (char === "\\")
-        escaped = true;
-      else if (char === '"')
-        inString = false;
-      continue;
-    }
-    if (char === '"') {
-      if (depth === 1 && json.startsWith(marker, index)) {
-        markerIndex = index;
-        break;
-      }
-      inString = true;
-    } else if (char === "{")
-      depth++;
-    else if (char === "}")
-      depth--;
-  }
-  const hash = createHash("sha256");
-  if (markerIndex < 0) {
-    hash.update(json);
-  } else {
-    hash.update(json.slice(0, markerIndex));
-    hash.update('"generatedAt":""');
-    hash.update(json.slice(markerIndex + marker.length));
-  }
-  return hash.digest("hex");
-}

package/extensions/dm-lens/dist/clients/project-snapshot-persist-worker.js

@@ -1,14 +0,0 @@
-import { serveGzipStageWorker } from "./gzip-stage-write.js";
-import { fingerprintProjectSnapshotJson } from "./project-snapshot-fingerprint.js";
-function semanticSnapshotFingerprint(request, json) {
-  const generatedAt = request.data.generatedAt;
-  return fingerprintProjectSnapshotJson(json, typeof generatedAt === "string" ? generatedAt : "");
-}
-serveGzipStageWorker((request) => ({
-  id: request.id,
-  generation: request.generation,
-  stagePath: request.stagePath
-}), {
-  semanticFingerprint: semanticSnapshotFingerprint,
-  skipIfFingerprints: (request) => request.priorFingerprints
-});