@renzrollon/interlock 1.4.2 → 1.5.1

package/lib/graph/extract/csharp.mjs

@@ -0,0 +1,206 @@
+/**
+ * Regex-based C# extractor. Line-oriented, no parser: type declarations as
+ * exports, plus a `csharp` record (namespaces, using directives, types,
+ * identifiers, tests) that `graph/link-csharp.mjs` links across files.
+ *
+ * Known limits: nesting is not tracked, and a declaration-shaped line inside a
+ * verbatim or raw string literal reads as a declaration.
+ */
+
+const COMMENT_LINE_RE = /^[ \t]*(?:\/\/|\*|\/\*)/;
+const NAMESPACE_RE = /^[ \t]*namespace[ \t]+([A-Za-z_][\w.]*)/;
+const USING_RE =
+  /^[ \t]*(?:global[ \t]+)?using[ \t]+(?:static[ \t]+)?(?:[A-Za-z_]\w*[ \t]*=[ \t]*)?(?:global::)?([A-Za-z_][\w.]*)(?:<[^;]*>)?[ \t]*;/;
+const MODIFIERS =
+  '(?:(?:public|private|protected|internal|static|sealed|abstract|partial|readonly|unsafe|new|file|ref|required|virtual)[ \\t]+)*';
+const TYPE_RE = new RegExp(
+  `^[ \\t]*(?:\\[[^\\]\\n]*\\][ \\t]*)*${MODIFIERS}(class|record(?:[ \\t]+(?:class|struct))?|struct|interface|enum)[ \\t]+@?([A-Za-z_]\\w*)`,
+);
+const IDENT_RE = /[A-Za-z_][A-Za-z0-9_]*/g;
+const TEST_ATTRIBUTES = new Set(['Fact', 'Theory', 'Test', 'TestCase', 'TestMethod', 'DataTestMethod']);
+const MAX_GROUP_CHARS = 4000;
+
+/** Index of the end of a string or char literal starting at `i`, inclusive. */
+function skipLiteral(text, i) {
+  const quote = text[i];
+  const verbatim = quote === '"' && text[i - 1] === '@';
+  for (let j = i + 1; j < text.length; j += 1) {
+    const c = text[j];
+    if (verbatim) {
+      if (c === '"') {
+        if (text[j + 1] === '"') j += 1;
+        else return j;
+      }
+    } else if (c === '\\') {
+      j += 1;
+    } else if (c === quote || c === '\n') {
+      return j;
+    }
+  }
+  return text.length - 1;
+}
+
+/**
+ * Read the `[...]` group opening at `pos`. Returns the index of its closing
+ * bracket and the names of the attributes at its top level, or null when it
+ * does not close within a plausible span.
+ */
+function scanGroup(text, pos) {
+  let depth = 0;
+  const names = [];
+  let segmentStart = pos + 1;
+  const flush = (end) => {
+    const seg = text.slice(segmentStart, end).trim();
+    const m = /^(?:[A-Za-z_]\w*[ \t]*:(?!:)[ \t]*)?([A-Za-z_][\w.]*)/.exec(seg);
+    if (!m) return;
+    let name = m[1].split('.').pop();
+    if (name.endsWith('Attribute') && name.length > 'Attribute'.length) name = name.slice(0, -'Attribute'.length);
+    names.push(name);
+  };
+  for (let i = pos; i < text.length && i - pos < MAX_GROUP_CHARS; i += 1) {
+    const c = text[i];
+    if (c === '"' || c === "'") {
+      i = skipLiteral(text, i);
+    } else if (c === '[' || c === '(' || c === '{') {
+      depth += 1;
+    } else if (c === ']' || c === ')' || c === '}') {
+      depth -= 1;
+      if (depth === 0 && c === ']') {
+        flush(i);
+        return { end: i, names };
+      }
+      if (depth <= 0) return null;
+    } else if (c === ',' && depth === 1) {
+      flush(i);
+      segmentStart = i + 1;
+    }
+  }
+  return null;
+}
+
+function lastLineOf(source, lines) {
+  return source.endsWith('\n') ? lines.length - 1 : lines.length;
+}
+
+/**
+ * @param {string} filePath relative posix path
+ * @param {string} source
+ */
+export function extractCsharp(filePath, source) {
+  const exports = [];
+  const namespaces = [];
+  const usings = [];
+  const types = [];
+  const identifierLines = new Map();
+
+  const lines = source.split(/\r?\n/);
+  const lineStarts = [];
+  {
+    let off = 0;
+    for (const raw of source.split('\n')) {
+      lineStarts.push(off);
+      off += raw.length + 1;
+    }
+  }
+  const lineAt = (offset) => {
+    let lo = 0;
+    let hi = lineStarts.length - 1;
+    while (lo < hi) {
+      const mid = (lo + hi + 1) >> 1;
+      if (lineStarts[mid] <= offset) lo = mid;
+      else hi = mid - 1;
+    }
+    return lo + 1;
+  };
+
+  const isComment = lines.map((l) => COMMENT_LINE_RE.test(l));
+
+  for (let i = 0; i < lines.length; i += 1) {
+    if (isComment[i]) continue;
+    const text = lines[i];
+    const line = i + 1;
+
+    let m = NAMESPACE_RE.exec(text);
+    if (m) {
+      namespaces.push({ name: m[1], line });
+    } else if ((m = USING_RE.exec(text))) {
+      usings.push({ name: m[1], line });
+    } else if ((m = TYPE_RE.exec(text))) {
+      const name = m[2];
+      const kind = m[1].split(/\s+/)[0];
+      exports.push({ name, kind, line, confidence: 'EXTRACTED' });
+      let ns = '';
+      for (const n of namespaces) if (n.line <= line) ns = n.name;
+      types.push({ name, line, namespace: ns });
+    }
+
+    IDENT_RE.lastIndex = 0;
+    let im;
+    while ((im = IDENT_RE.exec(text))) {
+      const seen = identifierLines.get(im[0]);
+      if (!seen) identifierLines.set(im[0], [line]);
+      else if (seen[seen.length - 1] !== line) seen.push(line);
+    }
+  }
+  const identifiers = Object.fromEntries(identifierLines);
+
+  // Tests: an attribute stack whose top-level names include a test attribute,
+  // followed by a method signature.
+  const found = [];
+  for (let i = 0; i < lines.length; i += 1) {
+    if (isComment[i] || !/^[ \t]*\[/.test(lines[i])) continue;
+    let p = lineStarts[i] + lines[i].search(/\S/);
+    let testLine = 0;
+    let groups = 0;
+    for (;;) {
+      while (p < source.length && /\s/.test(source[p])) p += 1;
+      if (source.startsWith('//', p)) {
+        const nl = source.indexOf('\n', p);
+        p = nl === -1 ? source.length : nl;
+        continue;
+      }
+      if (source[p] !== '[') break;
+      const g = scanGroup(source, p);
+      if (!g) break;
+      groups += 1;
+      if (!testLine && g.names.some((n) => TEST_ATTRIBUTES.has(n))) testLine = lineAt(p);
+      p = g.end + 1;
+    }
+    if (groups === 0) continue;
+    const sigLine = lineAt(Math.min(p, source.length - 1));
+    i = Math.max(i, sigLine - 1);
+    if (!testLine) continue;
+
+    const head = source.slice(p, p + 300);
+    const paren = head.indexOf('(');
+    if (paren === -1) continue;
+    const before = head.slice(0, paren);
+    if (/[;{}=]/.test(before) || /\b(?:class|struct|interface|enum|record|namespace)\b/.test(before)) continue;
+    const nm = /([A-Za-z_]\w*)$/.exec(before.replace(/<[^<>()]*(?:<[^<>()]*>[^<>()]*)*>\s*$/, '').trimEnd());
+    if (!nm) continue;
+    found.push({ name: nm[1], line: sigLine, start: testLine });
+  }
+
+  found.sort((a, b) => a.start - b.start);
+  const lastLine = lastLineOf(source, lines);
+  const tests = found.map((t, idx) => {
+    let type = '';
+    for (const ty of types) if (ty.line < t.start) type = ty.name;
+    const next = found[idx + 1];
+    return {
+      type,
+      name: t.name,
+      line: t.line,
+      start: t.start,
+      end: next ? next.start - 1 : lastLine,
+    };
+  });
+
+  return {
+    filePath,
+    imports: [],
+    exports,
+    references: [],
+    csharp: { namespaces, usings, types, identifiers, tests },
+  };
+}

package/lib/graph/extract/csproj.mjs

@@ -0,0 +1,42 @@
+/**
+ * Regex-based .csproj extractor: one `imports` entry per <ProjectReference Include>.
+ * The Include value is emitted as written (separators, `$(...)` and all);
+ * `resolveImport` normalizes it to a project identity.
+ */
+
+const PROJECT_REFERENCE_RE =
+  /<ProjectReference\b[^>]*?\bInclude\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+
+/** Blank out XML comments, keeping every newline so line numbers hold. */
+function blankComments(source) {
+  return source.replace(/<!--[\s\S]*?-->/g, (m) => m.replace(/[^\n]/g, ' '));
+}
+
+function lineOf(text, index) {
+  let line = 1;
+  for (let i = text.indexOf('\n'); i !== -1 && i < index; i = text.indexOf('\n', i + 1)) line += 1;
+  return line;
+}
+
+/**
+ * @param {string} filePath relative posix path
+ * @param {string} source
+ */
+export function extractCsproj(filePath, source) {
+  const imports = [];
+  const text = blankComments(source);
+  PROJECT_REFERENCE_RE.lastIndex = 0;
+  let m;
+  while ((m = PROJECT_REFERENCE_RE.exec(text))) {
+    const from = (m[1] ?? m[2] ?? '').trim();
+    if (!from) continue;
+    imports.push({
+      from,
+      imported: null,
+      local: null,
+      line: lineOf(text, m.index),
+      confidence: 'EXTRACTED',
+    });
+  }
+  return { filePath, imports, exports: [], references: [] };
+}

package/lib/graph/extract/memory.mjs

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { rel } from '../paths.mjs';
+import { readIndexed, rel } from '../paths.mjs';
 import { walkMarkdown } from './walk.mjs';
 
 const COUPLE_RE =
@@ -12,11 +12,11 @@ const FILE_PAIR_RE =
 /**
  * Extract memory nodes and coupling edges.
  */
-export function extractMemory(root, knownFiles = new Set()) {
+export function extractMemory(root, knownFiles = new Set(), { skips } = {}) {
   const candidates = [];
   const memRoot = path.join(root, '.claude', 'memory');
   if (fs.existsSync(memRoot)) {
-    candidates.push(...walkMarkdown(root, ['.claude/memory']));
+    candidates.push(...walkMarkdown(root, ['.claude/memory'], { skips }));
   }
   const legacy = path.join(root, '.claude', 'memory.md');
   if (fs.existsSync(legacy)) candidates.push(legacy);
@@ -27,7 +27,12 @@ export function extractMemory(root, knownFiles = new Set()) {
 
   for (const absPath of candidates) {
     const filePath = rel(root, absPath);
-    const text = fs.readFileSync(absPath, 'utf8');
+    const read = readIndexed(absPath);
+    if (!read.ok) {
+      if (skips) skips.add(absPath, read.code);
+      continue;
+    }
+    const text = read.text;
     const id = `memory:${filePath}`;
     if (!seenNodes.has(id)) {
       seenNodes.add(id);

package/lib/graph/extract/openspec.mjs

@@ -1,6 +1,5 @@
-import fs from 'node:fs';
 import path from 'node:path';
-import { rel } from '../paths.mjs';
+import { readIndexed, rel } from '../paths.mjs';
 import { walkMarkdown } from './walk.mjs';
 
 // Any repo-relative path with an extension. Deliberately NOT restricted to a
@@ -16,14 +15,19 @@ const SYMBOL_RE = /`([A-Z][A-Za-z0-9_]{2,})`|\b([A-Z][A-Za-z0-9_]{2,}(?:Service|
 /**
  * Extract OpenSpec artifact nodes and inferred links to code paths/symbols.
  */
-export function extractOpenspec(root, knownSymbols = new Set(), knownFiles = new Set()) {
-  const files = walkMarkdown(root, ['openspec']);
+export function extractOpenspec(root, knownSymbols = new Set(), knownFiles = new Set(), { skips } = {}) {
+  const files = walkMarkdown(root, ['openspec'], { skips });
   const nodes = [];
   const edges = [];
 
   for (const absPath of files) {
     const filePath = rel(root, absPath);
-    const text = fs.readFileSync(absPath, 'utf8');
+    const read = readIndexed(absPath);
+    if (!read.ok) {
+      if (skips) skips.add(absPath, read.code);
+      continue;
+    }
+    const text = read.text;
     const id = `openspec:${filePath}`;
     nodes.push({
       id,

package/lib/graph/extract/walk.mjs

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { rel } from '../paths.mjs';
+import { readIndexed, rel } from '../paths.mjs';
 
 const DEFAULT_SKIP_DIRS = new Set([
   'node_modules',
@@ -39,6 +39,9 @@ const SOURCE_EXTS = new Set([
   '.pyi',
   '.sh',
   '.bash',
+  '.cs',
+  '.csproj',
+  '.bicep',
 ]);
 
 /**
@@ -65,12 +68,24 @@ const CONFIG_JSON_NAMES = new Set([
 
 const CONFIG_JSON_MAX_BYTES = 64 * 1024;
 
-function loadIgnorePatterns(root) {
+function loadIgnorePatterns(root, skips) {
   const patterns = [];
   for (const name of ['.gitignore', '.interlockignore']) {
     const p = path.join(root, name);
     if (!fs.existsSync(p)) continue;
-    for (const line of fs.readFileSync(p, 'utf8').split('\n')) {
+    let text;
+    if (skips) {
+      // An unreadable ignore file contributes no patterns; the walk goes on as if it were absent.
+      const got = readIndexed(p);
+      if (!got.ok) {
+        skips.add(p, got.code, 'its patterns were not applied');
+        continue;
+      }
+      text = got.text;
+    } else {
+      text = fs.readFileSync(p, 'utf8');
+    }
+    for (const line of text.split('\n')) {
       const t = line.trim();
       if (!t || t.startsWith('#')) continue;
       patterns.push(t.replace(/\/$/, ''));
@@ -126,19 +141,26 @@ function shouldSkipDir(root, dir, entName, relPath) {
 
 /**
  * Walk root for source + curated config files. Returns absolute paths.
+ *
+ * `skips` is an optional collector (`createSkips`): with one, a directory that
+ * cannot be listed, a `.json` that cannot be stat'ed and an unreadable ignore
+ * file are recorded instead of passing in silence.
  */
-export function walkSourceFiles(root, { extraSkip = [] } = {}) {
+export function walkSourceFiles(root, { extraSkip = [], skips } = {}) {
   const skipExtra = new Set(extraSkip);
-  const patterns = loadIgnorePatterns(root);
+  const patterns = loadIgnorePatterns(root, skips);
   const out = [];
 
   function visit(dir) {
     let entries;
     try {
       entries = fs.readdirSync(dir, { withFileTypes: true });
-    } catch {
+    } catch (error) {
+      if (skips) skips.add(dir, error);
       return;
     }
+    // A .NET build writes generated sources under bin/ and obj/ next to the project file.
+    const holdsProject = entries.some((e) => e.name.endsWith('.csproj') && !e.isDirectory());
     for (const ent of entries) {
       const full = path.join(dir, ent.name);
       const r = rel(root, full);
@@ -146,6 +168,7 @@ export function walkSourceFiles(root, { extraSkip = [] } = {}) {
         if (skipExtra.has(ent.name) || shouldSkipDir(root, dir, ent.name, r) || ignored(r, patterns)) {
           continue;
         }
+        if (holdsProject && (ent.name === 'bin' || ent.name === 'obj')) continue;
         visit(full);
         continue;
       }
@@ -161,7 +184,8 @@ export function walkSourceFiles(root, { extraSkip = [] } = {}) {
         let size = 0;
         try {
           size = fs.statSync(full).size;
-        } catch {
+        } catch (error) {
+          if (skips) skips.add(full, error);
           continue;
         }
         if (isConfigJson(ent.name, r, size)) out.push(full);
@@ -176,7 +200,7 @@ export function walkSourceFiles(root, { extraSkip = [] } = {}) {
 // Accepts directories or individual markdown files, so callers can mix a docs
 // directory with root-level files such as README.md — on many repos those root
 // files are the only real documentation.
-export function walkMarkdown(root, subdirs) {
+export function walkMarkdown(root, subdirs, { skips } = {}) {
   const out = [];
   for (const sub of subdirs) {
     const base = path.join(root, sub);
@@ -186,24 +210,25 @@ export function walkMarkdown(root, subdirs) {
     } catch {
       continue;
     }
-    if (stat.isDirectory()) walkMd(base, out);
+    if (stat.isDirectory()) walkMd(base, out, skips);
     else if (/\.mdx?$/i.test(base)) out.push(base);
   }
   return [...new Set(out)].sort();
 }
 
-function walkMd(dir, out) {
+function walkMd(dir, out, skips) {
   let entries;
   try {
     entries = fs.readdirSync(dir, { withFileTypes: true });
-  } catch {
+  } catch (error) {
+    if (skips) skips.add(dir, error);
     return;
   }
   for (const ent of entries) {
     const full = path.join(dir, ent.name);
     if (ent.isDirectory()) {
       if (ent.name === 'node_modules' || ent.name === '.git' || ent.name === '__pycache__') continue;
-      walkMd(full, out);
+      walkMd(full, out, skips);
       continue;
     }
     if (ent.isFile() && ent.name.endsWith('.md')) out.push(full);

package/lib/graph/graph/build.mjs

@@ -5,15 +5,17 @@ import { extractOpenspec } from '../extract/openspec.mjs';
 import { extractMemory } from '../extract/memory.mjs';
 import { walkSourceFiles } from '../extract/walk.mjs';
 import {
+  createSkips,
   ensureGraphDir,
   graphPath,
   loadJson,
   manifestPath,
+  readIndexed,
   rel,
   reportPath,
-  sha256File,
   writeJson,
 } from '../paths.mjs';
+import { linkCsharp } from './link-csharp.mjs';
 import { writeReport } from './report.mjs';
 
 function langOf(filePath) {
@@ -21,6 +23,9 @@ function langOf(filePath) {
   if (ext === '.py' || ext === '.pyi') return 'python';
   if (ext === '.sh' || ext === '.bash') return 'shell';
   if (ext === '.json') return 'json';
+  if (ext === '.cs') return 'csharp';
+  if (ext === '.csproj') return 'csproj';
+  if (ext === '.bicep') return 'bicep';
   return 'js';
 }
 
@@ -106,6 +111,34 @@ function resolveJsImport(fromFile, specifier, fileIndex) {
   return { kind: 'unresolved', id: `unresolved:${candidate}`, path: candidate };
 }
 
+/**
+ * A project path is an identity compared in a Set, so it is normalized here and
+ * nowhere else: backslashes become forward slashes and the result is resolved
+ * against the referencing project's directory. A value holding an MSBuild
+ * property, and one that names no walked file, is unresolved — no edge to a
+ * file is invented for it.
+ */
+function resolveCsprojImport(fromFile, specifier, fileIndex) {
+  const spelled = String(specifier).replace(/\\/g, '/');
+  if (spelled.includes('$(') || path.posix.isAbsolute(spelled) || /^[A-Za-z]:\//.test(spelled)) {
+    return { kind: 'unresolved', id: `unresolved:${spelled}`, path: spelled };
+  }
+  const candidate = path.posix.normalize(path.posix.join(path.posix.dirname(fromFile), spelled));
+  if (fileIndex.has(candidate)) return { kind: 'file', id: `file:${candidate}`, path: candidate };
+  return { kind: 'unresolved', id: `unresolved:${candidate}`, path: candidate };
+}
+
+// A registry (`br:`, `br/<alias>:`) or template-spec (`ts:`, `ts/<alias>:`) module reference.
+const BICEP_EXTERNAL_RE = /^(?:br|ts)(?::|\/[^/:]+:)/;
+
+function resolveBicepImport(fromFile, specifier, fileIndex) {
+  const spec = String(specifier);
+  if (BICEP_EXTERNAL_RE.test(spec)) return { kind: 'external', id: `external:${spec}` };
+  const candidate = path.posix.normalize(path.posix.join(path.posix.dirname(fromFile), spec));
+  if (fileIndex.has(candidate)) return { kind: 'file', id: `file:${candidate}`, path: candidate };
+  return { kind: 'unresolved', id: `unresolved:${candidate}`, path: candidate };
+}
+
 /**
  * Resolve an import/require/source specifier against an importing file.
  */
@@ -113,6 +146,11 @@ export function resolveImport(fromFile, specifier, fileIndex) {
   const lang = langOf(fromFile);
   if (lang === 'python') return resolvePythonImport(fromFile, specifier, fileIndex);
   if (lang === 'shell') return resolveShellImport(fromFile, specifier, fileIndex);
+  if (lang === 'csproj') return resolveCsprojImport(fromFile, specifier, fileIndex);
+  if (lang === 'bicep') return resolveBicepImport(fromFile, specifier, fileIndex);
+  // A C# `using` names a namespace, not a path; linkCsharp places it. Nothing
+  // is resolved against the file set here.
+  if (lang === 'csharp') return { kind: 'external', id: `external:${specifier}` };
   if (lang === 'json') {
     // package.json main/bin paths are usually relative to package root
     if (fileIndex.has(specifier)) return { kind: 'file', id: `file:${specifier}`, path: specifier };
@@ -141,17 +179,21 @@ function moduleIdFor(filePath) {
 }
 
 /**
- * Build a full graph for root. Returns { graph, stats, extractorMode }.
+ * Build a full graph for root. Returns { graph, stats, hashes, skipped, extractorMode }.
+ *
+ * `skips` is the command's collector (`createSkips`). A path under the root that
+ * cannot be read is added to it and contributes nothing: no hash, no node, no
+ * edge, and no place in the file set imports resolve against. `skipped` is the
+ * collector's list when the build ends.
  */
-export function buildGraph(root, { fileFilter = null } = {}) {
+export function buildGraph(root, { fileFilter = null, skips = createSkips(root) } = {}) {
   const extractor = createExtractor(root);
-  let files = walkSourceFiles(root);
+  let files = walkSourceFiles(root, { skips });
   if (fileFilter) {
     const allow = new Set(fileFilter);
     files = files.filter((f) => allow.has(rel(root, f)));
   }
 
-  const fileIndex = new Set(files.map((f) => rel(root, f)));
   const nodes = new Map();
   const edges = [];
   const symbolByName = new Map(); // name -> [symbol ids]
@@ -161,11 +203,24 @@ export function buildGraph(root, { fileFilter = null } = {}) {
     if (!nodes.has(node.id)) nodes.set(node.id, node);
   }
 
+  // Read every file once, before anything is resolved: the file set an import
+  // resolves against must hold only what was actually read.
+  const read = [];
   for (const absPath of files) {
     const filePath = rel(root, absPath);
-    hashes[filePath] = sha256File(absPath);
-    const source = fs.readFileSync(absPath, 'utf8');
-    const extracted = extractor.extract(filePath, source);
+    const got = readIndexed(absPath);
+    if (!got.ok) {
+      skips.add(absPath, got.code);
+      continue;
+    }
+    hashes[filePath] = got.sha256;
+    read.push({ filePath, extracted: extractor.extract(filePath, got.text) });
+  }
+  const fileIndex = new Set(read.map((r) => r.filePath));
+  const csharpRecords = [];
+
+  for (const { filePath, extracted } of read) {
+    if (extracted.csharp) csharpRecords.push({ filePath, csharp: extracted.csharp });
 
     addNode({
       id: `file:${filePath}`,
@@ -276,8 +331,14 @@ export function buildGraph(root, { fileFilter = null } = {}) {
     }
   }
 
+  // C# is linked across files: a `using` names a namespace, and a namespace is
+  // declared in many files. External targets it names get their nodes below.
+  const csharp = linkCsharp(csharpRecords);
+  for (const n of csharp.nodes) addNode(n);
+  for (const e of csharp.edges) edges.push(e);
+
   const knownSymbols = new Set(symbolByName.keys());
-  const openspec = extractOpenspec(root, knownSymbols, fileIndex);
+  const openspec = extractOpenspec(root, knownSymbols, fileIndex, { skips });
   for (const n of openspec.nodes) addNode(n);
   for (const e of openspec.edges) {
     if (e.target.startsWith('symbol-name:')) {
@@ -292,7 +353,7 @@ export function buildGraph(root, { fileFilter = null } = {}) {
     }
   }
 
-  const memory = extractMemory(root, fileIndex);
+  const memory = extractMemory(root, fileIndex, { skips });
   for (const n of memory.nodes) addNode(n);
   for (const e of memory.edges) {
     if (nodes.has(e.source) && nodes.has(e.target)) edges.push(e);
@@ -349,18 +410,21 @@ export function buildGraph(root, { fileFilter = null } = {}) {
     extractor: extractor.mode,
   };
 
-  return { graph, stats, hashes, extractorMode: extractor.mode };
+  return { graph, stats, hashes, skipped: skips.list(), extractorMode: extractor.mode };
 }
 
-export function writeGraphArtifacts(root, { graph, stats, hashes }) {
+export function writeGraphArtifacts(root, { graph, stats, hashes, skipped = [] }) {
   ensureGraphDir(root);
   writeJson(graphPath(root), graph);
+  // The manifest keeps the path and the code; a skip's note is said on stderr.
+  const recorded = skipped.map(({ path: skippedPath, code }) => ({ path: skippedPath, code }));
   writeJson(manifestPath(root), {
     built_at: graph.graph.built_at,
     files: hashes,
+    skipped: recorded,
     stats,
   });
-  const report = writeReport(root, graph, stats);
+  const report = writeReport(root, graph, stats, recorded);
   fs.writeFileSync(reportPath(root), report);
   return { graphPath: graphPath(root), reportPath: reportPath(root), stats };
 }