impact-analysis 1.0.6 → 2.0.1

package/src/cache/graphCache.ts

@@ -0,0 +1,49 @@
+import fs from "fs";
+import { DependencyGraph } from "../graph/types";
+
+const CACHE_FILE = ".impact-analysis-cache.json";
+
+export function loadCache(): DependencyGraph | null {
+  try {
+    if (!fs.existsSync(CACHE_FILE)) {
+      return null;
+    }
+    
+    const data = JSON.parse(fs.readFileSync(CACHE_FILE, "utf-8"));
+    
+    return {
+      imports: new Map(
+        Object.entries(data.imports).map(([key, value]) => [key, new Set(value as string[])])
+      ),
+      importedBy: new Map(
+        Object.entries(data.importedBy).map(([key, value]) => [key, new Set(value as string[])])
+      ),
+      componentUsage: new Map(
+        Object.entries(data.componentUsage).map(([key, value]) => [key, new Set(value as string[])])
+      )
+    };
+  } catch (error) {
+    console.warn('Cache file corrupted, rebuilding...');
+    return null;
+  }
+}
+
+export function saveCache(data: DependencyGraph) {
+  try {
+    const serializable = {
+      imports: Object.fromEntries(
+        Array.from(data.imports.entries()).map(([key, value]) => [key, Array.from(value)])
+      ),
+      importedBy: Object.fromEntries(
+        Array.from(data.importedBy.entries()).map(([key, value]) => [key, Array.from(value)])
+      ),
+      componentUsage: Object.fromEntries(
+        Array.from(data.componentUsage.entries()).map(([key, value]) => [key, Array.from(value)])
+      )
+    };
+    
+    fs.writeFileSync(CACHE_FILE, JSON.stringify(serializable, null, 2));
+  } catch (error) {
+    console.warn('Failed to save cache:', error instanceof Error ? error.message : String(error));
+  }
+}

package/src/cli.ts

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+import 'dotenv/config';
+import path from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { getChangedFiles } from './git/getChangedFiles';
+import { scanRepo } from './scanner/scanRepo';
+import { buildGraph } from './graph/buildGraph';
+import { analyzeImpact } from './core/analyzer';
+import { generateHtmlReport } from './report/html-generator';
+import { explainImpact } from './ai/explain';
+
+const execAsync = promisify(exec);
+
+async function main() {
+  const args = process.argv.slice(2);
+  const showHtml = args.includes('--html');
+  const useAI = args.includes('--ai');
+  const clearCache = args.includes('--clear-cache');
+  const baseBranch = args.find(arg => !arg.startsWith('--')) || 'main';
+
+  try {
+    if (clearCache) {
+      const fs = await import('fs');
+      if (fs.existsSync('.impact-analysis-cache.json')) {
+        fs.unlinkSync('.impact-analysis-cache.json');
+        console.log('Cache cleared.');
+      }
+    }
+    
+    console.log('Scanning repository...');
+    const allFiles = await scanRepo();
+    
+    console.log(`Building dependency graph from ${allFiles.length} files...`);
+    const graph = await buildGraph(allFiles);
+    
+    console.log(`Getting changed files against ${baseBranch}...`);
+    const changedFiles = await getChangedFiles(baseBranch);
+    
+    if (changedFiles.length === 0) {
+      console.log('No changed files found.');
+      return;
+    }
+    
+    console.log(`Found ${changedFiles.length} changed files. Analyzing impact...`);
+    
+    const dependencyMap: Record<string, string[]> = {};
+    graph.importedBy.forEach((importers, file) => {
+      dependencyMap[file] = Array.from(importers);
+    });
+    
+    const results = analyzeImpact(changedFiles, dependencyMap);
+
+    if (useAI) {
+      try {
+        console.log('Getting AI explanation...');
+        const explanation = await explainImpact(results);
+        if (explanation) {
+          (results as any).aiExplanation = explanation;
+        }
+      } catch (error) {
+        console.warn('AI explanation failed:', error instanceof Error ? error.message : String(error));
+      }
+    }
+
+    console.log('\n--- Impact Analysis Results ---\n');
+    results.forEach((result, index) => {
+      console.log(`${index + 1}. ${path.basename(result.changedFile)}`);
+      console.log(`   Risk: ${result.risk}`);
+      console.log(`   Impacted files: ${result.impactedFiles.length}`);
+      if (result.impactedFiles.length > 0) {
+        result.impactedFiles.slice(0, 5).forEach(file => {
+          console.log(`     - ${path.basename(file)}`);
+        });
+        if (result.impactedFiles.length > 5) {
+          console.log(`     ... and ${result.impactedFiles.length - 5} more`);
+        }
+      }
+      console.log('');
+    });
+
+    // Generate HTML by default
+    console.log('Generating HTML report...');
+    const htmlPath = generateHtmlReport(results);
+    console.log(`Report saved: ${htmlPath}`);
+    
+    if (showHtml) {
+      try {
+        // Use platform-specific command to open the file
+        const command = process.platform === 'win32' 
+          ? `start "" "${htmlPath}"`
+          : process.platform === 'darwin'
+          ? `open "${htmlPath}"`
+          : `xdg-open "${htmlPath}"`;
+        
+        await execAsync(command);
+        console.log(`Report opened in browser`);
+      } catch (err) {
+        console.log(`Could not auto-open browser. Please open: ${htmlPath}`);
+      }
+    } else {
+      console.log(`\nTo view the graphical report, run: impact-analysis --html`);
+    }
+  } catch (error) {
+    console.error('Error:', error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+main();

package/src/core/analyzer.ts

@@ -0,0 +1,28 @@
+import path from 'path';
+
+export interface ImpactResult {
+  changedFile: string;
+  impactedFiles: string[];
+  risk: 'LOW' | 'MEDIUM' | 'HIGH';
+}
+
+export function analyzeImpact(
+  changedFiles: string[],
+  dependencyMap: Record<string, string[]>
+): ImpactResult[] {
+  return changedFiles.map(changed => {
+    const impacted = Object.entries(dependencyMap)
+      .filter(([, deps]) => deps.includes(changed))
+      .map(([file]) => file);
+
+    let risk: ImpactResult['risk'] = 'LOW';
+    if (impacted.length > 5) risk = 'HIGH';
+    else if (impacted.length > 2) risk = 'MEDIUM';
+
+    return {
+      changedFile: changed,
+      impactedFiles: impacted,
+      risk
+    };
+  });
+}

package/src/git/getChangedFiles.ts

@@ -0,0 +1,15 @@
+import simpleGit from "simple-git";
+import path from "path";
+
+export async function getChangedFiles(base: string): Promise<string[]> {
+  try {
+    const git = simpleGit();
+    const diff = await git.diff(["--name-only", base]);
+    return diff
+      .split("\n")
+      .filter(f => /\.(js|jsx|ts|tsx|vue)$/.test(f))
+      .map(f => path.resolve(process.cwd(), f));
+  } catch (error) {
+    throw new Error(`Failed to get changed files. Make sure Git is installed and you're in a Git repository. Base branch: ${base}`);
+  }
+}

package/src/graph/buildGraph.ts

@@ -0,0 +1,151 @@
+import fs from "fs";
+import path from "path";
+import { extractImports } from "../parser/parseJS";
+import { parseVue } from "../parser/parseVue";
+import { DependencyGraph } from "./types";
+import { loadCache, saveCache } from "../cache/graphCache";
+
+function resolveImportPath(importPath: string, fromFile: string, allFiles: string[]): string | null {
+    if (
+        (!importPath.startsWith('.') && !importPath.startsWith('/') && 
+         !importPath.startsWith('~') && !importPath.startsWith('@') && 
+         !importPath.startsWith('#')) ||
+        importPath.startsWith('virtual:') ||
+        importPath.startsWith('~icons/') ||
+        importPath.startsWith('unplugin-') ||
+        /\.(css|scss|sass|less|styl|stylus|png|jpg|jpeg|gif|svg|woff|woff2|ttf|eot)$/.test(importPath)
+    ) {
+        return null;
+    }
+
+    const baseDir = path.dirname(fromFile);
+    const projectRoot = process.cwd();
+    const extensions = ['.vue', '.js', '.ts', '.jsx', '.tsx', '.mjs', '.cjs', ''];
+    const indexFiles = ['/index.vue', '/index.js', '/index.ts', '/index.jsx', '/index.tsx', '/index.mjs'];
+
+    let resolvedBase: string | null = null;
+
+    // Handle various path alias patterns
+    if (importPath.startsWith('~/') || importPath.startsWith('@/')) {
+        // Common aliases: ~/ or @/ → project root
+        resolvedBase = path.join(projectRoot, importPath.substring(2));
+    } else if (importPath.startsWith('#')) {
+        // Nuxt 3 aliases: #app, #imports, #components
+        // Map to common locations
+        if (importPath.startsWith('#app') || importPath.startsWith('#imports')) {
+            return null; // Skip Nuxt internals
+        }
+        if (importPath.startsWith('#components/')) {
+            resolvedBase = path.join(projectRoot, 'components', importPath.substring(12));
+        } else {
+            return null;
+        }
+    } else if (importPath.startsWith('/')) {
+        // Absolute path from root
+        resolvedBase = path.join(projectRoot, importPath.substring(1));
+    } else if (importPath.startsWith('.')) {
+        // Relative path
+        resolvedBase = path.join(baseDir, importPath);
+    } else {
+        // Could be a tsconfig path alias (e.g., @components/...)
+        // Try common patterns
+        const aliasPatterns = [
+            ['@components/', 'components/'],
+            ['@utils/', 'utils/'],
+            ['@lib/', 'lib/'],
+            ['@src/', 'src/'],
+            ['@/', ''],
+        ];
+        
+        for (const [alias, replacement] of aliasPatterns) {
+            if (importPath.startsWith(alias)) {
+                resolvedBase = path.join(projectRoot, importPath.replace(alias, replacement));
+                break;
+            }
+        }
+        
+        if (!resolvedBase) {
+            return null; // Likely an external package
+        }
+    }
+
+    // Normalize path separators
+    resolvedBase = path.normalize(resolvedBase);
+
+    const hasExtension = extensions.some(ext => ext && importPath.endsWith(ext));
+
+    for (const ext of extensions) {
+        const withExt = hasExtension ? resolvedBase : resolvedBase + ext;
+        
+        if (allFiles.includes(withExt)) {
+            return withExt;
+        }
+    }
+
+    for (const indexFile of indexFiles) {
+        const resolved = resolvedBase + indexFile;
+        if (allFiles.includes(resolved)) {
+            return resolved;
+        }
+    }
+
+    return null;
+}
+
+export async function buildGraph(files: string[]): Promise<DependencyGraph> {
+    const cached = loadCache();
+    if (cached) {
+        console.log('Using cached dependency graph...');
+        return cached;
+    }
+
+    const graph: DependencyGraph = {
+        imports: new Map(),
+        importedBy: new Map(),
+        componentUsage: new Map()
+    };
+
+    let filesProcessed = 0;
+
+    for (const file of files) {
+        const code = fs.readFileSync(file, "utf-8");
+
+        if (file.endsWith(".vue")) {
+            const { imports, components } = parseVue(code);
+
+            imports.forEach(imp => {
+                const resolved = resolveImportPath(imp, file, files);
+                if (resolved) {
+                    graph.imports.set(file, (graph.imports.get(file) || new Set()).add(resolved));
+                    graph.importedBy.set(resolved, (graph.importedBy.get(resolved) || new Set()).add(file));
+                }
+            });
+
+            components.forEach(component => {
+                graph.componentUsage.set(
+                    component,
+                    (graph.componentUsage.get(component) || new Set()).add(file)
+                );
+            });
+        } else {
+            const imports = extractImports(code);
+
+            imports.forEach(imp => {
+                const resolved = resolveImportPath(imp, file, files);
+                if (resolved) {
+                    graph.imports.set(file, (graph.imports.get(file) || new Set()).add(resolved));
+                    graph.importedBy.set(resolved, (graph.importedBy.get(resolved) || new Set()).add(file));
+                }
+            });
+        }
+
+        filesProcessed++;
+    }
+
+    console.log(`Dependency graph built: ${graph.importedBy.size} files with dependencies`);
+    
+    saveCache(graph);
+    
+    return graph;
+}
+

package/src/graph/types.ts

@@ -0,0 +1,5 @@
+export interface DependencyGraph {
+  imports: Map<string, Set<string>>;
+  importedBy: Map<string, Set<string>>;
+  componentUsage: Map<string, Set<string>>;
+}

package/src/parser/parseJS.ts

@@ -0,0 +1,69 @@
+import { parse } from "@babel/parser";
+import traverse from "@babel/traverse";
+
+export function extractImports(code: string): string[] {
+  const imports: string[] = [];
+
+  try {
+    const ast = parse(code, {
+      sourceType: "unambiguous",
+      plugins: [
+        "typescript",
+        "jsx",
+        "decorators-legacy",
+        "classProperties",
+        "dynamicImport",
+        "importMeta",
+        "topLevelAwait",
+        "classStaticBlock",
+        "optionalChaining",
+        "nullishCoalescingOperator"
+      ],
+      errorRecovery: true
+    });
+
+    traverse(ast as any, {
+      // Static imports: import x from 'module'
+      ImportDeclaration(path) {
+        imports.push(path.node.source.value);
+      },
+      // Dynamic imports: import('module')
+      Import(path) {
+        const parent = path.parent;
+        if (parent.type === 'CallExpression' && parent.arguments[0]) {
+          const arg = parent.arguments[0];
+          if (arg.type === 'StringLiteral') {
+            imports.push(arg.value);
+          }
+        }
+      },
+      // Export from: export { x } from 'module'
+      ExportNamedDeclaration(path) {
+        if (path.node.source) {
+          imports.push(path.node.source.value);
+        }
+      },
+      // Export all: export * from 'module'
+      ExportAllDeclaration(path) {
+        imports.push(path.node.source.value);
+      },
+      // CommonJS require: const x = require('module')
+      CallExpression(path) {
+        if (
+          path.node.callee.type === 'Identifier' &&
+          path.node.callee.name === 'require' &&
+          path.node.arguments[0] &&
+          path.node.arguments[0].type === 'StringLiteral'
+        ) {
+          imports.push(path.node.arguments[0].value);
+        }
+      }
+    });
+  } catch (error) {
+    // Silently skip files with parse errors
+    // Most errors are from node_modules or generated files
+  }
+
+  // Remove duplicates
+  return [...new Set(imports)];
+}

package/src/parser/parseVue.ts

@@ -0,0 +1,23 @@
+import { parse as parseSFC } from "@vue/compiler-sfc";
+import { extractImports } from "./parseJS";
+import { extractTemplateComponents } from "./parseVueTemplate";
+
+export function parseVue(code: string) {
+  try {
+    const { descriptor } = parseSFC(code);
+
+    const scriptContent = descriptor.script?.content || '';
+    const scriptSetupContent = descriptor.scriptSetup?.content || '';
+    const allScript = scriptContent + '\n' + scriptSetupContent;
+
+    return {
+      imports: allScript.trim() ? extractImports(allScript) : [],
+      components: extractTemplateComponents(code)
+    };
+  } catch (error) {
+    return {
+      imports: [],
+      components: []
+    };
+  }
+}

package/src/parser/parseVueTemplate.ts

@@ -0,0 +1,16 @@
+import { parse as parseSFC } from "@vue/compiler-sfc";
+
+export function extractTemplateComponents(code: string): string[] {
+  const { descriptor } = parseSFC(code);
+  const template = descriptor.template?.content || "";
+
+  const componentRegex = /<([A-Z][\w-]*)/g;
+  const components = new Set<string>();
+
+  let match;
+  while ((match = componentRegex.exec(template))) {
+    components.add(match[1]);
+  }
+
+  return Array.from(components);
+}