@renzrollon/interlock 1.0.0

package/lib/graph/cli.mjs

@@ -0,0 +1,266 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { buildGraph, loadGraph, writeGraphArtifacts } from './graph/build.mjs';
+import { consumers, explain, findSeedNodes, shortestPath, traverse } from './graph/query.mjs';
+import { updateGraph } from './graph/update.mjs';
+import { writeReport } from './graph/report.mjs';
+import { formatContextResult, retrieveContext } from './retrieve/context.mjs';
+import {
+  DOCS_INDEX_DEFAULT_DIRS,
+  formatDocsIndexSummary,
+  writeDocsIndex,
+} from './retrieve/docs-index.mjs';
+import { formatDocsResult, retrieveMarkdownSections } from './retrieve/markdown.mjs';
+import { graphPath, reportPath, resolveRoot } from './paths.mjs';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+function usage() {
+  return `interlock-graph — lightweight codebase knowledge graph for agents
+
+Usage:
+  interlock-graph build [root]              Build graph into <root>/.claude/graph/
+  interlock-graph update [root]             Incremental rebuild when files change
+  interlock-graph report [root]             Print / regenerate GRAPH_REPORT.md
+  interlock-graph query <q> [options]       Neighborhood query (BFS default)
+  interlock-graph consumers <symbol|file>   Reverse imports / references
+  interlock-graph path <A> <B>              Shortest path
+  interlock-graph explain <node>            Node + neighbors
+  interlock-graph docs <q> [options]        Ranked markdown section excerpts
+  interlock-graph context <q> [options]     Graph subgraph + doc excerpts (default retrieval)
+  interlock-graph docs-index [root]         Deterministic docs/ + openspec/specs TOC → docs-index.json
+  interlock-graph which                     Print CLI path (for skills)
+
+Query options:
+  --budget <n>     Token budget for output (default 1500; docs=800, context=2000)
+  --depth <n>      Traversal depth (default 2)
+  --dfs            Use DFS instead of BFS
+  --root <path>    Project root (default: cwd)
+  --changed <paths> Comma-separated changed file paths (context/docs seeding)
+  --commit-subject <text>  Commit subject for term derivation
+  --dirs <list>    Comma-separated markdown roots (docs/context default: docs,openspec/…; docs-index default: docs,openspec/specs)
+  --graph-budget <n>  Structural slice of context budget
+  --docs-budget <n>   Documentation slice of context budget
+  --write          Write docs-index.json (default for docs-index)
+  --no-write       Print docs-index summary without writing
+
+Examples:
+  interlock-graph build .
+  interlock-graph query AuthService --budget 1500
+  interlock-graph consumers normalizeEmail
+  interlock-graph path lib/auth app/api
+  interlock-graph docs "authentication session" --budget 800
+  interlock-graph context "auth login" --changed lib/auth.ts,app/api/login.ts --budget 2000
+  interlock-graph docs-index . --write
+`;
+}
+
+function parseArgs(argv) {
+  const args = {
+    _: [],
+    budget: null,
+    depth: 2,
+    dfs: false,
+    root: null,
+    changed: [],
+    commitSubject: '',
+    dirs: null,
+    graphBudget: null,
+    docsBudget: null,
+    write: null,
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--budget') args.budget = Number(argv[++i]);
+    else if (a === '--depth') args.depth = Number(argv[++i]);
+    else if (a === '--dfs') args.dfs = true;
+    else if (a === '--root') args.root = argv[++i];
+    else if (a === '--changed') {
+      args.changed.push(...String(argv[++i]).split(',').map((s) => s.trim()).filter(Boolean));
+    } else if (a === '--commit-subject') args.commitSubject = argv[++i];
+    else if (a === '--dirs') args.dirs = String(argv[++i]).split(',').map((s) => s.trim()).filter(Boolean);
+    else if (a === '--graph-budget') args.graphBudget = Number(argv[++i]);
+    else if (a === '--docs-budget') args.docsBudget = Number(argv[++i]);
+    else if (a === '--write') args.write = true;
+    else if (a === '--no-write') args.write = false;
+    else if (a === '-h' || a === '--help') args.help = true;
+    else args._.push(a);
+  }
+  return args;
+}
+
+function defaultBudget(cmd, args) {
+  if (args.budget != null) return args.budget;
+  if (cmd === 'docs') return 800;
+  if (cmd === 'context') return 2000;
+  return 1500;
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help || args._.length === 0) {
+    process.stdout.write(usage());
+    process.exit(args.help || args._.length === 0 ? 0 : 1);
+  }
+
+  const cmd = args._[0];
+  const root = resolveRoot(
+    args.root ||
+      (cmd === 'build' || cmd === 'update' || cmd === 'report' || cmd === 'docs-index'
+        ? args._[1]
+        : null) ||
+      process.cwd(),
+  );
+
+  try {
+    switch (cmd) {
+      case 'which': {
+        process.stdout.write(`${path.join(__dirname, 'cli.mjs')}\n`);
+        break;
+      }
+      case 'build': {
+        const result = buildGraph(root);
+        const written = writeGraphArtifacts(root, result);
+        process.stdout.write(
+          `Built graph → ${written.graphPath}\nReport → ${written.reportPath}\n` +
+            `files=${result.stats.files} nodes=${result.stats.nodes} edges=${result.stats.edges} extractor=${result.stats.extractor}\n`,
+        );
+        // An empty graph is a legitimate outcome — this repo is written in a
+        // language the walker does not structurally index. Saying so is the
+        // difference between "unsupported" and "broken".
+        if (result.stats.files === 0) {
+          process.stdout.write(
+            '\nNo source files were indexed. Structural indexing covers ' +
+              '.ts .tsx .js .jsx .mjs .cjs .py .pyi .sh .bash\n' +
+              'plus curated config JSON. Other languages (Go, Rust, Java, Ruby) ' +
+              'are not structurally indexed yet:\n' +
+              'docs, OpenSpec specs and spec→file links still work, but there ' +
+              'are no import or symbol edges.\n' +
+              'Use `interlock-graph docs` and `interlock-graph docs-index` for ' +
+              'prose retrieval on this repo.\n',
+          );
+        }
+        break;
+      }
+      case 'update': {
+        const result = updateGraph(root);
+        if (!result.updated) {
+          process.stdout.write(`Graph up to date (${result.reason})\n`);
+        } else {
+          process.stdout.write(
+            `Updated graph (${result.reason})\n` +
+              `files=${result.stats.files} nodes=${result.stats.nodes} edges=${result.stats.edges}\n`,
+          );
+        }
+        break;
+      }
+      case 'report': {
+        const graph = loadGraph(root);
+        const stats = {
+          files: graph.nodes.filter((n) => n.type === 'file').length,
+          nodes: graph.nodes.length,
+          edges: graph.links.length,
+          symbols: graph.nodes.filter((n) => n.type === 'symbol').length,
+          modules: graph.nodes.filter((n) => n.type === 'module').length,
+          extractor: graph.graph?.extractor,
+        };
+        const report = writeReport(root, graph, stats);
+        fs.writeFileSync(reportPath(root), report);
+        process.stdout.write(report);
+        break;
+      }
+      case 'query': {
+        const q = args._.slice(1).join(' ');
+        if (!q) throw new Error('query requires a search string');
+        const graph = loadGraph(root);
+        const seeds = findSeedNodes(graph, q);
+        if (!seeds.length) {
+          process.stdout.write(`No nodes matched: ${q}\n(graph: ${graphPath(root)})\n`);
+          process.exit(1);
+        }
+        process.stdout.write(
+          traverse(graph, seeds, {
+            mode: args.dfs ? 'dfs' : 'bfs',
+            depth: args.depth,
+            budget: defaultBudget('query', args),
+          }),
+        );
+        break;
+      }
+      case 'consumers': {
+        const target = args._.slice(1).join(' ');
+        if (!target) throw new Error('consumers requires a symbol or file');
+        process.stdout.write(consumers(loadGraph(root), target));
+        break;
+      }
+      case 'path': {
+        const a = args._[1];
+        const b = args._[2];
+        if (!a || !b) throw new Error('path requires two endpoints');
+        process.stdout.write(shortestPath(loadGraph(root), a, b));
+        break;
+      }
+      case 'explain': {
+        const q = args._.slice(1).join(' ');
+        if (!q) throw new Error('explain requires a node query');
+        process.stdout.write(explain(loadGraph(root), q));
+        break;
+      }
+      case 'docs': {
+        const q = args._.slice(1).join(' ');
+        if (!q && args.changed.length === 0) throw new Error('docs requires a query or --changed paths');
+        const result = retrieveMarkdownSections(root, {
+          query: q,
+          changedFiles: args.changed,
+          dirs: args.dirs ?? undefined,
+          budget: defaultBudget('docs', args),
+        });
+        process.stdout.write(formatDocsResult(result));
+        if (result.empty) process.exit(1);
+        break;
+      }
+      case 'context': {
+        const q = args._.slice(1).join(' ');
+        if (!q && args.changed.length === 0 && !args.commitSubject) {
+          throw new Error('context requires a query, --changed paths, or --commit-subject');
+        }
+        const result = retrieveContext(root, {
+          query: q,
+          changedFiles: args.changed,
+          commitSubject: args.commitSubject,
+          budget: defaultBudget('context', args),
+          graphBudget: args.graphBudget ?? undefined,
+          docsBudget: args.docsBudget ?? undefined,
+          docsDirs: args.dirs ?? undefined,
+        });
+        process.stdout.write(formatContextResult(result));
+        if (result.empty) process.exit(1);
+        break;
+      }
+      case 'docs-index': {
+        const write = args.write !== false;
+        const { index, path: outPath, written } = writeDocsIndex(root, {
+          write,
+          // Omit rather than defaulting, so buildDocsIndex can probe for the
+          // docs root this repo actually uses (doc/, site/, root README, …).
+          dirs: args.dirs ?? undefined,
+        });
+        process.stdout.write(formatDocsIndexSummary(index, outPath, written));
+        if (!written) {
+          process.stdout.write(`${JSON.stringify(index, null, 2)}\n`);
+        }
+        break;
+      }
+      default:
+        process.stderr.write(`Unknown command: ${cmd}\n\n${usage()}`);
+        process.exit(1);
+    }
+  } catch (err) {
+    process.stderr.write(`interlock-graph: ${err.message || err}\n`);
+    process.exit(1);
+  }
+}
+
+main();

package/lib/graph/extract/config-json.mjs

@@ -0,0 +1,74 @@
+/**
+ * Lightweight extractor for curated config JSON files.
+ * Avoids lockfiles / large generated JSON — walk filters before we get here.
+ */
+
+/**
+ * @param {string} filePath relative posix path
+ * @param {string} source
+ */
+export function extractConfigJson(filePath, source) {
+  const imports = [];
+  const exports = [];
+  const references = [];
+
+  let data;
+  try {
+    data = JSON.parse(source);
+  } catch {
+    return { filePath, imports, exports, references };
+  }
+
+  const base = filePath.split('/').pop() || filePath;
+
+  if (base === 'package.json' && data && typeof data === 'object') {
+    if (data.scripts && typeof data.scripts === 'object') {
+      for (const name of Object.keys(data.scripts)) {
+        exports.push({
+          name: `script:${name}`,
+          kind: 'script',
+          line: 1,
+          confidence: 'EXTRACTED',
+        });
+      }
+    }
+    for (const key of ['main', 'module', 'types', 'typings']) {
+      const v = data[key];
+      if (typeof v === 'string' && v.length > 0 && !v.includes('*')) {
+        imports.push({
+          from: v.replace(/^\.\//, ''),
+          imported: null,
+          local: null,
+          line: 1,
+          confidence: 'INFERRED',
+        });
+      }
+    }
+    if (data.bin && typeof data.bin === 'object') {
+      for (const v of Object.values(data.bin)) {
+        if (typeof v === 'string') {
+          imports.push({
+            from: v.replace(/^\.\//, ''),
+            imported: null,
+            local: null,
+            line: 1,
+            confidence: 'INFERRED',
+          });
+        }
+      }
+    }
+  } else if (data && typeof data === 'object' && !Array.isArray(data)) {
+    // Surface a few top-level keys so query can find config knobs
+    for (const key of Object.keys(data).slice(0, 24)) {
+      if (!/^[A-Za-z_][\w.-]*$/.test(key)) continue;
+      exports.push({
+        name: key,
+        kind: 'key',
+        line: 1,
+        confidence: 'EXTRACTED',
+      });
+    }
+  }
+
+  return { filePath, imports, exports, references };
+}

package/lib/graph/extract/create-extractor.mjs

@@ -0,0 +1,35 @@
+import path from 'node:path';
+import { createJsExtractor } from './typescript.mjs';
+import { extractPython } from './python.mjs';
+import { extractShell } from './shell.mjs';
+import { extractConfigJson } from './config-json.mjs';
+
+/**
+ * Language-dispatching extractor. JS/TS uses typescript AST when available.
+ */
+export function createExtractor(root) {
+  const js = createJsExtractor(root);
+  const modes = new Set([js.mode]);
+
+  return {
+    get mode() {
+      return [...modes].sort().join('+');
+    },
+    extract(filePath, source) {
+      const ext = path.extname(filePath).toLowerCase();
+      if (ext === '.py' || ext === '.pyi') {
+        modes.add('python');
+        return extractPython(filePath, source);
+      }
+      if (ext === '.sh' || ext === '.bash') {
+        modes.add('shell');
+        return extractShell(filePath, source);
+      }
+      if (ext === '.json') {
+        modes.add('json');
+        return extractConfigJson(filePath, source);
+      }
+      return js.extract(filePath, source);
+    },
+  };
+}

package/lib/graph/extract/memory.mjs

@@ -0,0 +1,99 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { rel } from '../paths.mjs';
+import { walkMarkdown } from './walk.mjs';
+
+const COUPLE_RE =
+  /([`'"]?)([\w./-]+\.(?:ts|tsx|js|jsx|mjs))\1[^.\n]{0,80}(?:always changes with|couples with|paired with|together with)[^.\n]{0,80}([`'"]?)([\w./-]+\.(?:ts|tsx|js|jsx|mjs))\3/gi;
+
+const FILE_PAIR_RE =
+  /`([\w./-]+\.(?:ts|tsx|js|jsx|mjs))`[^`\n]{0,60}`([\w./-]+\.(?:ts|tsx|js|jsx|mjs))`/g;
+
+/**
+ * Extract memory nodes and coupling edges.
+ */
+export function extractMemory(root, knownFiles = new Set()) {
+  const candidates = [];
+  const memRoot = path.join(root, '.claude', 'memory');
+  if (fs.existsSync(memRoot)) {
+    candidates.push(...walkMarkdown(root, ['.claude/memory']));
+  }
+  const legacy = path.join(root, '.claude', 'memory.md');
+  if (fs.existsSync(legacy)) candidates.push(legacy);
+
+  const nodes = [];
+  const edges = [];
+  const seenNodes = new Set();
+
+  for (const absPath of candidates) {
+    const filePath = rel(root, absPath);
+    const text = fs.readFileSync(absPath, 'utf8');
+    const id = `memory:${filePath}`;
+    if (!seenNodes.has(id)) {
+      seenNodes.add(id);
+      nodes.push({
+        id,
+        type: 'memory',
+        label: path.basename(filePath),
+        source_file: filePath,
+        source_location: 'L1',
+      });
+    }
+
+    let m;
+    COUPLE_RE.lastIndex = 0;
+    while ((m = COUPLE_RE.exec(text))) {
+      const a = normalizeMention(m[2], knownFiles);
+      const b = normalizeMention(m[4], knownFiles);
+      if (!a || !b) continue;
+      const line = text.slice(0, m.index).split('\n').length;
+      edges.push({
+        source: `file:${a}`,
+        target: `file:${b}`,
+        relation: 'couples_with',
+        confidence: 'INFERRED',
+        source_file: filePath,
+        source_location: `L${line}`,
+        weight: 1,
+      });
+      edges.push({
+        source: id,
+        target: `file:${a}`,
+        relation: 'couples_with',
+        confidence: 'INFERRED',
+        source_file: filePath,
+        source_location: `L${line}`,
+        weight: 0.5,
+      });
+    }
+
+    FILE_PAIR_RE.lastIndex = 0;
+    while ((m = FILE_PAIR_RE.exec(text))) {
+      const a = normalizeMention(m[1], knownFiles);
+      const b = normalizeMention(m[2], knownFiles);
+      if (!a || !b || a === b) continue;
+      const line = text.slice(0, m.index).split('\n').length;
+      edges.push({
+        source: `file:${a}`,
+        target: `file:${b}`,
+        relation: 'couples_with',
+        confidence: 'INFERRED',
+        source_file: filePath,
+        source_location: `L${line}`,
+        weight: 0.5,
+      });
+    }
+  }
+
+  return { nodes, edges };
+}
+
+function normalizeMention(p, knownFiles) {
+  const clean = p.replace(/^\.\//, '');
+  if (knownFiles.has(clean)) return clean;
+  // Allow basename match
+  for (const f of knownFiles) {
+    if (f.endsWith(`/${clean}`) || f === clean) return f;
+  }
+  return null;
+}

package/lib/graph/extract/openspec.mjs

@@ -0,0 +1,80 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { rel } from '../paths.mjs';
+import { walkMarkdown } from './walk.mjs';
+
+// Any repo-relative path with an extension. Deliberately NOT restricted to a
+// directory allowlist or an extension allowlist: every match is gated below by
+// `knownFiles.has(mentioned)`, so the graph itself decides what is real. An
+// allowlist here can only produce false negatives — it used to drop Go/Rust/Java
+// layouts (cmd/, internal/, pkg/, apps/, services/) and indexed config files
+// entirely. The leading boundary class excludes URL path segments, which are
+// always preceded by `/`.
+const PATH_RE = /(?:^|[\s`"'(\[])((?:[\w.@-]+\/)+[\w.@-]+\.[A-Za-z0-9]{1,6})\b/gm;
+const SYMBOL_RE = /`([A-Z][A-Za-z0-9_]{2,})`|\b([A-Z][A-Za-z0-9_]{2,}(?:Service|Client|Router|Handler|Store|Provider|Context|Schema|Util|Utils)?)\b/g;
+
+/**
+ * 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']);
+  const nodes = [];
+  const edges = [];
+
+  for (const absPath of files) {
+    const filePath = rel(root, absPath);
+    const text = fs.readFileSync(absPath, 'utf8');
+    const id = `openspec:${filePath}`;
+    nodes.push({
+      id,
+      type: 'openspec',
+      label: path.basename(filePath),
+      source_file: filePath,
+      source_location: 'L1',
+    });
+
+    const seen = new Set();
+    let m;
+    PATH_RE.lastIndex = 0;
+    while ((m = PATH_RE.exec(text))) {
+      const mentioned = m[1];
+      if (seen.has(mentioned)) continue;
+      seen.add(mentioned);
+      const line = text.slice(0, m.index).split('\n').length;
+      if (knownFiles.has(mentioned)) {
+        edges.push({
+          source: id,
+          target: `file:${mentioned}`,
+          relation: 'implements_spec',
+          confidence: 'INFERRED',
+          source_file: filePath,
+          source_location: `L${line}`,
+          weight: 1,
+        });
+      }
+    }
+
+    SYMBOL_RE.lastIndex = 0;
+    while ((m = SYMBOL_RE.exec(text))) {
+      const name = m[1] || m[2];
+      if (!name || name.length < 3) continue;
+      if (!knownSymbols.has(name)) continue;
+      const key = `sym:${name}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const line = text.slice(0, m.index).split('\n').length;
+      // Link to all symbol nodes with that label — resolved later by build if needed.
+      edges.push({
+        source: id,
+        target: `symbol-name:${name}`,
+        relation: 'implements_spec',
+        confidence: 'INFERRED',
+        source_file: filePath,
+        source_location: `L${line}`,
+        weight: 0.5,
+      });
+    }
+  }
+
+  return { nodes, edges };
+}

package/lib/graph/extract/python.mjs

@@ -0,0 +1,137 @@
+/**
+ * Regex-based Python extractor (imports + top-level defs/classes).
+ * No AST dependency — good enough for package/module navigation.
+ */
+
+const FROM_IMPORT_RE =
+  /^([ \t]*)from[ \t]+(\.*[\w.]*)[ \t]+import[ \t]+(\([^)]*\)|.+)$/gm;
+const IMPORT_RE =
+  /^([ \t]*)import[ \t]+([\w.]+)(?:[ \t]+as[ \t]+(\w+))?(?:[ \t]*#.*)?$/gm;
+const CLASS_RE = /^class[ \t]+([A-Za-z_]\w*)\s*[:(]/gm;
+const DEF_RE = /^(?:async[ \t]+)?def[ \t]+([A-Za-z_]\w*)\s*\(/gm;
+
+function lineOf(text, index) {
+  return text.slice(0, index).split('\n').length;
+}
+
+function parseImportedNames(raw) {
+  const flat = raw.replace(/[()]/g, ' ').replace(/\\\s*\n/g, ' ').replace(/#.*/g, '');
+  const names = [];
+  for (const part of flat.split(',')) {
+    const t = part.trim();
+    if (!t) continue;
+    if (t === '*') {
+      names.push({ imported: '*', local: null });
+      continue;
+    }
+    const m = t.match(/^(\w+)(?:\s+as\s+(\w+))?$/);
+    if (!m) continue;
+    names.push({ imported: m[1], local: m[2] || m[1] });
+  }
+  return names;
+}
+
+/**
+ * Flatten parenthesized `from x import (` blocks so line-based regex can see them.
+ */
+function preprocessSource(source) {
+  return source.replace(
+    /^([ \t]*from[ \t]+\.*[\w.]*[ \t]+import[ \t]+)\(([\s\S]*?)\)/gm,
+    (full, head, body) => `${head}${body.replace(/\n/g, ' ')}`,
+  );
+}
+
+/**
+ * @param {string} filePath relative posix path
+ * @param {string} source
+ */
+export function extractPython(filePath, source) {
+  const imports = [];
+  const exports = [];
+  const references = [];
+  const importedLocals = new Map();
+  const text = preprocessSource(source);
+
+  let m;
+  FROM_IMPORT_RE.lastIndex = 0;
+  while ((m = FROM_IMPORT_RE.exec(text))) {
+    // Only module-level imports (no indent)
+    if (m[1] && m[1].length > 0) continue;
+    const from = m[2];
+    const line = lineOf(text, m.index);
+    const names = parseImportedNames(m[3]);
+    if (names.length === 0) {
+      imports.push({ from, imported: null, local: null, line, confidence: 'EXTRACTED' });
+      continue;
+    }
+    for (const spec of names) {
+      imports.push({
+        from,
+        imported: spec.imported,
+        local: spec.local,
+        line,
+        confidence: 'EXTRACTED',
+      });
+      if (spec.local) importedLocals.set(spec.local, { from, line });
+    }
+  }
+
+  IMPORT_RE.lastIndex = 0;
+  while ((m = IMPORT_RE.exec(text))) {
+    if (m[1] && m[1].length > 0) continue;
+    const from = m[2];
+    const local = m[3] || from.split('.')[0];
+    const line = lineOf(text, m.index);
+    imports.push({
+      from,
+      imported: m[3] ? from : '*',
+      local,
+      line,
+      confidence: 'EXTRACTED',
+    });
+    importedLocals.set(local, { from, line });
+  }
+
+  CLASS_RE.lastIndex = 0;
+  while ((m = CLASS_RE.exec(source))) {
+    exports.push({
+      name: m[1],
+      kind: 'class',
+      line: lineOf(source, m.index),
+      confidence: 'EXTRACTED',
+    });
+  }
+
+  DEF_RE.lastIndex = 0;
+  while ((m = DEF_RE.exec(source))) {
+    const name = m[1];
+    if (name.startsWith('_') && !name.startsWith('__')) continue; // skip private helpers
+    exports.push({
+      name,
+      kind: 'function',
+      line: lineOf(source, m.index),
+      confidence: 'EXTRACTED',
+    });
+  }
+
+  for (const [local, meta] of importedLocals) {
+    if (!local || local.length < 2) continue;
+    const useRe = new RegExp(`\\b${local}\\b`, 'g');
+    let um;
+    let count = 0;
+    while ((um = useRe.exec(source))) {
+      const line = lineOf(source, um.index);
+      if (line === meta.line) continue;
+      references.push({
+        name: local,
+        from: meta.from,
+        line,
+        confidence: 'EXTRACTED',
+      });
+      count += 1;
+      if (count >= 8) break;
+    }
+  }
+
+  return { filePath, imports, exports, references };
+}