thuban 0.3.3 → 0.4.0

package/packages/scanner/dependency-graph.js

@@ -1,541 +0,0 @@
-/**
- * Sentinel Dependency Graph
- *
- * Maps all file dependencies in the Orion codebase.
- * Answers: "If I change X, what breaks?"
- *
- * @purpose Track and analyze file dependencies across codebase
- * @module sentinel
- * @layer infrastructure
- * @exports-to sentinel-core, widget-generator
- * @side-effects File system reads
- */
-
-const fs = require('fs');
-const path = require('path');
-const EventEmitter = require('events');
-
-class DependencyGraph extends EventEmitter {
-  constructor(config = {}) {
-    super();
-
-    this.config = {
-      rootPath: config.rootPath || process.cwd(),
-      ignorePatterns: config.ignorePatterns || [
-        'node_modules', '.git', 'dist', '.vite', '.orion/snapshots'
-      ],
-      extensions: config.extensions || ['.js', '.ts', '.jsx', '.tsx', '.php', '.rb'],
-      ...config
-    };
-
-    // The graph: file -> { imports: [], importedBy: [] }
-    this.graph = new Map();
-
-    // Module resolution cache
-    this.resolveCache = new Map();
-
-    // Statistics
-    this.stats = {
-      filesAnalyzed: 0,
-      totalImports: 0,
-      unresolvedImports: 0,
-      circularDependencies: []
-    };
-  }
-
-  // Convenience getter so callers can use graph.circularDeps || []
-  get circularDeps() {
-    return this.stats.circularDependencies;
-  }
-
-  /**
-   * Build the full dependency graph
-   */
-  async build() {
-    // debug logging silenced for clean output
-    const startTime = Date.now();
-
-    // Clear existing graph
-    this.graph.clear();
-    this.resolveCache.clear();
-    this.stats = {
-      filesAnalyzed: 0,
-      totalImports: 0,
-      unresolvedImports: 0,
-      circularDependencies: []
-    };
-
-    // Discover all files
-    const files = await this._discoverFiles(this.config.rootPath);
-
-    // First pass: extract all imports
-    for (const file of files) {
-      await this._analyzeFile(file);
-    }
-
-    // Second pass: build reverse dependencies (importedBy)
-    this._buildReverseDependencies();
-
-    // Third pass: detect circular dependencies
-    this._detectCircularDependencies();
-
-    const duration = Date.now() - startTime;
-
-    return this.getStats();
-  }
-
-  /**
-   * Get what a file depends on (imports)
-   */
-  getDependencies(filePath) {
-    const normalized = this._normalizePath(filePath);
-    const node = this.graph.get(normalized);
-    return node ? node.imports : [];
-  }
-
-  /**
-   * Get what depends on a file (dependents)
-   */
-  getDependents(filePath) {
-    const normalized = this._normalizePath(filePath);
-    const node = this.graph.get(normalized);
-    return node ? node.importedBy : [];
-  }
-
-  /**
-   * Get full dependency chain (recursive)
-   */
-  getFullDependencyChain(filePath, visited = new Set()) {
-    const normalized = this._normalizePath(filePath);
-    if (visited.has(normalized)) return []; // Prevent infinite loop
-
-    visited.add(normalized);
-    const deps = this.getDependencies(normalized);
-    const chain = [...deps];
-
-    for (const dep of deps) {
-      if (dep.resolved) {
-        chain.push(...this.getFullDependencyChain(dep.resolved, visited));
-      }
-    }
-
-    return chain;
-  }
-
-  /**
-   * IMPACT ANALYSIS: What could break if I change this file?
-   */
-  getImpactAnalysis(filePath) {
-    const normalized = this._normalizePath(filePath);
-    const result = {
-      file: normalized,
-      relativePath: path.relative(this.config.rootPath, normalized),
-      directDependents: [],
-      indirectDependents: [],
-      totalImpact: 0,
-      riskLevel: 'low',
-      affectedModules: new Set()
-    };
-
-    // Get direct dependents
-    result.directDependents = this.getDependents(normalized).map(d => ({
-      file: d,
-      relativePath: path.relative(this.config.rootPath, d)
-    }));
-
-    // Get indirect dependents (recursive)
-    const visited = new Set([normalized]);
-    const queue = [...result.directDependents.map(d => d.file)];
-
-    while (queue.length > 0) {
-      const current = queue.shift();
-      if (visited.has(current)) continue;
-      visited.add(current);
-
-      const dependents = this.getDependents(current);
-      for (const dep of dependents) {
-        if (!visited.has(dep)) {
-          result.indirectDependents.push({
-            file: dep,
-            relativePath: path.relative(this.config.rootPath, dep),
-            via: path.relative(this.config.rootPath, current)
-          });
-          queue.push(dep);
-        }
-      }
-    }
-
-    // Calculate total impact
-    result.totalImpact = result.directDependents.length + result.indirectDependents.length;
-
-    // Determine risk level
-    if (result.totalImpact === 0) {
-      result.riskLevel = 'none';
-    } else if (result.totalImpact <= 3) {
-      result.riskLevel = 'low';
-    } else if (result.totalImpact <= 10) {
-      result.riskLevel = 'medium';
-    } else if (result.totalImpact <= 25) {
-      result.riskLevel = 'high';
-    } else {
-      result.riskLevel = 'critical';
-    }
-
-    // Extract affected modules
-    for (const dep of [...result.directDependents, ...result.indirectDependents]) {
-      const parts = dep.relativePath.split(path.sep);
-      if (parts.length > 0) {
-        result.affectedModules.add(parts[0]);
-      }
-    }
-    result.affectedModules = Array.from(result.affectedModules);
-
-    return result;
-  }
-
-  /**
-   * Find most critical files (most dependents)
-   */
-  getMostCriticalFiles(limit = 20) {
-    const files = [];
-
-    for (const [filePath, node] of this.graph) {
-      files.push({
-        file: filePath,
-        relativePath: path.relative(this.config.rootPath, filePath),
-        dependentCount: node.importedBy.length,
-        dependencyCount: node.imports.length
-      });
-    }
-
-    return files
-      .sort((a, b) => b.dependentCount - a.dependentCount)
-      .slice(0, limit);
-  }
-
-  /**
-   * Find orphan files (no imports, no dependents)
-   */
-  getOrphanFiles() {
-    const orphans = [];
-
-    for (const [filePath, node] of this.graph) {
-      if (node.imports.length === 0 && node.importedBy.length === 0) {
-        orphans.push({
-          file: filePath,
-          relativePath: path.relative(this.config.rootPath, filePath)
-        });
-      }
-    }
-
-    return orphans;
-  }
-
-  /**
-   * Get module dependency summary
-   */
-  getModuleSummary() {
-    const modules = new Map();
-
-    for (const [filePath, node] of this.graph) {
-      const relativePath = path.relative(this.config.rootPath, filePath);
-      const parts = relativePath.split(path.sep);
-      const moduleName = parts[0];
-
-      if (!modules.has(moduleName)) {
-        modules.set(moduleName, {
-          name: moduleName,
-          files: [],
-          internalDeps: 0,
-          externalDeps: 0,
-          dependedOnBy: new Set()
-        });
-      }
-
-      const mod = modules.get(moduleName);
-      mod.files.push(relativePath);
-
-      // Count internal vs external dependencies
-      for (const imp of node.imports) {
-        if (imp.resolved) {
-          const impRelative = path.relative(this.config.rootPath, imp.resolved);
-          const impModule = impRelative.split(path.sep)[0];
-          if (impModule === moduleName) {
-            mod.internalDeps++;
-          } else {
-            mod.externalDeps++;
-          }
-        }
-      }
-
-      // Track which modules depend on this one
-      for (const depPath of node.importedBy) {
-        const depRelative = path.relative(this.config.rootPath, depPath);
-        const depModule = depRelative.split(path.sep)[0];
-        if (depModule !== moduleName) {
-          mod.dependedOnBy.add(depModule);
-        }
-      }
-    }
-
-    // Convert to array and calculate metrics
-    const result = [];
-    for (const [name, mod] of modules) {
-      result.push({
-        name,
-        fileCount: mod.files.length,
-        internalDeps: mod.internalDeps,
-        externalDeps: mod.externalDeps,
-        dependedOnByCount: mod.dependedOnBy.size,
-        dependedOnBy: Array.from(mod.dependedOnBy)
-      });
-    }
-
-    return result.sort((a, b) => b.fileCount - a.fileCount);
-  }
-
-  /**
-   * Get statistics
-   */
-  getStats() {
-    return {
-      ...this.stats,
-      totalFiles: this.graph.size,
-      circularCount: this.stats.circularDependencies.length
-    };
-  }
-
-  /**
-   * Export graph as JSON
-   */
-  toJSON() {
-    const data = {
-      generated: new Date().toISOString(),
-      rootPath: this.config.rootPath,
-      stats: this.getStats(),
-      files: {}
-    };
-
-    for (const [filePath, node] of this.graph) {
-      const relativePath = path.relative(this.config.rootPath, filePath);
-      data.files[relativePath] = {
-        imports: node.imports.map(i => ({
-          module: i.module,
-          resolved: i.resolved ? path.relative(this.config.rootPath, i.resolved) : null,
-          specifiers: i.specifiers
-        })),
-        importedBy: node.importedBy.map(p => path.relative(this.config.rootPath, p))
-      };
-    }
-
-    return data;
-  }
-
-  // Private methods
-
-  async _discoverFiles(dir, files = []) {
-    try {
-      const entries = fs.readdirSync(dir, { withFileTypes: true });
-
-      for (const entry of entries) {
-        const fullPath = path.join(dir, entry.name);
-
-        // Check ignore patterns
-        if (this._shouldIgnore(entry.name)) {
-          continue;
-        }
-
-        if (entry.isDirectory()) {
-          await this._discoverFiles(fullPath, files);
-        } else if (entry.isFile()) {
-          const ext = path.extname(entry.name).toLowerCase();
-          if (this.config.extensions.includes(ext)) {
-            files.push(fullPath);
-          }
-        }
-      }
-    } catch (error) {
-      // Skip inaccessible directories
-    }
-
-    return files;
-  }
-
-  _shouldIgnore(name) {
-    return this.config.ignorePatterns.some(pattern =>
-      name === pattern || name.startsWith(pattern)
-    );
-  }
-
-  async _analyzeFile(filePath) {
-    try {
-      const content = fs.readFileSync(filePath, 'utf8');
-      const imports = this._extractImports(content, filePath);
-
-      this.graph.set(filePath, {
-        imports,
-        importedBy: [] // Will be filled in second pass
-      });
-
-      this.stats.filesAnalyzed++;
-      this.stats.totalImports += imports.length;
-      this.stats.unresolvedImports += imports.filter(i => !i.resolved).length;
-
-    } catch (error) {
-      // Skip files that can't be read
-    }
-  }
-
-  _extractImports(content, filePath) {
-    const imports = [];
-    const fileDir = path.dirname(filePath);
-
-    // CommonJS: require('module') or require("module")
-    const requireRegex = /(?:const|let|var)\s+(?:\{([^}]+)\}|(\w+))\s*=\s*require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
-    let match;
-
-    while ((match = requireRegex.exec(content)) !== null) {
-      const specifiers = match[1]
-        ? match[1].split(',').map(s => s.trim().split(':')[0].trim()).filter(Boolean)
-        : [match[2]];
-      const modulePath = match[3];
-
-      imports.push({
-        module: modulePath,
-        specifiers,
-        resolved: this._resolveModule(modulePath, fileDir),
-        type: 'require'
-      });
-    }
-
-    // Also catch: require('module') without assignment
-    const bareRequireRegex = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
-    while ((match = bareRequireRegex.exec(content)) !== null) {
-      const modulePath = match[1];
-      // Skip if already captured
-      if (!imports.some(i => i.module === modulePath)) {
-        imports.push({
-          module: modulePath,
-          specifiers: [],
-          resolved: this._resolveModule(modulePath, fileDir),
-          type: 'require'
-        });
-      }
-    }
-
-    // ES6: import ... from 'module'
-    const importRegex = /import\s+(?:(?:\{([^}]+)\}|(\w+)|\*\s+as\s+(\w+))(?:\s*,\s*)?)+\s+from\s+['"]([^'"]+)['"]/g;
-    while ((match = importRegex.exec(content)) !== null) {
-      const specifiers = [];
-      if (match[1]) specifiers.push(...match[1].split(',').map(s => s.trim().split(' as ')[0].trim()).filter(Boolean));
-      if (match[2]) specifiers.push(match[2]);
-      if (match[3]) specifiers.push(match[3]);
-      const modulePath = match[4];
-
-      imports.push({
-        module: modulePath,
-        specifiers,
-        resolved: this._resolveModule(modulePath, fileDir),
-        type: 'import'
-      });
-    }
-
-    return imports;
-  }
-
-  _resolveModule(modulePath, fromDir) {
-    // Check cache
-    const cacheKey = `${fromDir}:${modulePath}`;
-    if (this.resolveCache.has(cacheKey)) {
-      return this.resolveCache.get(cacheKey);
-    }
-
-    let resolved = null;
-
-    // Skip external modules (node_modules)
-    if (!modulePath.startsWith('.') && !modulePath.startsWith('/')) {
-      this.resolveCache.set(cacheKey, null);
-      return null;
-    }
-
-    // Try to resolve relative path
-    const basePath = path.resolve(fromDir, modulePath);
-    const extensions = ['', '.js', '.ts', '.jsx', '.tsx', '.php', '.rb', '/index.js', '/index.ts'];
-
-    for (const ext of extensions) {
-      const tryPath = basePath + ext;
-      if (fs.existsSync(tryPath) && fs.statSync(tryPath).isFile()) {
-        resolved = tryPath;
-        break;
-      }
-    }
-
-    this.resolveCache.set(cacheKey, resolved);
-    return resolved;
-  }
-
-  _buildReverseDependencies() {
-    for (const [filePath, node] of this.graph) {
-      for (const imp of node.imports) {
-        if (imp.resolved && this.graph.has(imp.resolved)) {
-          const targetNode = this.graph.get(imp.resolved);
-          if (!targetNode.importedBy.includes(filePath)) {
-            targetNode.importedBy.push(filePath);
-          }
-        }
-      }
-    }
-  }
-
-  _detectCircularDependencies() {
-    const visited = new Set();
-    const recursionStack = new Set();
-
-    const dfs = (filePath, chain = []) => {
-      if (recursionStack.has(filePath)) {
-        // Found circular dependency
-        const cycleStart = chain.indexOf(filePath);
-        const cycle = chain.slice(cycleStart).map(p =>
-          path.relative(this.config.rootPath, p)
-        );
-        cycle.push(path.relative(this.config.rootPath, filePath));
-
-        // Only add if not already recorded
-        const cycleKey = cycle.sort().join(' -> ');
-        if (!this.stats.circularDependencies.some(c => c.sort().join(' -> ') === cycleKey)) {
-          this.stats.circularDependencies.push(cycle);
-        }
-        return;
-      }
-
-      if (visited.has(filePath)) return;
-
-      visited.add(filePath);
-      recursionStack.add(filePath);
-
-      const node = this.graph.get(filePath);
-      if (node) {
-        for (const imp of node.imports) {
-          if (imp.resolved) {
-            dfs(imp.resolved, [...chain, filePath]);
-          }
-        }
-      }
-
-      recursionStack.delete(filePath);
-    };
-
-    for (const filePath of this.graph.keys()) {
-      dfs(filePath);
-    }
-  }
-
-  _normalizePath(filePath) {
-    if (path.isAbsolute(filePath)) {
-      return filePath;
-    }
-    return path.resolve(this.config.rootPath, filePath);
-  }
-}
-
-module.exports = DependencyGraph;