@chongyan/autospec 1.0.1

package/plugins/hooks/lib/source-code-scanner.js

@@ -0,0 +1,596 @@
+/**
+ * Code Scanner - 统一的代码扫描模块
+ *
+ * 合并了 evolver.js 和 environment-manager.js 中的重复扫描逻辑
+ * 提供统一的代码模式扫描、环境变量扫描、依赖检测和源码目录发现功能
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+// 默认支持的代码文件扩展名
+const DEFAULT_CODE_EXTENSIONS = ['.py', '.js', '.ts', '.jsx', '.tsx', '.java', '.go', '.rs'];
+
+// 默认支持的环境变量文件扩展名
+const DEFAULT_ENV_EXTENSIONS = ['.py', '.js', '.ts', '.jsx', '.tsx', '.java', '.go', '.rs', '.env', '.yaml', '.yml', '.json'];
+
+// 需要跳过的目录
+const SKIP_DIRS = ['node_modules', '.git', 'dist', 'build', '__pycache__', 'venv', '.venv', 'target', '.idea', '.vscode'];
+
+// 常见源码目录
+const COMMON_SOURCE_DIRS = ['src', 'lib', 'app', 'server', 'backend', 'frontend', 'api', 'web', 'client', 'mobile', 'ml', 'ai', 'data'];
+
+// 目录到类型的映射
+const DIR_TYPE_MAP = {
+  'backend': 'backend',
+  'server': 'backend',
+  'api': 'backend',
+  'frontend': 'frontend',
+  'web': 'frontend',
+  'client': 'frontend',
+  'mobile': 'mobile',
+  'app': 'mobile',
+  'ml': 'ai',
+  'ai': 'ai',
+  'model': 'ai',
+  'data': 'data',
+  'warehouse': 'data',
+  'datalake': 'data',
+  'pipeline': 'data',
+  'etl': 'data',
+};
+
+// 技术栈检测指示器
+const TECH_INDICATORS = [
+  { file: 'package.json', tech: 'Node.js' },
+  { file: 'pom.xml', tech: 'Java Maven' },
+  { file: 'build.gradle', tech: 'Java Gradle' },
+  { file: 'go.mod', tech: 'Go' },
+  { file: 'requirements.txt', tech: 'Python' },
+  { file: 'pyproject.toml', tech: 'Python' },
+  { file: 'Cargo.toml', tech: 'Rust' },
+  { file: 'composer.json', tech: 'PHP' },
+  { file: 'Gemfile', tech: 'Ruby' },
+];
+
+/**
+ * 扫描代码模式 - 统一版本
+ * @param {string} dirPath - 要扫描的目录路径
+ * @param {Array} codePatterns - 代码模式数组，每项包含 pattern, language, confidence
+ * @param {Object} options - 扫描选项
+ * @param {number} options.maxDepth - 最大扫描深度，默认4
+ * @param {Array} options.extensions - 要扫描的文件扩展名
+ * @param {string} projectRoot - 项目根目录（用于计算相对路径）
+ * @returns {Array} 匹配的证据数组
+ */
+export function scanCodePatterns(dirPath, codePatterns, options = {}, projectRoot = dirPath) {
+  const evidence = [];
+  const extensions = options.extensions || DEFAULT_CODE_EXTENSIONS;
+  const maxDepth = options.maxDepth ?? 4;
+
+  const scanDir = (dir, depth = 0) => {
+    if (depth > maxDepth) return;
+
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (entry.name.startsWith('.') || SKIP_DIRS.includes(entry.name)) continue;
+
+        const fullPath = path.join(dir, entry.name);
+
+        if (entry.isDirectory()) {
+          scanDir(fullPath, depth + 1);
+        } else if (entry.isFile()) {
+          const ext = path.extname(entry.name);
+          if (extensions.includes(ext)) {
+            try {
+              const content = fs.readFileSync(fullPath, 'utf-8');
+
+              for (const cp of codePatterns) {
+                try {
+                  const regex = new RegExp(cp.pattern, 'gi');
+                  if (regex.test(content)) {
+                    evidence.push({
+                      file: path.relative(projectRoot, fullPath),
+                      type: 'code-pattern',
+                      pattern: cp.pattern,
+                      language: cp.language,
+                      confidence: cp.confidence || 0.8,
+                    });
+                    break; // 每个文件只记录一次
+                  }
+                } catch (e) {
+                  // 忽略无效正则
+                }
+              }
+            } catch (e) {
+              // 忽略读取错误
+            }
+          }
+        }
+      }
+    } catch (e) {
+      // 忽略目录读取错误
+    }
+  };
+
+  scanDir(dirPath);
+  return evidence;
+}
+
+/**
+ * 快速扫描代码模式 - 返回布尔值版本（用于快速检测）
+ * @param {string} dirPath - 要扫描的目录路径
+ * @param {Array} codePatterns - 代码模式数组
+ * @param {Object} options - 扫描选项
+ * @returns {boolean} 是否找到匹配
+ */
+export function scanCodePatternsFast(dirPath, codePatterns, options = {}) {
+  const extensions = options.extensions || DEFAULT_CODE_EXTENSIONS;
+  const maxDepth = options.maxDepth ?? 4;
+
+  const scan = (dir, depth = 0) => {
+    if (depth > maxDepth) return false;
+
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          if (SKIP_DIRS.includes(entry.name)) continue;
+          if (scan(path.join(dir, entry.name), depth + 1)) {
+            return true;
+          }
+        } else if (entry.isFile()) {
+          const ext = path.extname(entry.name);
+          if (extensions.includes(ext)) {
+            try {
+              const content = fs.readFileSync(path.join(dir, entry.name), 'utf-8');
+              for (const cp of codePatterns) {
+                try {
+                  const regex = new RegExp(cp.pattern, 'i');
+                  if (regex.test(content)) {
+                    return true;
+                  }
+                } catch (e) {
+                  // 忽略无效正则
+                }
+              }
+            } catch (e) {
+              // 忽略读取错误
+            }
+          }
+        }
+      }
+    } catch (e) {
+      // 忽略目录读取错误
+    }
+
+    return false;
+  };
+
+  return scan(dirPath);
+}
+
+/**
+ * 扫描环境变量模式 - 统一版本
+ * @param {string} dirPath - 要扫描的目录路径
+ * @param {Array} envVarPatterns - 环境变量模式数组
+ * @param {Object} options - 扫描选项
+ * @param {string} projectRoot - 项目根目录
+ * @returns {Array} 匹配的证据数组
+ */
+export function scanEnvVarPatterns(dirPath, envVarPatterns, options = {}, projectRoot = dirPath) {
+  const evidence = [];
+  const extensions = options.extensions || DEFAULT_ENV_EXTENSIONS;
+  const maxDepth = options.maxDepth ?? 4;
+
+  const scanDir = (dir, depth = 0) => {
+    if (depth > maxDepth) return;
+
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (entry.name.startsWith('.') || SKIP_DIRS.includes(entry.name)) continue;
+
+        const fullPath = path.join(dir, entry.name);
+
+        if (entry.isDirectory()) {
+          scanDir(fullPath, depth + 1);
+        } else if (entry.isFile()) {
+          const ext = path.extname(entry.name);
+          if (extensions.includes(ext) || entry.name.includes('.env')) {
+            try {
+              const content = fs.readFileSync(fullPath, 'utf-8');
+
+              for (const evp of envVarPatterns) {
+                try {
+                  const regex = new RegExp(evp.pattern, 'g');
+                  const matches = content.match(regex);
+                  if (matches) {
+                    evidence.push({
+                      file: path.relative(projectRoot, fullPath),
+                      type: 'env-var',
+                      pattern: evp.pattern,
+                      envVars: [...new Set(matches)],
+                      extract: evp.extract,
+                    });
+                  }
+                } catch (e) {
+                  // 忽略无效正则
+                }
+              }
+            } catch (e) {
+              // 忽略读取错误
+            }
+          }
+        }
+      }
+    } catch (e) {
+      // 忽略目录读取错误
+    }
+  };
+
+  scanDir(dirPath);
+  return evidence;
+}
+
+/**
+ * 快速扫描环境变量模式 - 返回布尔值版本
+ * @param {string} dirPath - 要扫描的目录路径
+ * @param {Array} envVarPatterns - 环境变量模式数组
+ * @param {Object} options - 扫描选项
+ * @returns {boolean} 是否找到匹配
+ */
+export function scanEnvVarPatternsFast(dirPath, envVarPatterns, options = {}) {
+  const extensions = options.extensions || DEFAULT_ENV_EXTENSIONS;
+  const maxDepth = options.maxDepth ?? 4;
+
+  const scan = (dir, depth = 0) => {
+    if (depth > maxDepth) return false;
+
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          if (SKIP_DIRS.includes(entry.name)) continue;
+          if (scan(path.join(dir, entry.name), depth + 1)) {
+            return true;
+          }
+        } else if (entry.isFile()) {
+          const ext = path.extname(entry.name);
+          if (extensions.includes(ext) || entry.name.includes('.env')) {
+            try {
+              const content = fs.readFileSync(path.join(dir, entry.name), 'utf-8');
+              for (const evp of envVarPatterns) {
+                try {
+                  const regex = new RegExp(evp.pattern, 'g');
+                  if (regex.test(content)) {
+                    return true;
+                  }
+                } catch (e) {
+                  // 忽略无效正则
+                }
+              }
+            } catch (e) {
+              // 忽略读取错误
+            }
+          }
+        }
+      }
+    } catch (e) {
+      // 忽略目录读取错误
+    }
+
+    return false;
+  };
+
+  return scan(dirPath);
+}
+
+/**
+ * 扫描依赖文件 - 统一版本（返回详细证据）
+ * @param {string} projectRoot - 项目根目录
+ * @param {Array} dependencies - 依赖模式数组
+ * @returns {Array} 检测到的依赖证据数组
+ */
+export function scanDependencies(projectRoot, dependencies) {
+  const evidence = [];
+
+  for (const dep of dependencies) {
+    if (dep.packageManager === 'npm') {
+      const pkgPath = path.join(projectRoot, 'package.json');
+      if (fs.existsSync(pkgPath)) {
+        try {
+          const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+          const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+          for (const [depName] of Object.entries(allDeps)) {
+            if (matchDependency(dep.pattern, depName)) {
+              evidence.push({
+                file: 'package.json',
+                type: 'dependency',
+                dependency: depName,
+                packageManager: 'npm',
+                pattern: dep.pattern,
+              });
+            }
+          }
+        } catch (e) {
+          // 忽略解析错误
+        }
+      }
+    } else if (dep.packageManager === 'pip') {
+      const reqPath = path.join(projectRoot, 'requirements.txt');
+      if (fs.existsSync(reqPath)) {
+        try {
+          const content = fs.readFileSync(reqPath, 'utf-8');
+          const lines = content.split('\n');
+
+          for (const line of lines) {
+            const depName = line.split(/[=<>#\[]/)[0].trim();
+            if (depName && matchDependency(dep.pattern, depName)) {
+              evidence.push({
+                file: 'requirements.txt',
+                type: 'dependency',
+                dependency: depName,
+                packageManager: 'pip',
+                pattern: dep.pattern,
+              });
+            }
+          }
+        } catch (e) {
+          // 忽略解析错误
+        }
+      }
+    } else if (dep.packageManager === 'maven') {
+      const pomPath = path.join(projectRoot, 'pom.xml');
+      if (fs.existsSync(pomPath)) {
+        try {
+          const content = fs.readFileSync(pomPath, 'utf-8');
+          if (content.includes(dep.pattern)) {
+            evidence.push({
+              file: 'pom.xml',
+              type: 'dependency',
+              dependency: dep.pattern,
+              packageManager: 'maven',
+              pattern: dep.pattern,
+            });
+          }
+        } catch (e) {
+          // 忽略解析错误
+        }
+      }
+    }
+  }
+
+  return evidence;
+}
+
+/**
+ * 快速扫描依赖 - 返回检测到的名称数组
+ * @param {string} projectRoot - 项目根目录
+ * @param {Object} middlewarePatterns - 中间件模式对象
+ * @returns {Array} 检测到的中间件名称数组
+ */
+export function scanDependenciesFast(projectRoot, middlewarePatterns) {
+  const detected = [];
+
+  // package.json
+  const pkgPath = path.join(projectRoot, 'package.json');
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+      for (const [depName] of Object.entries(deps)) {
+        for (const [mwName, pattern] of Object.entries(middlewarePatterns)) {
+          if (detected.includes(mwName)) continue;
+          if (pattern.dependencies) {
+            for (const dep of pattern.dependencies) {
+              if (dep.packageManager === 'npm') {
+                const regex = new RegExp('^' + dep.pattern.replace(/\*/g, '.*') + '$');
+                if (regex.test(depName) || depName.includes(dep.pattern)) {
+                  detected.push(mwName);
+                  break;
+                }
+              }
+            }
+          }
+        }
+      }
+    } catch (e) {
+      // 忽略
+    }
+  }
+
+  // requirements.txt
+  const reqPath = path.join(projectRoot, 'requirements.txt');
+  if (fs.existsSync(reqPath)) {
+    try {
+      const content = fs.readFileSync(reqPath, 'utf-8');
+      const lines = content.split('\n');
+
+      for (const line of lines) {
+        const depName = line.split(/[=<>#\[]/)[0].trim();
+        if (!depName) continue;
+
+        for (const [mwName, pattern] of Object.entries(middlewarePatterns)) {
+          if (detected.includes(mwName)) continue;
+          if (pattern.dependencies) {
+            for (const dep of pattern.dependencies) {
+              if (dep.packageManager === 'pip') {
+                const regex = new RegExp('^' + dep.pattern.replace(/\*/g, '.*') + '$');
+                if (regex.test(depName) || depName.includes(dep.pattern)) {
+                  detected.push(mwName);
+                  break;
+                }
+              }
+            }
+          }
+        }
+      }
+    } catch (e) {
+      // 忽略
+    }
+  }
+
+  return detected;
+}
+
+/**
+ * 匹配依赖名称
+ * @param {string} pattern - 匹配模式
+ * @param {string} depName - 依赖名称
+ * @returns {boolean} 是否匹配
+ */
+function matchDependency(pattern, depName) {
+  if (pattern.startsWith('^') || pattern.includes('*')) {
+    const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
+    return regex.test(depName);
+  }
+  return depName === pattern || depName.includes(pattern);
+}
+
+/**
+ * 发现源码目录 - 统一版本（带类型信息）
+ * @param {string} projectRoot - 项目根目录
+ * @param {Object} config - 项目配置（可选，包含 subsystems）
+ * @returns {Array} 源码目录数组，每项包含 path, type, techStack
+ */
+export function discoverSourceDirs(projectRoot, config = {}) {
+  const dirs = [];
+
+  // 1. 从 config.json 的 subsystems 中获取
+  if (config.subsystems) {
+    for (const sub of config.subsystems) {
+      dirs.push({
+        path: sub.path,
+        type: sub.type,
+        techStack: sub.techStack,
+      });
+    }
+  }
+
+  // 2. 自动扫描常见源码目录
+  for (const dir of COMMON_SOURCE_DIRS) {
+    const fullPath = path.join(projectRoot, dir);
+    if (fs.existsSync(fullPath) && !dirs.find(d => d.path === dir)) {
+      dirs.push({
+        path: dir,
+        type: inferType(dir),
+        techStack: detectTechStack(fullPath),
+      });
+    }
+  }
+
+  return dirs;
+}
+
+/**
+ * 简单发现源码目录 - 只返回目录名数组
+ * @param {string} projectRoot - 项目根目录
+ * @returns {Array} 目录名数组
+ */
+export function discoverSourceDirsSimple(projectRoot) {
+  const dirs = [];
+
+  for (const dir of COMMON_SOURCE_DIRS) {
+    const fullPath = path.join(projectRoot, dir);
+    if (fs.existsSync(fullPath)) {
+      dirs.push(dir);
+    }
+  }
+
+  return dirs;
+}
+
+/**
+ * 推断目录类型
+ * @param {string} dirName - 目录名称
+ * @returns {string} 类型
+ */
+function inferType(dirName) {
+  return DIR_TYPE_MAP[dirName.toLowerCase()] || 'unknown';
+}
+
+/**
+ * 检测技术栈
+ * @param {string} dirPath - 目录路径
+ * @returns {string} 技术栈名称
+ */
+function detectTechStack(dirPath) {
+  for (const ind of TECH_INDICATORS) {
+    if (fs.existsSync(path.join(dirPath, ind.file))) {
+      return ind.tech;
+    }
+  }
+  return 'Unknown';
+}
+
+/**
+ * 综合扫描 - 使用 PatternLoader 检测中间件（用于 environment-manager）
+ * @param {string} projectRoot - 项目根目录
+ * @param {Object} patternLoader - PatternLoader 实例
+ * @returns {Array} 检测到的中间件名称数组
+ */
+export function detectMiddlewareWithPatterns(projectRoot, patternLoader) {
+  const middlewarePatterns = patternLoader.getMiddlewarePatterns();
+  const detected = [];
+  const sourceDirs = discoverSourceDirsSimple(projectRoot);
+
+  if (sourceDirs.length === 0) {
+    sourceDirs.push('src');
+  }
+
+  for (const dir of sourceDirs) {
+    const dirPath = path.join(projectRoot, dir);
+    if (!fs.existsSync(dirPath)) continue;
+
+    for (const [name, pattern] of Object.entries(middlewarePatterns)) {
+      if (detected.includes(name)) continue;
+
+      // 检测代码模式
+      if (pattern.codePatterns) {
+        const found = scanCodePatternsFast(dirPath, pattern.codePatterns);
+        if (found) {
+          detected.push(name);
+          continue;
+        }
+      }
+
+      // 检测环境变量模式
+      if (pattern.envVarPatterns) {
+        const found = scanEnvVarPatternsFast(dirPath, pattern.envVarPatterns);
+        if (found) {
+          detected.push(name);
+        }
+      }
+    }
+  }
+
+  // 从依赖文件检测
+  const depDetected = scanDependenciesFast(projectRoot, middlewarePatterns);
+  for (const name of depDetected) {
+    if (!detected.includes(name)) {
+      detected.push(name);
+    }
+  }
+
+  return detected;
+}
+
+export default {
+  scanCodePatterns,
+  scanCodePatternsFast,
+  scanEnvVarPatterns,
+  scanEnvVarPatternsFast,
+  scanDependencies,
+  scanDependenciesFast,
+  discoverSourceDirs,
+  discoverSourceDirsSimple,
+  detectMiddlewareWithPatterns,
+};