@chappibunny/repolens 0.7.0 → 0.8.0

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 All notable changes to RepoLens will be documented in this file.
 
+## 0.8.0
+
+### ✨ New Features
+- **GraphQL Schema Detection** (`src/analyzers/graphql-analyzer.js`): Detects `.graphql`/`.gql` schema files, inline SDL via gql tagged templates, 11 library patterns (Apollo, Yoga, Mercurius, Nexus, Pothos, type-graphql, Relay, urql, etc.), and resolver patterns. Parses queries, mutations, subscriptions, object types, enums, inputs, interfaces, unions, scalars, and directives.
+- **TypeScript Type Graph Analysis** (`src/analyzers/typescript-analyzer.js`): Parses interfaces (with extends), type aliases (with reference extraction), classes (extends + implements), enums, and generic constraints. Builds relationship graph with deduplication, filtering to project-declared types only.
+- **Dependency Graph with Cycle Detection** (`src/analyzers/dependency-graph.js`): Parses ES imports, dynamic imports, CommonJS require, and re-exports. Builds directed adjacency graph with cycle detection via iterative DFS (3-color marking). Tracks hub modules, orphan files, and external dependencies.
+- **Architecture Drift Detection** (`src/analyzers/drift-detector.js`): Compares current architecture against stored baseline snapshots. Detects changes across 8 categories (modules, APIs, pages, dependencies, frameworks, circular deps, GraphQL types, file count). Categorizes drifts by severity: 🔴 critical, 🟡 warning, 🟢 info. Baselines auto-saved to `.repolens/architecture-baseline.json`.
+- **Extended Analysis Renderers** (`src/renderers/renderAnalysis.js`): Markdown renderers for all 4 new document types with tables, Unicode relationship trees, and severity-grouped reports.
+- **4 New Document Types**: `graphql_schema`, `type_graph`, `dependency_graph`, `architecture_drift` — bringing total to 15 audience-aware documents.
+
+### 🧪 Tests
+- Added 31 new tests for extended analysis features (121 tests across 12 files)
+
 ## 0.7.0
 
 ### ✨ New Features

package/README.md

@@ -16,7 +16,7 @@
 
 AI-assisted documentation intelligence system that generates architecture docs for engineers AND readable system docs for stakeholders
 
-**Current Status**: v0.7.0 — Polish & Reliability
+**Current Status**: v0.8.0 — Extended Analysis
 
 RepoLens automatically generates and maintains living architecture documentation by analyzing your repository structure, extracting meaningful insights from your package.json, and creating visual dependency graphs. Run it once, or let it auto-update on every push.
 
@@ -133,6 +133,10 @@ RepoLens automatically detects:
 ✅ **Interactive Setup** - Step-by-step configuration wizard (NEW in v0.7.0)  
 ✅ **Performance Metrics** - Timing breakdown for scan/render/publish (NEW in v0.7.0)  
 ✅ **Actionable Errors** - Enhanced error messages with fix guidance (NEW in v0.7.0)  
+✅ **GraphQL Schema Detection** - Discover types, queries, mutations, and resolvers (NEW in v0.8.0)  
+✅ **TypeScript Type Graph** - Map interfaces, classes, and type relationships (NEW in v0.8.0)  
+✅ **Dependency Graph** - Import analysis with circular dependency detection (NEW in v0.8.0)  
+✅ **Architecture Drift** - Track structural changes against a baseline (NEW in v0.8.0)  
 
 ---
 
@@ -224,7 +228,7 @@ npm link
 Install from a specific version:
 
 ```bash
-npm install https://github.com/CHAPIBUNNY/repolens/releases/download/v0.7.0/chappibunny-repolens-0.7.0.tgz
+npm install https://github.com/CHAPIBUNNY/repolens/releases/download/v0.8.0/chappibunny-repolens-0.8.0.tgz
 ```
 </details>
 
@@ -1077,7 +1081,7 @@ Simulates the full user installation experience:
 npm pack
 
 # Install globally from tarball
-npm install -g chappibunny-repolens-0.7.0.tgz
+npm install -g chappibunny-repolens-0.8.0.tgz
 
 # Verify
 repolens --version
@@ -1101,9 +1105,13 @@ repolens/
 │   │   ├── diff.js          # Git diff operations
 │   │   └── scan.js          # Repository scanning + metadata extraction
 │   ├── analyzers/
-│   │   ├── domain-inference.js  # Business domain mapping
-│   │   ├── context-builder.js   # Structured AI context assembly
-│   │   └── flow-inference.js    # Data flow detection
+│   │   ├── domain-inference.js    # Business domain mapping
+│   │   ├── context-builder.js     # Structured AI context assembly
+│   │   ├── flow-inference.js      # Data flow detection
+│   │   ├── graphql-analyzer.js    # GraphQL schema detection
+│   │   ├── typescript-analyzer.js # TypeScript type graph analysis
+│   │   ├── dependency-graph.js    # Import graph with cycle detection
+│   │   └── drift-detector.js      # Architecture drift detection
 │   ├── ai/
 │   │   ├── provider.js          # Provider-agnostic AI generation
 │   │   ├── prompts.js           # Strict prompt templates
@@ -1113,9 +1121,10 @@ repolens/
 │   │   ├── generate-doc-set.js  # Document generation orchestration
 │   │   └── write-doc-set.js     # Write docs to disk
 │   ├── renderers/
-│   │   ├── render.js        # System overview, catalog, API, routes
-│   │   ├── renderDiff.js    # Architecture diff rendering
-│   │   └── renderMap.js     # Unicode dependency diagrams
+│   │   ├── render.js           # System overview, catalog, API, routes
+│   │   ├── renderDiff.js       # Architecture diff rendering
+│   │   ├── renderMap.js        # Unicode dependency diagrams
+│   │   └── renderAnalysis.js   # Extended analysis renderers
 │   ├── publishers/
 │   │   ├── index.js         # Publisher orchestration + branch filtering
 │   │   ├── publish.js       # Publishing pipeline
@@ -1137,7 +1146,7 @@ repolens/
 │       ├── telemetry.js     # Opt-in error tracking + performance timers
 │       ├── errors.js        # Enhanced error messages with guidance
 │       └── update-check.js  # Version update notifications
-├── tests/                   # Vitest test suite (90 tests across 11 files)
+├── tests/                   # Vitest test suite (121 tests across 12 files)
 ├── .repolens.yml            # Dogfooding config
 ├── package.json
 ├── CHANGELOG.md
@@ -1154,13 +1163,13 @@ RepoLens uses automated GitHub Actions releases.
 ### Creating a Release
 
 ```bash
-# Patch version (0.7.0 → 0.7.1) - Bug fixes
+# Patch version (0.8.0 → 0.8.1) - Bug fixes
 npm run release:patch
 
-# Minor version (0.7.0 → 0.8.0) - New features
+# Minor version (0.8.0 → 0.9.0) - New features
 npm run release:minor
 
-# Major version (0.7.0 → 1.0.0) - Breaking changes
+# Major version (0.8.0 → 1.0.0) - Breaking changes
 npm run release:major
 
 # Push the tag to trigger workflow
@@ -1192,7 +1201,7 @@ RepoLens is currently in early access. v1.0 will open for community contribution
 
 ## 🗺️ Roadmap to v1.0
 
-**Current Status:** v0.7.0 — Polish & Reliability
+**Current Status:** v0.8.0 — Extended Analysis
 
 ### Completed ✅
 
@@ -1208,7 +1217,7 @@ RepoLens is currently in early access. v1.0 will open for community contribution
 - [x] GitHub Actions automation (publish + release)
 - [x] PR architecture diff comments
 - [x] Performance guardrails (10k warning, 50k limit)
-- [x] Comprehensive test suite (90 tests across 11 files)
+- [x] Comprehensive test suite (121 tests across 12 files)
 - [x] Security hardening (secret detection, injection prevention, fuzzing)
 - [x] Discord notifications with rich embeds
 - [x] Documentation coverage & health scoring
@@ -1221,12 +1230,14 @@ RepoLens is currently in early access. v1.0 will open for community contribution
 - [x] Enhanced error messages with actionable guidance
 - [x] Performance monitoring (scan/render/publish timing)
 - [x] Improved documentation coverage scoring
+- [x] GraphQL schema detection (queries, mutations, types, resolvers)
+- [x] TypeScript type graph analysis (interfaces, classes, relationships)
+- [x] Dependency graph with circular dependency detection
+- [x] Architecture drift detection (baseline comparison)
 
 ### Planned for v1.0 🎯
 
 - [ ] Plugin system for custom renderers
-- [ ] GraphQL schema detection
-- [ ] TypeScript type graph analysis
 - [ ] Additional publishers (GitHub Wiki, Obsidian)
 
 See [ROADMAP.md](./ROADMAP.md) for detailed planning.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chappibunny/repolens",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "AI-assisted documentation intelligence system for technical and non-technical audiences",
   "license": "MIT",
   "type": "module",

package/src/ai/document-plan.js

@@ -88,6 +88,38 @@ export const DOCUMENT_PLAN = [
     audience: "technical",
     ai: true,
     description: "Quick start guide for new developers"
+  },
+  {
+    key: "graphql_schema",
+    filename: "11-graphql-schema.md",
+    title: "GraphQL Schema",
+    audience: "technical",
+    ai: false,
+    description: "GraphQL types, queries, mutations, and resolver map"
+  },
+  {
+    key: "type_graph",
+    filename: "12-type-graph.md",
+    title: "TypeScript Type Graph",
+    audience: "technical",
+    ai: false,
+    description: "TypeScript interfaces, types, classes, and relationships"
+  },
+  {
+    key: "dependency_graph",
+    filename: "13-dependency-graph.md",
+    title: "Dependency Graph",
+    audience: "technical",
+    ai: false,
+    description: "Module dependency analysis with cycle detection"
+  },
+  {
+    key: "architecture_drift",
+    filename: "14-architecture-drift.md",
+    title: "Architecture Drift",
+    audience: "mixed",
+    ai: false,
+    description: "Structural changes compared to baseline snapshot"
   }
 ];
 

package/src/analyzers/dependency-graph.js

@@ -0,0 +1,254 @@
+// Dependency graph analysis with cycle detection
+// Parses import/require statements, builds a directed graph, detects cycles via DFS
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import { info, warn } from "../utils/logger.js";
+
+const CODE_EXTENSIONS = new Set([".js", ".ts", ".jsx", ".tsx", ".mjs", ".cjs"]);
+
+// Patterns for extracting imports
+const IMPORT_PATTERNS = [
+  // ES module: import ... from "..."
+  /import\s+(?:[\w*{},\s]+\s+from\s+)?['"]([^'"]+)['"]/g,
+  // Dynamic import: import("...")
+  /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+  // CommonJS: require("...")
+  /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+  // Re-export: export ... from "..."
+  /export\s+(?:[\w*{},\s]+\s+from\s+)?['"]([^'"]+)['"]/g,
+];
+
+async function readFileSafe(filePath) {
+  try {
+    return await fs.readFile(filePath, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function isRelativeImport(specifier) {
+  return specifier.startsWith("./") || specifier.startsWith("../");
+}
+
+function resolveImportPath(importerFile, specifier) {
+  // Only resolve relative imports — skip node_modules / bare specifiers
+  if (!isRelativeImport(specifier)) return null;
+
+  const importerDir = path.dirname(importerFile);
+  let resolved = path.posix.join(importerDir, specifier);
+
+  // Normalize path separators
+  resolved = resolved.replace(/\\/g, "/");
+
+  // Strip known extensions for dedup — we normalize to extensionless keys
+  resolved = resolved.replace(/\.(js|ts|jsx|tsx|mjs|cjs)$/, "");
+
+  // Strip /index suffix
+  resolved = resolved.replace(/\/index$/, "");
+
+  return resolved;
+}
+
+function normalizeFileKey(file) {
+  // Normalize a source file to a key that can match resolved imports
+  let key = file.replace(/\\/g, "/");
+  key = key.replace(/\.(js|ts|jsx|tsx|mjs|cjs)$/, "");
+  key = key.replace(/\/index$/, "");
+  return key;
+}
+
+export async function analyzeDependencyGraph(files, repoRoot) {
+  const result = {
+    nodes: [],       // { key, file, imports: string[], importedBy: string[] }
+    edges: [],       // { from, to }
+    cycles: [],      // [ [a, b, c, a], ... ]
+    externalDeps: [],// sorted unique bare-specifier imports
+    stats: null,
+    summary: null,
+  };
+
+  const codeFiles = files.filter(f => {
+    const ext = path.extname(f);
+    return CODE_EXTENSIONS.has(ext);
+  });
+
+  if (codeFiles.length === 0) return result;
+
+  // Build adjacency: fileKey → Set<fileKey>
+  const adjacency = new Map();
+  const fileKeyToFile = new Map();
+  const allFileKeys = new Set();
+  const externalSet = new Set();
+
+  // Register all known file keys
+  for (const file of codeFiles) {
+    const key = normalizeFileKey(file);
+    allFileKeys.add(key);
+    fileKeyToFile.set(key, file);
+    if (!adjacency.has(key)) adjacency.set(key, new Set());
+  }
+
+  // Parse imports and build edges
+  for (const file of codeFiles) {
+    const content = await readFileSafe(path.join(repoRoot, file));
+    if (!content) continue;
+
+    const fromKey = normalizeFileKey(file);
+
+    for (const pattern of IMPORT_PATTERNS) {
+      // Reset lastIndex since we reuse regex objects
+      const regex = new RegExp(pattern.source, pattern.flags);
+      let match;
+      while ((match = regex.exec(content)) !== null) {
+        const specifier = match[1];
+
+        if (isRelativeImport(specifier)) {
+          const resolved = resolveImportPath(file, specifier);
+          if (resolved && allFileKeys.has(resolved)) {
+            adjacency.get(fromKey).add(resolved);
+          }
+        } else if (!specifier.startsWith("node:")) {
+          // Bare specifier → external dependency
+          // Normalize scoped packages: @scope/pkg/path → @scope/pkg
+          const parts = specifier.startsWith("@") ? specifier.split("/").slice(0, 2) : specifier.split("/").slice(0, 1);
+          externalSet.add(parts.join("/"));
+        }
+      }
+    }
+  }
+
+  // Build nodes and edges
+  const importedByMap = new Map();
+  for (const key of allFileKeys) {
+    importedByMap.set(key, []);
+  }
+
+  for (const [fromKey, deps] of adjacency) {
+    for (const toKey of deps) {
+      result.edges.push({ from: fromKey, to: toKey });
+      if (importedByMap.has(toKey)) {
+        importedByMap.get(toKey).push(fromKey);
+      }
+    }
+  }
+
+  for (const key of allFileKeys) {
+    result.nodes.push({
+      key,
+      file: fileKeyToFile.get(key) || key,
+      imports: [...(adjacency.get(key) || [])],
+      importedBy: importedByMap.get(key) || [],
+    });
+  }
+
+  result.externalDeps = [...externalSet].sort();
+
+  // Detect cycles using iterative DFS (Tarjan-lite / coloring)
+  result.cycles = detectCycles(adjacency);
+
+  // Stats
+  const totalImports = result.edges.length;
+  const orphans = result.nodes.filter(n => n.imports.length === 0 && n.importedBy.length === 0);
+  const hubThreshold = Math.max(5, Math.floor(result.nodes.length * 0.1));
+  const hubs = result.nodes
+    .filter(n => n.importedBy.length >= hubThreshold)
+    .sort((a, b) => b.importedBy.length - a.importedBy.length)
+    .slice(0, 10)
+    .map(n => ({ key: n.key, importedBy: n.importedBy.length }));
+
+  result.stats = {
+    totalFiles: codeFiles.length,
+    totalEdges: totalImports,
+    externalDeps: result.externalDeps.length,
+    cycles: result.cycles.length,
+    orphanFiles: orphans.length,
+    hubs,
+  };
+
+  result.summary = buildSummary(result);
+
+  if (result.cycles.length > 0) {
+    warn(`Dependency graph: ${result.cycles.length} circular dependency cycle(s) detected`);
+  } else {
+    info(`Dependency graph: ${totalImports} edges across ${codeFiles.length} files, no cycles`);
+  }
+
+  return result;
+}
+
+/**
+ * Detect all cycles in a directed graph using DFS with 3-color marking.
+ * Returns an array of cycle paths (each path ends where it started).
+ */
+function detectCycles(adjacency) {
+  const WHITE = 0, GRAY = 1, BLACK = 2;
+  const color = new Map();
+  const parent = new Map();
+  const cycles = [];
+
+  for (const node of adjacency.keys()) {
+    color.set(node, WHITE);
+  }
+
+  for (const startNode of adjacency.keys()) {
+    if (color.get(startNode) !== WHITE) continue;
+
+    // Iterative DFS
+    const stack = [{ node: startNode, neighbors: [...(adjacency.get(startNode) || [])], idx: 0 }];
+    color.set(startNode, GRAY);
+    parent.set(startNode, null);
+
+    while (stack.length > 0) {
+      const frame = stack[stack.length - 1];
+
+      if (frame.idx >= frame.neighbors.length) {
+        // All neighbors processed — mark black and backtrack
+        color.set(frame.node, BLACK);
+        stack.pop();
+        continue;
+      }
+
+      const neighbor = frame.neighbors[frame.idx++];
+
+      if (color.get(neighbor) === GRAY) {
+        // Back edge → cycle found. Reconstruct the cycle path.
+        const cyclePath = [neighbor];
+        for (let i = stack.length - 1; i >= 0; i--) {
+          cyclePath.push(stack[i].node);
+          if (stack[i].node === neighbor) break;
+        }
+        cyclePath.reverse();
+        // Only keep reasonably short cycles to avoid noise
+        if (cyclePath.length <= 20) {
+          cycles.push(cyclePath);
+        }
+        // Cap cycles to prevent runaway in huge graphs
+        if (cycles.length >= 50) return cycles;
+      } else if (color.get(neighbor) === WHITE) {
+        color.set(neighbor, GRAY);
+        parent.set(neighbor, frame.node);
+        stack.push({ node: neighbor, neighbors: [...(adjacency.get(neighbor) || [])], idx: 0 });
+      }
+    }
+  }
+
+  return cycles;
+}
+
+function buildSummary(result) {
+  const parts = [
+    `${result.stats.totalFiles} files`,
+    `${result.stats.totalEdges} imports`,
+    `${result.stats.externalDeps} external packages`,
+  ];
+  if (result.stats.cycles > 0) {
+    parts.push(`⚠️ ${result.stats.cycles} circular dependency cycle(s)`);
+  } else {
+    parts.push("✓ no circular dependencies");
+  }
+  if (result.stats.orphanFiles > 0) {
+    parts.push(`${result.stats.orphanFiles} orphan file(s)`);
+  }
+  return parts.join(" · ");
+}

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,
+  };
+}