mr-sliy 1.0.0

package/scripts/postinstall.js

@@ -0,0 +1,134 @@
+/**
+ * 安装后脚本
+ * 用于自动初始化数据库和下载 Tree-sitter WASM 文件
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { exec } = require('child_process');
+
+// 颜色输出
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  red: '\x1b[31m'
+};
+
+function log(message, color = 'reset') {
+  console.log(`${colors[color]}${message}${colors.reset}`);
+}
+
+function checkAndCreateEnvFile() {
+  const envPath = path.join(__dirname, '../.env');
+  const envExamplePath = path.join(__dirname, '../.env.example');
+
+  if (!fs.existsSync(envPath)) {
+    if (fs.existsSync(envExamplePath)) {
+      log('📝 检测到 .env.example，正在创建 .env...', 'yellow');
+      fs.copyFileSync(envExamplePath, envPath);
+      log('✅ .env 文件已创建', 'green');
+      log('⚠️  请编辑 .env 文件，配置您的 API Key', 'yellow');
+    }
+  }
+}
+
+function initializeDatabase() {
+  return new Promise((resolve, reject) => {
+    const dbPath = path.join(__dirname, '../database/code_optimizer.db');
+
+    if (fs.existsSync(dbPath)) {
+      log('📦 数据库已存在，跳过初始化', 'blue');
+      resolve();
+      return;
+    }
+
+    log('🗄️  正在初始化数据库...', 'yellow');
+
+    try {
+      // 动态导入 init 函数
+      const { initDatabase } = require('../database/init.js');
+      initDatabase();
+      log('✅ 数据库初始化完成', 'green');
+      resolve();
+    } catch (error) {
+      log(`⚠️  数据库初始化失败: ${error.message}`, 'yellow');
+      log('   请手动运行: npm run init', 'yellow');
+      resolve(); // 不阻塞安装
+    }
+  });
+}
+
+function downloadWasmFiles() {
+  return new Promise((resolve) => {
+    const wasmDir = path.join(__dirname, '../wasm');
+    let wasmFilesExist = false;
+
+    try {
+      const files = fs.readdirSync(wasmDir);
+      const wasmFiles = files.filter(f => f.endsWith('.wasm'));
+      wasmFilesExist = wasmFiles.some(f => {
+        const stat = fs.statSync(path.join(wasmDir, f));
+        return stat.size > 0;
+      });
+    } catch (error) {
+      wasmFilesExist = false;
+    }
+
+    if (wasmFilesExist) {
+      log('📦 Tree-sitter WASM 文件已存在，跳过下载', 'blue');
+      resolve();
+      return;
+    }
+
+    log('🌐 正在下载 Tree-sitter WASM 文件...', 'yellow');
+
+    try {
+      const { downloadAllWasm } = require('./download-tree-sitter.js');
+      downloadAllWasm()
+        .then(() => {
+          log('✅ Tree-sitter WASM 文件下载完成', 'green');
+          resolve();
+        })
+        .catch((error) => {
+          log(`⚠️  WASM 文件下载失败: ${error.message}`, 'yellow');
+          log('   请稍后手动运行: npm run download-wasm', 'yellow');
+          resolve(); // 不阻塞安装
+        });
+    } catch (error) {
+      log(`⚠️  WASM 下载脚本加载失败: ${error.message}`, 'yellow');
+      resolve();
+    }
+  });
+}
+
+async function main() {
+  log('\n🔧 Mr.Sliy 安装后配置...\n', 'bright');
+
+  try {
+    // 1. 检查并创建 .env 文件
+    checkAndCreateEnvFile();
+
+    // 2. 初始化数据库
+    await initializeDatabase();
+
+    // 3. 下载 WASM 文件
+    await downloadWasmFiles();
+
+    log('\n🎉 安装完成！', 'green');
+    log('\n下一步:');
+    log('1. 编辑 .env 文件配置您的 API Key', 'blue');
+    log('2. 运行 npm run start 启动智能体', 'blue');
+    log('\n或使用以下命令快速开始:', 'blue');
+    log('   npm run setup   # 初始化数据库', 'yellow');
+    log('   npm start       # 启动智能体', 'yellow');
+    log('\n');
+  } catch (error) {
+    log(`\n❌ 安装后配置失败: ${error.message}`, 'red');
+    process.exit(1);
+  }
+}
+
+main();

package/src/agent/agent.js

@@ -0,0 +1,563 @@
+/**
+ * Code Optimizer Agent 核心
+ * 智能体主逻辑：状态管理、任务调度、结果处理
+ */
+
+const { engine } = require('../engine/dualModeEngine');
+const { providerManager } = require('../services/llm/providers');
+const { knowledgeBase } = require('../services/vector/knowledgeBase');
+const { logger } = require('../utils/logger');
+const { getDatabase } = require('../utils/database');
+const { generateUUID } = require('../utils/helpers');
+const { skillManager } = require('../skills');
+
+/**
+ * Agent状态
+ */
+const AgentState = {
+  IDLE: 'idle',
+  ANALYZING: 'analyzing',
+  OPTIMIZING: 'optimizing',
+  LEARNING: 'learning',
+  ERROR: 'error'
+};
+
+/**
+ * 代码优化智能体
+ */
+class CodeOptimizerAgent {
+  constructor() {
+    this.state = AgentState.IDLE;
+    this.currentTask = null;
+    this.taskHistory = [];
+    this.chatHistory = [];
+    this.config = {
+      mode: 'auto',
+      autoSave: true,
+      maxIssuesPerFile: 100
+    };
+  }
+
+  /**
+   * 初始化Agent
+   */
+  async init() {
+    engine.init();
+    await skillManager.init();
+    logger.info('Code Optimizer Agent 初始化完成');
+    return this.getStatus();
+  }
+
+  /**
+   * 配置Agent
+   */
+  configure(options) {
+    Object.assign(this.config, options);
+    
+    if (options.mode) {
+      engine.setMode(options.mode);
+    }
+    
+    // 配置LLM提供商
+    if (options.providers) {
+      Object.entries(options.providers).forEach(([name, config]) => {
+        providerManager.register(name, config);
+      });
+    }
+    
+    // 设置活跃提供商
+    if (options.activeProvider) {
+      providerManager.setActiveProvider(options.activeProvider);
+    }
+    
+    logger.info('Agent配置已更新');
+    return this.getStatus();
+  }
+
+  /**
+   * 分析单个文件
+   */
+  async analyzeFile(filePath) {
+    this.setState(AgentState.ANALYZING);
+    this.currentTask = { type: 'analyze_file', filePath, id: generateUUID() };
+    
+    try {
+      const result = await engine.analyzeFile(filePath);
+      
+      if (result.success && this.config.autoSave) {
+        this.saveTaskResult(this.currentTask, result);
+      }
+      
+      this.addToHistory(this.currentTask, result);
+      this.setState(AgentState.IDLE);
+      
+      return result;
+    } catch (error) {
+      this.setState(AgentState.ERROR);
+      logger.error('分析文件失败:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * 分析代码片段
+   */
+  async analyzeSnippet(code, language = 'javascript') {
+    this.setState(AgentState.ANALYZING);
+    this.currentTask = { type: 'analyze_snippet', language, id: generateUUID() };
+    
+    try {
+      const result = await engine.analyzeSnippet(code, language, { generalOptimize: true });
+      
+      this.addToHistory(this.currentTask, result);
+      this.setState(AgentState.IDLE);
+      
+      return result;
+    } catch (error) {
+      this.setState(AgentState.ERROR);
+      logger.error('分析代码片段失败:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * 分析整个项目
+   */
+  async analyzeProject(projectPath, options = {}) {
+    this.setState(AgentState.ANALYZING);
+    this.currentTask = { type: 'analyze_project', projectPath, id: generateUUID() };
+    
+    try {
+      const result = await engine.analyzeProject(projectPath, options);
+      
+      if (result.success && this.config.autoSave) {
+        this.saveTaskResult(this.currentTask, result);
+      }
+      
+      this.addToHistory(this.currentTask, result);
+      this.setState(AgentState.IDLE);
+      
+      return result;
+    } catch (error) {
+      this.setState(AgentState.ERROR);
+      logger.error('分析项目失败:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * 优化单个代码片段（直接优化）
+   */
+  async optimize(code, language = 'javascript', context = {}) {
+    this.setState(AgentState.OPTIMIZING);
+    this.currentTask = { type: 'optimize', language, id: generateUUID() };
+    
+    try {
+      const issue = {
+        codeSnippet: code,
+        language,
+        issueType: context.issueType || 'general',
+        message: context.message || '代码优化'
+      };
+      
+      const mode = engine.getActualMode();
+      const result = await engine.optimizeIssue(issue, code, mode);
+      
+      this.addToHistory(this.currentTask, result);
+      this.setState(AgentState.IDLE);
+      
+      return result;
+    } catch (error) {
+      this.setState(AgentState.ERROR);
+      logger.error('优化失败:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * 添加知识到本地知识库
+   */
+  async learn(content, options = {}) {
+    this.setState(AgentState.LEARNING);
+    
+    try {
+      let id;
+      if (options.type === 'case' && options.originalCode && options.optimizedCode) {
+        id = knowledgeBase.addCase(
+          options.originalCode,
+          options.optimizedCode,
+          content,
+          {
+            language: options.language,
+            issueType: options.issueType
+          }
+        );
+      } else {
+        id = knowledgeBase.addEntry(content, {
+          type: options.type || 'general',
+          language: options.language,
+          tags: options.tags,
+          source: options.source
+        });
+      }
+      
+      this.setState(AgentState.IDLE);
+      return { success: true, id, message: '知识已添加到本地知识库' };
+    } catch (error) {
+      this.setState(AgentState.ERROR);
+      logger.error('学习失败:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * 查询知识库
+   */
+  queryKnowledge(query, options = {}) {
+    const cases = knowledgeBase.searchCases(query, {
+      language: options.language,
+      issueType: options.issueType,
+      topK: options.topK || 5
+    });
+    
+    const entries = knowledgeBase.searchEntries(query, {
+      language: options.language,
+      topK: options.topK || 5
+    });
+    
+    return {
+      cases,
+      entries,
+      total: cases.length + entries.length
+    };
+  }
+
+  /**
+   * 切换LLM提供商
+   */
+  switchProvider(providerName) {
+    try {
+      providerManager.setActiveProvider(providerName);
+      return {
+        success: true,
+        provider: providerName,
+        message: `已切换至 ${providerName} 提供商`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: error.message
+      };
+    }
+  }
+
+  /**
+   * 搜索知识库
+   */
+  async searchKnowledge(query, options = {}) {
+    const entries = knowledgeBase.searchEntries(query, options);
+    const cases = knowledgeBase.searchCases(query, options);
+    return [...entries, ...cases].slice(0, options.limit || 10);
+  }
+
+  /**
+   * 获取知识库统计
+   */
+  getKnowledgeStats() {
+    return knowledgeBase.getStats();
+  }
+
+  /**
+   * 导出知识库
+   */
+  exportKnowledge(filePath) {
+    const path = require('path');
+    const exportPath = filePath || path.join(__dirname, '../../data/knowledge-export.json');
+    return knowledgeBase.exportToFile(exportPath);
+  }
+
+  /**
+   * 导入知识库
+   */
+  importKnowledge(filePath, options = {}) {
+    return knowledgeBase.importFromFile(filePath, options);
+  }
+
+  /**
+   * 同步知识库到云端
+   */
+  async syncKnowledgeToCloud() {
+    return await knowledgeBase.syncToCloud();
+  }
+
+  /**
+   * 从云端同步知识库
+   */
+  async syncKnowledgeFromCloud() {
+    return await knowledgeBase.syncFromCloud();
+  }
+
+  /**
+   * 测试云端连接
+   */
+  async testCloudConnection() {
+    return await knowledgeBase.testCloudConnection();
+  }
+
+  /**
+   * 获取可用提供商列表
+   */
+  getProviders() {
+    return providerManager.getAvailableProviders();
+  }
+
+  /**
+   * 注册新的LLM提供商
+   */
+  registerProvider(name, config) {
+    try {
+      providerManager.register(name, config);
+      return {
+        success: true,
+        provider: name,
+        message: `已注册 ${name} 提供商`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: error.message
+      };
+    }
+  }
+
+  /**
+   * 更新提供商配置（如API Key）
+   */
+  updateProviderConfig(name, config) {
+    providerManager.updateProviderConfig(name, config);
+    return {
+      success: true,
+      message: `已更新 ${name} 配置`
+    };
+  }
+
+  /**
+   * 设置工作模式
+   */
+  setMode(mode) {
+    engine.setMode(mode);
+    this.config.mode = mode;
+    return {
+      success: true,
+      mode,
+      actualMode: engine.getActualMode()
+    };
+  }
+
+  /**
+   * 获取所有可用技能
+   */
+  getSkills() {
+    return skillManager.getAllSkills();
+  }
+
+  /**
+   * 获取已启用的技能
+   */
+  getEnabledSkills() {
+    return skillManager.getEnabledSkills();
+  }
+
+  /**
+   * 执行技能
+   */
+  async executeSkill(skillName, context = {}) {
+    return await skillManager.executeSkill(skillName, context);
+  }
+
+  /**
+   * 启用技能
+   */
+  enableSkill(skillName) {
+    return skillManager.enableSkill(skillName);
+  }
+
+  /**
+   * 禁用技能
+   */
+  disableSkill(skillName) {
+    return skillManager.disableSkill(skillName);
+  }
+
+  /**
+   * 获取Agent状态
+   */
+  getStatus() {
+    return {
+      state: this.state,
+      currentTask: this.currentTask,
+      config: this.config,
+      engine: engine.getStatus(),
+      historyCount: this.taskHistory.length
+    };
+  }
+
+  /**
+   * 获取任务历史
+   */
+  getHistory(limit = 10) {
+    return this.taskHistory.slice(-limit);
+  }
+
+  /**
+   * 与AI聊天
+   */
+  async chat(message, options = {}) {
+    const provider = providerManager.getActiveProvider();
+    if (!provider) {
+      throw new Error('未配置活跃的LLM提供商，请先在提供商管理中配置');
+    }
+
+    this.chatHistory.push({ role: 'user', content: message });
+
+    const messages = [
+      { 
+        role: 'system', 
+        content: `你是一个专业的代码优化助手，精通多种编程语言和代码优化技术。
+你可以：
+1. 回答代码相关的问题
+2. 提供代码优化建议
+3. 根据用户需求调用智能体的功能
+
+可用功能列表：
+- analyze_file: 分析单个文件的代码缺陷
+- scan_project: 扫描项目目录
+- optimize_code: 优化代码片段
+- search_knowledge: 搜索知识库
+- get_status: 获取系统状态
+- switch_provider: 切换LLM提供商
+- switch_mode: 切换工作模式
+
+当用户需要调用功能时，请使用以下格式输出：
+<function_call>
+{
+  "function": "功能名称",
+  "params": {参数对象}
+}
+</function_call>
+
+如果不需要调用功能，直接回答用户问题即可。`
+      },
+      ...this.chatHistory.slice(-10)
+    ];
+
+    const result = await provider.chat(messages, options);
+    
+    this.chatHistory.push({ role: 'assistant', content: result.content });
+    
+    return result;
+  }
+
+  /**
+   * 清空聊天历史
+   */
+  clearChatHistory() {
+    this.chatHistory = [];
+  }
+
+  /**
+   * 设置状态
+   */
+  setState(state) {
+    this.state = state;
+    logger.info(`Agent状态: ${state}`);
+  }
+
+  /**
+   * 添加任务到历史
+   */
+  addToHistory(task, result) {
+    this.taskHistory.push({
+      task,
+      result: {
+        success: result.success,
+        totalIssues: result.totalIssues,
+        mode: result.mode,
+        durationMs: result.durationMs
+      },
+      timestamp: new Date().toISOString()
+    });
+    
+    // 限制历史记录数量
+    if (this.taskHistory.length > 100) {
+      this.taskHistory = this.taskHistory.slice(-50);
+    }
+  }
+
+  /**
+   * 保存任务结果到数据库
+   */
+  saveTaskResult(task, result) {
+    try {
+      const db = getDatabase();
+      
+      // 创建扫描任务记录
+      const taskStmt = db.prepare(`
+        INSERT INTO scan_task (project_id, task_name, scan_mode, scan_type, 
+                               target_path, file_count, issue_count, duration_ms, status)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+      
+      const taskResult = taskStmt.run(
+        null,
+        task.type,
+        result.mode,
+        task.type === 'analyze_project' ? 'full_project' : 'single_file',
+        task.filePath || task.projectPath || 'snippet',
+        result.totalFiles || 1,
+        result.totalIssues || 0,
+        result.durationMs || 0,
+        'completed'
+      );
+      
+      const taskId = taskResult.lastInsertRowid;
+      
+      // 保存代码缺陷
+      if (result.issues && result.issues.length > 0) {
+        const issueStmt = db.prepare(`
+          INSERT INTO code_issue (task_id, file_path, file_name, language, issue_type,
+                                  severity, message, suggestion, line_start, code_snippet)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `);
+        
+        result.issues.forEach(issue => {
+          issueStmt.run(
+            taskId,
+            issue.filePath || 'snippet',
+            issue.fileName || 'snippet',
+            issue.language || 'unknown',
+            issue.issueType,
+            issue.severity,
+            issue.message,
+            issue.suggestion || '',
+            issue.lineStart || 1,
+            issue.codeSnippet || ''
+          );
+        });
+      }
+      
+      logger.info(`任务结果已保存: ${taskId}`);
+    } catch (error) {
+      logger.error('保存任务结果失败:', error);
+    }
+  }
+}
+
+// 单例实例
+const agent = new CodeOptimizerAgent();
+
+module.exports = {
+  CodeOptimizerAgent,
+  agent,
+  AgentState
+};