@chappibunny/repolens 0.6.4 → 0.8.0

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 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
+- **Interactive Init Wizard**: `repolens init --interactive` — step-by-step configuration wizard with scan presets (Next.js, Express, generic), publisher selection, AI provider setup, and branch filtering
+- **Watch Mode**: `repolens watch` — watches source directories for changes and regenerates Markdown docs with 500ms debounce (no API calls)
+- **Enhanced Error Messages**: Centralized error catalog with actionable guidance — every error now shows what went wrong, why, and how to fix it
+- **Performance Monitoring**: Scan, render, and publish timing summary printed after every `publish` run
+- **Coverage Scoring Improvements**: New section completeness metric (12 document types tracked), updated health score weights, and `metrics.json` snapshots saved to `.repolens/`
+
 ## 0.6.4
 
 ### 🔧 Maintenance

package/README.md

@@ -1,7 +1,3 @@
-<p align="center">
-  <img src="Avatar.png" alt="RepoLens" width="120" />
-</p>
-
 ```
     ██████╗ ███████╗██████╗  ██████╗ ██╗     ███████╗███╗   ██╗███████╗
     ██╔══██╗██╔════╝██╔══██╗██╔═══██╗██║     ██╔════╝████╗  ██║██╔════╝
@@ -9,7 +5,7 @@
     ██╔══██╗██╔══╝  ██╔═══╝ ██║   ██║██║     ██╔══╝  ██║╚██╗██║╚════██║
     ██║  ██║███████╗██║     ╚██████╔╝███████╗███████╗██║ ╚████║███████║
     ╚═╝  ╚═╝╚══════╝╚═╝      ╚═════╝ ╚══════╝╚══════╝╚═╝  ╚═══╝╚══════╝
-                        🔍 Repository Intelligence CLI 📊
+                        Repository Intelligence CLI
 ```
 
 [![Tests](https://img.shields.io/badge/tests-90%20passing-brightgreen)](https://github.com/CHAPIBUNNY/repolens/actions)
@@ -20,7 +16,7 @@
 
 AI-assisted documentation intelligence system that generates architecture docs for engineers AND readable system docs for stakeholders
 
-**Current Status**: v0.6.4 — User Feedback & Team Features
+**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.
 
@@ -132,7 +128,15 @@ RepoLens automatically detects:
 ✅ **Branch-Aware** - Prevent doc conflicts across branches  
 ✅ **GitHub Actions** - Autonomous operation on every push  
 ✅ **Team Notifications** - Discord integration with rich embeds (NEW in v0.6.0)  
-✅ **Health Score Tracking** - Monitor documentation quality over time (NEW in v0.6.0)  
+✅ **Health Score Tracking** - Monitor documentation quality over time  
+✅ **Watch Mode** - Auto-regenerate docs on file changes (NEW in v0.7.0)  
+✅ **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.6.4/chappibunny-repolens-0.6.4.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.6.4.tgz
+npm install -g chappibunny-repolens-0.8.0.tgz
 
 # Verify
 repolens --version
@@ -1091,18 +1095,23 @@ repolens/
 │   └── repolens.js          # CLI executable wrapper
 ├── src/
 │   ├── cli.js               # Command orchestration + banner
-│   ├── init.js              # Scaffolding command
+│   ├── init.js              # Scaffolding command (+ interactive wizard)
 │   ├── doctor.js            # Validation command
 │   ├── migrate.js           # Workflow migration (legacy → current)
+│   ├── watch.js             # Watch mode for local development
 │   ├── core/
 │   │   ├── config.js        # Config loading + validation
 │   │   ├── config-schema.js # Schema version tracking
 │   │   ├── 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
@@ -1112,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
@@ -1133,9 +1143,10 @@ repolens/
 │       ├── metrics.js       # Documentation coverage & health scoring
 │       ├── rate-limit.js    # Token bucket rate limiter for APIs
 │       ├── secrets.js       # Secret detection & sanitization
-│       ├── telemetry.js     # Opt-in error tracking (Sentry)
+│       ├── 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
@@ -1152,13 +1163,13 @@ RepoLens uses automated GitHub Actions releases.
 ### Creating a Release
 
 ```bash
-# Patch version (0.6.4 → 0.6.5) - Bug fixes
+# Patch version (0.8.0 → 0.8.1) - Bug fixes
 npm run release:patch
 
-# Minor version (0.6.4 → 0.7.0) - New features
+# Minor version (0.8.0 → 0.9.0) - New features
 npm run release:minor
 
-# Major version (0.6.4 → 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
@@ -1190,11 +1201,11 @@ RepoLens is currently in early access. v1.0 will open for community contribution
 
 ## 🗺️ Roadmap to v1.0
 
-**Current Status:** v0.6.4 — User Feedback & Team Features
+**Current Status:** v0.8.0 — Extended Analysis
 
 ### Completed ✅
 
-- [x] CLI commands: `init`, `doctor`, `publish`, `migrate`, `feedback`, `version`, `help`
+- [x] CLI commands: `init`, `doctor`, `publish`, `migrate`, `watch`, `feedback`, `version`, `help`
 - [x] Config schema v1 with validation
 - [x] Auto-discovery of `.repolens.yml`
 - [x] Publishers: Notion + Confluence + Markdown
@@ -1206,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
@@ -1214,14 +1225,19 @@ RepoLens is currently in early access. v1.0 will open for community contribution
 - [x] npm registry publication (`@chappibunny/repolens`)
 - [x] Automated npm releases via GitHub Actions
 - [x] Workflow migration command (`repolens migrate`)
+- [x] Interactive configuration wizard (`repolens init --interactive`)
+- [x] Watch mode for local development (`repolens watch`)
+- [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
-- [ ] Interactive configuration wizard
-- [ ] Watch mode for local development
 - [ ] 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.6.4",
+  "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(" · ");
+}