mr-sliy 1.0.0

package/src/config/index.js

@@ -0,0 +1,232 @@
+/**
+ * 配置管理模块
+ * 统一管理应用配置
+ */
+
+require('dotenv').config();
+
+const config = {
+  // 服务配置
+  server: {
+    port: parseInt(process.env.PORT) || 3000,
+    nodeEnv: process.env.NODE_ENV || 'development',
+    host: process.env.HOST || 'localhost'
+  },
+
+  // 数据库配置
+  database: {
+    path: process.env.DB_PATH || './database/code_optimizer.db',
+    // SQLite不需要连接池，但保留配置以备后用
+    pool: {
+      max: parseInt(process.env.DB_POOL_MAX) || 10,
+      min: parseInt(process.env.DB_POOL_MIN) || 2
+    }
+  },
+
+  // MySQL配置（云端同步，可选）
+  mysql: {
+    enabled: process.env.MYSQL_ENABLED === 'true' || false,
+    host: process.env.MYSQL_HOST || '',
+    port: parseInt(process.env.MYSQL_PORT) || 3306,
+    user: process.env.MYSQL_USER || '',
+    password: process.env.MYSQL_PASSWORD || '',
+    database: process.env.MYSQL_DATABASE || 'code_optimizer',
+    connectionLimit: parseInt(process.env.MYSQL_CONNECTION_LIMIT) || 10,
+    syncOnStartup: process.env.MYSQL_SYNC_ON_STARTUP !== 'false'
+  },
+
+  // AI配置
+  ai: {
+    apiKey: process.env.AI_API_KEY || '',
+    apiUrl: process.env.AI_API_URL || 'https://api.openai.com/v1',
+    model: process.env.AI_MODEL || 'gpt-4',
+    timeout: parseInt(process.env.AI_TIMEOUT) || 30000,
+    maxTokens: parseInt(process.env.AI_MAX_TOKENS) || 2000,
+    temperature: parseFloat(process.env.AI_TEMPERATURE) || 0.7
+  },
+
+  // LLM提供商配置
+  llm: {
+    // OpenAI
+    openai: {
+      apiKey: process.env.OPENAI_API_KEY || '',
+      baseURL: process.env.OPENAI_BASE_URL || 'https://api.openai.com/v1',
+      model: process.env.OPENAI_MODEL || 'gpt-4'
+    },
+    // Claude
+    claude: {
+      apiKey: process.env.CLAUDE_API_KEY || '',
+      model: process.env.CLAUDE_MODEL || 'claude-3-sonnet-20240229'
+    },
+    // Azure OpenAI
+    azure: {
+      apiKey: process.env.AZURE_OPENAI_KEY || '',
+      endpoint: process.env.AZURE_OPENAI_ENDPOINT || '',
+      deploymentName: process.env.AZURE_DEPLOYMENT_NAME || 'gpt-4'
+    },
+    // Google Gemini
+    gemini: {
+      apiKey: process.env.GEMINI_API_KEY || '',
+      model: process.env.GEMINI_MODEL || 'gemini-1.5-pro'
+    },
+    // 阿里通义千问
+    tongyi: {
+      apiKey: process.env.TONGYI_API_KEY || '',
+      model: process.env.TONGYI_MODEL || 'qwen-plus'
+    },
+    // 字节豆包
+    doubao: {
+      apiKey: process.env.DOUBAO_API_KEY || '',
+      model: process.env.DOUBAO_MODEL || 'Doubao-7B'
+    },
+    // 百度文心一言
+    wenxin: {
+      apiKey: process.env.WENXIN_API_KEY || '',
+      secretKey: process.env.WENXIN_SECRET_KEY || '',
+      model: process.env.WENXIN_MODEL || 'ernie-3.5'
+    },
+    // DeepSeek
+    deepseek: {
+      apiKey: process.env.DEEPSEEK_API_KEY || '',
+      baseURL: process.env.DEEPSEEK_BASE_URL || 'https://api.deepseek.com/v1',
+      model: process.env.DEEPSEEK_MODEL || 'deepseek-chat'
+    },
+    // 智谱AI
+    zhipu: {
+      apiKey: process.env.ZHIPU_API_KEY || '',
+      baseURL: process.env.ZHIPU_BASE_URL || 'https://open.bigmodel.cn/api/paas/v4',
+      model: process.env.ZHIPU_MODEL || 'glm-4'
+    },
+    // Moonshot AI
+    moonshot: {
+      apiKey: process.env.MOONSHOT_API_KEY || '',
+      baseURL: process.env.MOONSHOT_BASE_URL || 'https://api.moonshot.cn/v1',
+      model: process.env.MOONSHOT_MODEL || 'moonshot-v1-8k'
+    },
+    // Ollama (本地)
+    ollama: {
+      baseURL: process.env.OLLAMA_URL || 'http://localhost:11434',
+      model: process.env.OLLAMA_MODEL || 'codellama'
+    }
+  },
+
+  // AST扫描配置
+  scan: {
+    maxFileSize: parseInt(process.env.MAX_FILE_SIZE) || 1048576, // 1MB
+    timeout: parseInt(process.env.SCAN_TIMEOUT) || 60000, // 60秒
+    enableParallel: process.env.ENABLE_PARALLEL_SCAN !== 'false',
+    maxParallelJobs: parseInt(process.env.MAX_PARALLEL_JOBS) || 4,
+    extensions: (process.env.SCAN_EXTENSIONS || '.js,.ts,.jsx,.tsx,.py,.java,.go,.rs')
+      .split(',')
+      .map(ext => ext.trim()),
+    excludeDirs: (process.env.EXCLUDE_DIRS || 'node_modules,dist,build,out,.git,coverage')
+      .split(',')
+      .map(dir => dir.trim()),
+    excludeFiles: (process.env.EXCLUDE_FILES || 'min.js,min.css,.d.ts')
+      .split(',')
+      .map(file => file.trim())
+  },
+
+  // 检测规则配置
+  detection: {
+    unusedVariables: process.env.DETECT_UNUSED_VARIABLES !== 'false',
+    unusedImports: process.env.DETECT_UNUSED_IMPORTS !== 'false',
+    unusedFunctions: process.env.DETECT_UNUSED_FUNCTIONS !== 'false',
+    magicNumbers: process.env.DETECT_MAGIC_NUMBERS !== 'false',
+    maxFunctionLines: parseInt(process.env.MAX_FUNCTION_LINES) || 50,
+    maxCyclomaticComplexity: parseInt(process.env.MAX_CYCLOMATIC_COMPLEXITY) || 10,
+    maxNestingDepth: parseInt(process.env.MAX_NESTING_DEPTH) || 4,
+    enableDeepNestingCheck: process.env.ENABLE_DEEP_NESTING_CHECK !== 'false',
+    enableNullCheck: process.env.ENABLE_NULL_CHECK !== 'false',
+    enableConsoleLogCheck: process.env.ENABLE_CONSOLE_LOG_CHECK !== 'false',
+    enableDuplicateCodeCheck: process.env.ENABLE_DUPLICATE_CODE_CHECK !== 'false',
+    enableCommentCheck: process.env.ENABLE_COMMENT_CHECK !== 'false'
+  },
+
+  // 日志配置
+  logging: {
+    level: process.env.LOG_LEVEL || 'info',
+    file: process.env.LOG_FILE || './logs/app.log',
+    maxSize: parseInt(process.env.LOG_MAX_SIZE) || 5242880, // 5MB
+    maxFiles: parseInt(process.env.LOG_MAX_FILES) || 5
+  },
+
+  // CORS配置
+  cors: {
+    origins: (process.env.CORS_ORIGINS || 'http://localhost:5173,http://localhost:3000,http://localhost:1420')
+      .split(',')
+      .map(origin => origin.trim()),
+    credentials: true
+  },
+
+  // 速率限制配置
+  rateLimit: {
+    windowMs: 15 * 60 * 1000, // 15分钟
+    max: parseInt(process.env.RATE_LIMIT_MAX) || 100
+  },
+
+  // 默认运行模式
+  defaultMode: process.env.DEFAULT_MODE || 'offline' // offline | online
+};
+
+/**
+ * 获取配置值
+ */
+function get(key, defaultValue = null) {
+  const keys = key.split('.');
+  let value = config;
+  
+  for (const k of keys) {
+    if (value && typeof value === 'object' && k in value) {
+      value = value[k];
+    } else {
+      return defaultValue;
+    }
+  }
+  
+  return value;
+}
+
+/**
+ * 检查是否为在线模式
+ */
+function isOnlineMode() {
+  return config.defaultMode === 'online' && config.ai.apiKey && config.ai.apiKey.length > 0;
+}
+
+/**
+ * 检查是否为离线模式
+ */
+function isOfflineMode() {
+  return !isOnlineMode();
+}
+
+/**
+ * 验证必要配置
+ */
+function validate() {
+  const errors = [];
+  
+  if (!config.server.port) {
+    errors.push('服务端口未配置');
+  }
+  
+  if (!config.database.path) {
+    errors.push('数据库路径未配置');
+  }
+  
+  if (errors.length > 0) {
+    console.error('配置验证失败:', errors);
+    return false;
+  }
+  
+  return true;
+}
+
+module.exports = {
+  config,
+  get,
+  isOnlineMode,
+  isOfflineMode,
+  validate
+};

package/src/engine/dualModeEngine.js

@@ -0,0 +1,486 @@
+/**
+ * 双模工作引擎
+ * 核心特色：离线AST + 本地RAG知识库 / 在线AST + 云端大模型
+ * 自适应切换，AI为扩展功能，不依赖核心检测业务
+ */
+
+const { detectIssues, batchDetect } = require('../services/detection/detector');
+const { knowledgeBase } = require('../services/vector/knowledgeBase');
+const { providerManager } = require('../services/llm/providers');
+const { logger } = require('../utils/logger');
+const { generateUUID, getFileLanguage } = require('../utils/helpers');
+const { isOnlineMode } = require('../config');
+const fs = require('fs');
+
+/**
+ * 双模引擎类
+ */
+class DualModeEngine {
+  constructor() {
+    this.mode = 'auto'; // 'offline', 'online', 'auto'
+    this.initialized = false;
+  }
+
+  /**
+   * 初始化引擎
+   */
+  init() {
+    if (this.initialized) return;
+    
+    // 初始化本地知识库
+    knowledgeBase.init();
+    knowledgeBase.seedDefaultKnowledge();
+    
+    this.initialized = true;
+    logger.info('双模引擎初始化完成');
+  }
+
+  /**
+   * 设置工作模式
+   */
+  setMode(mode) {
+    const validModes = ['offline', 'online', 'auto'];
+    if (!validModes.includes(mode)) {
+      throw new Error(`无效模式: ${mode}，可选: ${validModes.join(', ')}`);
+    }
+    this.mode = mode;
+    logger.info(`工作模式切换为: ${mode}`);
+  }
+
+  /**
+   * 获取当前实际工作模式
+   */
+  getActualMode() {
+    if (this.mode === 'auto') {
+      // 自动判断：有可用云端提供商则在线，否则离线
+      const availableProviders = providerManager.getAvailableProviders();
+      const hasOnlineProvider = availableProviders.some(p => p.available && p.name !== 'ollama');
+      return hasOnlineProvider ? 'online' : 'offline';
+    }
+    return this.mode;
+  }
+
+  /**
+   * 检测并优化单个文件（双模入口）
+   */
+  async analyzeFile(filePath, options = {}) {
+    this.init();
+    const startTime = Date.now();
+    const actualMode = this.getActualMode();
+    
+    logger.info(`开始分析文件: ${filePath} [模式: ${actualMode}]`);
+
+    try {
+      // 1. 读取文件
+      const sourceCode = fs.readFileSync(filePath, 'utf-8');
+      const language = getFileLanguage(filePath);
+
+      // 2. AST静态检测（离线核心，永远执行）
+      const detectionResult = await detectIssues(sourceCode, filePath);
+      
+      if (!detectionResult.success) {
+        return {
+          success: false,
+          message: detectionResult.message,
+          filePath,
+          mode: actualMode
+        };
+      }
+
+      // 3. 根据模式进行优化
+      const optimizedIssues = [];
+      
+      for (const issue of detectionResult.issues) {
+        const optimization = await this.optimizeIssue(issue, sourceCode, actualMode);
+        optimizedIssues.push({
+          ...issue,
+          optimization
+        });
+      }
+
+      const result = {
+        success: true,
+        filePath,
+        language,
+        mode: actualMode,
+        totalIssues: detectionResult.totalIssues,
+        issueCounts: detectionResult.issueCounts,
+        issues: optimizedIssues,
+        durationMs: Date.now() - startTime
+      };
+
+      logger.info(`文件分析完成: ${filePath}, 发现 ${detectionResult.totalIssues} 个问题`);
+      return result;
+
+    } catch (error) {
+      logger.error(`分析文件失败: ${filePath}`, error);
+      return {
+        success: false,
+        message: error.message,
+        filePath,
+        mode: actualMode
+      };
+    }
+  }
+
+  /**
+   * 分析代码片段（用于交互式使用）
+   */
+  async analyzeSnippet(codeSnippet, language = 'javascript', options = {}) {
+    this.init();
+    const startTime = Date.now();
+    const actualMode = this.getActualMode();
+    
+    logger.info(`开始分析代码片段 [模式: ${actualMode}]`);
+
+    try {
+      // 1. AST检测
+      const detectionResult = await detectIssues(codeSnippet, `snippet.${language === 'javascript' ? 'js' : language}`);
+      
+      // 2. 优化每个问题
+      const optimizedIssues = [];
+      
+      for (const issue of detectionResult.issues) {
+        const optimization = await this.optimizeIssue(issue, codeSnippet, actualMode);
+        optimizedIssues.push({
+          ...issue,
+          optimization
+        });
+      }
+
+      // 3. 如果无问题但有优化需求，进行一般性优化
+      if (detectionResult.issues.length === 0 && options.generalOptimize) {
+        const generalOptimization = await this.optimizeIssue(
+          { codeSnippet, issueType: 'general', message: '一般性优化' },
+          codeSnippet,
+          actualMode
+        );
+        optimizedIssues.push({
+          id: generateUUID(),
+          issueType: 'general_optimization',
+          severity: 'low',
+          message: '建议进行一般性代码优化',
+          codeSnippet,
+          optimization: generalOptimization
+        });
+      }
+
+      return {
+        success: true,
+        mode: actualMode,
+        totalIssues: optimizedIssues.length,
+        issues: optimizedIssues,
+        durationMs: Date.now() - startTime
+      };
+
+    } catch (error) {
+      logger.error('分析代码片段失败:', error);
+      return {
+        success: false,
+        message: error.message,
+        mode: actualMode
+      };
+    }
+  }
+
+  /**
+   * 批量分析项目
+   */
+  async analyzeProject(projectPath, options = {}) {
+    this.init();
+    const startTime = Date.now();
+    const actualMode = this.getActualMode();
+    
+    logger.info(`开始分析项目: ${projectPath} [模式: ${actualMode}]`);
+
+    // 收集文件
+    const files = this.collectProjectFiles(projectPath, options.extensions);
+    
+    if (files.length === 0) {
+      return {
+        success: true,
+        projectPath,
+        mode: actualMode,
+        totalFiles: 0,
+        totalIssues: 0,
+        results: [],
+        durationMs: 0
+      };
+    }
+
+    // 批量检测
+    const results = [];
+    for (const file of files) {
+      const result = await this.analyzeFile(file, options);
+      results.push(result);
+    }
+
+    const totalIssues = results.reduce((sum, r) => sum + (r.totalIssues || 0), 0);
+    const successCount = results.filter(r => r.success).length;
+
+    return {
+      success: true,
+      projectPath,
+      mode: actualMode,
+      totalFiles: files.length,
+      scannedFiles: successCount,
+      failedFiles: files.length - successCount,
+      totalIssues,
+      results,
+      durationMs: Date.now() - startTime
+    };
+  }
+
+  /**
+   * 优化单个问题（双模核心）
+   * 离线模式：本地知识库RAG检索 + 规则匹配
+   * 在线模式：云端大模型 + RAG增强
+   */
+  async optimizeIssue(issue, fullCode, mode) {
+    const context = {
+      language: issue.language || 'javascript',
+      issueType: issue.issueType,
+      message: issue.message,
+      codeSnippet: issue.codeSnippet
+    };
+
+    if (mode === 'offline') {
+      return this.optimizeOffline(issue, context);
+    } else {
+      return this.optimizeOnline(issue, context);
+    }
+  }
+
+  /**
+   * 离线优化：本地知识库RAG
+   */
+  async optimizeOffline(issue, context) {
+    try {
+      // 1. 检索相似案例
+      const similarCases = knowledgeBase.findSimilarCases(issue.codeSnippet, {
+        language: context.language,
+        issueType: context.issueType,
+        topK: 3
+      });
+
+      // 2. 检索相关知识
+      const relatedKnowledge = knowledgeBase.searchEntries(
+        `${context.issueType} ${context.message}`,
+        {
+          language: context.language,
+          topK: 3
+        }
+      );
+
+      // 3. 构建离线优化建议
+      let optimizedCode = issue.codeSnippet;
+      let explanation = '';
+      const suggestions = [];
+
+      if (similarCases.length > 0 && similarCases[0].similarity > 0.5) {
+        const bestCase = similarCases[0];
+        optimizedCode = bestCase.optimizedCode;
+        explanation = bestCase.explanation;
+        suggestions.push(`参考相似案例(ID: ${bestCase.id})`);
+        
+        // 更新案例使用次数
+        knowledgeBase.updateCaseUsage(bestCase.id, 5);
+      } else {
+        // 基于知识库生成建议
+        optimizedCode = this.applyOfflineRules(issue);
+        explanation = this.generateOfflineExplanation(issue, relatedKnowledge);
+      }
+
+      relatedKnowledge.forEach(k => {
+        if (k.similarity > 0.3) {
+          suggestions.push(k.content);
+        }
+      });
+
+      return {
+        success: true,
+        mode: 'offline',
+        optimizedCode,
+        explanation: explanation || '基于本地知识库规则的建议',
+        suggestions: suggestions.length > 0 ? suggestions : ['建议参考编码规范进行优化'],
+        similarCases: similarCases.slice(0, 3),
+        knowledgeSources: relatedKnowledge.slice(0, 3)
+      };
+
+    } catch (error) {
+      logger.error('离线优化失败:', error);
+      return {
+        success: false,
+        mode: 'offline',
+        message: error.message,
+        optimizedCode: issue.codeSnippet,
+        explanation: '离线优化失败，建议切换在线模式',
+        suggestions: []
+      };
+    }
+  }
+
+  /**
+   * 在线优化：云端大模型 + RAG增强
+   */
+  async optimizeOnline(issue, context) {
+    try {
+      // 1. 先进行RAG检索（增强上下文）
+      const similarCases = knowledgeBase.findSimilarCases(issue.codeSnippet, {
+        language: context.language,
+        issueType: context.issueType,
+        topK: 3
+      });
+
+      const relatedKnowledge = knowledgeBase.searchEntries(
+        `${context.issueType} ${context.message}`,
+        {
+          language: context.language,
+          topK: 3
+        }
+      );
+
+      // 2. 构建增强提示
+      const enhancedContext = {
+        ...context,
+        similarCases: similarCases.filter(c => c.similarity > 0.3),
+        relatedKnowledge: relatedKnowledge.filter(k => k.similarity > 0.3)
+      };
+
+      // 3. 调用云端大模型
+      const llmResult = await providerManager.optimizeCode(issue.codeSnippet, enhancedContext);
+
+      // 4. 将优化结果存入知识库（持续学习）
+      if (llmResult.content && llmResult.content.optimizedCode) {
+        knowledgeBase.addCase(
+          issue.codeSnippet,
+          llmResult.content.optimizedCode,
+          llmResult.content.explanation || 'AI优化建议',
+          {
+            language: context.language,
+            issueType: context.issueType
+          }
+        );
+      }
+
+      return {
+        success: true,
+        mode: 'online',
+        optimizedCode: llmResult.content?.optimizedCode || issue.codeSnippet,
+        explanation: llmResult.content?.explanation || 'AI优化建议',
+        suggestions: llmResult.content?.suggestions || [],
+        rawResponse: llmResult.rawContent,
+        tokensUsed: llmResult.tokensUsed,
+        model: llmResult.model,
+        similarCases: similarCases.slice(0, 3)
+      };
+
+    } catch (error) {
+      logger.error('在线优化失败，回退到离线模式:', error);
+      // 在线失败时自动回退到离线模式
+      return this.optimizeOffline(issue, context);
+    }
+  }
+
+  /**
+   * 应用离线规则生成优化代码
+   */
+  applyOfflineRules(issue) {
+    const code = issue.codeSnippet;
+    
+    switch (issue.issueType) {
+      case 'unused_variable':
+        return `// 建议删除未使用的变量\n// ${code}`;
+      
+      case 'unused_import':
+        return `// 建议删除未使用的导入\n// ${code}`;
+      
+      case 'magic_number': {
+        const match = code.match(/(\d+)/);
+        const num = match ? match[1] : 'NUMBER';
+        return code.replace(new RegExp(num, 'g'), `CONSTANT_${num}`);
+      }
+      
+      case 'long_function':
+        return `// 建议将函数拆分为多个小函数\n// ${code.substring(0, 50)}...`;
+      
+      default:
+        return code;
+    }
+  }
+
+  /**
+   * 生成离线优化说明
+   */
+  generateOfflineExplanation(issue, knowledge) {
+    let explanation = issue.suggestion || '';
+    
+    if (knowledge.length > 0) {
+      explanation += '\n\n参考知识：';
+      knowledge.slice(0, 2).forEach(k => {
+        explanation += `\n- ${k.content}`;
+      });
+    }
+    
+    return explanation;
+  }
+
+  /**
+   * 收集项目文件
+   */
+  collectProjectFiles(projectPath, extensions = ['.js', '.ts', '.jsx', '.tsx', '.py', '.java', '.go']) {
+    const files = [];
+    const excludeDirs = ['node_modules', 'dist', 'build', 'out', '.git', 'coverage', 'vendor', '__pycache__'];
+    
+    const walk = (dir) => {
+      try {
+        const items = fs.readdirSync(dir);
+        for (const item of items) {
+          const fullPath = require('path').join(dir, item);
+          if (excludeDirs.includes(item)) continue;
+          
+          const stat = fs.statSync(fullPath);
+          if (stat.isDirectory()) {
+            walk(fullPath);
+          } else if (extensions.some(ext => item.endsWith(ext))) {
+            files.push(fullPath);
+          }
+        }
+      } catch (e) {
+        // 忽略无权限访问的目录
+      }
+    };
+    
+    walk(projectPath);
+    return files;
+  }
+
+  /**
+   * 获取引擎状态
+   */
+  getStatus() {
+    const actualMode = this.getActualMode();
+    const providers = providerManager.getAvailableProviders();
+    const kbStats = knowledgeBase.getStats();
+    
+    return {
+      mode: this.mode,
+      actualMode,
+      initialized: this.initialized,
+      providers: providers.map(p => ({
+        name: p.name,
+        available: p.available,
+        model: p.model
+      })),
+      knowledgeBase: kbStats
+    };
+  }
+}
+
+// 单例实例
+const engine = new DualModeEngine();
+
+module.exports = {
+  DualModeEngine,
+  engine
+};