rules-enforcer 1.0.0

package/rules-server.js

@@ -0,0 +1,350 @@
+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');
+  }
+});

package/test/test-mcp-full.js

@@ -0,0 +1,193 @@
+/**
+ * MCP 全链路测试脚本
+ * 
+ * 用途:
+ * 1. 检查关键文件存在性
+ * 2. 验证 MCP 配置正确性
+ * 3. 验证双规则目录存在
+ * 4. 验证 G 记忆五级目录
+ * 5. 测试 MCP 协议通信和工具列表
+ * 
+ * 运行方式:
+ * cd .trae/mcp/rules-enforcer
+ * node test/test-mcp-full.js
+ */
+
+const { spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+// 路径配置 - 更新为合并后的结构
+const RULES_ENFORCER_DIR = path.join(__dirname, '..');  // rules-enforcer 目录
+const MCP_ROOT = path.join(RULES_ENFORCER_DIR, '..');    // .trae/mcp 目录
+const PROJECT_ROOT = path.join(MCP_ROOT, '..');          // 项目根目录
+const MCP_SERVER = path.join(RULES_ENFORCER_DIR, 'rules-server.js');
+const HOOKS_SERVER = path.join(RULES_ENFORCER_DIR, 'hooks', 'custom-hook-server.js');
+const DETECTOR_SERVER = path.join(RULES_ENFORCER_DIR, 'detector', 'mcp-server.js');
+const DB_PATH = path.join(PROJECT_ROOT, '.trae', 'database', 'rzero-test.db');
+const RULES_DIR = path.join(PROJECT_ROOT, '.trae', 'rules');
+const GMEMORY_DIR = path.join(PROJECT_ROOT, '.trae', 'g_memory');
+
+console.log('='.repeat(60));
+console.log('MCP 全链路测试 (rules-enforcer 合并版)');
+console.log('='.repeat(60));
+console.log();
+
+console.log('[1] 检查关键目录');
+console.log('    rules-enforcer:', fs.existsSync(RULES_ENFORCER_DIR) ? '✅ 存在' : '❌ 缺失');
+console.log('    hooks 子目录:', fs.existsSync(path.join(RULES_ENFORCER_DIR, 'hooks')) ? '✅ 存在' : '❌ 缺失');
+console.log('    detector 子目录:', fs.existsSync(path.join(RULES_ENFORCER_DIR, 'detector')) ? '✅ 存在' : '❌ 缺失');
+console.log('    test 子目录:', fs.existsSync(path.join(RULES_ENFORCER_DIR, 'test')) ? '✅ 存在' : '❌ 缺失');
+console.log();
+
+console.log('[2] MCP 服务入口检查');
+console.log('    rules-server.js:', fs.existsSync(MCP_SERVER) ? '✅ 存在' : '❌ 缺失');
+console.log('    hooks/server.js:', fs.existsSync(HOOKS_SERVER) ? '✅ 存在' : '❌ 缺失');
+console.log('    detector/server.js:', fs.existsSync(DETECTOR_SERVER) ? '✅ 存在' : '❌ 缺失');
+console.log();
+
+console.log('[3] SQLite 数据库检查');
+console.log('    数据库文件:', fs.existsSync(DB_PATH) ? '✅ 存在' : '⚠️ 缺失');
+if (fs.existsSync(DB_PATH)) {
+  const stats = fs.statSync(DB_PATH);
+  console.log('    文件大小:', stats.size, 'bytes');
+}
+console.log();
+
+console.log('[4] MCP 配置检查');
+const projectMcp = path.join(MCP_ROOT, 'mcp.json');
+console.log('    项目配置:', fs.existsSync(projectMcp) ? '✅ 存在' : '❌ 缺失');
+
+if (fs.existsSync(projectMcp)) {
+  try {
+    const mcpConfig = JSON.parse(fs.readFileSync(projectMcp, 'utf8'));
+    const services = Object.keys(mcpConfig.mcpServers || {});
+    console.log('    注册服务:', services.join(', '));
+    
+    // 检查是否只有一个 rules-enforcer
+    if (services.length === 1 && services[0] === 'rules-enforcer') {
+      console.log('    ✅ 配置正确: 只注册了 rules-enforcer');
+    } else {
+      console.log('    ⚠️ 配置异常: 应只注册 rules-enforcer');
+    }
+  } catch (err) {
+    console.warn('    ⚠️ 项目配置解析失败');
+  }
+}
+console.log();
+
+console.log('[5] 双规则目录检查');
+const rzeroDir = path.join(RULES_DIR, 'L3', 'RZero');
+const customDir = path.join(RULES_DIR, 'custom_config');
+console.log('    RZero 规则:', fs.existsSync(rzeroDir) ? '✅ 存在' : '❌ 缺失');
+console.log('    Custom 规则:', fs.existsSync(customDir) ? '✅ 存在' : '❌ 缺失');
+console.log();
+
+console.log('[6] G 记忆五级目录检查');
+const gmemoryDirs = ['短期记忆', '中期记忆', '长期记忆', '明知识', '暗知识'];
+let gmemoryCount = 0;
+gmemoryDirs.forEach(dir => {
+  const dirPath = path.join(GMEMORY_DIR, dir);
+  const exists = fs.existsSync(dirPath);
+  console.log(`    ${exists ? '✅' : '⚠️'}  ${dir}`);
+  if (exists) gmemoryCount++;
+});
+console.log(`    目录存在: ${gmemoryCount}/${gmemoryDirs.length}`);
+console.log();
+
+console.log('[7] 测试 rules-server.js MCP 协议');
+return new Promise((resolve, reject) => {
+  const mcpProc = spawn('node', [MCP_SERVER], {
+    cwd: PROJECT_ROOT,
+    stdio: ['pipe', 'pipe', 'pipe']
+  });
+
+  let output = '';
+  let errorOutput = '';
+
+  mcpProc.stdout.on('data', (data) => {
+    output += data.toString();
+  });
+
+  mcpProc.stderr.on('data', (data) => {
+    errorOutput += data.toString();
+  });
+
+  mcpProc.on('error', (err) => {
+    console.log('    ❌ MCP 服务器启动失败:', err.message);
+    reject(err);
+  });
+
+  // 发送 initialize 请求
+  setTimeout(() => {
+    const initRequest = JSON.stringify({
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'initialize',
+      params: {
+        protocolVersion: '2024-11-05',
+        capabilities: {},
+        clientInfo: { name: 'test', version: '1.0.0' }
+      }
+    }) + '\n';
+    mcpProc.stdin.write(initRequest);
+  }, 500);
+
+  // 发送 tools/list 请求
+  setTimeout(() => {
+    const listRequest = JSON.stringify({
+      jsonrpc: '2.0',
+      id: 2,
+      method: 'tools/list',
+      params: {}
+    }) + '\n';
+    mcpProc.stdin.write(listRequest);
+  }, 1000);
+
+  // 接收响应
+  setTimeout(() => {
+    console.log('    MCP 服务器响应:');
+    const lines = output.split('\n').filter(l => l.trim());
+
+    if (lines.length > 0) {
+      let hasValidResponse = false;
+      lines.forEach(line => {
+        try {
+          const resp = JSON.parse(line);
+          if (resp.result) {
+            hasValidResponse = true;
+            if (resp.result.tools) {
+              const toolNames = resp.result.tools.map(t => t.name);
+              console.log('    ✅ MCP 协议通信正常');
+              console.log('    可用工具:', toolNames.join(', '));
+            } else if (resp.result.serverInfo) {
+              console.log('    ✅ 初始化成功:', resp.result.serverInfo.name);
+            }
+          }
+          if (resp.error) {
+            console.log('    ⚠️  MCP 错误:', resp.error.message);
+          }
+        } catch (err) {
+          // 忽略解析错误
+        }
+      });
+
+      if (!hasValidResponse) {
+        console.log('    ⚠️  未收到有效响应');
+      }
+    } else {
+      console.log('    ⚠️  无输出');
+    }
+
+    if (errorOutput) {
+      console.log('    stderr:', errorOutput.substring(0, 200));
+    }
+
+    mcpProc.kill();
+    console.log();
+    console.log('='.repeat(60));
+    console.log('✅ MCP 全链路检查完成');
+    console.log('='.repeat(60));
+    resolve();
+  }, 2000);
+});