@chappibunny/repolens 0.6.4 → 0.8.0

package/src/analyzers/drift-detector.js

@@ -0,0 +1,226 @@
+// Architecture drift detection
+// Compares current scan snapshot against a stored reference baseline
+// Flags structural changes: new/removed modules, dependency shifts, API surface changes
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import { info, warn } from "../utils/logger.js";
+
+const BASELINE_FILENAME = "architecture-baseline.json";
+
+/**
+ * Save the current architecture state as a baseline for future drift detection.
+ * @param {object} snapshot - The architecture snapshot to save
+ * @param {string} outputDir - Directory to save the baseline (typically .repolens/)
+ */
+export async function saveBaseline(snapshot, outputDir) {
+  const baselinePath = path.join(outputDir, BASELINE_FILENAME);
+  const baseline = {
+    version: 1,
+    timestamp: new Date().toISOString(),
+    ...snapshot,
+  };
+  await fs.mkdir(outputDir, { recursive: true });
+  await fs.writeFile(baselinePath, JSON.stringify(baseline, null, 2), "utf8");
+  info(`Architecture baseline saved to ${baselinePath}`);
+  return baselinePath;
+}
+
+/**
+ * Load a previously saved baseline. Returns null if none exists.
+ */
+export async function loadBaseline(outputDir) {
+  const baselinePath = path.join(outputDir, BASELINE_FILENAME);
+  try {
+    const raw = await fs.readFile(baselinePath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Build an architecture snapshot from scan results and analysis outputs.
+ * This is the canonical representation used for drift comparison.
+ */
+export function buildSnapshot(scanResult, depGraph, graphqlResult, tsResult) {
+  return {
+    modules: (scanResult.modules || []).map(m => m.key).sort(),
+    moduleFileCounts: Object.fromEntries(
+      (scanResult.modules || []).map(m => [m.key, m.fileCount])
+    ),
+    filesCount: scanResult.filesCount || 0,
+    apiEndpoints: (scanResult.api || []).map(a => `${a.methods.join(",")}:${a.path}`).sort(),
+    pages: (scanResult.pages || []).map(p => p.path).sort(),
+    externalApis: (scanResult.externalApis || []).map(e => e.name).sort(),
+    frameworks: scanResult.metadata?.frameworks || [],
+    depGraphEdgeCount: depGraph?.edges?.length || 0,
+    depGraphCycleCount: depGraph?.cycles?.length || 0,
+    externalDeps: depGraph?.externalDeps || [],
+    graphqlTypes: graphqlResult?.detected ? graphqlResult.types.map(t => t.name).sort() : [],
+    graphqlQueries: graphqlResult?.detected ? graphqlResult.queries.map(q => q.name).sort() : [],
+    graphqlMutations: graphqlResult?.detected ? graphqlResult.mutations.map(m => m.name).sort() : [],
+    tsInterfaces: tsResult?.detected ? tsResult.interfaces.map(i => i.name).sort() : [],
+    tsClasses: tsResult?.detected ? tsResult.classes.map(c => c.name).sort() : [],
+  };
+}
+
+/**
+ * Compare a current snapshot against a stored baseline and produce drift analysis.
+ */
+export function detectDrift(baseline, current) {
+  if (!baseline) {
+    return {
+      hasBaseline: false,
+      drifts: [],
+      summary: "No baseline found. Run `repolens publish` once to establish a baseline.",
+    };
+  }
+
+  const drifts = [];
+
+  // Module drift
+  const baseModules = new Set(baseline.modules || []);
+  const currModules = new Set(current.modules || []);
+  const addedModules = [...currModules].filter(m => !baseModules.has(m));
+  const removedModules = [...baseModules].filter(m => !currModules.has(m));
+  if (addedModules.length > 0) {
+    drifts.push({ category: "modules", type: "added", items: addedModules, severity: "info" });
+  }
+  if (removedModules.length > 0) {
+    drifts.push({ category: "modules", type: "removed", items: removedModules, severity: "warning" });
+  }
+
+  // Significant module size changes (>50% file count change)
+  for (const mod of current.modules || []) {
+    const baseCount = baseline.moduleFileCounts?.[mod] || 0;
+    const currCount = current.moduleFileCounts?.[mod] || 0;
+    if (baseCount > 0 && currCount > 0) {
+      const changeRatio = Math.abs(currCount - baseCount) / baseCount;
+      if (changeRatio > 0.5) {
+        drifts.push({
+          category: "modules",
+          type: "size-change",
+          items: [`${mod}: ${baseCount} → ${currCount} files (${changeRatio > 0 ? "+" : ""}${Math.round(changeRatio * 100)}%)`],
+          severity: changeRatio > 1.0 ? "warning" : "info",
+        });
+      }
+    }
+  }
+
+  // API endpoint drift
+  const baseApis = new Set(baseline.apiEndpoints || []);
+  const currApis = new Set(current.apiEndpoints || []);
+  const addedApis = [...currApis].filter(a => !baseApis.has(a));
+  const removedApis = [...baseApis].filter(a => !currApis.has(a));
+  if (addedApis.length > 0) {
+    drifts.push({ category: "api", type: "added", items: addedApis, severity: "info" });
+  }
+  if (removedApis.length > 0) {
+    drifts.push({ category: "api", type: "removed", items: removedApis, severity: "warning" });
+  }
+
+  // Page drift
+  const basePages = new Set(baseline.pages || []);
+  const currPages = new Set(current.pages || []);
+  const addedPages = [...currPages].filter(p => !basePages.has(p));
+  const removedPages = [...basePages].filter(p => !currPages.has(p));
+  if (addedPages.length > 0) {
+    drifts.push({ category: "pages", type: "added", items: addedPages, severity: "info" });
+  }
+  if (removedPages.length > 0) {
+    drifts.push({ category: "pages", type: "removed", items: removedPages, severity: "warning" });
+  }
+
+  // External dependency drift
+  const baseDeps = new Set(baseline.externalDeps || []);
+  const currDeps = new Set(current.externalDeps || []);
+  const addedDeps = [...currDeps].filter(d => !baseDeps.has(d));
+  const removedDeps = [...baseDeps].filter(d => !currDeps.has(d));
+  if (addedDeps.length > 0) {
+    drifts.push({ category: "dependencies", type: "added", items: addedDeps, severity: "info" });
+  }
+  if (removedDeps.length > 0) {
+    drifts.push({ category: "dependencies", type: "removed", items: removedDeps, severity: "warning" });
+  }
+
+  // Framework changes
+  const baseFrameworks = new Set(baseline.frameworks || []);
+  const currFrameworks = new Set(current.frameworks || []);
+  const addedFrameworks = [...currFrameworks].filter(f => !baseFrameworks.has(f));
+  const removedFrameworks = [...baseFrameworks].filter(f => !currFrameworks.has(f));
+  if (addedFrameworks.length > 0) {
+    drifts.push({ category: "frameworks", type: "added", items: addedFrameworks, severity: "info" });
+  }
+  if (removedFrameworks.length > 0) {
+    drifts.push({ category: "frameworks", type: "removed", items: removedFrameworks, severity: "critical" });
+  }
+
+  // Circular dependency drift
+  const baseCycles = baseline.depGraphCycleCount || 0;
+  const currCycles = current.depGraphCycleCount || 0;
+  if (currCycles > baseCycles) {
+    drifts.push({
+      category: "cycles",
+      type: "increased",
+      items: [`${baseCycles} → ${currCycles} circular dependencies`],
+      severity: "warning",
+    });
+  } else if (currCycles < baseCycles) {
+    drifts.push({
+      category: "cycles",
+      type: "decreased",
+      items: [`${baseCycles} → ${currCycles} circular dependencies`],
+      severity: "info",
+    });
+  }
+
+  // GraphQL schema drift
+  const baseGqlTypes = new Set(baseline.graphqlTypes || []);
+  const currGqlTypes = new Set(current.graphqlTypes || []);
+  const addedTypes = [...currGqlTypes].filter(t => !baseGqlTypes.has(t));
+  const removedTypes = [...baseGqlTypes].filter(t => !currGqlTypes.has(t));
+  if (addedTypes.length > 0 || removedTypes.length > 0) {
+    drifts.push({
+      category: "graphql",
+      type: "schema-changed",
+      items: [
+        ...(addedTypes.length ? [`+${addedTypes.length} types: ${addedTypes.join(", ")}`] : []),
+        ...(removedTypes.length ? [`-${removedTypes.length} types: ${removedTypes.join(", ")}`] : []),
+      ],
+      severity: removedTypes.length > 0 ? "warning" : "info",
+    });
+  }
+
+  // Overall file count change
+  const baseFiles = baseline.filesCount || 0;
+  const currFiles = current.filesCount || 0;
+  if (baseFiles > 0 && currFiles > 0) {
+    const fileChange = Math.abs(currFiles - baseFiles) / baseFiles;
+    if (fileChange > 0.2) {
+      drifts.push({
+        category: "scale",
+        type: "file-count-change",
+        items: [`${baseFiles} → ${currFiles} files (${currFiles > baseFiles ? "+" : ""}${Math.round(fileChange * 100)}%)`],
+        severity: fileChange > 0.5 ? "warning" : "info",
+      });
+    }
+  }
+
+  const summary = drifts.length === 0
+    ? "No architecture drift detected since last baseline."
+    : `${drifts.length} drift(s) detected: ${drifts.filter(d => d.severity === "critical").length} critical, ${drifts.filter(d => d.severity === "warning").length} warning(s), ${drifts.filter(d => d.severity === "info").length} informational`;
+
+  if (drifts.length > 0) {
+    warn(`Architecture drift: ${summary}`);
+  } else {
+    info("Architecture drift: no drift detected");
+  }
+
+  return {
+    hasBaseline: true,
+    baselineTimestamp: baseline.timestamp,
+    drifts,
+    summary,
+  };
+}

package/src/analyzers/graphql-analyzer.js

@@ -0,0 +1,261 @@
+// GraphQL schema detection — discovers schemas, queries, mutations, subscriptions, and resolvers
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import { info } from "../utils/logger.js";
+
+const GRAPHQL_EXTENSIONS = [".graphql", ".gql"];
+
+const TYPE_PATTERNS = {
+  query: /type\s+Query\s*\{([^}]*)\}/gs,
+  mutation: /type\s+Mutation\s*\{([^}]*)\}/gs,
+  subscription: /type\s+Subscription\s*\{([^}]*)\}/gs,
+  objectType: /type\s+(\w+)(?:\s+implements\s+[\w&\s]+)?\s*\{([^}]*)\}/gs,
+  inputType: /input\s+(\w+)\s*\{([^}]*)\}/gs,
+  enumType: /enum\s+(\w+)\s*\{([^}]*)\}/gs,
+  interfaceType: /interface\s+(\w+)\s*\{([^}]*)\}/gs,
+  unionType: /union\s+(\w+)\s*=\s*([^;\n]+)/g,
+  scalarType: /scalar\s+(\w+)/g,
+  directive: /directive\s+@(\w+)/g,
+};
+
+const RESOLVER_PATTERNS = [
+  /(?:Query|Mutation|Subscription)\s*:\s*\{/,
+  /resolvers?\s*=\s*\{/,
+  /createResolversMap/,
+  /\bresolveType\b/,
+  /fieldResolver/,
+];
+
+const SCHEMA_LIBRARY_PATTERNS = [
+  { name: "Apollo Server", pattern: /ApolloServer|@apollo\/server|apollo-server/ },
+  { name: "GraphQL Yoga", pattern: /graphql-yoga|createYoga/ },
+  { name: "Mercurius", pattern: /mercurius/ },
+  { name: "graphql-js", pattern: /graphql\b.*buildSchema|GraphQLSchema|GraphQLObjectType/ },
+  { name: "type-graphql", pattern: /type-graphql|@Resolver|@Query|@Mutation/ },
+  { name: "Nexus", pattern: /nexus|makeSchema|objectType\(/ },
+  { name: "Pothos", pattern: /pothos|SchemaBuilder/ },
+  { name: "Hasura", pattern: /hasura/ },
+  { name: "Relay", pattern: /relay-runtime|RelayEnvironment/ },
+  { name: "urql", pattern: /urql|@urql/ },
+  { name: "Apollo Client", pattern: /ApolloClient|@apollo\/client|apollo-client|useQuery|useMutation/ },
+];
+
+function parseFieldsFromBlock(block) {
+  const fields = [];
+  const lines = block.split("\n").map(l => l.trim()).filter(l => l && !l.startsWith("#"));
+  for (const line of lines) {
+    const match = line.match(/^(\w+)\s*(?:\([^)]*\))?\s*:\s*(.+)/);
+    if (match) {
+      fields.push({ name: match[1], type: match[2].replace(/\s*#.*/, "").trim() });
+    }
+  }
+  return fields;
+}
+
+async function readFileSafe(filePath) {
+  try {
+    return await fs.readFile(filePath, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+export async function analyzeGraphQL(files, repoRoot) {
+  const result = {
+    detected: false,
+    schemaFiles: [],
+    types: [],
+    queries: [],
+    mutations: [],
+    subscriptions: [],
+    enums: [],
+    inputs: [],
+    interfaces: [],
+    unions: [],
+    scalars: [],
+    directives: [],
+    resolverFiles: [],
+    libraries: [],
+    summary: null,
+  };
+
+  // Phase 1: Find dedicated .graphql/.gql schema files
+  const schemaFiles = files.filter(f => GRAPHQL_EXTENSIONS.some(ext => f.endsWith(ext)));
+
+  // Phase 2: Find JS/TS files with inline schema or resolvers
+  const codeFiles = files.filter(f =>
+    f.endsWith(".js") || f.endsWith(".ts") || f.endsWith(".jsx") || f.endsWith(".tsx")
+  );
+
+  // Parse .graphql/.gql files
+  for (const file of schemaFiles) {
+    const content = await readFileSafe(path.join(repoRoot, file));
+    if (!content) continue;
+    result.schemaFiles.push(file);
+    extractSchemaTypes(content, file, result);
+  }
+
+  // Scan code files for inline schemas, resolvers, and libraries
+  for (const file of codeFiles) {
+    const content = await readFileSafe(path.join(repoRoot, file));
+    if (!content) continue;
+
+    // Detect GraphQL libraries
+    for (const { name, pattern } of SCHEMA_LIBRARY_PATTERNS) {
+      if (pattern.test(content) && !result.libraries.includes(name)) {
+        result.libraries.push(name);
+      }
+    }
+
+    // Detect inline SDL (template literals with gql tag or type definitions)
+    const inlineSdlPattern = /(?:gql|graphql)\s*`([^`]+)`/gs;
+    let match;
+    while ((match = inlineSdlPattern.exec(content)) !== null) {
+      extractSchemaTypes(match[1], file, result);
+    }
+
+    // Also detect raw type definitions in string literals
+    if (/type\s+(?:Query|Mutation|Subscription)\s*\{/.test(content)) {
+      extractSchemaTypes(content, file, result);
+    }
+
+    // Detect resolver files
+    const isResolver = RESOLVER_PATTERNS.some(p => p.test(content));
+    if (isResolver && !result.resolverFiles.includes(file)) {
+      result.resolverFiles.push(file);
+    }
+  }
+
+  result.detected = result.schemaFiles.length > 0 ||
+    result.types.length > 0 ||
+    result.resolverFiles.length > 0 ||
+    result.libraries.length > 0;
+
+  if (result.detected) {
+    result.summary = buildSummary(result);
+    info(`GraphQL detected: ${result.types.length} types, ${result.queries.length} queries, ${result.mutations.length} mutations`);
+  }
+
+  return result;
+}
+
+function extractSchemaTypes(content, sourceFile, result) {
+  let match;
+
+  // Object types (skip Query/Mutation/Subscription — handled separately)
+  const typeRegex = /type\s+(\w+)(?:\s+implements\s+([\w&\s]+))?\s*\{([^}]*)\}/gs;
+  while ((match = typeRegex.exec(content)) !== null) {
+    const name = match[1];
+    if (["Query", "Mutation", "Subscription"].includes(name)) continue;
+    const implements_ = match[2] ? match[2].split("&").map(s => s.trim()) : [];
+    const fields = parseFieldsFromBlock(match[3]);
+    if (!result.types.some(t => t.name === name)) {
+      result.types.push({ name, fields, implements: implements_, source: sourceFile });
+    }
+  }
+
+  // Query fields
+  const queryRegex = /type\s+Query\s*\{([^}]*)\}/gs;
+  while ((match = queryRegex.exec(content)) !== null) {
+    const fields = parseFieldsFromBlock(match[1]);
+    for (const field of fields) {
+      if (!result.queries.some(q => q.name === field.name)) {
+        result.queries.push({ ...field, source: sourceFile });
+      }
+    }
+  }
+
+  // Mutation fields
+  const mutationRegex = /type\s+Mutation\s*\{([^}]*)\}/gs;
+  while ((match = mutationRegex.exec(content)) !== null) {
+    const fields = parseFieldsFromBlock(match[1]);
+    for (const field of fields) {
+      if (!result.mutations.some(m => m.name === field.name)) {
+        result.mutations.push({ ...field, source: sourceFile });
+      }
+    }
+  }
+
+  // Subscription fields
+  const subRegex = /type\s+Subscription\s*\{([^}]*)\}/gs;
+  while ((match = subRegex.exec(content)) !== null) {
+    const fields = parseFieldsFromBlock(match[1]);
+    for (const field of fields) {
+      if (!result.subscriptions.some(s => s.name === field.name)) {
+        result.subscriptions.push({ ...field, source: sourceFile });
+      }
+    }
+  }
+
+  // Enums
+  const enumRegex = /enum\s+(\w+)\s*\{([^}]*)\}/gs;
+  while ((match = enumRegex.exec(content)) !== null) {
+    const name = match[1];
+    const values = match[2].split("\n").map(l => l.trim()).filter(l => l && !l.startsWith("#"));
+    if (!result.enums.some(e => e.name === name)) {
+      result.enums.push({ name, values, source: sourceFile });
+    }
+  }
+
+  // Input types
+  const inputRegex = /input\s+(\w+)\s*\{([^}]*)\}/gs;
+  while ((match = inputRegex.exec(content)) !== null) {
+    const name = match[1];
+    const fields = parseFieldsFromBlock(match[2]);
+    if (!result.inputs.some(i => i.name === name)) {
+      result.inputs.push({ name, fields, source: sourceFile });
+    }
+  }
+
+  // Interfaces
+  const ifaceRegex = /interface\s+(\w+)\s*\{([^}]*)\}/gs;
+  while ((match = ifaceRegex.exec(content)) !== null) {
+    const name = match[1];
+    const fields = parseFieldsFromBlock(match[2]);
+    if (!result.interfaces.some(i => i.name === name)) {
+      result.interfaces.push({ name, fields, source: sourceFile });
+    }
+  }
+
+  // Unions
+  const unionRegex = /union\s+(\w+)\s*=\s*([^;\n]+)/g;
+  while ((match = unionRegex.exec(content)) !== null) {
+    const name = match[1];
+    const members = match[2].split("|").map(s => s.trim());
+    if (!result.unions.some(u => u.name === name)) {
+      result.unions.push({ name, members, source: sourceFile });
+    }
+  }
+
+  // Scalars
+  const scalarRegex = /scalar\s+(\w+)/g;
+  while ((match = scalarRegex.exec(content)) !== null) {
+    if (!result.scalars.includes(match[1])) {
+      result.scalars.push(match[1]);
+    }
+  }
+
+  // Directives
+  const directiveRegex = /directive\s+@(\w+)/g;
+  while ((match = directiveRegex.exec(content)) !== null) {
+    if (!result.directives.includes(match[1])) {
+      result.directives.push(match[1]);
+    }
+  }
+}
+
+function buildSummary(result) {
+  const parts = [];
+  if (result.schemaFiles.length) parts.push(`${result.schemaFiles.length} schema file(s)`);
+  if (result.types.length) parts.push(`${result.types.length} object type(s)`);
+  if (result.queries.length) parts.push(`${result.queries.length} quer${result.queries.length === 1 ? "y" : "ies"}`);
+  if (result.mutations.length) parts.push(`${result.mutations.length} mutation(s)`);
+  if (result.subscriptions.length) parts.push(`${result.subscriptions.length} subscription(s)`);
+  if (result.enums.length) parts.push(`${result.enums.length} enum(s)`);
+  if (result.inputs.length) parts.push(`${result.inputs.length} input type(s)`);
+  if (result.interfaces.length) parts.push(`${result.interfaces.length} interface(s)`);
+  if (result.resolverFiles.length) parts.push(`${result.resolverFiles.length} resolver file(s)`);
+  if (result.libraries.length) parts.push(`libraries: ${result.libraries.join(", ")}`);
+  return parts.join(" · ");
+}

package/src/analyzers/typescript-analyzer.js

@@ -0,0 +1,171 @@
+// TypeScript type graph analysis — maps interfaces, types, classes, and their relationships
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import { info } from "../utils/logger.js";
+
+const TS_EXTENSIONS = [".ts", ".tsx"];
+
+// Patterns for extracting type declarations
+const INTERFACE_PATTERN = /(?:export\s+)?interface\s+(\w+)(?:\s+extends\s+([\w,\s<>]+))?\s*\{/g;
+const TYPE_ALIAS_PATTERN = /(?:export\s+)?type\s+(\w+)(?:<[^>]*>)?\s*=\s*([^;]+);/g;
+const CLASS_PATTERN = /(?:export\s+)?(?:abstract\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?(?:\s+implements\s+([\w,\s]+))?\s*\{/g;
+const ENUM_PATTERN = /(?:export\s+)?(?:const\s+)?enum\s+(\w+)\s*\{/g;
+const GENERIC_CONSTRAINT = /<(\w+)\s+extends\s+(\w+)/g;
+
+async function readFileSafe(filePath) {
+  try {
+    return await fs.readFile(filePath, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function extractTypeReferences(typeExpression) {
+  // Extract named type references from a type expression (strips primitives, operators)
+  const primitives = new Set([
+    "string", "number", "boolean", "void", "null", "undefined", "never", "any",
+    "unknown", "object", "bigint", "symbol", "true", "false",
+  ]);
+  const refs = new Set();
+  // Match word boundaries that look like type names (PascalCase or all-caps)
+  const namePattern = /\b([A-Z]\w*)\b/g;
+  let match;
+  while ((match = namePattern.exec(typeExpression)) !== null) {
+    const name = match[1];
+    if (!primitives.has(name.toLowerCase()) && name !== "Array" && name !== "Promise" &&
+        name !== "Record" && name !== "Partial" && name !== "Required" && name !== "Omit" &&
+        name !== "Pick" && name !== "Readonly" && name !== "Map" && name !== "Set" &&
+        name !== "Date" && name !== "RegExp" && name !== "Error" && name !== "Buffer") {
+      refs.add(name);
+    }
+  }
+  return [...refs];
+}
+
+export async function analyzeTypeScript(files, repoRoot) {
+  const result = {
+    detected: false,
+    interfaces: [],
+    typeAliases: [],
+    classes: [],
+    enums: [],
+    relationships: [],  // { from, to, type: extends|implements|references }
+    files: [],
+    summary: null,
+  };
+
+  const tsFiles = files.filter(f => TS_EXTENSIONS.some(ext => f.endsWith(ext)));
+  if (tsFiles.length === 0) return result;
+
+  result.detected = true;
+  const typeNames = new Set(); // track all declared type names for relationship resolution
+
+  for (const file of tsFiles) {
+    const content = await readFileSafe(path.join(repoRoot, file));
+    if (!content) continue;
+
+    let hasTypes = false;
+
+    // Interfaces
+    let match;
+    const ifaceRegex = new RegExp(INTERFACE_PATTERN.source, "g");
+    while ((match = ifaceRegex.exec(content)) !== null) {
+      const name = match[1];
+      const extends_ = match[2] ? match[2].split(",").map(s => s.replace(/<.*/, "").trim()) : [];
+      typeNames.add(name);
+      result.interfaces.push({ name, extends: extends_, source: file });
+      hasTypes = true;
+
+      for (const parent of extends_) {
+        result.relationships.push({ from: name, to: parent, type: "extends" });
+      }
+    }
+
+    // Type aliases
+    const typeRegex = new RegExp(TYPE_ALIAS_PATTERN.source, "g");
+    while ((match = typeRegex.exec(content)) !== null) {
+      const name = match[1];
+      const definition = match[2].trim();
+      const refs = extractTypeReferences(definition);
+      typeNames.add(name);
+      result.typeAliases.push({ name, refs, source: file });
+      hasTypes = true;
+
+      for (const ref of refs) {
+        result.relationships.push({ from: name, to: ref, type: "references" });
+      }
+    }
+
+    // Classes
+    const classRegex = new RegExp(CLASS_PATTERN.source, "g");
+    while ((match = classRegex.exec(content)) !== null) {
+      const name = match[1];
+      const extends_ = match[2] || null;
+      const implements_ = match[3] ? match[3].split(",").map(s => s.trim()) : [];
+      typeNames.add(name);
+      result.classes.push({ name, extends: extends_, implements: implements_, source: file });
+      hasTypes = true;
+
+      if (extends_) {
+        result.relationships.push({ from: name, to: extends_, type: "extends" });
+      }
+      for (const iface of implements_) {
+        result.relationships.push({ from: name, to: iface, type: "implements" });
+      }
+    }
+
+    // Enums
+    const enumRegex = new RegExp(ENUM_PATTERN.source, "g");
+    while ((match = enumRegex.exec(content)) !== null) {
+      typeNames.add(match[1]);
+      result.enums.push({ name: match[1], source: file });
+      hasTypes = true;
+    }
+
+    // Generic constraints (e.g., <T extends SomeType>)
+    const constraintRegex = new RegExp(GENERIC_CONSTRAINT.source, "g");
+    while ((match = constraintRegex.exec(content)) !== null) {
+      // Only track if the constraint references a known (non-primitive) type
+      const refs = extractTypeReferences(match[2]);
+      for (const ref of refs) {
+        result.relationships.push({ from: match[1], to: ref, type: "constrained-by" });
+      }
+    }
+
+    if (hasTypes) {
+      result.files.push(file);
+    }
+  }
+
+  // Filter relationships to only include edges where both sides are project-declared types
+  result.relationships = result.relationships.filter(
+    r => typeNames.has(r.from) && typeNames.has(r.to) && r.from !== r.to
+  );
+
+  // Deduplicate relationships
+  const relKey = r => `${r.from}→${r.to}:${r.type}`;
+  const seen = new Set();
+  result.relationships = result.relationships.filter(r => {
+    const k = relKey(r);
+    if (seen.has(k)) return false;
+    seen.add(k);
+    return true;
+  });
+
+  result.summary = buildSummary(result);
+  info(`TypeScript types: ${result.interfaces.length} interfaces, ${result.typeAliases.length} aliases, ${result.classes.length} classes, ${result.enums.length} enums`);
+
+  return result;
+}
+
+function buildSummary(result) {
+  const parts = [];
+  if (result.files.length) parts.push(`${result.files.length} file(s) with type declarations`);
+  if (result.interfaces.length) parts.push(`${result.interfaces.length} interface(s)`);
+  if (result.typeAliases.length) parts.push(`${result.typeAliases.length} type alias(es)`);
+  if (result.classes.length) parts.push(`${result.classes.length} class(es)`);
+  if (result.enums.length) parts.push(`${result.enums.length} enum(s)`);
+  if (result.relationships.length) parts.push(`${result.relationships.length} relationship(s)`);
+  return parts.join(" · ");
+}