smart-review 1.0.1

package/lib/config-loader.js

@@ -0,0 +1,223 @@
+import fs from 'fs';
+import path from 'path';
+import { createRequire } from 'module';
+import { defaultConfig, defaultRules } from './default-config.js';
+import { logger } from './utils/logger.js';
+
+export class ConfigLoader {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.reviewDir = path.join(projectRoot, '.smart-review');
+    
+    // 启动时清理遗留的临时文件
+    this.cleanupTempFiles();
+  }
+  
+  cleanupTempFiles() {
+    try {
+      const tempDir = path.join(this.reviewDir, 'local-rules', '.temp-smart-review');
+      if (fs.existsSync(tempDir)) {
+        const files = fs.readdirSync(tempDir);
+        for (const file of files) {
+          if (file.startsWith('temp-') && file.endsWith('.mjs')) {
+            try {
+              fs.unlinkSync(path.join(tempDir, file));
+            } catch (e) {
+              // 忽略单个文件删除失败
+            }
+          }
+        }
+        
+        // 尝试删除空的临时目录
+        try {
+          fs.rmdirSync(tempDir);
+        } catch (e) {
+          // 忽略目录删除失败（可能不为空）
+        }
+      }
+    } catch (error) {
+      // 忽略清理过程中的错误，不影响主要功能
+    }
+  }
+
+  async loadConfig() {
+    let externalConfig = {};
+    
+    // 尝试加载外部配置文件
+    const configPath = path.join(this.reviewDir, 'smart-review.json');
+    if (fs.existsSync(configPath)) {
+      try {
+        const configContent = await fs.promises.readFile(configPath, 'utf8');
+        externalConfig = JSON.parse(configContent);
+
+      } catch (error) {
+        logger.warn('外部配置文件解析失败，使用默认配置:', error.message);
+      }
+    }
+
+    // 深度合并配置（外部配置覆盖默认配置）
+    const mergedConfig = this.deepMerge(defaultConfig, externalConfig);
+    
+    // 设置项目根目录
+    mergedConfig.projectRoot = this.projectRoot;
+    mergedConfig.reviewDir = this.reviewDir;
+    
+    return mergedConfig;
+  }
+
+  async loadRules(config = {}) {
+    // 2) 加载外部规则
+    const externalRules = await this.loadExternalRules();
+
+    // 根据配置决定规则加载策略
+    if (config.useExternalRulesOnly) {
+      // 仅使用外部规则模式：只返回外部规则，不加载内置规则
+      logger.info('使用外部规则模式：仅加载 local-rules 目录中的规则');
+      return externalRules;
+    }
+
+    // 默认合并模式：内置规则 + 外部规则合并
+    // 1) 收集内置规则
+    const builtInRules = Object.values(defaultRules).flat();
+
+    // 3) 根据规则ID进行去重合并（外部规则优先生效）
+    const ruleMap = new Map();
+
+    for (const rule of builtInRules) {
+      const key = rule.id || `${rule.pattern}__${rule.risk}`;
+      ruleMap.set(key, rule);
+    }
+
+    for (const rule of externalRules) {
+      const key = rule.id || `${rule.pattern}__${rule.risk}`;
+      ruleMap.set(key, rule); // 外部规则覆盖同ID的内置规则
+    }
+
+    const allRules = Array.from(ruleMap.values());
+
+    return allRules;
+  }
+
+  async loadExternalRules() {
+    const externalRules = [];
+    // 改为读取 .smart-review/local-rules 作为静态规则目录，避免与AI提示目录冲突
+    const rulesDir = path.join(this.reviewDir, 'local-rules');
+    
+    if (!fs.existsSync(rulesDir)) {
+      return externalRules;
+    }
+
+    try {
+      const ruleFiles = fs.readdirSync(rulesDir);
+      
+      for (const file of ruleFiles) {
+        if (file.endsWith('.js') || file.endsWith('.mjs') || file.endsWith('.json')) {
+          const filePath = path.join(rulesDir, file);
+          const rules = await this.loadRuleFile(filePath);
+          externalRules.push(...rules);
+        }
+      }
+    } catch (error) {
+      logger.warn('加载外部规则失败:', error.message);
+    }
+    
+    return externalRules;
+  }
+
+  async loadRuleFile(filePath) {
+    try {
+      const ext = path.extname(filePath).toLowerCase();
+      
+      if (ext === '.js' || ext === '.mjs') {
+        let mod;
+        
+        if (ext === '.mjs') {
+          // .mjs 文件肯定是 ES 模块，直接导入
+          const fileUrl = `file://${filePath.replace(/\\/g, '/')}`;
+          mod = await import(fileUrl);
+        } else {
+          // .js 文件需要判断 ESM/CommonJS
+          const content = await fs.promises.readFile(filePath, 'utf8');
+          const looksESM = /\bexport\b|^\s*import\b/m.test(content);
+          
+          if (looksESM) {
+              // 为了避免 base64 编码导致转义字符丢失，我们创建一个临时的 .mjs 文件
+              const tempDir = path.join(path.dirname(filePath), '.temp-smart-review');
+              const tempFile = path.join(tempDir, `temp-${Date.now()}-${Math.random().toString(36).substr(2, 9)}.mjs`);
+              
+              try {
+                // 确保临时目录存在
+                if (!fs.existsSync(tempDir)) {
+                  await fs.promises.mkdir(tempDir, { recursive: true });
+                }
+                
+                // 写入临时文件
+                await fs.promises.writeFile(tempFile, content, 'utf8');
+                
+                // 导入临时文件
+                const fileUrl = `file://${tempFile.replace(/\\/g, '/')}`;
+                mod = await import(fileUrl);
+                
+                // 清理临时文件
+                fs.unlinkSync(tempFile);
+                
+                // 如果临时目录为空，删除它
+                try {
+                  fs.rmdirSync(tempDir);
+                } catch (e) {
+                  // 忽略删除目录失败的错误（可能不为空）
+                }
+              } catch (tempError) {
+                // 如果临时文件方法失败，回退到原来的 base64 方法
+                logger.warn(`临时文件方法失败，回退到 base64 方法: ${tempError.message}`);
+                
+                // 清理可能已创建的临时文件
+                try {
+                  if (fs.existsSync(tempFile)) {
+                    fs.unlinkSync(tempFile);
+                  }
+                } catch (cleanupError) {
+                  // 忽略清理错误
+                }
+                
+                const base64 = Buffer.from(content, 'utf8').toString('base64');
+                mod = await import(`data:text/javascript;base64,${base64}`);
+              }
+            } else {
+              // CommonJS 规则：使用 createRequire 加载
+              const require = createRequire(import.meta.url);
+              mod = require(filePath);
+            }
+          }
+        // 兼容多种导出风格
+        const candidates = [mod?.rules, mod?.default?.rules, mod?.default, mod];
+        for (const c of candidates) {
+          if (Array.isArray(c)) return c;
+        }
+        return [];
+      } else if (ext === '.json') {
+        const content = await fs.promises.readFile(filePath, 'utf8');
+        const config = JSON.parse(content);
+        return config.rules || [];
+      }
+    } catch (error) {
+      logger.warn(`加载规则文件失败 ${filePath}:`, error.message);
+    }
+    
+    return [];
+  }
+
+  deepMerge(target, source) {
+    const result = { ...target };
+    
+    for (const key in source) {
+      if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+        result[key] = this.deepMerge(result[key] || {}, source[key]);
+      } else {
+        result[key] = source[key];
+      }
+    }
+    
+    return result;
+  }
+}

package/lib/default-config.js

@@ -0,0 +1,203 @@
+export const defaultConfig = {
+  // AI配置
+  ai: {
+    enabled: true,
+    model: 'gpt-4o-mini',
+    apiKey: process.env.OPENAI_API_KEY || '',
+    baseURL: '',
+    temperature: 0.1,
+    maxResponseTokens: 4096,
+    maxFileSizeKB: 100,
+    enabledFor: ['.js', '.ts', '.jsx', '.tsx', '.vue', '.py', '.java', '.cpp', '.c', '.cs', '.php', '.rb', '.go', '.rs', '.swift', '.kt'],
+    // 当本地规则存在时，是否将本地规则提示作为上下文提供给AI
+    useStaticHints: true,
+    // 在存在阻断级别本地问题时是否仍运行AI
+    runWhenBlocked: false,
+    maxRequestTokens: 8000,
+    minFilesPerBatch: 1,
+    maxFilesPerBatch: 10,
+    tokenRatio: 4,
+    chunkOverlapLines: 5,
+    includeStaticHints: true,
+    // 并发处理配置
+    concurrency: 3, // 并发AI请求数量，默认3个，<=1时串行，>1时并发
+    // Git Diff 增量审查配置
+    reviewOnlyChanges: true, // 是否仅审查暂存区变动内容（git diff），而非全文件
+    contextMergeLines: 10 // 上下文合并行长度（大概值），用于在diff审查时提供足够的上下文
+  },
+
+  // 风险等级配置
+  riskLevels: {
+    critical: { block: true },
+    high: { block: false },
+    medium: { block: false },
+    low: { block: false },
+    suggestion: { block: false }
+  },
+
+  // 是否抑制低等级问题的输出（仅输出阻断等级的问题）
+  suppressLowLevelOutput: false,
+
+  // 规则加载策略：true=仅使用外部规则，false=内部和外部规则合并（默认）
+  useExternalRulesOnly: false,
+
+  // 文件处理配置
+  fileExtensions: [
+    '.js', '.jsx', '.ts', '.tsx', '.vue', '.svelte',
+    '.py', '.java', '.go', '.rs', '.cpp', '.c', '.h',
+    '.php', '.rb', '.html', '.css', '.scss', '.less'
+  ],
+  
+  // 统一的忽略文件配置：支持相对路径、绝对路径、glob模式和正则表达式
+  // 示例：["./test/src/test-file.js", "test/*", "**/node_modules/**", "/.*\\.generated\\./"]
+  ignoreFiles: [
+    // 依赖目录
+    '**/node_modules/**',
+    '**/vendor/**',
+    '**/.pnpm/**',
+    '**/bower_components/**',
+    
+    // 测试覆盖率和报告
+    '**/coverage/**',
+    '**/test-results/**',
+    '**/reports/**',
+    
+    // 压缩和打包文件
+    '**/*.min.js',
+    '**/*.min.css',
+    '**/*.bundle.js',
+    '**/*.chunk.js',
+    '**/*.umd.js',
+    
+    // 生成的文件
+    '**/*.generated.*',
+    '**/*.auto.*',
+    '**/generated/**',
+    
+    // 版本控制和临时文件
+    '**/.git/**',
+    '**/.svn/**',
+    '**/.hg/**',
+    '**/tmp/**',
+    '**/temp/**',
+    '**/*.tmp',
+    '**/*.temp',
+    '**/*.swp',
+    '**/*.swo',
+    '**/*~',
+    
+    // IDE和编辑器文件
+    '**/.vscode/**',
+    '**/.idea/**',
+    '**/*.iml',
+    '**/.project',
+    '**/.classpath',
+    '**/.settings/**',
+    
+    // 日志文件
+    '**/*.log',
+    '**/logs/**',
+    
+    // 缓存目录
+    '**/.cache/**',
+    '**/.next/**',
+    '**/.nuxt/**',
+    '**/.vuepress/**',
+    
+    // 包管理器锁文件
+    '**/package-lock.json',
+    '**/yarn.lock',
+    '**/pnpm-lock.yaml',
+    '**/composer.lock',
+    '**/Pipfile.lock',
+    
+    // 环境和配置文件（可能包含敏感信息）
+    '**/.env',
+    '**/.env.*',
+    '**/config/secrets.*'
+  ],
+  
+};
+
+export const defaultRules = {
+  security: [
+    {
+      id: 'SEC001',
+      name: '硬编码密码',
+      pattern: '(password|pwd|pass)\\s*=\\s*[\'"][^\'"]+[\'"]',
+      risk: 'high',
+      message: '发现硬编码的密码，建议使用环境变量或安全的配置管理',
+      suggestion: '使用环境变量或加密的配置存储',
+      flags: 'gi'
+    },
+    {
+      id: 'SEC002',
+      name: 'SQL注入风险',
+      pattern: '(execute|query)\\s*\\(\\s*[fF]?[\'"][^\']*\\+.*[\'"]',
+      risk: 'critical',
+      message: '发现可能的SQL注入风险，字符串拼接SQL查询',
+      suggestion: '使用参数化查询或ORM的安全方法',
+      flags: 'gi'
+    },
+    {
+      id: 'SEC003',
+      name: 'XSS风险',
+      pattern: 'innerHTML\\s*=|document\\.write\\s*\\(',
+      risk: 'high',
+      message: '发现直接操作HTML内容，可能存在XSS风险',
+      suggestion: '使用textContent或安全的DOM操作方法',
+      flags: 'gi'
+    }
+  ],
+  
+  performance: [
+    {
+      id: 'PERF001',
+      name: '循环内数据库查询',
+      pattern: 'for\\s*\\([^)]*\\)\\s*\\{[^}]*\\.(find|query|select)[^}]*\\}',
+      risk: 'medium',
+      message: '在循环内执行数据库查询，可能导致N+1查询问题',
+      suggestion: '使用批量查询或预加载数据',
+      flags: 'gi'
+    },
+    {
+      id: 'PERF002',
+      name: '内存泄漏风险',
+      pattern: 'setInterval\\s*\\([^)]*\\)|setTimeout\\s*\\([^)]*\\)',
+      risk: 'medium',
+      message: '发现定时器使用，可能存在内存泄漏风险',
+      suggestion: '确保在组件卸载时清理定时器',
+      flags: 'gi'
+    }
+  ],
+  
+  'best-practices': [
+    {
+      id: 'BP001',
+      name: '调试代码',
+      pattern: 'console\\.log|print\\(|alert\\(',
+      risk: 'low',
+      message: '发现调试代码，建议在提交前移除',
+      suggestion: '使用日志系统替代console.log',
+      flags: 'gi'
+    },
+    {
+      id: 'BP002',
+      name: '魔法数字',
+      pattern: '\\b(?<!\\.)(?!(?:0|1|10|12|24|30|60|100|200|201|300|400|401|403|404|500|503|1000|3000|5000|8080|9000)\\b)\\d{3,}(?!\\.\\d)\\b',
+      risk: 'low',
+      message: '检测到魔法数字，建议使用常量定义',
+      suggestion: '将数字定义为有意义的常量',
+      flags: 'g'
+    },
+    {
+      id: 'BP013',
+      name: '使用var声明',
+      pattern: '\\bvar\\s+\\w+',
+      risk: 'medium',
+      message: '检测到使用var声明变量，可能导致作用域问题',
+      suggestion: '使用let或const替代var，提高代码安全性',
+      flags: 'gi'
+    }
+  ]
+};