rules-enforcer 1.0.0 → 2.0.0

package/rules-server.js

@@ -1,350 +1,1066 @@
-const readline = require('readline');
-const { stdin, stdout } = require('process');
-
-const l1Rules = {
-  codeQuality: {
-    name: "代码质量检查",
-    description: "TypeScript严格模式、ESLint检查",
-    validate: (code) => {
-      const issues = [];
-      if (code.includes('var ')) {
-        issues.push({ rule: 'L1-001', message: '使用var声明变量，应使用const或let', severity: 'warning' });
-      }
-      if (code.includes('console.log(')) {
-        issues.push({ rule: 'L1-002', message: '存在console.log，生产环境应移除', severity: 'info' });
-      }
-      return issues;
-    }
-  },
-  simplicity: {
-    name: "简约原则检查",
-    description: "代码应简洁明了",
-    validate: (code) => {
-      const issues = [];
-      const lines = code.split('\n');
-      for (let i = 0; i < lines.length; i++) {
-        if (lines[i].length > 120) {
-          issues.push({ rule: 'L1-003', message: `第${i + 1}行超过120字符`, severity: 'warning' });
-        }
-      }
-      if (lines.length > 50) {
-        issues.push({ rule: 'L1-004', message: '函数超过50行，建议拆分', severity: 'info' });
-      }
-      return issues;
-    }
-  }
-};
-
-const l2Rules = {
-  singleResponsibility: {
-    name: "单一职责检查",
-    description: "每个类/函数只负责一件事",
-    validate: (code) => {
-      const issues = [];
-      const functionMatches = code.match(/function\s+\w+\s*\([^)]*\)\s*\{/g);
-      if (functionMatches) {
-        functionMatches.forEach((func) => {
-          const funcName = func.match(/function\s+(\w+)/)[1];
-          if (funcName.includes('And') || funcName.includes('Or')) {
-            issues.push({ rule: 'L2-001', message: `函数${funcName}可能违反单一职责原则`, severity: 'warning' });
-          }
-        });
-      }
-      return issues;
-    }
-  },
-  directoryStructure: {
-    name: "目录结构检查",
-    description: "符合项目目录结构规范",
-    validate: (code, context) => {
-      const issues = [];
-      if (context && context.filePath) {
-        const path = context.filePath.toLowerCase();
-        if (path.includes('controllers') && !path.endsWith('.js') && !path.endsWith('.ts')) {
-          issues.push({ rule: 'L2-002', message: `控制器文件应使用.js或.ts扩展名`, severity: 'error' });
-        }
-        if (path.includes('routes') && !path.endsWith('.js') && !path.endsWith('.ts')) {
-          issues.push({ rule: 'L2-003', message: `路由文件应使用.js或.ts扩展名`, severity: 'error' });
-        }
-      }
-      return issues;
-    }
-  },
-  namingConvention: {
-    name: "命名规范检查",
-    description: "符合项目命名规范",
-    validate: (code) => {
-      const issues = [];
-      const camelCaseRegex = /\b[A-Z][a-zA-Z0-9]*\b/g;
-      const matches = code.match(camelCaseRegex);
-      if (matches) {
-        matches.forEach(match => {
-          if (match.length > 1 && !['class', 'function', 'const', 'let', 'var', 'if', 'else', 'for', 'while', 'return', 'import', 'export', 'from', 'async', 'await', 'new', 'this', 'try', 'catch', 'throw'].includes(match.toLowerCase())) {
-            if (!/^[A-Z]/.test(match)) {
-              issues.push({ rule: 'L2-004', message: `类名${match}应使用PascalCase`, severity: 'warning' });
-            }
-          }
-        });
-      }
-      return issues;
-    }
-  }
-};
-
-const l3Rules = {
-  dry: {
-    name: "DRY原则检查",
-    description: "避免重复代码",
-    validate: (code) => {
-      const issues = [];
-      const lines = code.split('\n');
-      const lineCounts = {};
-      lines.forEach(line => {
-        const trimmed = line.trim();
-        if (trimmed && trimmed.length > 20) {
-          lineCounts[trimmed] = (lineCounts[trimmed] || 0) + 1;
-        }
-      });
-      Object.entries(lineCounts).forEach(([line, count]) => {
-        if (count >= 3) {
-          issues.push({ rule: 'L3-001', message: `发现重复代码片段，出现${count}次，应提取为函数`, severity: 'warning' });
-        }
-      });
-      return issues;
-    }
-  },
-  solid: {
-    name: "SOLID原则检查",
-    description: "符合SOLID设计原则",
-    validate: (code) => {
-      const issues = [];
-      if (code.includes('extends') && code.includes('implements')) {
-        issues.push({ rule: 'L3-002', message: '同时使用extends和implements，建议检查是否符合里氏替换原则', severity: 'info' });
-      }
-      return issues;
-    }
-  },
-  dataStructure: {
-    name: "数据结构优先检查",
-    description: "使用合适的数据结构",
-    validate: (code) => {
-      const issues = [];
-      if (code.includes('for (let i = 0; i < ') && code.includes('.length')) {
-        issues.push({ rule: 'L3-003', message: '使用普通for循环，考虑使用forEach或map', severity: 'info' });
-      }
-      return issues;
-    }
-  }
-};
-
-function validateCode(code, context = {}) {
-  const results = [];
-  Object.values(l1Rules).forEach(rule => {
-    const issues = rule.validate(code, context);
-    issues.forEach(issue => {
-      results.push({ ...issue, level: 'L1', ruleName: rule.name });
-    });
-  });
-  Object.values(l2Rules).forEach(rule => {
-    const issues = rule.validate(code, context);
-    issues.forEach(issue => {
-      results.push({ ...issue, level: 'L2', ruleName: rule.name });
-    });
-  });
-  Object.values(l3Rules).forEach(rule => {
-    const issues = rule.validate(code, context);
-    issues.forEach(issue => {
-      results.push({ ...issue, level: 'L3', ruleName: rule.name });
-    });
-  });
-  return results;
-}
-
-function getRules() {
-  return {
-    L1: Object.keys(l1Rules).map(key => ({
-      id: key,
-      name: l1Rules[key].name,
-      description: l1Rules[key].description
-    })),
-    L2: Object.keys(l2Rules).map(key => ({
-      id: key,
-      name: l2Rules[key].name,
-      description: l2Rules[key].description
-    })),
-    L3: Object.keys(l3Rules).map(key => ({
-      id: key,
-      name: l3Rules[key].name,
-      description: l3Rules[key].description
-    }))
-  };
-}
-
-const rl = readline.createInterface({
-  input: stdin,
-  output: stdout,
-  terminal: false
-});
-
-rl.on('line', (input) => {
-  try {
-    const request = JSON.parse(input);
-    const { id, method, params } = request;
-    let response;
-
-    if (method === 'initialize') {
-      response = {
-        jsonrpc: "2.0",
-        id: id,
-        result: {
-          protocolVersion: "2024-11-05",
-          capabilities: {
-            tools: {}
-          },
-          serverInfo: {
-            name: "rules-enforcer",
-            version: "1.0.0"
-          }
-        }
-      };
-    } else if (method === 'notifications/initialized') {
-      return;
-    } else if (method === 'tools/list') {
-      response = {
-        jsonrpc: "2.0",
-        id: id,
-        result: {
-          tools: [
-            {
-              name: "validate",
-              description: "验证代码是否符合L1/L2/L3规则",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  code: { type: "string", description: "要验证的代码" },
-                  context: { type: "object", description: "上下文信息" }
-                },
-                required: ["code"]
-              }
-            },
-            {
-              name: "get_rules",
-              description: "获取所有规则定义",
-              inputSchema: {
-                type: "object",
-                properties: {}
-              }
-            },
-            {
-              name: "enforce",
-              description: "强制执行规则验证，不通过则拒绝",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  code: { type: "string", description: "要验证的代码" },
-                  context: { type: "object", description: "上下文信息" }
-                },
-                required: ["code"]
-              }
-            }
-          ]
-        }
-      };
-    } else if (method === 'tools/call') {
-      const toolName = params?.name;
-      const toolArgs = params?.arguments || {};
-
-      if (toolName === 'validate') {
-        const issues = validateCode(toolArgs.code, toolArgs.context);
-        response = {
-          jsonrpc: "2.0",
-          id: id,
-          result: {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify({
-                  success: true,
-                  issues,
-                  summary: {
-                    total: issues.length,
-                    errors: issues.filter(i => i.severity === 'error').length,
-                    warnings: issues.filter(i => i.severity === 'warning').length,
-                    info: issues.filter(i => i.severity === 'info').length
-                  }
-                })
-              }
-            ]
-          }
-        };
-      } else if (toolName === 'get_rules') {
-        response = {
-          jsonrpc: "2.0",
-          id: id,
-          result: {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify({
-                  success: true,
-                  rules: getRules()
-                })
-              }
-            ]
-          }
-        };
-      } else if (toolName === 'enforce') {
-        const issues = validateCode(toolArgs.code, toolArgs.context);
-        const errors = issues.filter(i => i.severity === 'error');
-        const status = errors.length === 0 ? 'accepted' : 'rejected';
-        response = {
-          jsonrpc: "2.0",
-          id: id,
-          result: {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify({
-                  success: true,
-                  status,
-                  issues,
-                  errors
-                })
-              }
-            ]
-          }
-        };
-      } else {
-        response = {
-          jsonrpc: "2.0",
-          id: id,
-          error: {
-            code: -32601,
-            message: 'Tool not found'
-          }
-        };
-      }
-    } else {
-      response = {
-        jsonrpc: "2.0",
-        id: id,
-        error: {
-          code: -32601,
-          message: 'Method not found'
-        }
-      };
-    }
-
-    stdout.write(JSON.stringify(response) + '\n');
-  } catch (error) {
-    console.error('Error:', error.message);
-    stdout.write(JSON.stringify({
-      jsonrpc: "2.0",
-      id: null,
-      error: {
-        code: -32603,
-        message: 'Internal error'
-      }
-    }) + '\n');
-  }
-});
+/**
+ * Rules Enforcer MCP Server - 整合版
+ * 
+ * 整合内容：
+ * - 原有功能：L1/L2/L3 规则验证（validate、get_rules、enforce）
+ * - 新增功能：项目扫描、技术栈识别、目录拓扑、组件检测（来自 project-detector 插件）
+ * 
+ * 修改记录：
+ * - 2026-06-06: 整合 project-detector 插件功能到 MCP
+ */
+
+const readline = require('readline');
+const { stdin, stdout } = require('process');
+const fs = require('fs');
+const path = require('path');
+
+// ============================================================
+// 第一部分：原有规则验证功能（保留不变）
+// ============================================================
+
+const l1Rules = {
+  codeQuality: {
+    name: "代码质量检查",
+    description: "TypeScript严格模式、ESLint检查",
+    validate: (code) => {
+      const issues = [];
+      if (code.includes('var ')) {
+        issues.push({ rule: 'L1-001', message: '使用var声明变量，应使用const或let', severity: 'warning' });
+      }
+      if (code.includes('console.log(')) {
+        issues.push({ rule: 'L1-002', message: '存在console.log，生产环境应移除', severity: 'info' });
+      }
+      return issues;
+    }
+  },
+  simplicity: {
+    name: "简约原则检查",
+    description: "代码应简洁明了",
+    validate: (code) => {
+      const issues = [];
+      const lines = code.split('\n');
+      for (let i = 0; i < lines.length; i++) {
+        if (lines[i].length > 120) {
+          issues.push({ rule: 'L1-003', message: `第${i + 1}行超过120字符`, severity: 'warning' });
+        }
+      }
+      if (lines.length > 50) {
+        issues.push({ rule: 'L1-004', message: '函数超过50行，建议拆分', severity: 'info' });
+      }
+      return issues;
+    }
+  }
+};
+
+const l2Rules = {
+  singleResponsibility: {
+    name: "单一职责检查",
+    description: "每个类/函数只负责一件事",
+    validate: (code) => {
+      const issues = [];
+      const functionMatches = code.match(/function\s+\w+\s*\([^)]*\)\s*\{/g);
+      if (functionMatches) {
+        functionMatches.forEach((func) => {
+          const funcName = func.match(/function\s+(\w+)/)[1];
+          if (funcName.includes('And') || funcName.includes('Or')) {
+            issues.push({ rule: 'L2-001', message: `函数${funcName}可能违反单一职责原则`, severity: 'warning' });
+          }
+        });
+      }
+      return issues;
+    }
+  },
+  directoryStructure: {
+    name: "目录结构检查",
+    description: "符合项目目录结构规范",
+    validate: (code, context) => {
+      const issues = [];
+      if (context && context.filePath) {
+        const filePath = context.filePath.toLowerCase();
+        if (filePath.includes('controllers') && !filePath.endsWith('.js') && !filePath.endsWith('.ts')) {
+          issues.push({ rule: 'L2-002', message: `控制器文件应使用.js或.ts扩展名`, severity: 'error' });
+        }
+        if (filePath.includes('routes') && !filePath.endsWith('.js') && !filePath.endsWith('.ts')) {
+          issues.push({ rule: 'L2-003', message: `路由文件应使用.js或.ts扩展名`, severity: 'error' });
+        }
+      }
+      return issues;
+    }
+  },
+  namingConvention: {
+    name: "命名规范检查",
+    description: "符合项目命名规范",
+    validate: (code) => {
+      const issues = [];
+      const camelCaseRegex = /\b[A-Z][a-zA-Z0-9]*\b/g;
+      const matches = code.match(camelCaseRegex);
+      if (matches) {
+        matches.forEach(match => {
+          if (match.length > 1 && !['class', 'function', 'const', 'let', 'var', 'if', 'else', 'for', 'while', 'return', 'import', 'export', 'from', 'async', 'await', 'new', 'this', 'try', 'catch', 'throw'].includes(match.toLowerCase())) {
+            if (!/^[A-Z]/.test(match)) {
+              issues.push({ rule: 'L2-004', message: `类名${match}应使用PascalCase`, severity: 'warning' });
+            }
+          }
+        });
+      }
+      return issues;
+    }
+  }
+};
+
+const l3Rules = {
+  dry: {
+    name: "DRY原则检查",
+    description: "避免重复代码",
+    validate: (code) => {
+      const issues = [];
+      const lines = code.split('\n');
+      const lineCounts = {};
+      lines.forEach(line => {
+        const trimmed = line.trim();
+        if (trimmed && trimmed.length > 20) {
+          lineCounts[trimmed] = (lineCounts[trimmed] || 0) + 1;
+        }
+      });
+      Object.entries(lineCounts).forEach(([line, count]) => {
+        if (count >= 3) {
+          issues.push({ rule: 'L3-001', message: `发现重复代码片段，出现${count}次，应提取为函数`, severity: 'warning' });
+        }
+      });
+      return issues;
+    }
+  },
+  solid: {
+    name: "SOLID原则检查",
+    description: "符合SOLID设计原则",
+    validate: (code) => {
+      const issues = [];
+      if (code.includes('extends') && code.includes('implements')) {
+        issues.push({ rule: 'L3-002', message: '同时使用extends和implements，建议检查是否符合里氏替换原则', severity: 'info' });
+      }
+      return issues;
+    }
+  },
+  dataStructure: {
+    name: "数据结构优先检查",
+    description: "使用合适的数据结构",
+    validate: (code) => {
+      const issues = [];
+      if (code.includes('for (let i = 0; i < ') && code.includes('.length')) {
+        issues.push({ rule: 'L3-003', message: '使用普通for循环，考虑使用forEach或map', severity: 'info' });
+      }
+      return issues;
+    }
+  }
+};
+
+function validateCode(code, context = {}) {
+  const results = [];
+  Object.values(l1Rules).forEach(rule => {
+    const issues = rule.validate(code, context);
+    issues.forEach(issue => {
+      results.push({ ...issue, level: 'L1', ruleName: rule.name });
+    });
+  });
+  Object.values(l2Rules).forEach(rule => {
+    const issues = rule.validate(code, context);
+    issues.forEach(issue => {
+      results.push({ ...issue, level: 'L2', ruleName: rule.name });
+    });
+  });
+  Object.values(l3Rules).forEach(rule => {
+    const issues = rule.validate(code, context);
+    issues.forEach(issue => {
+      results.push({ ...issue, level: 'L3', ruleName: rule.name });
+    });
+  });
+  return results;
+}
+
+function getRules() {
+  return {
+    L1: Object.keys(l1Rules).map(key => ({
+      id: key,
+      name: l1Rules[key].name,
+      description: l1Rules[key].description
+    })),
+    L2: Object.keys(l2Rules).map(key => ({
+      id: key,
+      name: l2Rules[key].name,
+      description: l2Rules[key].description
+    })),
+    L3: Object.keys(l3Rules).map(key => ({
+      id: key,
+      name: l3Rules[key].name,
+      description: l3Rules[key].description
+    }))
+  };
+}
+
+// ============================================================
+// 第二部分：新增项目扫描功能（来自 project-detector 插件）
+// ============================================================
+
+/**
+ * ProjectDetector 类 - 整合自 project-detector 插件
+ * 功能：只读扫描项目结构，识别技术栈、目录拓扑、已有组件
+ */
+class ProjectDetector {
+  constructor(projectRoot) {
+    if (!projectRoot || typeof projectRoot !== 'string') {
+      throw new Error('[ProjectDetector] 项目路径参数无效');
+    }
+
+    this.root = path.resolve(projectRoot);
+    
+    if (!fs.existsSync(this.root) || !fs.statSync(this.root).isDirectory()) {
+      throw new Error(`[ProjectDetector] 项目路径不存在或不是目录: ${this.root}`);
+    }
+
+    this.techStack = [];
+    this.structure = null;
+    this.fullTopology = [];
+    this.existingComponents = {
+      mcp: [],
+      agents: [],
+      rules: []
+    };
+    this.fileErrors = [];
+  }
+
+  logFileError(filePath, error, context) {
+    this.fileErrors.push({
+      file: filePath,
+      error: String(error),
+      context: context,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  scanTechStack() {
+    const checks = [
+      { file: 'package.json', detect: (content) => this.detectNodeJS(content) },
+      { file: 'tsconfig.json', detect: () => 'TypeScript' },
+      { file: 'requirements.txt', detect: () => 'Python' },
+      { file: 'go.mod', detect: () => 'Go' },
+      { file: 'Cargo.toml', detect: () => 'Rust' },
+      { file: 'pom.xml', detect: () => 'Maven/Java' }
+    ];
+
+    for (const check of checks) {
+      const filePath = path.join(this.root, check.file);
+      if (fs.existsSync(filePath)) {
+        try {
+          const content = fs.readFileSync(filePath, 'utf8');
+          const detected = check.detect(content);
+          if (detected) {
+            const stacks = Array.isArray(detected) ? detected : [detected];
+            for (const stack of stacks) {
+              if (stack && !this.techStack.includes(stack)) {
+                this.techStack.push(stack);
+              }
+            }
+          }
+        } catch (e) {
+          this.logFileError(check.file, e, 'scanTechStack');
+        }
+      }
+    }
+
+    return this.techStack;
+  }
+
+  detectNodeJS(pkgContent) {
+    try {
+      const pkg = JSON.parse(pkgContent);
+      const deps = pkg.dependencies || {};
+      const frameworks = [];
+
+      if (deps.express || deps['express-']) frameworks.push('Express.js');
+      if (deps.koa) frameworks.push('Koa');
+      if (deps.fastify) frameworks.push('Fastify');
+      if (deps.next) frameworks.push('Next.js');
+      if (deps.nuxt) frameworks.push('Nuxt.js');
+      if (deps.vite) frameworks.push('Vite');
+      if (deps.webpack) frameworks.push('Webpack');
+      if (deps.react) frameworks.push('React');
+      if (deps.vue) frameworks.push('Vue.js');
+      if (deps.sequelize) frameworks.push('Sequelize/ORM');
+      if (deps.typeorm) frameworks.push('TypeORM');
+      if (deps['better-sqlite3'] || deps.sqlite3) frameworks.push('SQLite');
+      if (deps.mongoose) frameworks.push('MongoDB/Mongoose');
+
+      return ['Node.js', ...frameworks];
+    } catch {
+      return ['Node.js'];
+    }
+  }
+
+  scanDirectoryStructure(maxDepth = 4) {
+    this.fullTopology = [];
+
+    try {
+      this.structure = this._scanDir(this.root, 0, maxDepth);
+    } catch (e) {
+      this.logFileError(this.root, e, 'scanDirectoryStructure');
+      this.structure = null;
+    }
+
+    return this.structure;
+  }
+
+  _scanDir(dir, depth, maxDepth) {
+    if (depth > maxDepth) return null;
+
+    const name = path.basename(dir);
+    const relativePath = path.relative(this.root, dir) || '.';
+
+    const node = {
+      name,
+      path: relativePath,
+      depth,
+      type: this.categorizeDir(name),
+      files: [],
+      dirs: []
+    };
+
+    this.fullTopology.push({
+      path: relativePath,
+      depth,
+      type: 'directory',
+      category: node.type
+    });
+
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (entry.name.startsWith('.') || entry.name === 'node_modules') {
+          continue;
+        }
+
+        const fullPath = path.join(dir, entry.name);
+
+        if (entry.isDirectory()) {
+          const childNode = this._scanDir(fullPath, depth + 1, maxDepth);
+          if (childNode) {
+            node.dirs.push(childNode);
+          }
+        } else {
+          const fileInfo = {
+            name: entry.name,
+            path: path.relative(this.root, fullPath),
+            type: this.categorizeFile(entry.name)
+          };
+          node.files.push(fileInfo);
+
+          this.fullTopology.push({
+            path: fileInfo.path,
+            depth: depth + 1,
+            type: 'file',
+            category: fileInfo.type
+          });
+        }
+      }
+    } catch (e) {
+      this.logFileError(dir, e, `_scanDir depth=${depth}`);
+    }
+
+    return node;
+  }
+
+  categorizeDir(name) {
+    const categories = {
+      'src': 'business_code',
+      'lib': 'business_code',
+      'app': 'business_code',
+      'pages': 'frontend_pages',
+      'components': 'frontend_components',
+      'views': 'frontend_views',
+      'test': 'test_directory',
+      'tests': 'test_directory',
+      '__tests__': 'test_directory',
+      'spec': 'test_directory',
+      'scripts': 'deployment_scripts',
+      'config': 'configuration',
+      'configs': 'configuration',
+      'docs': 'documentation',
+      'public': 'static_assets',
+      'static': 'static_assets',
+      'dist': 'build_output',
+      'build': 'build_output',
+      '.trae': 'trae_config',
+      '.claude': 'claude_config',
+      'database': 'data_storage',
+      'mcp': 'mcp_services',
+      'rules': 'rules_engine',
+      'utils': 'utilities',
+      'middleware': 'middleware',
+      'routes': 'routing'
+    };
+    return categories[name] || 'other';
+  }
+
+  categorizeFile(name) {
+    if (name.endsWith('.test.js') || name.endsWith('.spec.js')) return 'test_file';
+    if (name.endsWith('.test.ts') || name.endsWith('.spec.ts')) return 'test_file';
+    if (name === 'package.json') return 'dependency_manifest';
+    if (name === 'AGENTS.md' || name === 'CLAUDE.md') return 'trae_config';
+    if (name === 'user_rules.md') return 'rules_L1';
+    if (name === 'project_rules.md') return 'rules_L2';
+    if (name.endsWith('.yml') || name.endsWith('.yaml')) return 'config_yaml';
+    if (name.endsWith('.json')) return 'config_json';
+    if (name.endsWith('.js') || name.endsWith('.ts')) return 'source_code';
+    if (name.endsWith('.md')) return 'documentation';
+    return 'other';
+  }
+
+  scanMCP() {
+    const mcpConfigPaths = [
+      path.join(this.root, '.trae', 'mcp', 'mcp.json'),
+      path.join(this.root, '.trae', 'mcp.json'),
+      path.join(process.env.APPDATA || '', 'Trae', 'User', 'globalStorage', 'mcp.json')
+    ];
+
+    for (const configPath of mcpConfigPaths) {
+      if (fs.existsSync(configPath)) {
+        try {
+          const content = fs.readFileSync(configPath, 'utf8');
+          const config = JSON.parse(content);
+          if (config.mcpServers) {
+            this.existingComponents.mcp = Object.keys(config.mcpServers);
+            break;
+          }
+        } catch (e) {
+          this.logFileError(configPath, e, 'scanMCP');
+        }
+      }
+    }
+
+    return this.existingComponents.mcp;
+  }
+
+  scanAgents() {
+    const rootAgentsPath = path.join(this.root, 'AGENTS.md');
+    if (fs.existsSync(rootAgentsPath)) {
+      this.existingComponents.agents.push({
+        name: 'AGENTS.md',
+        path: 'AGENTS.md',
+        type: 'root_config'
+      });
+    }
+
+    const agentsDir = path.join(this.root, '.trae', 'agents');
+    if (fs.existsSync(agentsDir)) {
+      try {
+        const files = fs.readdirSync(agentsDir);
+        for (const file of files) {
+          if (file.endsWith('.md')) {
+            this.existingComponents.agents.push({
+              name: file,
+              path: path.join('.trae', 'agents', file),
+              type: 'sub_agent'
+            });
+          }
+        }
+      } catch (e) {
+        this.logFileError(agentsDir, e, 'scanAgents');
+      }
+    }
+
+    return this.existingComponents.agents;
+  }
+
+  scanRules() {
+    const rulesDir = path.join(this.root, '.trae', 'rules');
+
+    if (!fs.existsSync(rulesDir)) {
+      return this.existingComponents.rules;
+    }
+
+    const levelRules = [
+      { dir: 'L1', level: 'L1' },
+      { dir: 'L2', level: 'L2' }
+    ];
+
+    for (const rule of levelRules) {
+      const levelDir = path.join(rulesDir, rule.dir);
+      if (fs.existsSync(levelDir)) {
+        try {
+          const files = fs.readdirSync(levelDir);
+          for (const file of files) {
+            if (file.endsWith('.md')) {
+              this.existingComponents.rules.push({
+                name: file,
+                path: path.join('.trae', 'rules', rule.dir, file),
+                level: rule.level
+              });
+            }
+          }
+        } catch (e) {
+          this.logFileError(levelDir, e, `scanRules/${rule.dir}`);
+        }
+      }
+    }
+
+    const l3Dirs = ['L3/RZero', 'custom_config'];
+    for (const l3Dir of l3Dirs) {
+      const l3Path = path.join(rulesDir, l3Dir);
+      if (fs.existsSync(l3Path)) {
+        try {
+          const files = fs.readdirSync(l3Path);
+          for (const file of files) {
+            if (file.endsWith('.md') || file.endsWith('.yml') || file.endsWith('.yaml')) {
+              this.existingComponents.rules.push({
+                name: file,
+                path: path.join('.trae', 'rules', l3Dir, file),
+                level: 'L3',
+                module: l3Dir.includes('RZero') ? 'RZero' : 'custom_config'
+              });
+            }
+          }
+        } catch (e) {
+          this.logFileError(l3Path, e, `scanRules/${l3Dir}`);
+        }
+      }
+    }
+
+    const attnPath = path.join(rulesDir, 'attention_optim_rule.md');
+    if (fs.existsSync(attnPath)) {
+      this.existingComponents.rules.push({
+        name: 'attention_optim_rule.md',
+        path: path.join('.trae', 'rules', 'attention_optim_rule.md'),
+        level: 'custom',
+        module: 'attention_optimization'
+      });
+    }
+
+    return this.existingComponents.rules;
+  }
+
+  scan() {
+    this.techStack = this.scanTechStack();
+    this.scanDirectoryStructure();
+    this.scanMCP();
+    this.scanAgents();
+    this.scanRules();
+    return this.getReport();
+  }
+
+  getReport() {
+    return {
+      projectRoot: this.root,
+      techStack: this.techStack,
+      structure: this.structure,
+      fullTopology: this.fullTopology,
+      existingComponents: this.existingComponents,
+      fileErrors: this.fileErrors,
+      stats: {
+        mcpCount: this.existingComponents.mcp.length,
+        agentCount: this.existingComponents.agents.length,
+        ruleCount: this.existingComponents.rules.length,
+        l1Rules: this.existingComponents.rules.filter(r => r.level === 'L1').length,
+        l2Rules: this.existingComponents.rules.filter(r => r.level === 'L2').length,
+        l3Rules: this.existingComponents.rules.filter(r => r.level === 'L3').length,
+        customRules: this.existingComponents.rules.filter(r => r.level === 'custom').length,
+        topologyNodeCount: this.fullTopology.length
+      },
+      timestamp: new Date().toISOString()
+    };
+  }
+
+  estimateComplexity() {
+    let score = 0;
+    score += this.techStack.length * 5;
+    score += Math.min(this.fullTopology.length, 100);
+    score += this.existingComponents.mcp.length * 10;
+    score += this.existingComponents.agents.length * 5;
+    score += this.existingComponents.rules.length * 3;
+
+    if (score < 30) return 'simple';
+    if (score < 80) return 'medium';
+    return 'complex';
+  }
+}
+
+// ============================================================
+// 第三部分：MCP 服务主逻辑
+// ============================================================
+
+// 缓存项目扫描结果
+let projectCache = null;
+
+const rl = readline.createInterface({
+  input: stdin,
+  output: stdout,
+  terminal: false
+});
+
+rl.on('line', (input) => {
+  try {
+    const request = JSON.parse(input);
+    const { id, method, params } = request;
+    let response;
+
+    if (method === 'initialize') {
+      response = {
+        jsonrpc: "2.0",
+        id: id,
+        result: {
+          protocolVersion: "2024-11-05",
+          capabilities: {
+            tools: {}
+          },
+          serverInfo: {
+            name: "rules-enforcer",
+            version: "2.0.0",
+            description: "规则验证 + 项目扫描整合版"
+          }
+        }
+      };
+    } else if (method === 'notifications/initialized') {
+      return;
+    } else if (method === 'tools/list') {
+      response = {
+        jsonrpc: "2.0",
+        id: id,
+        result: {
+          tools: [
+            // ===== 原有工具 =====
+            {
+              name: "validate",
+              description: "验证代码是否符合L1/L2/L3规则",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  code: { type: "string", description: "要验证的代码" },
+                  context: { type: "object", description: "上下文信息" }
+                },
+                required: ["code"]
+              }
+            },
+            {
+              name: "get_rules",
+              description: "获取所有规则定义",
+              inputSchema: {
+                type: "object",
+                properties: {}
+              }
+            },
+            {
+              name: "enforce",
+              description: "强制执行规则验证，不通过则拒绝",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  code: { type: "string", description: "要验证的代码" },
+                  context: { type: "object", description: "上下文信息" }
+                },
+                required: ["code"]
+              }
+            },
+            // ===== 新增工具（来自 project-detector） =====
+            {
+              name: "scan_project",
+              description: "扫描项目结构，识别技术栈、目录拓扑、已有组件",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  projectPath: { type: "string", description: "项目路径（默认当前工作目录）" },
+                  maxDepth: { type: "number", description: "最大扫描深度（默认4）" }
+                }
+              }
+            },
+            {
+              name: "get_tech_stack",
+              description: "获取项目技术栈信息",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  projectPath: { type: "string", description: "项目路径" }
+                }
+              }
+            },
+            {
+              name: "get_topology",
+              description: "获取项目目录拓扑结构",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  projectPath: { type: "string", description: "项目路径" }
+                }
+              }
+            },
+            {
+              name: "get_components",
+              description: "获取项目中的MCP服务、Agent配置、规则文件",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  projectPath: { type: "string", description: "项目路径" }
+                }
+              }
+            },
+            {
+              name: "analyze_project",
+              description: "分析项目并生成完整报告",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  projectPath: { type: "string", description: "项目路径" }
+                }
+              }
+            }
+          ]
+        }
+      };
+    } else if (method === 'tools/call') {
+      const toolName = params?.name;
+      const toolArgs = params?.arguments || {};
+
+      // ===== 原有工具处理 =====
+      if (toolName === 'validate') {
+        const issues = validateCode(toolArgs.code, toolArgs.context);
+        response = {
+          jsonrpc: "2.0",
+          id: id,
+          result: {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  success: true,
+                  issues,
+                  summary: {
+                    total: issues.length,
+                    errors: issues.filter(i => i.severity === 'error').length,
+                    warnings: issues.filter(i => i.severity === 'warning').length,
+                    info: issues.filter(i => i.severity === 'info').length
+                  }
+                })
+              }
+            ]
+          }
+        };
+      } else if (toolName === 'get_rules') {
+        response = {
+          jsonrpc: "2.0",
+          id: id,
+          result: {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  success: true,
+                  rules: getRules()
+                })
+              }
+            ]
+          }
+        };
+      } else if (toolName === 'enforce') {
+        const issues = validateCode(toolArgs.code, toolArgs.context);
+        const errors = issues.filter(i => i.severity === 'error');
+        const status = errors.length === 0 ? 'accepted' : 'rejected';
+        response = {
+          jsonrpc: "2.0",
+          id: id,
+          result: {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  success: true,
+                  status,
+                  issues,
+                  errors
+                })
+              }
+            ]
+          }
+        };
+      }
+      // ===== 新增工具处理（来自 project-detector） =====
+      else if (toolName === 'scan_project') {
+        try {
+          const projectPath = toolArgs.projectPath || process.cwd();
+          const maxDepth = toolArgs.maxDepth || 4;
+          const detector = new ProjectDetector(projectPath);
+          const report = detector.scan();
+          projectCache = report;
+          response = {
+            jsonrpc: "2.0",
+            id: id,
+            result: {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify({
+                    success: true,
+                    report
+                  })
+                }
+              ]
+            }
+          };
+        } catch (e) {
+          response = {
+            jsonrpc: "2.0",
+            id: id,
+            result: {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify({
+                    success: false,
+                    error: e.message
+                  })
+                }
+              ]
+            }
+          };
+        }
+      } else if (toolName === 'get_tech_stack') {
+        try {
+          const projectPath = toolArgs.projectPath || process.cwd();
+          const detector = new ProjectDetector(projectPath);
+          const techStack = detector.scanTechStack();
+          response = {
+            jsonrpc: "2.0",
+            id: id,
+            result: {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify({
+                    success: true,
+                    techStack,
+                    count: techStack.length
+                  })
+                }
+              ]
+            }
+          };
+        } catch (e) {
+          response = {
+            jsonrpc: "2.0",
+            id: id,
+            result: {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify({
+                    success: false,
+                    error: e.message
+                  })
+                }
+              ]
+            }
+          };
+        }
+      } else if (toolName === 'get_topology') {
+        try {
+          const projectPath = toolArgs.projectPath || process.cwd();
+          const detector = new ProjectDetector(projectPath);
+          detector.scanDirectoryStructure();
+          response = {
+            jsonrpc: "2.0",
+            id: id,
+            result: {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify({
+                    success: true,
+                    structure: detector.structure,
+                    topology: detector.fullTopology,
+                    nodeCount: detector.fullTopology.length
+                  })
+                }
+              ]
+            }
+          };
+        } catch (e) {
+          response = {
+            jsonrpc: "2.0",
+            id: id,
+            result: {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify({
+                    success: false,
+                    error: e.message
+                  })
+                }
+              ]
+            }
+          };
+        }
+      } else if (toolName === 'get_components') {
+        try {
+          const projectPath = toolArgs.projectPath || process.cwd();
+          const detector = new ProjectDetector(projectPath);
+          detector.scanMCP();
+          detector.scanAgents();
+          detector.scanRules();
+          response = {
+            jsonrpc: "2.0",
+            id: id,
+            result: {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify({
+                    success: true,
+                    components: detector.existingComponents,
+                    stats: {
+                      mcpCount: detector.existingComponents.mcp.length,
+                      agentCount: detector.existingComponents.agents.length,
+                      ruleCount: detector.existingComponents.rules.length
+                    }
+                  })
+                }
+              ]
+            }
+          };
+        } catch (e) {
+          response = {
+            jsonrpc: "2.0",
+            id: id,
+            result: {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify({
+                    success: false,
+                    error: e.message
+                  })
+                }
+              ]
+            }
+          };
+        }
+      } else if (toolName === 'analyze_project') {
+        try {
+          const projectPath = toolArgs.projectPath || process.cwd();
+          const detector = new ProjectDetector(projectPath);
+          const report = detector.scan();
+          const complexity = detector.estimateComplexity();
+          response = {
+            jsonrpc: "2.0",
+            id: id,
+            result: {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify({
+                    success: true,
+                    analysis: {
+                      ...report,
+                      complexity,
+                      recommendations: generateRecommendations(report)
+                    }
+                  })
+                }
+              ]
+            }
+          };
+        } catch (e) {
+          response = {
+            jsonrpc: "2.0",
+            id: id,
+            result: {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify({
+                    success: false,
+                    error: e.message
+                  })
+                }
+              ]
+            }
+          };
+        }
+      } else {
+        response = {
+          jsonrpc: "2.0",
+          id: id,
+          error: {
+            code: -32601,
+            message: 'Tool not found'
+          }
+        };
+      }
+    } else {
+      response = {
+        jsonrpc: "2.0",
+        id: id,
+        error: {
+          code: -32601,
+          message: 'Method not found'
+        }
+      };
+    }
+
+    stdout.write(JSON.stringify(response) + '\n');
+  } catch (error) {
+    stdout.write(JSON.stringify({
+      jsonrpc: "2.0",
+      id: null,
+      error: {
+        code: -32603,
+        message: 'Internal error: ' + error.message
+      }
+    }) + '\n');
+  }
+});
+
+/**
+ * 生成项目优化建议
+ */
+function generateRecommendations(report) {
+  const recommendations = [];
+  
+  // 技术栈建议
+  if (report.techStack.includes('Node.js') && !report.techStack.includes('TypeScript')) {
+    recommendations.push({
+      type: 'tech_stack',
+      message: '建议引入TypeScript提升代码质量',
+      priority: 'medium'
+    });
+  }
+  
+  // MCP服务建议
+  if (report.stats.mcpCount === 0) {
+    recommendations.push({
+      type: 'mcp',
+      message: '项目未配置MCP服务，建议添加rules-enforcer',
+      priority: 'high'
+    });
+  }
+  
+  // 规则建议
+  if (report.stats.l1Rules === 0) {
+    recommendations.push({
+      type: 'rules',
+      message: '缺少L1用户规则，建议添加基础代码规范',
+      priority: 'medium'
+    });
+  }
+  
+  if (report.stats.l2Rules === 0) {
+    recommendations.push({
+      type: 'rules',
+      message: '缺少L2项目规则，建议添加项目特定规范',
+      priority: 'medium'
+    });
+  }
+  
+  return recommendations;
+}
+
+// 启动日志
+console.error('[rules-enforcer v2.0.0] MCP服务已启动');
+console.error('[rules-enforcer] 整合功能: 规则验证 + 项目扫描');