@renzrollon/interlock 1.0.0

package/lib/graph/extract/regex-fallback.mjs

@@ -0,0 +1,187 @@
+/**
+ * Regex-based JS/TS extractor. Used when typescript package is unavailable.
+ * Extracts imports, exports, and best-effort same-file references.
+ */
+
+const IMPORT_RE =
+  /(?:import\s+(?:type\s+)?(?:([\w*{}\s,]+)\s+from\s+)?|export\s+(?:type\s+)?(?:[\w*{}\s,]+\s+from\s+)?|require\s*\(\s*)['"]([^'"]+)['"]/g;
+
+const NAMED_IMPORT_RE = /(?:import|export)\s+(?:type\s+)?\{([^}]+)\}\s+from\s+['"]([^'"]+)['"]/g;
+const DEFAULT_IMPORT_RE =
+  /import\s+(?:type\s+)?([A-Za-z_$][\w$]*)\s*(?:,\s*\{[^}]*\})?\s*from\s+['"]([^'"]+)['"]/g;
+const NS_IMPORT_RE = /import\s+\*\s+as\s+([A-Za-z_$][\w$]*)\s+from\s+['"]([^'"]+)['"]/g;
+const REQUIRE_RE = /(?:const|let|var)\s+(?:\{([^}]+)\}|([A-Za-z_$][\w$]*))\s*=\s*require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+
+const EXPORT_NAMED_RE =
+  /export\s+(?:async\s+)?(?:function|class|const|let|var|type|interface|enum)\s+([A-Za-z_$][\w$]*)/g;
+const EXPORT_LIST_RE = /export\s+(?:type\s+)?\{([^}]+)\}/g;
+const EXPORT_DEFAULT_RE = /export\s+default\s+(?:async\s+)?(?:function|class)?\s*([A-Za-z_$][\w$]*)?/g;
+
+function lineOf(text, index) {
+  return text.slice(0, index).split('\n').length;
+}
+
+function parseSpecifiers(raw) {
+  return raw
+    .split(',')
+    .map((s) => s.trim())
+    .filter(Boolean)
+    .map((s) => {
+      const parts = s.split(/\s+as\s+/i);
+      const local = (parts[1] || parts[0]).trim();
+      const imported = parts[0].replace(/^type\s+/, '').trim();
+      return { imported, local };
+    })
+    .filter((s) => s.local && s.local !== 'type');
+}
+
+/**
+ * @param {string} filePath relative posix path
+ * @param {string} source
+ */
+export function extractWithRegex(filePath, source) {
+  const imports = [];
+  const exports = [];
+  const references = [];
+  const importedLocals = new Map(); // localName -> { from, line }
+
+  let m;
+  NAMED_IMPORT_RE.lastIndex = 0;
+  while ((m = NAMED_IMPORT_RE.exec(source))) {
+    const line = lineOf(source, m.index);
+    const from = m[2];
+    for (const spec of parseSpecifiers(m[1])) {
+      imports.push({
+        from,
+        imported: spec.imported,
+        local: spec.local,
+        line,
+        confidence: 'EXTRACTED',
+      });
+      importedLocals.set(spec.local, { from, line });
+    }
+  }
+
+  DEFAULT_IMPORT_RE.lastIndex = 0;
+  while ((m = DEFAULT_IMPORT_RE.exec(source))) {
+    const line = lineOf(source, m.index);
+    const local = m[1];
+    const from = m[2];
+    imports.push({ from, imported: 'default', local, line, confidence: 'EXTRACTED' });
+    importedLocals.set(local, { from, line });
+  }
+
+  NS_IMPORT_RE.lastIndex = 0;
+  while ((m = NS_IMPORT_RE.exec(source))) {
+    const line = lineOf(source, m.index);
+    imports.push({
+      from: m[2],
+      imported: '*',
+      local: m[1],
+      line,
+      confidence: 'EXTRACTED',
+    });
+    importedLocals.set(m[1], { from: m[2], line });
+  }
+
+  REQUIRE_RE.lastIndex = 0;
+  while ((m = REQUIRE_RE.exec(source))) {
+    const line = lineOf(source, m.index);
+    const from = m[3];
+    if (m[1]) {
+      for (const spec of parseSpecifiers(m[1])) {
+        imports.push({
+          from,
+          imported: spec.imported,
+          local: spec.local,
+          line,
+          confidence: 'EXTRACTED',
+        });
+        importedLocals.set(spec.local, { from, line });
+      }
+    } else if (m[2]) {
+      imports.push({
+        from,
+        imported: 'default',
+        local: m[2],
+        line,
+        confidence: 'EXTRACTED',
+      });
+      importedLocals.set(m[2], { from, line });
+    }
+  }
+
+  // Bare side-effect imports / export-from without binding already covered partially;
+  // catch remaining import 'x' and export ... from 'x'
+  IMPORT_RE.lastIndex = 0;
+  const seenFrom = new Set(imports.map((i) => `${i.from}@${i.line}`));
+  while ((m = IMPORT_RE.exec(source))) {
+    const from = m[2];
+    const line = lineOf(source, m.index);
+    const key = `${from}@${line}`;
+    if (seenFrom.has(key)) continue;
+    // Only add if this looks like a side-effect import (no binding captured in m[1] meaningfully)
+    if (!m[1] || !m[1].trim()) {
+      imports.push({ from, imported: null, local: null, line, confidence: 'EXTRACTED' });
+      seenFrom.add(key);
+    }
+  }
+
+  EXPORT_NAMED_RE.lastIndex = 0;
+  while ((m = EXPORT_NAMED_RE.exec(source))) {
+    exports.push({
+      name: m[1],
+      kind: 'named',
+      line: lineOf(source, m.index),
+      confidence: 'EXTRACTED',
+    });
+  }
+
+  EXPORT_LIST_RE.lastIndex = 0;
+  while ((m = EXPORT_LIST_RE.exec(source))) {
+    // skip re-exports that have `from` — handled as imports + export list
+    const after = source.slice(m.index, m.index + m[0].length + 40);
+    if (/\bfrom\b/.test(after.slice(m[0].length))) {
+      // still record exported names
+    }
+    for (const spec of parseSpecifiers(m[1])) {
+      exports.push({
+        name: spec.local,
+        kind: 'named',
+        line: lineOf(source, m.index),
+        confidence: 'EXTRACTED',
+      });
+    }
+  }
+
+  EXPORT_DEFAULT_RE.lastIndex = 0;
+  while ((m = EXPORT_DEFAULT_RE.exec(source))) {
+    exports.push({
+      name: m[1] || 'default',
+      kind: 'default',
+      line: lineOf(source, m.index),
+      confidence: 'EXTRACTED',
+    });
+  }
+
+  // Cross-file references only for imported locals (identifier use after import)
+  for (const [local, meta] of importedLocals) {
+    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; // the import site itself
+      references.push({
+        name: local,
+        from: meta.from,
+        line,
+        confidence: 'EXTRACTED',
+      });
+      count += 1;
+      if (count >= 8) break; // cap per local
+    }
+  }
+
+  return { filePath, imports, exports, references };
+}

package/lib/graph/extract/shell.mjs

@@ -0,0 +1,71 @@
+/**
+ * Regex-based shell script extractor (source/. includes, .sh calls, functions).
+ */
+
+const SOURCE_RE =
+  /(?:^|[\n;&|])\s*(?:source|\.)[ \t]+(?:["']([^"']+)["']|(\S+))/gm;
+const SH_PATH_RE = /(?:^|[\n;&|\s`"'])((?:\$[\w{]+\/)?(?:\.\/)?[\w./-]+\.sh)\b/gm;
+const FN_RE = /^(?:function[ \t]+)?([A-Za-z_][\w]*)[ \t]*\(\)[ \t]*\{/gm;
+
+function lineOf(text, index) {
+  return text.slice(0, index).split('\n').length;
+}
+
+function normalizeShellPath(raw) {
+  let p = String(raw || '').trim();
+  if (!p) return null;
+  // Drop variable prefixes like $SCRIPT_DIR/ or ${APP_DIR}/ — keep trailing path
+  p = p.replace(/^\$\{?[\w]+\}?\//, '');
+  p = p.replace(/^\.\//, '');
+  if (p.includes('$') || p.includes('`')) return null;
+  return p;
+}
+
+/**
+ * @param {string} filePath relative posix path
+ * @param {string} source
+ */
+export function extractShell(filePath, source) {
+  const imports = [];
+  const exports = [];
+  const references = [];
+  const seen = new Set();
+
+  let m;
+  SOURCE_RE.lastIndex = 0;
+  while ((m = SOURCE_RE.exec(source))) {
+    const raw = m[1] || m[2];
+    const from = normalizeShellPath(raw);
+    if (!from) continue;
+    const line = lineOf(source, m.index);
+    const key = `src:${from}@${line}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    imports.push({ from, imported: null, local: null, line, confidence: 'EXTRACTED' });
+  }
+
+  SH_PATH_RE.lastIndex = 0;
+  while ((m = SH_PATH_RE.exec(source))) {
+    const from = normalizeShellPath(m[1]);
+    if (!from || from === filePath) continue;
+    // Skip self basename echoes in comments loosely handled by seen
+    const line = lineOf(source, m.index);
+    const key = `sh:${from}@${line}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    // Don't double-count pure source lines already captured
+    imports.push({ from, imported: null, local: null, line, confidence: 'INFERRED' });
+  }
+
+  FN_RE.lastIndex = 0;
+  while ((m = FN_RE.exec(source))) {
+    exports.push({
+      name: m[1],
+      kind: 'function',
+      line: lineOf(source, m.index),
+      confidence: 'EXTRACTED',
+    });
+  }
+
+  return { filePath, imports, exports, references };
+}

package/lib/graph/extract/typescript.mjs

@@ -0,0 +1,217 @@
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { extractWithRegex } from './regex-fallback.mjs';
+
+/**
+ * Try to load typescript from the target project (or cwd), then fall back to regex.
+ * @returns {{ mode: 'typescript'|'regex', extract: Function }}
+ */
+export function createJsExtractor(root) {
+  const ts = tryLoadTypescript(root);
+  if (!ts) {
+    return {
+      mode: 'regex',
+      extract(filePath, source) {
+        return extractWithRegex(filePath, source);
+      },
+    };
+  }
+
+  return {
+    mode: 'typescript',
+    extract(filePath, source) {
+      try {
+        return extractWithTypescript(ts, filePath, source);
+      } catch {
+        return extractWithRegex(filePath, source);
+      }
+    },
+  };
+}
+
+/** @deprecated use createExtractor from ./create-extractor.mjs */
+export function createExtractor(root) {
+  return createJsExtractor(root);
+}
+
+function tryLoadTypescript(root) {
+  const candidates = [
+    path.join(root, 'package.json'),
+    path.join(root, 'node_modules', 'typescript', 'package.json'),
+  ];
+  for (const c of candidates) {
+    try {
+      return createRequire(c)('typescript');
+    } catch {
+      // try next
+    }
+  }
+  try {
+    return createRequire(import.meta.url)('typescript');
+  } catch {
+    return null;
+  }
+}
+
+function lineOf(ts, sourceFile, pos) {
+  return sourceFile.getLineAndCharacterOfPosition(pos).line + 1;
+}
+
+function extractWithTypescript(ts, filePath, source) {
+  const scriptKind = filePath.endsWith('x')
+    ? filePath.endsWith('.tsx')
+      ? ts.ScriptKind.TSX
+      : ts.ScriptKind.JSX
+    : filePath.endsWith('.ts')
+      ? ts.ScriptKind.TS
+      : ts.ScriptKind.JS;
+
+  const sf = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true, scriptKind);
+  const imports = [];
+  const exports = [];
+  const references = [];
+  const importedLocals = new Map();
+
+  for (const stmt of sf.statements) {
+    if (ts.isImportDeclaration(stmt) && stmt.moduleSpecifier && ts.isStringLiteral(stmt.moduleSpecifier)) {
+      const from = stmt.moduleSpecifier.text;
+      const line = lineOf(ts, sf, stmt.getStart(sf));
+      const clause = stmt.importClause;
+      if (!clause) {
+        imports.push({ from, imported: null, local: null, line, confidence: 'EXTRACTED' });
+        continue;
+      }
+      if (clause.name) {
+        const local = clause.name.text;
+        imports.push({ from, imported: 'default', local, line, confidence: 'EXTRACTED' });
+        importedLocals.set(local, { from, line });
+      }
+      if (clause.namedBindings) {
+        if (ts.isNamespaceImport(clause.namedBindings)) {
+          const local = clause.namedBindings.name.text;
+          imports.push({ from, imported: '*', local, line, confidence: 'EXTRACTED' });
+          importedLocals.set(local, { from, line });
+        } else if (ts.isNamedImports(clause.namedBindings)) {
+          for (const el of clause.namedBindings.elements) {
+            const imported = el.propertyName ? el.propertyName.text : el.name.text;
+            const local = el.name.text;
+            imports.push({ from, imported, local, line, confidence: 'EXTRACTED' });
+            importedLocals.set(local, { from, line });
+          }
+        }
+      }
+    }
+
+    if (ts.isExportDeclaration(stmt)) {
+      const line = lineOf(ts, sf, stmt.getStart(sf));
+      if (stmt.moduleSpecifier && ts.isStringLiteral(stmt.moduleSpecifier)) {
+        const from = stmt.moduleSpecifier.text;
+        if (stmt.exportClause && ts.isNamedExports(stmt.exportClause)) {
+          for (const el of stmt.exportClause.elements) {
+            const name = el.name.text;
+            imports.push({
+              from,
+              imported: el.propertyName ? el.propertyName.text : name,
+              local: name,
+              line,
+              confidence: 'EXTRACTED',
+            });
+            exports.push({ name, kind: 'named', line, confidence: 'EXTRACTED' });
+          }
+        } else {
+          imports.push({ from, imported: '*', local: null, line, confidence: 'EXTRACTED' });
+        }
+      } else if (stmt.exportClause && ts.isNamedExports(stmt.exportClause)) {
+        for (const el of stmt.exportClause.elements) {
+          exports.push({
+            name: el.name.text,
+            kind: 'named',
+            line,
+            confidence: 'EXTRACTED',
+          });
+        }
+      }
+    }
+
+    if (ts.isFunctionDeclaration(stmt) || ts.isClassDeclaration(stmt) || ts.isEnumDeclaration(stmt)) {
+      if (stmt.name && hasExportModifier(ts, stmt)) {
+        exports.push({
+          name: stmt.name.text,
+          kind: 'named',
+          line: lineOf(ts, sf, stmt.getStart(sf)),
+          confidence: 'EXTRACTED',
+        });
+      }
+    }
+
+    if (ts.isVariableStatement(stmt) && hasExportModifier(ts, stmt)) {
+      for (const decl of stmt.declarationList.declarations) {
+        if (ts.isIdentifier(decl.name)) {
+          exports.push({
+            name: decl.name.text,
+            kind: 'named',
+            line: lineOf(ts, sf, decl.getStart(sf)),
+            confidence: 'EXTRACTED',
+          });
+        }
+      }
+    }
+
+    if (
+      (ts.isTypeAliasDeclaration(stmt) || ts.isInterfaceDeclaration(stmt)) &&
+      hasExportModifier(ts, stmt)
+    ) {
+      exports.push({
+        name: stmt.name.text,
+        kind: 'named',
+        line: lineOf(ts, sf, stmt.getStart(sf)),
+        confidence: 'EXTRACTED',
+      });
+    }
+
+    if (ts.isExportAssignment(stmt) && !stmt.isExportEquals) {
+      let name = 'default';
+      if (ts.isIdentifier(stmt.expression)) name = stmt.expression.text;
+      exports.push({
+        name,
+        kind: 'default',
+        line: lineOf(ts, sf, stmt.getStart(sf)),
+        confidence: 'EXTRACTED',
+      });
+    }
+  }
+
+  // Walk identifiers for imported local references
+  function visit(node) {
+    if (ts.isIdentifier(node)) {
+      const name = node.text;
+      const meta = importedLocals.get(name);
+      if (meta) {
+        const line = lineOf(ts, sf, node.getStart(sf));
+        if (line !== meta.line) {
+          references.push({ name, from: meta.from, line, confidence: 'EXTRACTED' });
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sf);
+
+  // Cap references per local
+  const capped = [];
+  const counts = new Map();
+  for (const ref of references) {
+    const n = counts.get(ref.name) || 0;
+    if (n >= 8) continue;
+    counts.set(ref.name, n + 1);
+    capped.push(ref);
+  }
+
+  return { filePath, imports, exports, references: capped };
+}
+
+function hasExportModifier(ts, node) {
+  return !!node.modifiers?.some(
+    (m) => m.kind === ts.SyntaxKind.ExportKeyword || m.kind === ts.SyntaxKind.DefaultKeyword,
+  );
+}