@duckmind/dm-linux-x64 0.63.9 → 0.64.6

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

@@ -0,0 +1,30 @@
+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/clients/review-graph/git-identity.js

@@ -0,0 +1,111 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { BoundedLruCache } from "../bounded-cache.js";
+import { normalizeFilePath, walkUpDirs } from "../path-utils.js";
+const _gitDirCache = new BoundedLruCache(32);
+export function _resetGitIdentityCacheForTests() {
+  _gitDirCache.clear();
+}
+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) {
+  const key = normalizeFilePath(path.resolve(cwd));
+  if (_gitDirCache.has(key))
+    return _gitDirCache.get(key) ?? null;
+  let resolved;
+  try {
+    resolved = resolveGitDir(cwd);
+  } catch {
+    resolved = null;
+  }
+  _gitDirCache.set(key, resolved);
+  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/clients/review-graph/import-resolvers.js

@@ -0,0 +1,328 @@
+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"]);
+}
+export 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/clients/review-graph/persist-worker.js

@@ -0,0 +1,10 @@
+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/clients/review-graph/query.js

@@ -0,0 +1,199 @@
+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/clients/review-graph/revision-drift.js

@@ -0,0 +1,3 @@
+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.";
+}