@duckmind/dm-linux-x64 0.66.0 → 0.66.2

package/extensions/dm-lens/dist/clients/review-graph/format.js

@@ -1,30 +0,0 @@
-import * as path from "node:path";
-const MAX_SYMBOLS = 5;
-function displayList(items, maxFiles, map) {
-  return items.slice(0, maxFiles).map((item) => map ? map(item) : item);
-}
-export function formatImpactCascade(result, maxFiles = 4) {
-  if (result.changedSymbols.length === 0 && result.neighborFiles.length === 0 && result.riskFlags.length === 0) {
-    return;
-  }
-  const lines = ["\uD83D\uDD78️ Impact cascade from edited file:"];
-  if (result.changedSymbols.length > 0) {
-    const shown = result.changedSymbols.slice(0, MAX_SYMBOLS);
-    const suffix = result.changedSymbols.length > shown.length ? ` (+${result.changedSymbols.length - shown.length} more)` : "";
-    lines.push(`Changed symbols: ${shown.join(", ")}${suffix}`);
-  }
-  if (result.directImporters.length > 0) {
-    lines.push(`Direct importers: ${displayList(result.directImporters, maxFiles, (item) => path.basename(item)).join(", ")}`);
-  }
-  if (result.directCallers.length > 0) {
-    lines.push(`Direct callers: ${displayList(result.directCallers, maxFiles, (item) => path.basename(item)).join(", ")}`);
-  }
-  if (result.neighborFiles.length > 0) {
-    lines.push(`Check next: ${displayList(result.neighborFiles, maxFiles, (item) => path.basename(item)).join(", ")}`);
-  }
-  if (result.riskFlags.length > 0) {
-    lines.push(`Risk: ${result.riskFlags.join(", ")}`);
-  }
-  return lines.join(`
-`);
-}

package/extensions/dm-lens/dist/clients/review-graph/git-identity.js

@@ -1,115 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { normalizeFilePath, walkUpDirs } from "../path-utils.js";
-export function createGitIdentityResolver() {
-  const memo = new Map;
-  return (cwd) => {
-    if (memo.has(cwd))
-      return memo.get(cwd);
-    const identity = resolveGitIdentity(cwd);
-    memo.set(cwd, identity);
-    return identity;
-  };
-}
-export function _resetGitIdentityCacheForTests() {
-  return;
-}
-function readCommonDir(gitDir) {
-  try {
-    const raw = fs.readFileSync(path.join(gitDir, "commondir"), "utf-8").trim();
-    if (!raw)
-      return gitDir;
-    return path.isAbsolute(raw) ? raw : path.resolve(gitDir, raw);
-  } catch {
-    return gitDir;
-  }
-}
-function resolveGitDir(cwd) {
-  for (const dir of walkUpDirs(cwd)) {
-    const gitPath = path.join(dir, ".git");
-    let stat;
-    try {
-      stat = fs.statSync(gitPath);
-    } catch {
-      continue;
-    }
-    if (stat.isDirectory()) {
-      return {
-        gitDir: gitPath,
-        commonDir: readCommonDir(gitPath),
-        worktreeRoot: dir
-      };
-    }
-    if (stat.isFile()) {
-      try {
-        const contents = fs.readFileSync(gitPath, "utf-8").trim();
-        const match = contents.match(/^gitdir:\s*(.+)$/);
-        if (!match)
-          return null;
-        const linkedGitDir = path.isAbsolute(match[1]) ? match[1] : path.resolve(dir, match[1]);
-        if (!fs.statSync(linkedGitDir).isDirectory())
-          return null;
-        return {
-          gitDir: linkedGitDir,
-          commonDir: readCommonDir(linkedGitDir),
-          worktreeRoot: dir
-        };
-      } catch {
-        return null;
-      }
-    }
-    return null;
-  }
-  return null;
-}
-function getResolvedGitDir(cwd) {
-  let resolved;
-  try {
-    resolved = resolveGitDir(cwd);
-  } catch {
-    resolved = null;
-  }
-  return resolved;
-}
-function resolveRefToSha(commonDir, ref) {
-  try {
-    const loose = fs.readFileSync(path.join(commonDir, ref), "utf-8").trim();
-    if (loose)
-      return loose;
-  } catch {}
-  try {
-    const packed = fs.readFileSync(path.join(commonDir, "packed-refs"), "utf-8");
-    for (const line of packed.split(`
-`)) {
-      if (line.startsWith("#") || line.startsWith("^") || !line.trim())
-        continue;
-      const [sha, packedRef] = line.trim().split(/\s+/, 2);
-      if (packedRef === ref)
-        return sha;
-    }
-  } catch {}
-  return null;
-}
-export function resolveGitIdentity(cwd) {
-  try {
-    const resolved = getResolvedGitDir(cwd);
-    if (!resolved)
-      return;
-    const headRaw = fs.readFileSync(path.join(resolved.gitDir, "HEAD"), "utf-8").trim();
-    const refMatch = headRaw.match(/^ref:\s*(.+)$/);
-    let headCommit;
-    if (refMatch) {
-      headCommit = resolveRefToSha(resolved.commonDir, refMatch[1].trim());
-    } else {
-      headCommit = /^[0-9a-f]{7,40}$/i.test(headRaw) ? headRaw : null;
-    }
-    if (!headCommit)
-      return;
-    return {
-      headCommit,
-      worktreeRoot: normalizeFilePath(resolved.worktreeRoot)
-    };
-  } catch {
-    return;
-  }
-}

package/extensions/dm-lens/dist/clients/review-graph/import-resolvers.js

@@ -1,325 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { normalizeMapKey } from "../path-utils.js";
-import { aliasedImportTargets, referencedProjectImportTarget } from "./tsconfig-paths.js";
-import { buildModuleGraph } from "./workspace-modules.js";
-function isWithin(cwd, p) {
-  const root = path.resolve(cwd);
-  const rp = path.resolve(p);
-  return rp === root || rp.startsWith(root + path.sep);
-}
-function isFile(p) {
-  try {
-    return fs.statSync(p).isFile();
-  } catch {
-    return false;
-  }
-}
-function isDir(p) {
-  try {
-    return fs.statSync(p).isDirectory();
-  } catch {
-    return false;
-  }
-}
-function firstExistingFile(cwd, candidates) {
-  for (const c of candidates) {
-    if (isWithin(cwd, c) && isFile(c))
-      return [normalizeMapKey(c)];
-  }
-  return [];
-}
-function sourceFilesIn(cwd, dir, ext) {
-  if (!isWithin(cwd, dir) || !isDir(dir))
-    return [];
-  try {
-    return fs.readdirSync(dir).filter((n) => n.endsWith(ext)).map((n) => normalizeMapKey(path.join(dir, n))).sort();
-  } catch {
-    return [];
-  }
-}
-function resolveRelative(cwd, filePath, source, exts) {
-  const base = path.resolve(path.dirname(filePath), source);
-  return firstExistingFile(cwd, [base, ...exts.map((e) => base + e)]);
-}
-function resolveDart(cwd, filePath, source) {
-  if (source.startsWith("package:") || source.startsWith("dart:"))
-    return [];
-  return resolveRelative(cwd, filePath, source, [".dart"]);
-}
-const JS_TS_EXT_RE = /\.(mjs|cjs|mts|cts|jsx?|tsx?)$/i;
-function jsTsExtensionCandidates(base, strippedBase, ext) {
-  const candidates = [];
-  if (ext === ".mjs")
-    candidates.push(`${strippedBase}.mts`);
-  if (ext === ".cjs")
-    candidates.push(`${strippedBase}.cts`);
-  if (ext === ".mts")
-    candidates.push(`${strippedBase}.mts`);
-  if (ext === ".cts")
-    candidates.push(`${strippedBase}.cts`);
-  candidates.push(`${strippedBase}.ts`, `${strippedBase}.tsx`, `${strippedBase}.mts`, `${strippedBase}.cts`);
-  candidates.push(base, `${strippedBase}.js`, `${strippedBase}.jsx`, `${strippedBase}.mjs`, `${strippedBase}.cjs`);
-  for (const index of [
-    "index.js",
-    "index.tsx",
-    "index.mts",
-    "index.cts",
-    "index.js",
-    "index.jsx",
-    "index.mjs",
-    "index.cjs"
-  ]) {
-    candidates.push(path.join(base, index));
-  }
-  return [...new Set(candidates)];
-}
-export function jsTsCandidatePaths(filePath, source) {
-  const base = path.resolve(path.dirname(filePath), source);
-  const strippedSource = source.replace(JS_TS_EXT_RE, "");
-  const strippedBase = strippedSource === source ? base : path.resolve(path.dirname(filePath), strippedSource);
-  const ext = path.extname(source).toLowerCase();
-  return jsTsExtensionCandidates(base, strippedBase, ext);
-}
-function findWorkspaceModuleForSpecifier(modules, source) {
-  let best;
-  for (const mod of modules) {
-    let subpath;
-    if (source === mod.name)
-      subpath = "";
-    else if (source.startsWith(`${mod.name}/`))
-      subpath = source.slice(mod.name.length + 1);
-    if (subpath === undefined)
-      continue;
-    if (!best || mod.name.length > best.mod.name.length)
-      best = { mod, subpath };
-  }
-  return best;
-}
-function pickExportsMain(exportsField) {
-  if (typeof exportsField === "string")
-    return exportsField;
-  if (!exportsField || typeof exportsField !== "object")
-    return;
-  const obj = exportsField;
-  const dot = obj["."] ?? obj;
-  if (typeof dot === "string")
-    return dot;
-  if (dot && typeof dot === "object") {
-    for (const key of ["import", "require", "default"]) {
-      const v = dot[key];
-      if (typeof v === "string")
-        return v;
-    }
-  }
-  return;
-}
-function workspaceEntryCandidates(pkgRoot) {
-  let main;
-  try {
-    const pkg = JSON.parse(fs.readFileSync(path.join(pkgRoot, "package.json"), "utf-8"));
-    main = pickExportsMain(pkg.exports) ?? pkg.module ?? pkg.main;
-  } catch {}
-  const candidates = [];
-  if (main) {
-    const mainPath = path.resolve(pkgRoot, main);
-    const ext = path.extname(mainPath).toLowerCase();
-    const stripped = mainPath.replace(JS_TS_EXT_RE, "");
-    candidates.push(...jsTsExtensionCandidates(mainPath, stripped, ext));
-  }
-  for (const base of [pkgRoot, path.join(pkgRoot, "src")]) {
-    candidates.push(path.join(base, "index.js"), path.join(base, "index.tsx"), path.join(base, "index.mts"), path.join(base, "index.cts"), path.join(base, "index.js"), path.join(base, "index.jsx"), path.join(base, "index.mjs"), path.join(base, "index.cjs"));
-  }
-  return [...new Set(candidates)];
-}
-function workspaceSubpathCandidates(pkgRoot, subpath) {
-  const base = path.join(pkgRoot, subpath);
-  const strippedSubpath = subpath.replace(JS_TS_EXT_RE, "");
-  const strippedBase = strippedSubpath === subpath ? base : path.join(pkgRoot, strippedSubpath);
-  const ext = path.extname(subpath).toLowerCase();
-  return jsTsExtensionCandidates(base, strippedBase, ext);
-}
-export function resolveAliasedImport(cwd, specifier, importerDir) {
-  for (const target of aliasedImportTargets(specifier, importerDir)) {
-    const ext = path.extname(target).toLowerCase();
-    const stripped = target.replace(JS_TS_EXT_RE, "");
-    const found = firstExistingFile(cwd, jsTsExtensionCandidates(target, stripped, ext));
-    if (found.length)
-      return found;
-  }
-  return [];
-}
-export function resolveProjectReferenceImport(cwd, specifier, importerDir) {
-  const target = referencedProjectImportTarget(specifier, importerDir);
-  return target ? firstExistingFile(cwd, [target]) : [];
-}
-export function resolveWorkspacePackageImport(cwd, source) {
-  if (source.startsWith("."))
-    return [];
-  const graph = buildModuleGraph(cwd);
-  if (!graph)
-    return [];
-  const match = findWorkspaceModuleForSpecifier(graph.modules.values(), source);
-  if (!match)
-    return [];
-  const candidates = match.subpath ? workspaceSubpathCandidates(match.mod.root, match.subpath) : workspaceEntryCandidates(match.mod.root);
-  return firstExistingFile(cwd, candidates);
-}
-function resolveJsTs(cwd, filePath, source) {
-  if (!source.startsWith(".")) {
-    const aliased = resolveAliasedImport(cwd, source, path.dirname(filePath));
-    if (aliased.length)
-      return aliased;
-    const referenced = resolveProjectReferenceImport(cwd, source, path.dirname(filePath));
-    return referenced.length ? referenced : resolveWorkspacePackageImport(cwd, source);
-  }
-  return firstExistingFile(cwd, jsTsCandidatePaths(filePath, source));
-}
-function resolveCxx(cwd, filePath, source) {
-  if (source.startsWith("<"))
-    return [];
-  const dir = path.dirname(path.resolve(filePath));
-  return firstExistingFile(cwd, [
-    path.resolve(dir, source),
-    path.resolve(cwd, source),
-    path.resolve(cwd, "include", source),
-    path.resolve(cwd, "src", source)
-  ]);
-}
-function pythonRoots(cwd, fileDir) {
-  let p = fileDir;
-  const root = path.resolve(cwd);
-  while (isWithin(cwd, p) && isFile(path.join(p, "__init__.py"))) {
-    const parent = path.dirname(p);
-    if (parent === p)
-      break;
-    p = parent;
-  }
-  const roots = new Set([p, root, path.join(root, "src")]);
-  return [...roots].filter((r) => isDir(r));
-}
-function resolvePython(cwd, filePath, source) {
-  const fileDir = path.dirname(path.resolve(filePath));
-  if (source.startsWith(".")) {
-    const m = source.match(/^(\.+)(.*)$/);
-    if (!m)
-      return [];
-    const dots = m[1].length;
-    let baseDir = fileDir;
-    for (let i = 1;i < dots; i++)
-      baseDir = path.dirname(baseDir);
-    const rest = m[2] ? m[2].split(".") : [];
-    const target = path.join(baseDir, ...rest);
-    return firstExistingFile(cwd, [
-      `${target}.py`,
-      path.join(target, "__init__.py")
-    ]);
-  }
-  const parts = source.split(".");
-  for (const root of pythonRoots(cwd, fileDir)) {
-    const target = path.join(root, ...parts);
-    const found = firstExistingFile(cwd, [
-      `${target}.py`,
-      path.join(target, "__init__.py")
-    ]);
-    if (found.length)
-      return found;
-  }
-  return [];
-}
-function findGoModule(cwd, filePath) {
-  let dir = path.dirname(path.resolve(filePath));
-  const root = path.resolve(cwd);
-  while (true) {
-    try {
-      const content = fs.readFileSync(path.join(dir, "go.mod"), "utf-8");
-      const m = content.match(/^\s*module\s+(\S+)/m);
-      if (m)
-        return { moduleDir: dir, modulePath: m[1] };
-    } catch {}
-    if (dir === root)
-      break;
-    const parent = path.dirname(dir);
-    if (parent === dir || !isWithin(cwd, parent))
-      break;
-    dir = parent;
-  }
-  return null;
-}
-function resolveGo(cwd, filePath, source) {
-  const mod = findGoModule(cwd, filePath);
-  if (!mod)
-    return [];
-  if (source !== mod.modulePath && !source.startsWith(`${mod.modulePath}/`)) {
-    return [];
-  }
-  const rel = source === mod.modulePath ? "" : source.slice(mod.modulePath.length + 1);
-  return sourceFilesIn(cwd, path.join(mod.moduleDir, rel), ".go");
-}
-function javaSourceRoots(cwd, filePath) {
-  const root = path.resolve(cwd);
-  const roots = new Set;
-  for (const c of ["src/main/java", "src/test/java", "src", ""]) {
-    roots.add(path.join(root, c));
-  }
-  let p = path.dirname(path.resolve(filePath));
-  while (true) {
-    roots.add(p);
-    if (p === root)
-      break;
-    const parent = path.dirname(p);
-    if (parent === p || !isWithin(cwd, parent))
-      break;
-    p = parent;
-  }
-  return [...roots].filter((r) => isDir(r));
-}
-function resolveJava(cwd, filePath, source) {
-  const parts = source.split(".");
-  for (const root of javaSourceRoots(cwd, filePath)) {
-    const asFile = firstExistingFile(cwd, [
-      `${path.join(root, ...parts)}.java`
-    ]);
-    if (asFile.length)
-      return asFile;
-    const asPkg = sourceFilesIn(cwd, path.join(root, ...parts), ".java");
-    if (asPkg.length)
-      return asPkg;
-    if (parts.length > 1) {
-      const dropLast = firstExistingFile(cwd, [
-        `${path.join(root, ...parts.slice(0, -1))}.java`
-      ]);
-      if (dropLast.length)
-        return dropLast;
-    }
-  }
-  return [];
-}
-export function resolveImportToFiles(cwd, filePath, languageId, source) {
-  switch (languageId) {
-    case "typescript":
-    case "tsx":
-    case "javascript":
-    case "jsts":
-      return resolveJsTs(cwd, filePath, source);
-    case "c":
-    case "cpp":
-      return resolveCxx(cwd, filePath, source);
-    case "ruby":
-      return resolveRelative(cwd, filePath, source, [".rb"]);
-    case "zig":
-      return resolveRelative(cwd, filePath, source, [".zig"]);
-    case "bash":
-      return resolveRelative(cwd, filePath, source, [".sh", ".bash"]);
-    case "dart":
-      return resolveDart(cwd, filePath, source);
-    case "python":
-      return resolvePython(cwd, filePath, source);
-    case "go":
-      return resolveGo(cwd, filePath, source);
-    case "java":
-      return resolveJava(cwd, filePath, source);
-    default:
-      return [];
-  }
-}

package/extensions/dm-lens/dist/clients/review-graph/persist-worker.js

@@ -1,8 +0,0 @@
-import { serveGzipStageWorker } from "../gzip-stage-write.js";
-serveGzipStageWorker((request) => ({
-  id: request.id,
-  cwd: request.cwd,
-  generation: request.generation,
-  stagePath: request.stagePath,
-  elements: request.elements
-}));

package/extensions/dm-lens/dist/clients/review-graph/query.js

@@ -1,195 +0,0 @@
-import { detectFileRole } from "../file-role.js";
-import { normalizeMapKey } from "../path-utils.js";
-import { findModuleForPath, getDownstreamModules, getModuleSourceFiles } from "./workspace-modules.js";
-function dedupe(items) {
-  return [...new Set(items)].sort((a, b) => a.localeCompare(b));
-}
-function filePathFromNode(graph, nodeId) {
-  return graph.nodes.get(nodeId)?.filePath;
-}
-function collectIncomingEdges(graph, nodeIds, kind) {
-  const edges = [];
-  for (const nodeId of nodeIds) {
-    for (const edge of graph.edgesByTo.get(nodeId) ?? []) {
-      if (edge.kind === kind)
-        edges.push(edge);
-    }
-  }
-  return edges;
-}
-const DEFAULT_IMPACT_RELATIONS = [
-  "calls",
-  "references",
-  "imports"
-];
-export function computeTransitiveImpact(graph, seedFile, options) {
-  const normalized = normalizeMapKey(seedFile);
-  const maxDepth = Math.max(1, options?.maxDepth ?? 3);
-  const maxHits = Math.max(1, options?.maxHits ?? 200);
-  const relations = new Set(options?.relations ?? DEFAULT_IMPACT_RELATIONS);
-  const seeds = [...graph.symbolNodesByFile.get(normalized) ?? []];
-  const fileNodeId = graph.fileNodes.get(normalized);
-  if (fileNodeId)
-    seeds.push(fileNodeId);
-  const visited = new Set(seeds);
-  let frontier = seeds.map((id) => ({ id, depth: 0 }));
-  const hits = [];
-  let maxDepthReached = 0;
-  for (let depth = 0;depth < maxDepth && frontier.length > 0; depth += 1) {
-    const next = [];
-    for (const node of frontier) {
-      for (const edge of graph.edgesByTo.get(node.id) ?? []) {
-        if (!relations.has(edge.kind))
-          continue;
-        if (visited.has(edge.from))
-          continue;
-        if (hits.length >= maxHits) {
-          return {
-            seedFile: normalized,
-            hits,
-            truncated: true,
-            maxDepthReached
-          };
-        }
-        visited.add(edge.from);
-        const dependent = graph.nodes.get(edge.from);
-        const hitDepth = node.depth + 1;
-        maxDepthReached = Math.max(maxDepthReached, hitDepth);
-        hits.push({
-          symbol: dependent?.symbolName ?? "",
-          file: dependent?.filePath ?? "",
-          depth: hitDepth,
-          relation: edge.kind
-        });
-        next.push({ id: edge.from, depth: hitDepth });
-      }
-    }
-    frontier = next;
-  }
-  return { seedFile: normalized, hits, truncated: false, maxDepthReached };
-}
-function describeMissingNode(graph, normalizedFile) {
-  const lastSlash = normalizedFile.lastIndexOf("/");
-  const dir = lastSlash === -1 ? "" : normalizedFile.slice(0, lastSlash);
-  const base = normalizedFile.slice(lastSlash + 1);
-  const stem = base.replace(/\.[^./]*$/, "");
-  let sameDirFileCount = 0;
-  let sameDirSibling;
-  let sameStemTwin;
-  for (const known of graph.fileNodes.keys()) {
-    const knownLastSlash = known.lastIndexOf("/");
-    const knownDir = knownLastSlash === -1 ? "" : known.slice(0, knownLastSlash);
-    const knownBase = known.slice(knownLastSlash + 1);
-    if (knownDir === dir) {
-      sameDirFileCount += 1;
-      sameDirSibling ??= known;
-      if (sameStemTwin === undefined && knownBase.replace(/\.[^./]*$/, "") === stem) {
-        sameStemTwin = known;
-      }
-    }
-  }
-  return {
-    soughtNodeId: `file:${normalizedFile}`,
-    graphFileCount: graph.fileNodes.size,
-    symbolNodeCount: graph.symbolNodesByFile.get(normalizedFile)?.length ?? 0,
-    sameDirFileCount,
-    nearestFile: sameStemTwin ?? sameDirSibling
-  };
-}
-export function computeImpactCascade(graph, changedFile, moduleGraph) {
-  const normalizedFile = normalizeMapKey(changedFile);
-  const fileNodeId = graph.fileNodes.get(normalizedFile);
-  if (!fileNodeId) {
-    if (detectFileRole(normalizedFile) === "test") {
-      return {
-        filePath: normalizedFile,
-        changedSymbols: [],
-        directImporters: [],
-        directCallers: [],
-        neighborFiles: [],
-        riskFlags: [],
-        indeterminate: {
-          reason: "excluded_by_role",
-          detail: "test-role file — excluded from the review graph by design (#260)"
-        }
-      };
-    }
-    return {
-      filePath: normalizedFile,
-      changedSymbols: [],
-      directImporters: [],
-      directCallers: [],
-      neighborFiles: [],
-      riskFlags: [],
-      indeterminate: {
-        reason: "missing_node",
-        diagnostic: describeMissingNode(graph, normalizedFile)
-      }
-    };
-  }
-  const changedSymbols = graph.changedSymbolsByFile.get(normalizedFile) ?? [];
-  const symbolNodeIds = (graph.symbolNodesByFile.get(normalizedFile) ?? []).filter((nodeId) => {
-    const symbolName = graph.nodes.get(nodeId)?.symbolName;
-    return !changedSymbols.length || symbolName && changedSymbols.includes(symbolName);
-  });
-  const effectiveSymbolNodeIds = symbolNodeIds.length > 0 ? symbolNodeIds : graph.symbolNodesByFile.get(normalizedFile) ?? [];
-  const importerFiles = dedupe((graph.edgesByTo.get(fileNodeId) ?? []).filter((edge) => edge.kind === "imports").flatMap((edge) => filePathFromNode(graph, edge.from) ?? []));
-  let callerFiles = dedupe(collectIncomingEdges(graph, effectiveSymbolNodeIds, "calls").flatMap((edge) => filePathFromNode(graph, edge.from) ?? []));
-  if (callerFiles.length === 0 && changedSymbols.length > 0 && importerFiles.length > 0) {
-    callerFiles = importerFiles;
-  }
-  const referenceFiles = dedupe(collectIncomingEdges(graph, effectiveSymbolNodeIds, "references").flatMap((edge) => filePathFromNode(graph, edge.from) ?? []));
-  let neighborFiles = dedupe([
-    ...importerFiles,
-    ...callerFiles,
-    ...referenceFiles
-  ]).filter((candidate) => normalizeMapKey(candidate) !== normalizedFile);
-  const downstreamModuleFiles = [];
-  if (moduleGraph) {
-    const changedModule = findModuleForPath(moduleGraph, normalizedFile);
-    if (changedModule) {
-      const downstream = getDownstreamModules(moduleGraph, changedModule.name);
-      for (const depName of downstream) {
-        const depMod = moduleGraph.modules.get(depName);
-        if (depMod) {
-          downstreamModuleFiles.push(...getModuleSourceFiles(depMod.root));
-        }
-      }
-    }
-  }
-  if (downstreamModuleFiles.length > 0) {
-    neighborFiles = dedupe([...neighborFiles, ...downstreamModuleFiles]);
-  }
-  const directImports = dedupe((graph.edgesByFrom.get(fileNodeId) ?? []).filter((edge) => edge.kind === "imports").flatMap((edge) => filePathFromNode(graph, edge.to) ?? []));
-  const riskFlags = new Set;
-  for (const nodeId of effectiveSymbolNodeIds) {
-    const node = graph.nodes.get(nodeId);
-    if (!node)
-      continue;
-    if (node.exported)
-      riskFlags.add("exported symbol changed");
-    const fanout = (graph.edgesByFrom.get(nodeId) ?? []).filter((edge) => edge.kind === "calls").length;
-    if (fanout >= 4)
-      riskFlags.add("high fanout");
-    const complexity = Number(node.metadata?.cyclomaticComplexity ?? 0);
-    if (complexity >= 8)
-      riskFlags.add("high complexity");
-    if (node.metadata?.isBoundaryWrapper)
-      riskFlags.add("boundary wrapper changed");
-  }
-  if (importerFiles.some((file) => directImports.includes(file))) {
-    riskFlags.add("cycle-adjacent file");
-  }
-  const riskFlagList = dedupe(riskFlags);
-  if (downstreamModuleFiles.length > 0) {
-    riskFlagList.push(`${downstreamModuleFiles.length} downstream module file(s)`);
-  }
-  return {
-    filePath: normalizedFile,
-    changedSymbols,
-    directImporters: importerFiles,
-    directCallers: callerFiles,
-    neighborFiles,
-    riskFlags: riskFlagList
-  };
-}

package/extensions/dm-lens/dist/clients/review-graph/revision-drift.js

@@ -1,3 +0,0 @@
-export function formatReviewGraphRevisionDriftNote(drift) {
-  return `Graph was built at commit ${drift.stampedHead.slice(0, 8)}; HEAD is now ` + `${drift.currentHead.slice(0, 8)}. Results below reflect the earlier ` + "revision — run dmlens_rebuild or re-analyze to refresh.";
-}