@sun-asterisk/impact-analyzer 1.0.0

package/modules/utils/ast-parser.js

@@ -0,0 +1,241 @@
+/**
+ * AST Parser Utilities
+ * Handles parsing and symbol extraction from JavaScript/TypeScript code
+ */
+
+import { parse } from '@babel/parser';
+import traverse from '@babel/traverse';
+
+export class ASTParser {
+  /**
+   * Parse code and extract symbols
+   */
+  static extractSymbols(content, filePath) {
+    try {
+      const ast = parse(content, {
+        sourceType: 'module',
+        plugins: [
+          'jsx',
+          'typescript',
+          'decorators-legacy',
+          'classProperties',
+          'dynamicImport',
+          'optionalChaining',
+          'nullishCoalescingOperator',
+        ],
+      });
+
+      return this.traverseAST(ast, filePath);
+    } catch (error) {
+      console.warn(`Failed to parse ${filePath}:`, error.message);
+      return [];
+    }
+  }
+
+  /**
+   * Traverse AST and extract symbols
+   */
+  static traverseAST(ast, filePath) {
+    const symbols = [];
+    const self = ASTParser;
+
+    traverse.default(ast, {
+      // Function declarations
+      FunctionDeclaration(path) {
+        if (path.node.id) {
+          symbols.push({
+            type: 'function',
+            name: path.node.id.name,
+            signature: self.getSignature(path),
+            startLine: path.node.loc?.start.line || 0,
+            endLine: path.node.loc?.end.line || 0,
+            file: filePath,
+          });
+        }
+      },
+
+      // Arrow functions and function expressions assigned to variables
+      VariableDeclarator(path) {
+        if (
+          path.node.id.type === 'Identifier' &&
+          (path.node.init?.type === 'ArrowFunctionExpression' ||
+           path.node.init?.type === 'FunctionExpression')
+        ) {
+          symbols.push({
+            type: 'function',
+            name: path.node.id.name,
+            signature: self.getSignature(path.get('init')),
+            startLine: path.node.loc?.start.line || 0,
+            endLine: path.node.loc?.end.line || 0,
+            file: filePath,
+          });
+        }
+      },
+
+      // Class declarations
+      ClassDeclaration(path) {
+        if (path.node.id) {
+          symbols.push({
+            type: 'class',
+            name: path.node.id.name,
+            startLine: path.node.loc?.start.line || 0,
+            endLine: path.node.loc?.end.line || 0,
+            file: filePath,
+          });
+
+          // Extract class methods
+          path.node.body.body.forEach((member) => {
+            if (member.type === 'ClassMethod' && member.key.type === 'Identifier') {
+              symbols.push({
+                type: 'method',
+                name: `${path.node.id.name}.${member.key.name}`,
+                signature: self.getMethodSignature(member),
+                startLine: member.loc?.start.line || 0,
+                endLine: member.loc?.end.line || 0,
+                file: filePath,
+              });
+            }
+          });
+        }
+      },
+
+      // Export declarations
+      ExportNamedDeclaration(path) {
+        if (path.node.declaration) {
+          // Handle exported functions, classes, etc.
+          const declaration = path.node.declaration;
+          if (declaration.id) {
+            symbols.push({
+              type: declaration.type.toLowerCase().replace('declaration', ''),
+              name: declaration.id.name,
+              exported: true,
+              startLine: declaration.loc?.start.line || 0,
+              endLine: declaration.loc?.end.line || 0,
+              file: filePath,
+            });
+          }
+        }
+      },
+    });
+
+    return symbols;
+  }
+
+  /**
+   * Get function signature
+   */
+  static getSignature(path) {
+    try {
+      if (!path || !path.node) {
+        return '(...)';
+      }
+      const params = path.node.params || [];
+      const paramNames = params.map(p => {
+        if (p.type === 'Identifier') return p.name;
+        if (p.type === 'RestElement') return `...${p.argument.name}`;
+        return '_';
+      });
+      return `(${paramNames.join(', ')})`;
+    } catch (error) {
+      return '(...)';
+    }
+  }
+
+  /**
+   * Get method signature
+   */
+  static getMethodSignature(node) {
+    try {
+      const params = node.params || [];
+      const paramNames = params.map(p => p.name || '_');
+      return `(${paramNames.join(', ')})`;
+    } catch (error) {
+      return '(...)';
+    }
+  }
+
+  /**
+   * Extract imports from code
+   */
+  static extractImports(content) {
+    const imports = [];
+
+    try {
+      const ast = parse(content, {
+        sourceType: 'module',
+        plugins: ['jsx', 'typescript', 'dynamicImport'],
+      });
+
+      traverse.default(ast, {
+        ImportDeclaration(path) {
+          imports.push({
+            source: path.node.source.value,
+            specifiers: path.node.specifiers.map(s => ({
+              imported: s.imported?.name || s.local.name,
+              local: s.local.name,
+            })),
+          });
+        },
+
+        // Dynamic imports
+        CallExpression(path) {
+          if (path.node.callee.type === 'Import') {
+            const arg = path.node.arguments[0];
+            if (arg?.type === 'StringLiteral') {
+              imports.push({
+                source: arg.value,
+                dynamic: true,
+              });
+            }
+          }
+        },
+      });
+    } catch (error) {
+      // Ignore parse errors
+    }
+
+    return imports;
+  }
+
+  /**
+   * Find function calls in code
+   */
+  static findFunctionCalls(content, functionName) {
+    const calls = [];
+
+    try {
+      const ast = parse(content, {
+        sourceType: 'module',
+        plugins: ['jsx', 'typescript'],
+      });
+
+      traverse.default(ast, {
+        CallExpression(path) {
+          const callee = path.node.callee;
+
+          // Direct function call
+          if (callee.type === 'Identifier' && callee.name === functionName) {
+            calls.push({
+              line: path.node.loc?.start.line || 0,
+              type: 'direct',
+            });
+          }
+
+          // Method call
+          if (callee.type === 'MemberExpression' &&
+              callee.property.type === 'Identifier' &&
+              callee.property.name === functionName) {
+            calls.push({
+              line: path.node.loc?.start.line || 0,
+              type: 'method',
+            });
+          }
+        },
+      });
+    } catch (error) {
+      // Ignore parse errors
+    }
+
+    return calls;
+  }
+}

package/modules/utils/dependency-graph.js

@@ -0,0 +1,159 @@
+/**
+ * Dependency Graph Builder
+ * Builds and queries dependency relationships between code modules
+ */
+
+export class DependencyGraph {
+  constructor() {
+    this.graph = new Map(); // file -> Set of dependencies
+    this.reverseGraph = new Map(); // file -> Set of dependents
+    this.symbolGraph = new Map(); // symbol -> Set of callers
+  }
+
+  /**
+   * Add a dependency edge
+   */
+  addDependency(from, to) {
+    if (! this.graph.has(from)) {
+      this.graph.set(from, new Set());
+    }
+    this.graph.get(from).add(to);
+
+    // Build reverse graph
+    if (!this.reverseGraph.has(to)) {
+      this.reverseGraph.set(to, new Set());
+    }
+    this.reverseGraph.get(to).add(from);
+  }
+
+  /**
+   * Add symbol usage
+   */
+  addSymbolUsage(symbol, usedIn) {
+    if (!this.symbolGraph.has(symbol)) {
+      this.symbolGraph.set(symbol, new Set());
+    }
+    this.symbolGraph.get(symbol).add(usedIn);
+  }
+
+  /**
+   * Get dependencies of a file
+   */
+  getDependencies(file) {
+    return Array.from(this.graph.get(file) || []);
+  }
+
+  /**
+   * Get dependents of a file (files that depend on this file)
+   */
+  getDependents(file) {
+    return Array.from(this.reverseGraph.get(file) || []);
+  }
+
+  /**
+   * Get callers of a symbol
+   */
+  getSymbolCallers(symbol) {
+    return Array.from(this.symbolGraph.get(symbol) || []);
+  }
+
+  /**
+   * Get transitive dependencies up to maxDepth
+   */
+  getTransitiveDependencies(file, maxDepth = 3) {
+    const visited = new Set();
+    const result = new Set();
+
+    const traverse = (current, depth) => {
+      if (depth > maxDepth || visited.has(current)) return;
+
+      visited.add(current);
+      const deps = this.getDependencies(current);
+
+      for (const dep of deps) {
+        result.add(dep);
+        traverse(dep, depth + 1);
+      }
+    };
+
+    traverse(file, 0);
+    return Array.from(result);
+  }
+
+  /**
+   * Get transitive dependents (reverse dependencies)
+   */
+  getTransitiveDependents(file, maxDepth = 3) {
+    const visited = new Set();
+    const result = new Set();
+
+    const traverse = (current, depth) => {
+      if (depth > maxDepth || visited.has(current)) return;
+
+      visited.add(current);
+      const dependents = this.getDependents(current);
+
+      for (const dependent of dependents) {
+        result.add(dependent);
+        traverse(dependent, depth + 1);
+      }
+    };
+
+    traverse(file, 0);
+    return Array.from(result);
+  }
+
+  /**
+   * Calculate impact radius for a file
+   */
+  getImpactRadius(file) {
+    const directDeps = this.getDependents(file);
+    const transitiveDeps = this.getTransitiveDependents(file, 2);
+
+    return {
+      direct: directDeps.length,
+      transitive: transitiveDeps.length,
+      total: transitiveDeps.length + directDeps.length,
+    };
+  }
+
+  /**
+   * Find path between two files
+   */
+  findPath(from, to, maxDepth = 5) {
+    const queue = [[from]];
+    const visited = new Set([from]);
+
+    while (queue.length > 0) {
+      const path = queue.shift();
+      const current = path[path.length - 1];
+
+      if (path.length > maxDepth) continue;
+      if (current === to) return path;
+
+      const deps = this.getDependencies(current);
+      for (const dep of deps) {
+        if (!visited.has(dep)) {
+          visited.add(dep);
+          queue.push([...path, dep]);
+        }
+      }
+    }
+
+    return null; // No path found
+  }
+
+  /**
+   * Get graph statistics
+   */
+  getStats() {
+    return {
+      totalFiles: this.graph.size,
+      totalEdges: Array.from(this.graph.values()).reduce((sum, set) => sum + set.size, 0),
+      totalSymbols: this.symbolGraph.size,
+      avgDependencies: this.graph.size > 0
+        ? Array.from(this.graph.values()).reduce((sum, set) => sum + set.size, 0) / this.graph.size
+        : 0,
+    };
+  }
+}

package/modules/utils/file-utils.js

@@ -0,0 +1,116 @@
+/**
+ * File Utilities
+ * Helper functions for file operations
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { glob } from 'glob';
+
+export class FileUtils {
+  /**
+   * Check if file is a source code file
+   */
+  static isSourceFile(filePath) {
+    const extensions = ['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs'];
+    return extensions.some(ext => filePath.endsWith(ext));
+  }
+
+  /**
+   * Check if file is a test file
+   */
+  static isTestFile(filePath) {
+    return (
+      filePath.includes('.test.') ||
+      filePath.includes('.spec.') ||
+      filePath.includes('__tests__') ||
+      filePath.includes('__mocks__')
+    );
+  }
+
+  /**
+   * Check if file is a config file
+   */
+  static isConfigFile(filePath) {
+    return (
+      filePath.includes('config') ||
+      filePath.endsWith('.config.js') ||
+      filePath.endsWith('.config.ts') ||
+      filePath.includes('jest.') ||
+      filePath.includes('webpack.') ||
+      filePath.includes('vite.')
+    );
+  }
+
+  /**
+   * Categorize file type
+   */
+  static categorizeFile(filePath) {
+    if (this.isTestFile(filePath)) return 'test';
+    if (this.isConfigFile(filePath)) return 'config';
+    if (this.isSourceFile(filePath)) return 'source';
+    return 'other';
+  }
+
+  /**
+   * Get all source files in directory
+   */
+  static getAllSourceFiles(sourceDir, excludePaths = []) {
+    const pattern = `${sourceDir}/**/*.{js,jsx,ts,tsx,mjs,cjs}`;
+    const ignore = excludePaths.map(p => `${sourceDir}/**/${p}/**`);
+
+    try {
+      return glob.sync(pattern, { ignore, absolute: true });
+    } catch (error) {
+      console.error('Error scanning source files:', error.message);
+      return [];
+    }
+  }
+
+  /**
+   * Read file content safely
+   */
+  static readFile(filePath) {
+    try {
+      return fs.readFileSync(filePath, 'utf-8');
+    } catch (error) {
+      console.warn(`Failed to read ${filePath}:`, error.message);
+      return '';
+    }
+  }
+
+  /**
+   * Calculate line changes between two file versions
+   */
+  static calculateLineChanges(oldContent, newContent) {
+    const oldLines = oldContent ? oldContent.split('\n').length : 0;
+    const newLines = newContent ? newContent.split('\n').length : 0;
+
+    return {
+      added: Math.max(0, newLines - oldLines),
+      deleted: Math.max(0, oldLines - newLines),
+      total: Math.abs(newLines - oldLines),
+    };
+  }
+
+  /**
+   * Extract module name from file path
+   */
+  static extractModuleName(filePath) {
+    const parts = filePath.split(path.sep);
+    const srcIndex = parts.indexOf('src');
+
+    if (srcIndex !== -1 && parts.length > srcIndex + 1) {
+      return parts[srcIndex + 1];
+    }
+
+    return path.basename(filePath, path.extname(filePath));
+  }
+
+  /**
+   * Get relative path from project root
+   */
+  static getRelativePath(filePath) {
+    return path.relative(process.cwd(), filePath);
+  }
+}

package/modules/utils/git-utils.js

@@ -0,0 +1,198 @@
+/**
+ * Git Utilities
+ * Helper functions for git operations
+ */
+
+import { execSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+
+export class GitUtils {
+  /**
+   * Get list of changed files between two refs
+   * @param {string} baseRef - Base git reference
+   * @param {string} headRef - Head git reference
+   * @param {string} workDir - Working directory (optional, defaults to cwd)
+   */
+  static getChangedFiles(baseRef, headRef, workDir = null) {
+    try {
+      const cwd = workDir ?  path.resolve(workDir) : process.cwd();
+
+      // Verify the directory exists and is a git repo
+      if (! fs.existsSync(cwd)) {
+        throw new Error(`Directory does not exist: ${cwd}`);
+      }
+
+      const diffCommand = `git diff --name-status ${baseRef}...${headRef}`;
+      const diffOutput = execSync(diffCommand, {
+        encoding: 'utf-8',
+        cwd: cwd  // FIXED: Execute git command in the source directory
+      });
+
+      const changedFiles = [];
+      const lines = diffOutput.trim().split('\n').filter(line => line);
+
+      for (const line of lines) {
+        const parts = line.split('\t');
+        const status = parts[0];
+        const filePath = parts[1];
+
+        changedFiles.push({
+          status: this.parseStatus(status),
+          path: filePath,
+        });
+      }
+
+      return changedFiles;
+    } catch (error) {
+      console.error('Error getting changed files:', error.message);
+      console.error('  Working directory:', workDir || process.cwd());
+      console.error('  Base ref:', baseRef);
+      console.error('  Head ref:', headRef);
+      return [];
+    }
+  }
+
+  /**
+   * Get file content at specific ref
+   * @param {string} filePath - Relative file path
+   * @param {string} ref - Git reference
+   * @param {string} workDir - Working directory (optional)
+   */
+  static getFileContent(filePath, ref, workDir = null) {
+    try {
+      const cwd = workDir ? path.resolve(workDir) : process.cwd();
+
+      return execSync(`git show ${ref}:${filePath}`, {
+        encoding: 'utf-8',
+        cwd: cwd  // FIXED: Execute in source directory
+      });
+    } catch (error) {
+      // File might be new or deleted
+      return '';
+    }
+  }
+
+  /**
+   * Get diff between two versions of a file
+   * @param {string} filePath - File path relative to git root (e.g., 'src/modules/file.ts')
+   * @param {string} baseRef - Base git reference
+   * @param {string} headRef - Head git reference  
+   * @param {string} workDir - Working directory to run git from (optional)
+   */
+  static getFileDiff(filePath, baseRef, headRef, workDir = null) {
+    try {
+      // Determine working directory (should be git root or a path inside it)
+      const cwd = workDir ? path.resolve(workDir) : process.cwd();
+      
+      // Get git root from the working directory
+      const gitRoot = this.getGitRoot(cwd);
+      
+      if (!gitRoot) {
+        console.error('Not a git repository:', cwd);
+        return '';
+      }
+
+      // filePath is already relative to git root (from git diff --name-status)
+      // Execute git diff from git root
+      const diffCommand = `git diff ${baseRef}...${headRef} -- ${filePath}`;
+      
+      const result = execSync(diffCommand, {
+        encoding: 'utf-8',
+        cwd: gitRoot,
+        maxBuffer: 10 * 1024 * 1024, // 10MB buffer for large diffs
+      });
+
+      return result;
+    } catch (error) {
+      console.error('Error getting file diff:', error.message);
+      console.error('  File:', filePath);
+      console.error('  Base:', baseRef);
+      console.error('  Head:', headRef);
+      console.error('  Working dir:', workDir);
+      return '';
+    }
+  }
+
+  /**
+   * Parse git status code
+   */
+  static parseStatus(statusCode) {
+    const statusMap = {
+      'A': 'added',
+      'M': 'modified',
+      'D': 'deleted',
+      'R': 'renamed',
+      'C': 'copied',
+    };
+    return statusMap[statusCode[0]] || 'unknown';
+  }
+
+  /**
+   * Get current branch name
+   */
+  static getCurrentBranch(workDir = null) {
+    try {
+      const cwd = workDir ? path.resolve(workDir) : process.cwd();
+
+      return execSync('git rev-parse --abbrev-ref HEAD', {
+        encoding: 'utf-8',
+        cwd: cwd
+      }).trim();
+    } catch (error) {
+      return 'unknown';
+    }
+  }
+
+  /**
+   * Check if ref exists
+   */
+  static refExists(ref, workDir = null) {
+    try {
+      const cwd = workDir ? path.resolve(workDir) : process.cwd();
+
+      execSync(`git rev-parse --verify ${ref}`, {
+        encoding: 'utf-8',
+        stdio: 'ignore',
+        cwd: cwd
+      });
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Check if directory is a git repository
+   */
+  static isGitRepo(workDir = null) {
+    try {
+      const cwd = workDir ? path.resolve(workDir) : process.cwd();
+
+      execSync('git rev-parse --git-dir', {
+        encoding: 'utf-8',
+        stdio: 'ignore',
+        cwd: cwd
+      });
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Get git root directory
+   */
+  static getGitRoot(workDir = null) {
+    try {
+      const cwd = workDir ? path.resolve(workDir) : process.cwd();
+
+      return execSync('git rev-parse --show-toplevel', {
+        encoding: 'utf-8',
+        cwd: cwd
+      }).trim();
+    } catch (error) {
+      return null;
+    }
+  }
+}