mr-sliy 1.0.0

package/src/skills/code-optimization/index.js

@@ -0,0 +1,319 @@
+/**
+ * 代码优化技能
+ * 提供多种代码优化策略，包括自动修复和改进建议
+ */
+
+const Skill = require('../Skill');
+const { logger } = require('../../utils/logger');
+const { getFileLanguage } = require('../../utils/helpers');
+const { knowledgeBase } = require('../../services/vector/knowledgeBase');
+
+class CodeOptimizationSkill extends Skill {
+  constructor() {
+    super(
+      'code-optimization',
+      '代码优化技能 - 提供代码优化建议和自动修复',
+      '1.0.0'
+    );
+    this.dependencies = ['code-detection', 'knowledge-base'];
+    this.optimizationStrategies = [
+      'remove-unused-imports',
+      'remove-unused-variables',
+      'remove-console-log',
+      'remove-unnecessary-else',
+      'extract-magic-numbers',
+      'add-null-checks',
+      'add-comments',
+      'simplify-deep-nesting',
+      'split-long-functions'
+    ];
+  }
+
+  async init() {
+    logger.info('代码优化技能初始化完成');
+    return true;
+  }
+
+  canExecute(context = {}) {
+    return this.enabled && (context.sourceCode || context.filePath || context.issues);
+  }
+
+  async execute(context = {}) {
+    const { sourceCode, filePath, issues, options = {} } = context;
+
+    if (!sourceCode && !filePath) {
+      throw new Error('请提供源代码或文件路径');
+    }
+
+    const code = sourceCode || this._readFile(filePath);
+    const language = options.language || getFileLanguage(filePath || '');
+
+    return this._optimizeCode(code, filePath || 'unknown', language, issues, options);
+  }
+
+  async optimizeFile(filePath, options = {}) {
+    const fs = require('fs');
+    const sourceCode = fs.readFileSync(filePath, 'utf-8');
+    return this.execute({ sourceCode, filePath, options });
+  }
+
+  async getOptimizationSuggestions(issues, context = {}) {
+    const suggestions = [];
+    const language = context.language || 'javascript';
+
+    for (const issue of issues) {
+      const suggestion = await this._getSuggestionForIssue(issue, language);
+      if (suggestion) {
+        suggestions.push(suggestion);
+      }
+    }
+
+    return {
+      success: true,
+      totalSuggestions: suggestions.length,
+      suggestions
+    };
+  }
+
+  async applyAutoFix(issue, sourceCode) {
+    const fixStrategy = this._getFixStrategy(issue.issueType);
+    if (!fixStrategy) {
+      return {
+        success: false,
+        message: `没有可用的自动修复策略: ${issue.issueType}`
+      };
+    }
+
+    try {
+      const result = fixStrategy.apply(sourceCode, issue);
+      return {
+        success: true,
+        issueType: issue.issueType,
+        originalCode: issue.codeSnippet,
+        optimizedCode: result.fixedCode,
+        explanation: result.explanation
+      };
+    } catch (error) {
+      logger.error(`自动修复失败: ${issue.issueType}`, error);
+      return {
+        success: false,
+        issueType: issue.issueType,
+        error: error.message
+      };
+    }
+  }
+
+  getAvailableStrategies() {
+    return this.optimizationStrategies;
+  }
+
+  _readFile(filePath) {
+    const fs = require('fs');
+    return fs.readFileSync(filePath, 'utf-8');
+  }
+
+  async _optimizeCode(sourceCode, filePath, language, issues, options) {
+    const startTime = Date.now();
+
+    try {
+      logger.debug(`开始优化代码: ${filePath}`);
+
+      let detectionIssues = issues;
+
+      if (!detectionIssues || detectionIssues.length === 0) {
+        const codeDetection = require('../code-detection');
+        const detectResult = await codeDetection.execute({
+          sourceCode,
+          filePath,
+          options: { language }
+        });
+        detectionIssues = detectResult.issues || [];
+      }
+
+      const optimizableIssues = detectionIssues.filter(issue =>
+        this._canAutoFix(issue.issueType)
+      );
+
+      const suggestions = await this._generateSuggestions(detectionIssues, language);
+
+      let optimizedCode = sourceCode;
+      const appliedFixes = [];
+
+      if (options.autoFix !== false) {
+        for (const issue of optimizableIssues) {
+          const fixResult = await this.applyAutoFix(issue, optimizedCode);
+          if (fixResult.success) {
+            optimizedCode = fixResult.optimizedCode;
+            appliedFixes.push(fixResult);
+          }
+        }
+      }
+
+      const knowledgeSuggestions = await this._getKnowledgeBaseSuggestions(
+        detectionIssues,
+        language
+      );
+
+      return {
+        success: true,
+        filePath,
+        language,
+        totalIssues: detectionIssues.length,
+        autoFixable: optimizableIssues.length,
+        appliedFixes: appliedFixes.length,
+        suggestions: [...suggestions, ...knowledgeSuggestions],
+        originalCode: sourceCode,
+        optimizedCode,
+        issues: detectionIssues,
+        durationMs: Date.now() - startTime
+      };
+    } catch (error) {
+      logger.error(`代码优化失败: ${filePath}`, error);
+      return {
+        success: false,
+        message: error.message,
+        filePath,
+        durationMs: Date.now() - startTime
+      };
+    }
+  }
+
+  _canAutoFix(issueType) {
+    const autoFixable = [
+      'unused_import',
+      'unused_variable',
+      'console_log',
+      'unnecessary_else',
+      'magic_number'
+    ];
+    return autoFixable.includes(issueType);
+  }
+
+  _getFixStrategy(issueType) {
+    const strategies = {
+      unused_import: {
+        apply: (code, issue) => {
+          const lines = code.split('\n');
+          const lineIndex = issue.lineStart - 1;
+          if (lineIndex >= 0 && lineIndex < lines.length) {
+            lines.splice(lineIndex, 1);
+            return {
+              fixedCode: lines.join('\n'),
+              explanation: '删除了未使用的导入语句'
+            };
+          }
+          return { fixedCode: code, explanation: '无法定位导入语句' };
+        }
+      },
+      console_log: {
+        apply: (code, issue) => {
+          const lines = code.split('\n');
+          const lineIndex = issue.lineStart - 1;
+          if (lineIndex >= 0 && lineIndex < lines.length) {
+            lines[lineIndex] = `// ${lines[lineIndex].trim()}`;
+            return {
+              fixedCode: lines.join('\n'),
+              explanation: '注释掉了调试用的 console.log'
+            };
+          }
+          return { fixedCode: code, explanation: '无法定位 console.log' };
+        }
+      },
+      unnecessary_else: {
+        apply: (code, issue) => {
+          return {
+            fixedCode: code,
+            explanation: '建议手动移除 return 后的 else 语句'
+          };
+        }
+      },
+      magic_number: {
+        apply: (code, issue) => {
+          return {
+            fixedCode: code,
+            explanation: '建议将魔法数字提取为具名常量'
+          };
+        }
+      }
+    };
+
+    return strategies[issueType] || null;
+  }
+
+  async _generateSuggestions(issues, language) {
+    const suggestions = [];
+    const seenTypes = new Set();
+
+    for (const issue of issues) {
+      if (!seenTypes.has(issue.issueType)) {
+        seenTypes.add(issue.issueType);
+        suggestions.push({
+          type: issue.issueType,
+          severity: issue.severity,
+          title: this._getIssueTitle(issue.issueType),
+          description: issue.suggestion,
+          count: issues.filter(i => i.issueType === issue.issueType).length,
+          autoFixable: this._canAutoFix(issue.issueType)
+        });
+      }
+    }
+
+    return suggestions.sort((a, b) => {
+      const severityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+      return severityOrder[a.severity] - severityOrder[b.severity];
+    });
+  }
+
+  _getIssueTitle(issueType) {
+    const titles = {
+      unused_variable: '未使用的变量',
+      unused_import: '未使用的导入',
+      unused_function: '未使用的函数',
+      magic_number: '魔法数字',
+      long_function: '过长函数',
+      high_complexity: '圈复杂度过高',
+      deep_nesting: '嵌套层级过深',
+      null_check: '缺少空值检查',
+      unnecessary_else: '不必要的 else 语句',
+      console_log: '调试 console.log',
+      duplicate_code: '重复代码',
+      missing_comment: '缺少注释'
+    };
+    return titles[issueType] || issueType;
+  }
+
+  async _getKnowledgeBaseSuggestions(issues, language) {
+    const suggestions = [];
+
+    try {
+      if (issues.length > 0) {
+        const topIssues = issues.slice(0, 3);
+        for (const issue of topIssues) {
+          const query = `${issue.issueType} ${issue.message} best practices`;
+          const knowledgeResults = await knowledgeBase.search(query, {
+            language,
+            limit: 2
+          });
+
+          if (knowledgeResults && knowledgeResults.length > 0) {
+            suggestions.push({
+              type: 'knowledge-base',
+              severity: 'info',
+              title: `知识库建议: ${this._getIssueTitle(issue.issueType)}`,
+              description: `找到 ${knowledgeResults.length} 条相关知识`,
+              relatedKnowledge: knowledgeResults
+            });
+          }
+        }
+      }
+    } catch (error) {
+      logger.debug('知识库建议获取失败:', error.message);
+    }
+
+    return suggestions;
+  }
+}
+
+const codeOptimizationSkill = new CodeOptimizationSkill();
+
+module.exports = codeOptimizationSkill;

package/src/skills/index.js

@@ -0,0 +1,152 @@
+/**
+ * 技能管理器
+ * 管理所有智能体技能的注册、加载和执行
+ */
+
+const { logger } = require('../utils/logger');
+const Skill = require('./Skill');
+
+class SkillManager {
+  constructor() {
+    this.skills = new Map();
+    this.initialized = false;
+  }
+
+  async init() {
+    if (this.initialized) return;
+
+    logger.info('正在初始化技能管理器...');
+
+    const codeDetectionSkill = require('./code-detection');
+    this.register(codeDetectionSkill);
+
+    const codeOptimizationSkill = require('./code-optimization');
+    this.register(codeOptimizationSkill);
+
+    const codeAnalysisSkill = require('./code-analysis');
+    this.register(codeAnalysisSkill);
+
+    for (const skill of this.skills.values()) {
+      if (typeof skill.init === 'function') {
+        try {
+          await skill.init();
+          logger.debug(`技能初始化完成: ${skill.name}`);
+        } catch (error) {
+          logger.error(`技能初始化失败: ${skill.name}`, error);
+        }
+      }
+    }
+
+    this.initialized = true;
+    logger.info(`技能管理器初始化完成，共加载 ${this.skills.size} 个技能`);
+  }
+
+  register(skill) {
+    if (!(skill instanceof Skill)) {
+      throw new Error('注册的技能必须是 Skill 类的实例');
+    }
+
+    if (this.skills.has(skill.name)) {
+      logger.warn(`技能已存在，将被覆盖: ${skill.name}`);
+    }
+
+    this.skills.set(skill.name, skill);
+    logger.debug(`注册技能: ${skill.name} v${skill.version}`);
+    return true;
+  }
+
+  unregister(skillName) {
+    if (this.skills.has(skillName)) {
+      this.skills.delete(skillName);
+      logger.debug(`注销技能: ${skillName}`);
+      return true;
+    }
+    return false;
+  }
+
+  getSkill(skillName) {
+    return this.skills.get(skillName) || null;
+  }
+
+  hasSkill(skillName) {
+    return this.skills.has(skillName);
+  }
+
+  getAllSkills() {
+    return Array.from(this.skills.values()).map(skill => skill.getInfo());
+  }
+
+  getEnabledSkills() {
+    return Array.from(this.skills.values())
+      .filter(skill => skill.enabled)
+      .map(skill => skill.getInfo());
+  }
+
+  async executeSkill(skillName, context = {}) {
+    const skill = this.skills.get(skillName);
+    
+    if (!skill) {
+      throw new Error(`未找到技能: ${skillName}`);
+    }
+
+    if (!skill.enabled) {
+      throw new Error(`技能已禁用: ${skillName}`);
+    }
+
+    if (!skill.canExecute(context)) {
+      throw new Error(`技能 ${skillName} 无法在当前上下文执行`);
+    }
+
+    logger.debug(`执行技能: ${skillName}`);
+    const startTime = Date.now();
+    
+    try {
+      const result = await skill.execute(context);
+      const duration = Date.now() - startTime;
+      logger.debug(`技能执行完成: ${skillName} (${duration}ms)`);
+      return {
+        success: true,
+        skill: skillName,
+        result,
+        durationMs: duration
+      };
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      logger.error(`技能执行失败: ${skillName}`, error);
+      return {
+        success: false,
+        skill: skillName,
+        error: error.message,
+        durationMs: duration
+      };
+    }
+  }
+
+  enableSkill(skillName) {
+    const skill = this.skills.get(skillName);
+    if (skill) {
+      skill.enabled = true;
+      logger.info(`启用技能: ${skillName}`);
+      return true;
+    }
+    return false;
+  }
+
+  disableSkill(skillName) {
+    const skill = this.skills.get(skillName);
+    if (skill) {
+      skill.enabled = false;
+      logger.info(`禁用技能: ${skillName}`);
+      return true;
+    }
+    return false;
+  }
+}
+
+const skillManager = new SkillManager();
+
+module.exports = {
+  SkillManager,
+  skillManager,
+  Skill
+};

package/src/utils/crypto.js

@@ -0,0 +1,212 @@
+/**
+ * 加密工具模块
+ * 用于安全存储敏感配置数据（API Key、密码等）
+ * 使用 AES-256-GCM 加密算法
+ */
+
+const crypto = require('crypto');
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+
+const ALGORITHM = 'aes-256-gcm';
+const IV_LENGTH = 16;
+const SALT_LENGTH = 64;
+const TAG_LENGTH = 16;
+
+/**
+ * 生成机器唯一密钥（基于机器特征派生）
+ * 这样每台机器的密钥不同，即使文件泄露也无法在其他机器解密
+ */
+function getMachineKey() {
+  const hostname = os.hostname();
+  const username = os.userInfo().username;
+  const platform = os.platform();
+  const release = os.release();
+  const cpuCores = os.cpus().length;
+  const totalMem = os.totalmem();
+  
+  const machineSeed = `${hostname}|${username}|${platform}|${release}|${cpuCores}|${totalMem}`;
+  
+  return crypto.createHash('sha256')
+    .update(machineSeed)
+    .digest();
+}
+
+/**
+ * 加密数据
+ */
+function encrypt(plaintext, key = null) {
+  if (!key) {
+    key = getMachineKey();
+  }
+  
+  if (typeof plaintext === 'object') {
+    plaintext = JSON.stringify(plaintext);
+  }
+  
+  const iv = crypto.randomBytes(IV_LENGTH);
+  const salt = crypto.randomBytes(SALT_LENGTH);
+  
+  const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
+  cipher.setAAD(salt);
+  
+  let encrypted = cipher.update(plaintext, 'utf8', 'hex');
+  encrypted += cipher.final('hex');
+  
+  const tag = cipher.getAuthTag();
+  
+  const result = {
+    iv: iv.toString('hex'),
+    salt: salt.toString('hex'),
+    tag: tag.toString('hex'),
+    encrypted: encrypted
+  };
+  
+  return JSON.stringify(result);
+}
+
+/**
+ * 解密数据
+ */
+function decrypt(encryptedData, key = null) {
+  if (!key) {
+    key = getMachineKey();
+  }
+  
+  try {
+    const data = typeof encryptedData === 'string' 
+      ? JSON.parse(encryptedData) 
+      : encryptedData;
+    
+    const iv = Buffer.from(data.iv, 'hex');
+    const salt = Buffer.from(data.salt, 'hex');
+    const tag = Buffer.from(data.tag, 'hex');
+    const encrypted = data.encrypted;
+    
+    const decipher = crypto.createDecipheriv(ALGORITHM, key, iv);
+    decipher.setAAD(salt);
+    decipher.setAuthTag(tag);
+    
+    let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+    decrypted += decipher.final('utf8');
+    
+    try {
+      return JSON.parse(decrypted);
+    } catch {
+      return decrypted;
+    }
+  } catch (error) {
+    throw new Error('解密失败：密钥不匹配或数据已损坏');
+  }
+}
+
+/**
+ * 加密存储到文件
+ */
+function encryptToFile(filePath, data) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  
+  const encrypted = encrypt(data);
+  fs.writeFileSync(filePath, encrypted, 'utf8');
+  
+  return true;
+}
+
+/**
+ * 从加密文件读取
+ */
+function decryptFromFile(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  
+  const encryptedData = fs.readFileSync(filePath, 'utf8');
+  return decrypt(encryptedData);
+}
+
+/**
+ * 哈希数据（用于校验，不可逆）
+ */
+function hash(data, algorithm = 'sha256') {
+  return crypto.createHash(algorithm)
+    .update(typeof data === 'string' ? data : JSON.stringify(data))
+    .digest('hex');
+}
+
+/**
+ * 生成随机密钥
+ */
+function generateKey(length = 32) {
+  return crypto.randomBytes(length).toString('hex');
+}
+
+/**
+ * 安全比较（防止时序攻击）
+ */
+function safeCompare(a, b) {
+  return crypto.timingSafeEqual(
+    Buffer.from(a),
+    Buffer.from(b)
+  );
+}
+
+/**
+ * 密码哈希（使用 scrypt + salt）
+ * 返回格式: scrypt$N$r$p$salt$hash
+ */
+function hashPassword(password) {
+  const salt = crypto.randomBytes(16).toString('hex');
+  const N = 16384;
+  const r = 8;
+  const p = 1;
+  const keyLength = 64;
+  
+  const derivedKey = crypto.scryptSync(password, salt, keyLength, { N, r, p });
+  
+  return `scrypt$${N}$${r}$${p}$${salt}$${derivedKey.toString('hex')}`;
+}
+
+/**
+ * 密码验证
+ */
+function verifyPassword(password, hashedPassword) {
+  try {
+    const parts = hashedPassword.split('$');
+    if (parts.length !== 6 || parts[0] !== 'scrypt') {
+      return false;
+    }
+    
+    const [, N, r, p, salt, hash] = parts;
+    const keyLength = Buffer.from(hash, 'hex').length;
+    
+    const derivedKey = crypto.scryptSync(password, salt, keyLength, {
+      N: parseInt(N),
+      r: parseInt(r),
+      p: parseInt(p)
+    });
+    
+    return crypto.timingSafeEqual(
+      Buffer.from(hash, 'hex'),
+      derivedKey
+    );
+  } catch (error) {
+    return false;
+  }
+}
+
+module.exports = {
+  encrypt,
+  decrypt,
+  encryptToFile,
+  decryptFromFile,
+  hash,
+  generateKey,
+  safeCompare,
+  getMachineKey,
+  hashPassword,
+  verifyPassword
+};