mr-sliy 1.0.0

package/src/skills/Skill.js

@@ -0,0 +1,38 @@
+/**
+ * 技能基类
+ * 所有智能体技能都继承自此类
+ */
+
+class Skill {
+  constructor(name, description, version = '1.0.0') {
+    this.name = name;
+    this.description = description;
+    this.version = version;
+    this.enabled = true;
+    this.dependencies = [];
+  }
+
+  async init() {
+    return true;
+  }
+
+  async execute(context = {}) {
+    throw new Error(`技能 ${this.name} 必须实现 execute 方法`);
+  }
+
+  canExecute(context = {}) {
+    return this.enabled;
+  }
+
+  getInfo() {
+    return {
+      name: this.name,
+      description: this.description,
+      version: this.version,
+      enabled: this.enabled,
+      dependencies: this.dependencies
+    };
+  }
+}
+
+module.exports = Skill;

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

@@ -0,0 +1,272 @@
+/**
+ * 代码分析技能
+ * 提供代码统计、结构分析、复杂度评估等功能
+ */
+
+const Skill = require('../Skill');
+const { logger } = require('../../utils/logger');
+const { getFileLanguage, countLines } = require('../../utils/helpers');
+const { parseCode, extractFunctions, extractVariables, extractImports } = require('../../services/ast/parser');
+
+class CodeAnalysisSkill extends Skill {
+  constructor() {
+    super(
+      'code-analysis',
+      '代码分析技能 - 代码统计、结构分析和复杂度评估',
+      '1.0.0'
+    );
+    this.dependencies = ['ast-parser'];
+  }
+
+  async init() {
+    logger.info('代码分析技能初始化完成');
+    return true;
+  }
+
+  canExecute(context = {}) {
+    return this.enabled && (context.sourceCode || context.filePath);
+  }
+
+  async execute(context = {}) {
+    const { sourceCode, filePath, options = {} } = context;
+
+    if (!sourceCode && !filePath) {
+      throw new Error('请提供源代码或文件路径');
+    }
+
+    const code = sourceCode || this._readFile(filePath);
+    const language = options.language || getFileLanguage(filePath || '');
+
+    return this._analyzeCode(code, filePath || 'unknown', language, options);
+  }
+
+  async analyzeFile(filePath, options = {}) {
+    const fs = require('fs');
+    const sourceCode = fs.readFileSync(filePath, 'utf-8');
+    return this.execute({ sourceCode, filePath, options });
+  }
+
+  async analyzeProject(dirPath, options = {}) {
+    const fs = require('fs');
+    const path = require('path');
+    const { scanExtensions, excludeDirs, excludeFiles } = require('../../config').config.scan;
+
+    const files = this._collectFiles(dirPath, scanExtensions, excludeDirs, excludeFiles);
+    const results = [];
+    const summary = {
+      totalFiles: files.length,
+      totalLines: 0,
+      totalFunctions: 0,
+      totalClasses: 0,
+      languages: {},
+      fileTypes: {}
+    };
+
+    for (const file of files) {
+      try {
+        const sourceCode = fs.readFileSync(file, 'utf-8');
+        const relPath = path.relative(dirPath, file);
+        const result = await this.execute({
+          sourceCode,
+          filePath: relPath,
+          options
+        });
+
+        if (result.success) {
+          results.push(result);
+          summary.totalLines += result.metrics.totalLines;
+          summary.totalFunctions += result.metrics.functionCount;
+
+          const lang = result.language;
+          summary.languages[lang] = (summary.languages[lang] || 0) + 1;
+
+          const ext = path.extname(file);
+          summary.fileTypes[ext] = (summary.fileTypes[ext] || 0) + 1;
+        }
+      } catch (error) {
+        logger.debug(`分析文件失败: ${file}`, error.message);
+      }
+    }
+
+    return {
+      success: true,
+      projectPath: dirPath,
+      summary,
+      files: results,
+      totalFiles: files.length,
+      analyzedFiles: results.length
+    };
+  }
+
+  async getMetrics(sourceCode, language = 'javascript') {
+    const lines = countLines(sourceCode);
+    const parseResult = await parseCode(sourceCode, language);
+
+    if (!parseResult.success) {
+      return { totalLines: lines };
+    }
+
+    const tree = parseResult.tree;
+    const functions = extractFunctions(tree, sourceCode);
+    const variables = extractVariables(tree, sourceCode);
+    const imports = extractImports(tree, sourceCode);
+
+    const avgFunctionLength = functions.length > 0
+      ? Math.round(functions.reduce((sum, f) => sum + (f.endLine - f.startLine + 1), 0) / functions.length)
+      : 0;
+
+    const maxFunctionLength = functions.length > 0
+      ? Math.max(...functions.map(f => f.endLine - f.startLine + 1))
+      : 0;
+
+    const commentLines = this._countCommentLines(sourceCode, language);
+    const commentRatio = lines > 0 ? (commentLines / lines * 100).toFixed(1) : 0;
+
+    return {
+      totalLines: lines,
+      codeLines: lines - commentLines,
+      commentLines,
+      commentRatio: `${commentRatio}%`,
+      functionCount: functions.length,
+      variableCount: variables.length,
+      importCount: imports.length,
+      avgFunctionLength,
+      maxFunctionLength,
+      functions: functions.map(f => ({
+        name: f.name,
+        startLine: f.startLine,
+        endLine: f.endLine,
+        lineCount: f.endLine - f.startLine + 1
+      }))
+    };
+  }
+
+  async getStructure(sourceCode, language = 'javascript') {
+    const parseResult = await parseCode(sourceCode, language);
+
+    if (!parseResult.success) {
+      return { success: false, error: parseResult.error };
+    }
+
+    const tree = parseResult.tree;
+    const functions = extractFunctions(tree, sourceCode);
+    const imports = extractImports(tree, sourceCode);
+    const variables = extractVariables(tree, sourceCode);
+
+    return {
+      success: true,
+      language,
+      structure: {
+        imports: imports.map(i => i.name),
+        functions: functions.map(f => ({
+          name: f.name,
+          line: f.startLine,
+          params: f.params || [],
+          isAsync: f.isAsync || false
+        })),
+        variables: variables.map(v => ({
+          name: v.name,
+          line: v.line,
+          type: v.kind || 'var'
+        }))
+      }
+    };
+  }
+
+  _readFile(filePath) {
+    const fs = require('fs');
+    return fs.readFileSync(filePath, 'utf-8');
+  }
+
+  async _analyzeCode(sourceCode, filePath, language, options) {
+    const startTime = Date.now();
+
+    try {
+      logger.debug(`开始分析代码: ${filePath}`);
+
+      const metrics = await this.getMetrics(sourceCode, language);
+      const structure = await this.getStructure(sourceCode, language);
+
+      return {
+        success: true,
+        filePath,
+        fileName: filePath.split(/[/\\]/).pop(),
+        language,
+        metrics,
+        structure: structure.structure || {},
+        durationMs: Date.now() - startTime
+      };
+    } catch (error) {
+      logger.error(`代码分析失败: ${filePath}`, error);
+      return {
+        success: false,
+        message: error.message,
+        filePath,
+        durationMs: Date.now() - startTime
+      };
+    }
+  }
+
+  _countCommentLines(sourceCode, language) {
+    const lines = sourceCode.split('\n');
+    let commentLines = 0;
+    let inBlockComment = false;
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+
+      if (inBlockComment) {
+        commentLines++;
+        if (trimmed.includes('*/')) {
+          inBlockComment = false;
+        }
+        continue;
+      }
+
+      if (trimmed.startsWith('//')) {
+        commentLines++;
+      } else if (trimmed.startsWith('/*')) {
+        commentLines++;
+        if (!trimmed.includes('*/')) {
+          inBlockComment = true;
+        }
+      } else if (trimmed.startsWith('#') && ['python', 'ruby'].includes(language)) {
+        commentLines++;
+      }
+    }
+
+    return commentLines;
+  }
+
+  _collectFiles(dirPath, extensions, excludeDirs, excludeFiles) {
+    const fs = require('fs');
+    const path = require('path');
+    const files = [];
+
+    function scanDirectory(currentPath) {
+      const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const fullPath = path.join(currentPath, entry.name);
+
+        if (entry.isDirectory()) {
+          if (!excludeDirs.includes(entry.name)) {
+            scanDirectory(fullPath);
+          }
+        } else if (entry.isFile()) {
+          const ext = path.extname(entry.name);
+          if (extensions.includes(ext) && !excludeFiles.some(ef => entry.name.endsWith(ef))) {
+            files.push(fullPath);
+          }
+        }
+      }
+    }
+
+    scanDirectory(dirPath);
+    return files;
+  }
+}
+
+const codeAnalysisSkill = new CodeAnalysisSkill();
+
+module.exports = codeAnalysisSkill;

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

@@ -0,0 +1,166 @@
+/**
+ * 代码检测技能
+ * 基于 AST 静态分析检测代码中的各种问题和不规范之处
+ */
+
+const Skill = require('../Skill');
+const { logger } = require('../../utils/logger');
+const { parseCode } = require('../../services/ast/parser');
+const { getFileLanguage } = require('../../utils/helpers');
+const { getEnabledRules, getRuleConfig } = require('./rules');
+
+class CodeDetectionSkill extends Skill {
+  constructor() {
+    super(
+      'code-detection',
+      '代码缺陷检测技能 - 基于AST静态分析检测代码问题',
+      '1.0.0'
+    );
+    this.dependencies = ['ast-parser'];
+    this.enabledRules = [];
+  }
+
+  async init() {
+    this.enabledRules = getEnabledRules();
+    logger.info(`代码检测技能初始化完成，启用 ${this.enabledRules.length} 条检测规则`);
+    return true;
+  }
+
+  canExecute(context = {}) {
+    return this.enabled && (context.sourceCode || context.filePath);
+  }
+
+  async execute(context = {}) {
+    const { sourceCode, filePath, options = {} } = context;
+
+    if (!sourceCode && !filePath) {
+      throw new Error('请提供源代码或文件路径');
+    }
+
+    const code = sourceCode || this._readFile(filePath);
+    const language = options.language || getFileLanguage(filePath || '');
+
+    return this._detectIssues(code, filePath || 'unknown', language, options);
+  }
+
+  async detectFile(filePath, options = {}) {
+    const fs = require('fs');
+    const sourceCode = fs.readFileSync(filePath, 'utf-8');
+    return this.execute({ sourceCode, filePath, options });
+  }
+
+  async detectSource(sourceCode, language = 'javascript', options = {}) {
+    return this.execute({ sourceCode, language, options });
+  }
+
+  async batchDetect(filePaths, options = {}) {
+    const fs = require('fs');
+    const results = [];
+    const startTime = Date.now();
+
+    for (const filePath of filePaths) {
+      try {
+        const sourceCode = fs.readFileSync(filePath, 'utf-8');
+        const result = await this.execute({ sourceCode, filePath, options });
+        results.push(result);
+      } catch (error) {
+        logger.error(`批量检测文件失败: ${filePath}`, error);
+        results.push({
+          success: false,
+          message: error.message,
+          filePath
+        });
+      }
+    }
+
+    return {
+      success: true,
+      totalFiles: filePaths.length,
+      scannedFiles: results.filter(r => r.success).length,
+      failedFiles: results.filter(r => !r.success).length,
+      totalIssues: results.reduce((sum, r) => sum + (r.totalIssues || 0), 0),
+      results,
+      durationMs: Date.now() - startTime
+    };
+  }
+
+  getRules() {
+    return this.enabledRules;
+  }
+
+  _readFile(filePath) {
+    const fs = require('fs');
+    return fs.readFileSync(filePath, 'utf-8');
+  }
+
+  async _detectIssues(sourceCode, filePath, language, options = {}) {
+    const startTime = Date.now();
+
+    try {
+      logger.debug(`开始检测: ${filePath} [${language}]`);
+
+      const parseResult = await parseCode(sourceCode, language);
+
+      if (!parseResult.success) {
+        return {
+          success: false,
+          message: parseResult.error,
+          filePath,
+          language
+        };
+      }
+
+      const tree = parseResult.tree;
+      const issues = [];
+
+      for (const rule of this.enabledRules) {
+        try {
+          const ruleConfig = getRuleConfig(rule.id);
+          if (!ruleConfig.enabled) continue;
+
+          const ruleModule = require(`./rules/${this._ruleIdToFileName(rule.id)}`);
+          const ruleIssues = ruleModule.detect(tree, sourceCode, filePath, ruleConfig);
+          issues.push(...ruleIssues);
+        } catch (ruleError) {
+          logger.warn(`规则 ${rule.id} 执行失败: ${ruleError.message}`);
+        }
+      }
+
+      const result = {
+        success: true,
+        filePath,
+        language,
+        totalIssues: issues.length,
+        issueCounts: {
+          critical: issues.filter(i => i.severity === 'critical').length,
+          high: issues.filter(i => i.severity === 'high').length,
+          medium: issues.filter(i => i.severity === 'medium').length,
+          low: issues.filter(i => i.severity === 'low').length
+        },
+        issues,
+        rulesApplied: this.enabledRules.map(r => r.id),
+        durationMs: Date.now() - startTime
+      };
+
+      logger.debug(`检测完成: ${filePath}, 发现 ${issues.length} 个问题`);
+      return result;
+    } catch (error) {
+      logger.error(`检测失败: ${filePath}`, error);
+      return {
+        success: false,
+        message: error.message,
+        filePath,
+        language,
+        durationMs: Date.now() - startTime
+      };
+    }
+  }
+
+  _ruleIdToFileName(ruleId) {
+    return ruleId.replace(/_/g, '-');
+  }
+}
+
+const codeDetectionSkill = new CodeDetectionSkill();
+
+module.exports = codeDetectionSkill;

package/src/skills/code-detection/rules/console-log.js

@@ -0,0 +1,45 @@
+const { getNodesByType } = require('../../../services/ast/parser');
+const { generateUUID, getFileLanguage } = require('../../../utils/helpers');
+
+const meta = {
+  id: 'console_log',
+  name: 'console.log检测',
+  description: '检测调试用的console.log语句',
+  category: 'code-smell',
+  defaultSeverity: 'low'
+};
+
+function detect(tree, sourceCode, filePath, ruleConfig) {
+  const issues = [];
+
+  try {
+    const callExpressions = getNodesByType(tree.rootNode, 'call_expression');
+
+    callExpressions.forEach(callExpr => {
+      if (callExpr.text.startsWith('console.log(')) {
+        issues.push({
+          id: generateUUID(),
+          filePath,
+          fileName: filePath.split(/[/\\]/).pop(),
+          language: getFileLanguage(filePath),
+          issueType: 'console_log',
+          severity: ruleConfig.severity || meta.defaultSeverity,
+          message: '存在调试用的console.log',
+          suggestion: '删除或替换为正式的日志记录',
+          lineStart: callExpr.startPosition.row + 1,
+          lineEnd: callExpr.endPosition.row + 1,
+          columnStart: callExpr.startPosition.column,
+          columnEnd: callExpr.endPosition.column,
+          codeSnippet: callExpr.text.substring(0, 80),
+          astNodeType: 'call_expression'
+        });
+      }
+    });
+  } catch (error) {
+    console.error('检测console.log失败:', error);
+  }
+
+  return issues;
+}
+
+module.exports = { meta, detect };

package/src/skills/code-detection/rules/deep-nesting.js

@@ -0,0 +1,76 @@
+const { generateUUID, getFileLanguage } = require('../../../utils/helpers');
+
+const meta = {
+  id: 'deep_nesting',
+  name: '嵌套过深检测',
+  description: '检测代码中嵌套层级过深的情况',
+  category: 'code-smell',
+  defaultSeverity: 'medium'
+};
+
+const DEFAULT_THRESHOLD = 4;
+
+function detect(tree, sourceCode, filePath, ruleConfig) {
+  const issues = [];
+  const threshold = ruleConfig.threshold || DEFAULT_THRESHOLD;
+
+  try {
+    const lines = sourceCode.split('\n');
+    let maxDepth = 0;
+    let deepLines = [];
+
+    lines.forEach((line, index) => {
+      const trimmed = line.trim();
+      if (!trimmed) return;
+
+      const indentMatch = line.match(/^(\s+)/);
+      const indentSpaces = indentMatch ? indentMatch[1].length : 0;
+      const indentLevel = Math.floor(indentSpaces / 2);
+
+      const currentDepth = indentLevel;
+
+      if (currentDepth > maxDepth) {
+        maxDepth = currentDepth;
+      }
+
+      if (currentDepth > threshold) {
+        deepLines.push({
+          line: index + 1,
+          depth: currentDepth,
+          text: trimmed.substring(0, 50)
+        });
+      }
+    });
+
+    if (maxDepth > threshold && deepLines.length > 0) {
+      const firstDeepLine = deepLines[0];
+      issues.push({
+        id: generateUUID(),
+        filePath,
+        fileName: filePath.split(/[/\\]/).pop(),
+        language: getFileLanguage(filePath),
+        issueType: 'deep_nesting',
+        severity: ruleConfig.severity || meta.defaultSeverity,
+        message: `嵌套层级过深(最大${maxDepth}层，阈值${threshold}层)`,
+        suggestion: '减少嵌套层级，提取内层逻辑为独立函数',
+        lineStart: firstDeepLine.line,
+        lineEnd: firstDeepLine.line,
+        columnStart: 0,
+        columnEnd: firstDeepLine.text.length,
+        codeSnippet: firstDeepLine.text,
+        astNodeType: 'deep_nesting',
+        metadata: {
+          maxDepth,
+          threshold,
+          deepLineCount: deepLines.length
+        }
+      });
+    }
+  } catch (error) {
+    console.error('检测嵌套过深失败:', error);
+  }
+
+  return issues;
+}
+
+module.exports = { meta, detect };

package/src/skills/code-detection/rules/duplicate-code.js

@@ -0,0 +1,57 @@
+const { generateUUID, getFileLanguage } = require('../../../utils/helpers');
+
+const meta = {
+  id: 'duplicate_code',
+  name: '重复代码检测',
+  description: '检测代码中重复的代码片段',
+  category: 'code-smell',
+  defaultSeverity: 'medium'
+};
+
+const DEFAULT_MIN_LINES = 3;
+
+function detect(tree, sourceCode, filePath, ruleConfig) {
+  const issues = [];
+  const minDuplicateLines = ruleConfig.threshold || DEFAULT_MIN_LINES;
+
+  try {
+    const lines = sourceCode.split('\n');
+    const seenBlocks = new Map();
+
+    for (let i = 0; i < lines.length - minDuplicateLines; i++) {
+      const block = lines.slice(i, i + minDuplicateLines).join('\n').trim();
+      if (block.length < 20) continue;
+
+      const trimmed = block.replace(/\s+/g, '');
+      if (seenBlocks.has(trimmed)) {
+        const previousLine = seenBlocks.get(trimmed);
+        if (i > previousLine + minDuplicateLines) {
+          issues.push({
+            id: generateUUID(),
+            filePath,
+            fileName: filePath.split(/[/\\]/).pop(),
+            language: getFileLanguage(filePath),
+            issueType: 'duplicate_code',
+            severity: ruleConfig.severity || meta.defaultSeverity,
+            message: `发现重复代码片段(第${previousLine + 1}行和第${i + 1}行)`,
+            suggestion: '提取重复代码为独立函数或模块',
+            lineStart: i + 1,
+            lineEnd: i + minDuplicateLines,
+            columnStart: 0,
+            columnEnd: block.length,
+            codeSnippet: block.substring(0, 100),
+            astNodeType: 'duplicate_block'
+          });
+        }
+      } else {
+        seenBlocks.set(trimmed, i);
+      }
+    }
+  } catch (error) {
+    console.error('检测重复代码失败:', error);
+  }
+
+  return issues;
+}
+
+module.exports = { meta, detect };