mr-sliy 1.0.0

package/src/skills/code-detection/rules/high-complexity.js

@@ -0,0 +1,109 @@
+const { generateUUID, getFileLanguage } = require('../../../utils/helpers');
+
+const meta = {
+  id: 'high_complexity',
+  name: '圈复杂度检测',
+  description: '检测圈复杂度过高的函数',
+  category: 'code-smell',
+  defaultSeverity: 'medium'
+};
+
+const DEFAULT_THRESHOLD = 10;
+
+function detect(tree, sourceCode, filePath, ruleConfig) {
+  const issues = [];
+  const threshold = ruleConfig.threshold || DEFAULT_THRESHOLD;
+
+  try {
+    const lines = sourceCode.split('\n');
+    const funcDeclarations = [];
+
+    for (let i = 0; i < lines.length; i++) {
+      const match = lines[i].trim().match(/function\s+(\w+)\s*\(/);
+      if (match) {
+        let braceCount = 0;
+        const hasOpenBrace = lines[i].includes('{');
+        if (hasOpenBrace) braceCount++;
+
+        let endLine = i;
+        for (let j = i + 1; j < lines.length; j++) {
+          const lineBraces = (lines[j].match(/\{/g) || []).length;
+          const closeBraces = (lines[j].match(/\}/g) || []).length;
+          braceCount += lineBraces - closeBraces;
+
+          if (braceCount <= 0) {
+            endLine = j;
+            break;
+          }
+        }
+
+        funcDeclarations.push({
+          name: match[1],
+          startLine: i,
+          endLine: endLine,
+          text: lines[i].trim()
+        });
+      }
+    }
+
+    funcDeclarations.forEach(funcDecl => {
+      let complexity = 1;
+
+      for (let i = funcDecl.startLine; i <= funcDecl.endLine; i++) {
+        const line = lines[i];
+        if (!line) continue;
+
+        const trimmed = line.trim();
+
+        if (trimmed.startsWith('if (') || trimmed.startsWith('if(')) {
+          complexity++;
+        }
+        if (trimmed.startsWith('for (')) {
+          complexity++;
+        }
+        if (trimmed.startsWith('while (')) {
+          complexity++;
+        }
+        if (trimmed.startsWith('case ')) {
+          complexity++;
+        }
+        if (trimmed.startsWith('catch (')) {
+          complexity++;
+        }
+
+        const andCount = (trimmed.match(/&&/g) || []).length;
+        const orCount = (trimmed.match(/\|\|/g) || []).length;
+        complexity += andCount + orCount;
+      }
+
+      if (complexity > threshold) {
+        issues.push({
+          id: generateUUID(),
+          filePath,
+          fileName: filePath.split(/[/\\]/).pop(),
+          language: getFileLanguage(filePath),
+          issueType: 'high_complexity',
+          severity: ruleConfig.severity || meta.defaultSeverity,
+          message: `函数"${funcDecl.name}"圈复杂度过高(${complexity})`,
+          suggestion: '简化逻辑结构，减少嵌套层级',
+          lineStart: funcDecl.startLine + 1,
+          lineEnd: funcDecl.endLine + 1,
+          columnStart: 0,
+          columnEnd: funcDecl.text.length,
+          codeSnippet: funcDecl.text.substring(0, 100),
+          astNodeType: 'function_declaration',
+          metadata: {
+            complexity,
+            threshold
+          }
+        });
+      }
+    });
+  } catch (error) {
+    console.error('检测圈复杂度失败:', error);
+  }
+
+  return issues;
+}
+
+module.exports = { meta, detect };

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

@@ -0,0 +1,59 @@
+/**
+ * 检测规则索引
+ * 所有检测规则的统一入口
+ */
+
+const { config } = require('../../../config');
+
+const rules = {
+  unused_variables: require('./unused-variables'),
+  unused_imports: require('./unused-imports'),
+  unused_functions: require('./unused-functions'),
+  magic_numbers: require('./magic-numbers'),
+  long_functions: require('./long-functions'),
+  high_complexity: require('./high-complexity'),
+  deep_nesting: require('./deep-nesting'),
+  null_check: require('./null-check'),
+  unnecessary_else: require('./unnecessary-else'),
+  console_log: require('./console-log'),
+  duplicate_code: require('./duplicate-code'),
+  missing_comment: require('./missing-comment')
+};
+
+function getRuleConfig(ruleId) {
+  const ruleConfigMap = {
+    unused_variables: { enabled: config.detection.unusedVariables, severity: 'medium' },
+    unused_imports: { enabled: config.detection.unusedImports, severity: 'low' },
+    unused_functions: { enabled: config.detection.unusedFunctions, severity: 'high' },
+    magic_numbers: { enabled: config.detection.magicNumbers, severity: 'low' },
+    long_functions: { enabled: true, severity: 'medium', threshold: config.detection.maxFunctionLines },
+    high_complexity: { enabled: true, severity: 'medium', threshold: config.detection.maxCyclomaticComplexity },
+    deep_nesting: { enabled: config.detection.enableDeepNestingCheck, severity: 'medium', threshold: config.detection.maxNestingDepth },
+    null_check: { enabled: config.detection.enableNullCheck, severity: 'high' },
+    unnecessary_else: { enabled: true, severity: 'low' },
+    console_log: { enabled: config.detection.enableConsoleLogCheck, severity: 'low' },
+    duplicate_code: { enabled: config.detection.enableDuplicateCodeCheck, severity: 'medium' },
+    missing_comment: { enabled: config.detection.enableCommentCheck, severity: 'low' }
+  };
+  
+  return ruleConfigMap[ruleId] || { enabled: false, severity: 'low' };
+}
+
+function getAllRules() {
+  return Object.entries(rules).map(([id, rule]) => ({
+    id,
+    ...rule.meta,
+    config: getRuleConfig(id)
+  }));
+}
+
+function getEnabledRules() {
+  return getAllRules().filter(rule => rule.config.enabled);
+}
+
+module.exports = {
+  rules,
+  getRuleConfig,
+  getAllRules,
+  getEnabledRules
+};

package/src/skills/code-detection/rules/long-functions.js

@@ -0,0 +1,54 @@
+const { getNodesByType } = require('../../../services/ast/parser');
+const { generateUUID, getFileLanguage } = require('../../../utils/helpers');
+
+const meta = {
+  id: 'long_functions',
+  name: '过长函数检测',
+  description: '检测行数超过阈值的函数',
+  category: 'code-smell',
+  defaultSeverity: 'medium'
+};
+
+const DEFAULT_THRESHOLD = 50;
+
+function detect(tree, sourceCode, filePath, ruleConfig) {
+  const issues = [];
+  const threshold = ruleConfig.threshold || DEFAULT_THRESHOLD;
+
+  try {
+    const functionDeclarations = getNodesByType(tree.rootNode, 'function_declaration');
+
+    functionDeclarations.forEach(funcDecl => {
+      const funcLines = funcDecl.endPosition.row - funcDecl.startPosition.row + 1;
+
+      if (funcLines > threshold) {
+        issues.push({
+          id: generateUUID(),
+          filePath,
+          fileName: filePath.split(/[/\\]/).pop(),
+          language: getFileLanguage(filePath),
+          issueType: 'long_function',
+          severity: ruleConfig.severity || meta.defaultSeverity,
+          message: `函数过长(${funcLines}行)，建议拆分`,
+          suggestion: '将长函数拆分为多个小函数，每个函数负责单一职责',
+          lineStart: funcDecl.startPosition.row + 1,
+          lineEnd: funcDecl.endPosition.row + 1,
+          columnStart: funcDecl.startPosition.column,
+          columnEnd: funcDecl.endPosition.column,
+          codeSnippet: funcDecl.text.substring(0, 100),
+          astNodeType: 'function_declaration',
+          metadata: {
+            lineCount: funcLines,
+            threshold
+          }
+        });
+      }
+    });
+  } catch (error) {
+    console.error('检测过长函数失败:', error);
+  }
+
+  return issues;
+}
+
+module.exports = { meta, detect };

package/src/skills/code-detection/rules/magic-numbers.js

@@ -0,0 +1,48 @@
+const { getNodesByType } = require('../../../services/ast/parser');
+const { generateUUID, getFileLanguage } = require('../../../utils/helpers');
+
+const meta = {
+  id: 'magic_numbers',
+  name: '魔法数字检测',
+  description: '检测代码中出现的魔法数字',
+  category: 'code-smell',
+  defaultSeverity: 'low'
+};
+
+function detect(tree, sourceCode, filePath, ruleConfig) {
+  const issues = [];
+
+  try {
+    const numberNodes = getNodesByType(tree.rootNode, 'number');
+    const magicThresholds = [100, 1000, 60, 24, 7, 30, 365, 86400];
+
+    numberNodes.forEach(numNode => {
+      const numValue = parseFloat(numNode.text);
+
+      if (magicThresholds.includes(numValue) || numValue > 1000) {
+        issues.push({
+          id: generateUUID(),
+          filePath,
+          fileName: filePath.split(/[/\\]/).pop(),
+          language: getFileLanguage(filePath),
+          issueType: 'magic_number',
+          severity: ruleConfig.severity || meta.defaultSeverity,
+          message: `发现魔法数字: ${numValue}`,
+          suggestion: '将魔法数字提取为常量并添加说明性名称',
+          lineStart: numNode.startPosition.row + 1,
+          lineEnd: numNode.endPosition.row + 1,
+          columnStart: numNode.startPosition.column,
+          columnEnd: numNode.endPosition.column,
+          codeSnippet: numNode.text,
+          astNodeType: 'number'
+        });
+      }
+    });
+  } catch (error) {
+    console.error('检测魔法数字失败:', error);
+  }
+
+  return issues;
+}
+
+module.exports = { meta, detect };

package/src/skills/code-detection/rules/missing-comment.js

@@ -0,0 +1,64 @@
+const { getNodesByType } = require('../../../services/ast/parser');
+const { generateUUID, getFileLanguage } = require('../../../utils/helpers');
+
+const meta = {
+  id: 'missing_comment',
+  name: '缺少注释检测',
+  description: '检测较长函数是否缺少注释说明',
+  category: 'code-smell',
+  defaultSeverity: 'low'
+};
+
+const DEFAULT_MIN_LINES = 10;
+
+function detect(tree, sourceCode, filePath, ruleConfig) {
+  const issues = [];
+  const minLines = ruleConfig.threshold || DEFAULT_MIN_LINES;
+
+  try {
+    const functionDeclarations = getNodesByType(tree.rootNode, 'function_declaration');
+
+    functionDeclarations.forEach(funcDecl => {
+      const funcLines = funcDecl.endPosition.row - funcDecl.startPosition.row + 1;
+      if (funcLines > minLines) {
+        const lineNum = funcDecl.startPosition.row;
+        let hasComment = false;
+
+        if (lineNum > 0) {
+          const previousLine = sourceCode.split('\n')[lineNum - 1];
+          if (previousLine.trim().startsWith('//') || previousLine.trim().startsWith('/**') || previousLine.trim().startsWith('/*')) {
+            hasComment = true;
+          }
+        }
+
+        if (!hasComment) {
+          const funcNameMatch = funcDecl.text.match(/function\s+(\w+)/);
+          const funcName = funcNameMatch ? funcNameMatch[1] : 'anonymous';
+
+          issues.push({
+            id: generateUUID(),
+            filePath,
+            fileName: filePath.split(/[/\\]/).pop(),
+            language: getFileLanguage(filePath),
+            issueType: 'missing_comment',
+            severity: ruleConfig.severity || meta.defaultSeverity,
+            message: `函数"${funcName}"缺少注释说明`,
+            suggestion: '添加函数说明注释，提高代码可读性',
+            lineStart: funcDecl.startPosition.row + 1,
+            lineEnd: funcDecl.endPosition.row + 1,
+            columnStart: funcDecl.startPosition.column,
+            columnEnd: funcDecl.endPosition.column,
+            codeSnippet: funcDecl.text.substring(0, 50),
+            astNodeType: 'function_declaration'
+          });
+        }
+      }
+    });
+  } catch (error) {
+    console.error('检测缺少注释失败:', error);
+  }
+
+  return issues;
+}
+
+module.exports = { meta, detect };

package/src/skills/code-detection/rules/null-check.js

@@ -0,0 +1,71 @@
+const { getNodesByType, traverseAST } = require('../../../services/ast/parser');
+const { generateUUID, getFileLanguage } = require('../../../utils/helpers');
+
+const meta = {
+  id: 'null_check',
+  name: '空值检查检测',
+  description: '检测函数参数缺少空值检查的情况',
+  category: 'bug-risk',
+  defaultSeverity: 'high'
+};
+
+function detect(tree, sourceCode, filePath, ruleConfig) {
+  const issues = [];
+
+  try {
+    const functionDeclarations = getNodesByType(tree.rootNode, 'function_declaration');
+
+    functionDeclarations.forEach(funcDecl => {
+      const identifiers = getNodesByType(funcDecl, 'identifier');
+      const params = funcDecl.text.match(/function\s+\w+\s*\(([^)]*)\)/);
+
+      if (params) {
+        const paramNames = params[1].split(',').map(p => p.trim()).filter(p => p.length > 0);
+
+        paramNames.forEach(param => {
+          const paramUsages = identifiers.filter(id => id.text === param);
+          if (paramUsages.length > 1) {
+            let hasNullCheck = false;
+
+            traverseAST(funcDecl, (node) => {
+              if (node.type === 'if_statement') {
+                if (node.text.includes(`!${param}`) || node.text.includes(`${param} !== null`) ||
+                    node.text.includes(`${param} !== undefined`) || node.text.includes(`${param} != null`)) {
+                  hasNullCheck = true;
+                }
+              }
+            });
+
+            if (!hasNullCheck && paramUsages.length > 2) {
+              issues.push({
+                id: generateUUID(),
+                filePath,
+                fileName: filePath.split(/[/\\]/).pop(),
+                language: getFileLanguage(filePath),
+                issueType: 'null_check',
+                severity: ruleConfig.severity || meta.defaultSeverity,
+                message: `参数"${param}"缺少空值检查`,
+                suggestion: '添加空值检查以防止运行时错误',
+                lineStart: funcDecl.startPosition.row + 1,
+                lineEnd: funcDecl.endPosition.row + 1,
+                columnStart: funcDecl.startPosition.column,
+                columnEnd: funcDecl.endPosition.column,
+                codeSnippet: funcDecl.text.substring(0, 100),
+                astNodeType: 'function_declaration',
+                metadata: {
+                  paramName: param
+                }
+              });
+            }
+          }
+        });
+      }
+    });
+  } catch (error) {
+    console.error('检测空值检查失败:', error);
+  }
+
+  return issues;
+}
+
+module.exports = { meta, detect };

package/src/skills/code-detection/rules/unnecessary-else.js

@@ -0,0 +1,46 @@
+const { traverseAST } = require('../../../services/ast/parser');
+const { generateUUID, getFileLanguage } = require('../../../utils/helpers');
+
+const meta = {
+  id: 'unnecessary_else',
+  name: '不必要else检测',
+  description: '检测return语句后不必要的else语句',
+  category: 'code-smell',
+  defaultSeverity: 'low'
+};
+
+function detect(tree, sourceCode, filePath, ruleConfig) {
+  const issues = [];
+
+  try {
+    traverseAST(tree.rootNode, (node) => {
+      if (node.type === 'if_statement' && node.text.includes('else')) {
+        const ifBody = node.text.split('else')[0];
+        if (ifBody.includes('return ') || ifBody.includes('throw ')) {
+          issues.push({
+            id: generateUUID(),
+            filePath,
+            fileName: filePath.split(/[/\\]/).pop(),
+            language: getFileLanguage(filePath),
+            issueType: 'unnecessary_else',
+            severity: ruleConfig.severity || meta.defaultSeverity,
+            message: 'return后使用不必要的else',
+            suggestion: '删除return后的else语句以简化代码',
+            lineStart: node.startPosition.row + 1,
+            lineEnd: node.endPosition.row + 1,
+            columnStart: node.startPosition.column,
+            columnEnd: node.endPosition.column,
+            codeSnippet: node.text.substring(0, 80),
+            astNodeType: 'if_statement'
+          });
+        }
+      }
+    });
+  } catch (error) {
+    console.error('检测不必要else失败:', error);
+  }
+
+  return issues;
+}
+
+module.exports = { meta, detect };

package/src/skills/code-detection/rules/unused-functions.js

@@ -0,0 +1,57 @@
+const { getNodesByType } = require('../../../services/ast/parser');
+const { generateUUID, getFileLanguage } = require('../../../utils/helpers');
+
+const meta = {
+  id: 'unused_functions',
+  name: '未使用函数检测',
+  description: '检测已定义但从未被调用的函数',
+  category: 'code-smell',
+  defaultSeverity: 'high'
+};
+
+function detect(tree, sourceCode, filePath, ruleConfig) {
+  const issues = [];
+
+  try {
+    const functionDeclarations = getNodesByType(tree.rootNode, 'function_declaration');
+    const identifiers = getNodesByType(tree.rootNode, 'identifier');
+
+    functionDeclarations.forEach(funcDecl => {
+      const funcNameMatch = funcDecl.text.match(/function\s+(\w+)\s*\(/);
+
+      if (funcNameMatch) {
+        const funcName = funcNameMatch[1];
+
+        const isCalled = identifiers.some(id =>
+          id.text === funcName &&
+          id.startPosition.row !== funcDecl.startPosition.row
+        );
+
+        if (!isCalled) {
+          issues.push({
+            id: generateUUID(),
+            filePath,
+            fileName: filePath.split(/[/\\]/).pop(),
+            language: getFileLanguage(filePath),
+            issueType: 'unused_function',
+            severity: ruleConfig.severity || meta.defaultSeverity,
+            message: `函数"${funcName}"已定义但从未被调用`,
+            suggestion: '删除未使用的函数或确认是否应该在代码中使用它',
+            lineStart: funcDecl.startPosition.row + 1,
+            lineEnd: funcDecl.endPosition.row + 1,
+            columnStart: funcDecl.startPosition.column,
+            columnEnd: funcDecl.endPosition.column,
+            codeSnippet: funcDecl.text.substring(0, 100),
+            astNodeType: 'function_declaration'
+          });
+        }
+      }
+    });
+  } catch (error) {
+    console.error('检测未使用函数失败:', error);
+  }
+
+  return issues;
+}
+
+module.exports = { meta, detect };

package/src/skills/code-detection/rules/unused-imports.js

@@ -0,0 +1,57 @@
+const { getNodesByType } = require('../../../services/ast/parser');
+const { generateUUID, getFileLanguage } = require('../../../utils/helpers');
+
+const meta = {
+  id: 'unused_imports',
+  name: '未使用导入检测',
+  description: '检测已声明但从未使用的导入',
+  category: 'code-smell',
+  defaultSeverity: 'low'
+};
+
+function detect(tree, sourceCode, filePath, ruleConfig) {
+  const issues = [];
+
+  try {
+    const importStatements = getNodesByType(tree.rootNode, 'import_statement');
+    const identifiers = getNodesByType(tree.rootNode, 'identifier');
+
+    importStatements.forEach(importStmt => {
+      const importMatch = importStmt.text.match(/import\s+(\w+)\s+from/);
+
+      if (importMatch) {
+        const importedName = importMatch[1];
+
+        const isUsed = identifiers.some(id =>
+          id.text === importedName &&
+          id.startPosition.row !== importStmt.startPosition.row
+        );
+
+        if (!isUsed) {
+          issues.push({
+            id: generateUUID(),
+            filePath,
+            fileName: filePath.split(/[/\\]/).pop(),
+            language: getFileLanguage(filePath),
+            issueType: 'unused_import',
+            severity: ruleConfig.severity || meta.defaultSeverity,
+            message: `导入"${importedName}"已声明但从未使用`,
+            suggestion: '删除未使用的导入以减少打包体积',
+            lineStart: importStmt.startPosition.row + 1,
+            lineEnd: importStmt.endPosition.row + 1,
+            columnStart: importStmt.startPosition.column,
+            columnEnd: importStmt.endPosition.column,
+            codeSnippet: importStmt.text,
+            astNodeType: 'import_statement'
+          });
+        }
+      }
+    });
+  } catch (error) {
+    console.error('检测未使用导入失败:', error);
+  }
+
+  return issues;
+}
+
+module.exports = { meta, detect };

package/src/skills/code-detection/rules/unused-variables.js

@@ -0,0 +1,54 @@
+const { getNodesByType } = require('../../../services/ast/parser');
+const { generateUUID, getFileLanguage } = require('../../../utils/helpers');
+
+const meta = {
+  id: 'unused_variables',
+  name: '未使用变量检测',
+  description: '检测已声明但从未使用的变量',
+  category: 'code-smell',
+  defaultSeverity: 'medium'
+};
+
+function detect(tree, sourceCode, filePath, ruleConfig) {
+  const issues = [];
+
+  try {
+    const variableDeclarations = getNodesByType(tree.rootNode, 'variable_declarator');
+    const identifiers = getNodesByType(tree.rootNode, 'identifier');
+
+    variableDeclarations.forEach(varDecl => {
+      const varName = varDecl.text.split('=')[0].trim();
+
+      const isUsed = identifiers.some(id => {
+        return id.text === varName &&
+               (id.startPosition.row !== varDecl.startPosition.row ||
+                id.startPosition.column !== varDecl.startPosition.column);
+      });
+
+      if (!isUsed) {
+        issues.push({
+          id: generateUUID(),
+          filePath,
+          fileName: filePath.split(/[/\\]/).pop(),
+          language: getFileLanguage(filePath),
+          issueType: 'unused_variable',
+          severity: ruleConfig.severity || meta.defaultSeverity,
+          message: `变量"${varName}"已声明但从未使用`,
+          suggestion: '删除未使用的变量或根据需要使用它',
+          lineStart: varDecl.startPosition.row + 1,
+          lineEnd: varDecl.endPosition.row + 1,
+          columnStart: varDecl.startPosition.column,
+          columnEnd: varDecl.endPosition.column,
+          codeSnippet: varDecl.text,
+          astNodeType: 'variable_declarator'
+        });
+      }
+    });
+  } catch (error) {
+    console.error('检测未使用变量失败:', error);
+  }
+
+  return issues;
+}
+
+module.exports = { meta, detect };