blast-radius-analyzer 1.2.1

package/dist/types.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Blast Radius Analyzer - Type Definitions
+ * 分析代码改动影响范围的核心类型
+ */
+export interface CodeChange {
+    file: string;
+    type: ChangeType;
+    symbol?: string;
+    line?: number;
+    diff?: string;
+}
+export type ChangeType = 'add' | 'delete' | 'modify' | 'rename';
+export interface DependencyNode {
+    id: string;
+    kind: NodeKind;
+    file?: string;
+    line?: number;
+    exports?: string[];
+    imports?: ImportInfo[];
+    dependents: string[];
+    depth: number;
+}
+export type NodeKind = 'file' | 'function' | 'class' | 'interface' | 'type' | 'variable' | 'export';
+export interface ImportInfo {
+    source: string;
+    imported: string[];
+    isReExport: boolean;
+}
+export interface DependencyGraph {
+    nodes: Map<string, DependencyNode>;
+    edges: Edge[];
+    entryPoints: string[];
+}
+export interface Edge {
+    from: string;
+    to: string;
+    type: EdgeType;
+    symbol?: string;
+}
+export type EdgeType = 'import' | 'extend' | 'implement' | 'type-ref' | 'call' | 'property-access' | 'param-type';
+export interface ImpactScope {
+    changedFile: string;
+    timestamp: string;
+    stats: ImpactStats;
+    levels: ImpactLevel[];
+    affectedFiles: AffectedFile[];
+    propagationPaths: PropagationPath[];
+    highRiskImpacts: HighRiskImpact[];
+    recommendations: string[];
+}
+export interface ImpactStats {
+    totalAffectedFiles: number;
+    directDependencies: number;
+    transitiveDependencies: number;
+    filesWithBreakingChanges: number;
+    criticalFiles: number;
+    estimatedRippleDepth: number;
+}
+export interface ImpactLevel {
+    depth: number;
+    description: string;
+    files: string[];
+    nodeCount: number;
+}
+export interface AffectedFile {
+    file: string;
+    kind: NodeKind;
+    changeType: ChangeType;
+    impactLevel: number;
+    impactFactors: ImpactFactor[];
+    line?: number;
+}
+export interface ImpactFactor {
+    factor: string;
+    weight: number;
+    reason: string;
+}
+export interface PropagationPath {
+    from: string;
+    to: string;
+    path: string[];
+    edgeTypes: EdgeType[];
+    riskLevel: RiskLevel;
+}
+export type RiskLevel = 'low' | 'medium' | 'high' | 'critical';
+export interface HighRiskImpact {
+    file: string;
+    reason: string;
+    riskLevel: RiskLevel;
+    mitigation?: string;
+}
+export interface AnalyzerConfig {
+    projectRoot: string;
+    tsConfigPath?: string;
+    maxDepth: number;
+    includeNodeModules: boolean;
+    includeTests: boolean;
+    criticalPatterns: string[];
+    ignorePatterns: string[];
+    verbose: boolean;
+    outputFormat: 'json' | 'text' | 'html' | 'graph';
+}

package/dist/types.js

@@ -0,0 +1,5 @@
+/**
+ * Blast Radius Analyzer - Type Definitions
+ * 分析代码改动影响范围的核心类型
+ */
+export {};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "blast-radius-analyzer",
+  "version": "1.2.1",
+  "description": "Analyze code change impact and blast radius - 改动影响范围分析器",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "blast-radius": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "analyze": "node dist/index.js"
+  },
+  "keywords": [
+    "blast-radius",
+    "impact-analysis",
+    "code-analysis",
+    "dependency-tracking",
+    "data-flow",
+    "typescript"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "dependencies": {
+    "ts-morph": "^25.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.4.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/core/AnalysisCache.ts

@@ -0,0 +1,189 @@
+/**
+ * AnalysisCache - 增量分析缓存
+ *
+ * 缓存符号分析结果，检测文件变更，只重新分析受影响的部分
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import type { ReferenceInfo, SymbolInfo } from './SymbolAnalyzer.js';
+
+export interface CacheEntry {
+  symbolName: string;
+  file: string;
+  timestamp: number;
+  fileHash: string;
+  references: ReferenceInfo[];
+  symbolInfo: SymbolInfo | null;
+}
+
+export interface FileState {
+  mtime: number;
+  hash: string;
+}
+
+export class AnalysisCache {
+  private cacheDir: string;
+  private fileStates: Map<string, FileState> = new Map();
+  private memoryCache: Map<string, CacheEntry> = new Map();
+
+  constructor(projectRoot: string) {
+    this.cacheDir = path.join(projectRoot, '.blast-radius-cache');
+    this.ensureCacheDir();
+    this.loadFileStates();
+  }
+
+  private ensureCacheDir(): void {
+    if (!fs.existsSync(this.cacheDir)) {
+      fs.mkdirSync(this.cacheDir, { recursive: true });
+    }
+  }
+
+  private loadFileStates(): void {
+    const stateFile = path.join(this.cacheDir, 'file-states.json');
+    if (fs.existsSync(stateFile)) {
+      try {
+        const data = JSON.parse(fs.readFileSync(stateFile, 'utf-8'));
+        for (const [key, value] of Object.entries(data)) {
+          this.fileStates.set(key, value as FileState);
+        }
+      } catch {
+        // 忽略解析错误
+      }
+    }
+  }
+
+  private saveFileStates(): void {
+    const stateFile = path.join(this.cacheDir, 'file-states.json');
+    const data: Record<string, FileState> = {};
+    for (const [key, value] of this.fileStates) {
+      data[key] = value;
+    }
+    fs.writeFileSync(stateFile, JSON.stringify(data, null, 2), 'utf-8');
+  }
+
+  private computeFileHash(filePath: string): string {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    // 简单的哈希计算
+    let hash = 0;
+    for (let i = 0; i < content.length; i++) {
+      const char = content.charCodeAt(i);
+      hash = ((hash << 5) - hash) + char;
+      hash = hash & hash;
+    }
+    return Math.abs(hash).toString(16);
+  }
+
+  /**
+   * 检测文件是否有变更
+   */
+  hasFileChanged(filePath: string): boolean {
+    if (!fs.existsSync(filePath)) {
+      return true;
+    }
+
+    const stat = fs.statSync(filePath);
+    const currentMtime = stat.mtimeMs;
+    const currentHash = this.computeFileHash(filePath);
+
+    const saved = this.fileStates.get(filePath);
+    if (!saved) {
+      return true;
+    }
+
+    return saved.hash !== currentHash || saved.mtime !== currentMtime;
+  }
+
+  /**
+   * 获取所有变更的文件
+   */
+  getChangedFiles(filePaths: string[]): string[] {
+    return filePaths.filter(f => this.hasFileChanged(f));
+  }
+
+  /**
+   * 更新文件状态
+   */
+  updateFileState(filePath: string): void {
+    if (!fs.existsSync(filePath)) {
+      this.fileStates.delete(filePath);
+      return;
+    }
+
+    const stat = fs.statSync(filePath);
+    this.fileStates.set(filePath, {
+      mtime: stat.mtimeMs,
+      hash: this.computeFileHash(filePath),
+    });
+    this.saveFileStates();
+  }
+
+  /**
+   * 获取缓存的引用结果
+   */
+  getCachedReferences(symbolName: string, file: string): CacheEntry | null {
+    const key = `${file}:${symbolName}`;
+    return this.memoryCache.get(key) || null;
+  }
+
+  /**
+   * 缓存引用结果
+   */
+  cacheReferences(symbolName: string, file: string, symbolInfo: SymbolInfo | null, references: ReferenceInfo[]): void {
+    const key = `${file}:${symbolName}`;
+    this.memoryCache.set(key, {
+      symbolName,
+      file,
+      timestamp: Date.now(),
+      fileHash: this.computeFileHash(file),
+      references,
+      symbolInfo,
+    });
+
+    // 同时持久化到磁盘
+    const cacheFile = path.join(this.cacheDir, `${Buffer.from(key).toString('base64url')}.json`);
+    try {
+      fs.writeFileSync(cacheFile, JSON.stringify({
+        symbolName,
+        file,
+        timestamp: Date.now(),
+        references,
+        symbolInfo: symbolInfo ? {
+          name: symbolInfo.name,
+          kind: symbolInfo.kind,
+          file: symbolInfo.file,
+          line: symbolInfo.line,
+        } : null,
+      }, null, 2), 'utf-8');
+    } catch {
+      // 忽略缓存写入错误
+    }
+  }
+
+  /**
+   * 清除缓存
+   */
+  clear(): void {
+    this.memoryCache.clear();
+    this.fileStates.clear();
+    this.saveFileStates();
+
+    // 清除缓存文件
+    const files = fs.readdirSync(this.cacheDir);
+    for (const file of files) {
+      if (file.endsWith('.json') && file !== 'file-states.json') {
+        fs.unlinkSync(path.join(this.cacheDir, file));
+      }
+    }
+  }
+
+  /**
+   * 获取缓存统计
+   */
+  getStats(): { entries: number; files: number } {
+    return {
+      entries: this.memoryCache.size,
+      files: this.fileStates.size,
+    };
+  }
+}

package/src/core/CallStackBuilder.ts

@@ -0,0 +1,345 @@
+/**
+ * CallStackBuilder - 调用栈视图构建器
+ *
+ * 从改动点向上追踪，构建完整的调用链视图
+ */
+
+import { Project, Node, SyntaxKind, SourceFile } from 'ts-morph';
+import * as path from 'path';
+
+export interface CallStackNode {
+  name: string;
+  file: string;
+  line: number;
+  type: 'function' | 'arrow' | 'method' | 'component';
+  children: CallStackNode[];
+  /** 调用此函数的代码（父节点的调用点） */
+  callSite?: {
+    line: number;
+    expression: string;
+  };
+}
+
+export interface CallStackTree {
+  root: CallStackNode;
+  depth: number;
+  path: string[];  // 路径字符串
+}
+
+export class CallStackBuilder {
+  private project: Project;
+  private projectRoot: string;
+
+  constructor(projectRoot: string, tsConfigPath: string) {
+    this.projectRoot = projectRoot;
+    this.project = new Project({
+      tsConfigFilePath: tsConfigPath,
+      skipAddingFilesFromTsConfig: true,
+    });
+  }
+
+  /**
+   * 添加源文件到项目
+   */
+  addSourceFiles(patterns: string[]): void {
+    for (const pattern of patterns) {
+      this.project.addSourceFilesAtPaths(pattern);
+    }
+    // 过滤 node_modules
+    const sourceFiles = this.project.getSourceFiles();
+    for (const sf of sourceFiles) {
+      if (sf.getFilePath().includes('node_modules')) {
+        sf.forget();
+      }
+    }
+  }
+
+  /**
+   * 构建调用栈视图（从改动点向上追踪到入口）
+   */
+  buildCallStack(targetSymbol: string, targetFile: string): CallStackTree | null {
+    // 找到目标函数的定义
+    const definition = this.findSymbolDefinition(targetSymbol, targetFile);
+    if (!definition) return null;
+
+    const root: CallStackNode = {
+      name: targetSymbol,
+      file: definition.file,
+      line: definition.line,
+      type: 'function',
+      children: [],
+    };
+
+    // 递归追踪调用者
+    this.traceCallers(root, new Set<string>(), 0, 10);
+
+    // 计算深度
+    const depth = this.calculateDepth(root);
+
+    // 构建路径字符串
+    const pathStr = this.buildPathString(root);
+
+    return { root, depth, path: pathStr };
+  }
+
+  /**
+   * 查找符号定义
+   */
+  private findSymbolDefinition(symbolName: string, inFile: string): {
+    file: string;
+    line: number;
+    type: 'function' | 'variable' | 'class' | 'interface';
+  } | null {
+    const sourceFile = this.project.getSourceFile(inFile);
+    if (!sourceFile) return null;
+
+    let result: { file: string; line: number; type: 'function' | 'variable' | 'class' | 'interface' } | null = null;
+
+    sourceFile.forEachDescendant(node => {
+      if (Node.isFunctionDeclaration(node)) {
+        const func = node;
+        if (func.getName() === symbolName) {
+          result = {
+            file: inFile,
+            line: func.getStartLineNumber(),
+            type: 'function',
+          };
+        }
+      }
+
+      if (Node.isVariableStatement(node)) {
+        const varDecl = node.getFirstDescendantByKind(SyntaxKind.VariableDeclaration);
+        if (varDecl && varDecl.getName() === symbolName) {
+          result = {
+            file: inFile,
+            line: varDecl.getStartLineNumber(),
+            type: 'variable',
+          };
+        }
+      }
+    });
+
+    return result;
+  }
+
+  /**
+   * 递归追踪调用者
+   */
+  private traceCallers(node: CallStackNode, visited: Set<string>, depth: number, maxDepth: number): void {
+    if (depth > maxDepth) return;
+
+    // 找所有调用此函数的地方
+    const callers = this.findCallers(node.name, node.file);
+
+    for (const caller of callers) {
+      const key = `${caller.file}:${caller.line}:${caller.name}`;
+      if (visited.has(key)) continue;
+      visited.add(key);
+
+      // 创建调用者节点
+      const callerNode: CallStackNode = {
+        name: caller.name,
+        file: caller.file,
+        line: caller.line,
+        type: caller.type,
+        children: [],
+        callSite: {
+          line: caller.callLine,
+          expression: caller.callExpression,
+        },
+      };
+
+      node.children.push(callerNode);
+
+      // 递归追踪调用者的调用者
+      this.traceCallers(callerNode, visited, depth + 1, maxDepth);
+    }
+  }
+
+  /**
+   * 查找调用某个函数的所有地方
+   */
+  private findCallers(symbolName: string, definedInFile: string): Array<{
+    name: string;
+    file: string;
+    line: number;
+    type: 'function' | 'arrow' | 'method' | 'component';
+    callLine: number;
+    callExpression: string;
+  }> {
+    const results: Array<{
+      name: string;
+      file: string;
+      line: number;
+      type: 'function' | 'arrow' | 'method' | 'component';
+      callLine: number;
+      callExpression: string;
+    }> = [];
+
+    for (const sourceFile of this.project.getSourceFiles()) {
+      const filePath = sourceFile.getFilePath();
+
+      sourceFile.forEachDescendant((node: Node) => {
+        // 查找函数定义
+        let funcInfo: {
+          name: string;
+          file: string;
+          line: number;
+          type: 'function' | 'arrow' | 'method' | 'component';
+        } | null = null;
+
+        if (Node.isFunctionDeclaration(node)) {
+          const func = node;
+          const name = func.getName();
+          if (name) {
+            funcInfo = {
+              name,
+              file: filePath,
+              line: func.getStartLineNumber(),
+              type: 'function',
+            };
+          }
+        } else if (Node.isArrowFunction(node)) {
+          // 检查是否是某个 const/let 声明的箭头函数
+          const parent = node.getParent();
+          if (parent && Node.isVariableDeclaration(parent)) {
+            const varDecl = parent;
+            const name = varDecl.getName();
+            if (name && !name.startsWith('_')) {
+              funcInfo = {
+                name,
+                file: filePath,
+                line: node.getStartLineNumber(),
+                type: 'arrow',
+              };
+            }
+          }
+        } else if (Node.isMethodDeclaration(node)) {
+          const method = node;
+          const name = method.getName();
+          funcInfo = {
+            name,
+            file: filePath,
+            line: method.getStartLineNumber(),
+            type: 'method',
+          };
+        } else if (Node.isPropertyAssignment(node) && Node.isFunctionExpression(node.getInitializer())) {
+          // React 组件: onClick={() => ...}
+          const prop = node;
+          const name = prop.getName();
+          funcInfo = {
+            name: name || 'anonymous',
+            file: filePath,
+            line: node.getStartLineNumber(),
+            type: 'component',
+          };
+        }
+
+        // 如果找到了函数定义，检查是否调用了目标符号
+        if (funcInfo && funcInfo.name !== symbolName) {
+          const calls = this.findCallsInNode(node, symbolName);
+          for (const call of calls) {
+            results.push({
+              ...funcInfo,
+              callLine: call.line,
+              callExpression: call.expression,
+            });
+          }
+        }
+      });
+    }
+
+    return results;
+  }
+
+  /**
+   * 在节点内查找对某个符号的调用
+   */
+  private findCallsInNode(node: Node, symbolName: string): Array<{ line: number; expression: string }> {
+    const results: Array<{ line: number; expression: string }> = [];
+
+    node.forEachDescendant((child: Node) => {
+      if (Node.isCallExpression(child)) {
+        const callExpr = child;
+        const expr = callExpr.getExpression();
+
+        if (Node.isIdentifier(expr)) {
+          const name = expr.getText();
+          if (name === symbolName) {
+            results.push({
+              line: callExpr.getStartLineNumber(),
+              expression: callExpr.getText().slice(0, 50),
+            });
+          }
+        }
+      }
+    });
+
+    return results;
+  }
+
+  /**
+   * 计算树深度
+   */
+  private calculateDepth(node: CallStackNode): number {
+    if (node.children.length === 0) return 0;
+    return 1 + Math.max(...node.children.map(c => this.calculateDepth(c)));
+  }
+
+  /**
+   * 构建路径字符串
+   */
+  private buildPathString(node: CallStackNode): string[] {
+    const result: string[] = [];
+    const build = (n: CallStackNode) => {
+      result.push(`${path.basename(n.file)}:${n.line} (${n.name})`);
+      if (n.children.length > 0) {
+        build(n.children[0]);
+      }
+    };
+    build(node);
+    return result;
+  }
+
+  /**
+   * 生成文本格式的调用栈视图
+   */
+  formatAsText(tree: CallStackTree, changedSymbol: string): string {
+    const lines: string[] = [];
+
+    lines.push('');
+    lines.push('═══════════════════════════════════════════════════════════════');
+    lines.push('                    📞 调用栈视图 (Call Stack)                  ');
+    lines.push('═══════════════════════════════════════════════════════════════');
+    lines.push('');
+
+    const renderNode = (n: CallStackNode, prefix: string, isLast: boolean, isRoot: boolean) => {
+      const connector = isLast ? '└─' : '├─';
+      const current = isRoot
+        ? `📍 ${n.name} (改动点)`
+        : `${connector} ${n.name}`;
+
+      lines.push(`${prefix}${current} → ${path.basename(n.file)}:${n.line}`);
+
+      if (n.callSite) {
+        lines.push(`${prefix}  │`);
+        lines.push(`${prefix}  └── 调用: 第${n.callSite.line}行 "${n.callSite.expression}"`);
+      }
+
+      const childPrefix = prefix + (isLast ? '   ' : '│  ');
+      n.children.forEach((child, idx) => {
+        const isChildLast = idx === n.children.length - 1;
+        renderNode(child, childPrefix, isChildLast, false);
+      });
+    };
+
+    renderNode(tree.root, '', true, true);
+
+    lines.push('');
+    lines.push(`深度: ${tree.depth} 层`);
+    lines.push(`路径: ${tree.path.join(' → ')}`);
+    lines.push('');
+
+    return lines.join('\n');
+  }
+}