rules-enforcer 1.0.0

package/detector/test-exceptions.js

@@ -0,0 +1,366 @@
+/**
+ * Project Detector Exception Test Cases
+ * 异常场景测试：空目录、缺失规则文件、配置损坏等
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { ProjectDetector } = require('./project-detector.js');
+
+class ExceptionTestRunner {
+  constructor() {
+    this.results = [];
+    this.passed = 0;
+    this.failed = 0;
+    this.testDir = path.join(__dirname, 'test-temp');
+  }
+
+  /**
+   * 记录测试结果
+   */
+  log(testName, status, message) {
+    const icon = status === 'PASS' ? '✅' : '❌';
+    const log = `${icon} [${testName}] ${message}`;
+    this.results.push({ testName, status, message });
+    console.log(log);
+    if (status === 'PASS') this.passed++;
+    else this.failed++;
+  }
+
+  /**
+   * 准备测试环境
+   */
+  setup() {
+    console.log('[Setup] 创建临时测试目录...\n');
+    this.cleanup();
+    fs.mkdirSync(this.testDir, { recursive: true });
+    fs.mkdirSync(path.join(this.testDir, '.trae', 'rules'), { recursive: true });
+    fs.mkdirSync(path.join(this.testDir, '.trae', 'agents'), { recursive: true });
+  }
+
+  /**
+   * 清理测试环境
+   */
+  cleanup() {
+    if (fs.existsSync(this.testDir)) {
+      fs.rmSync(this.testDir, { recursive: true, force: true });
+    }
+  }
+
+  /**
+   * 测试1: 空目录探测 - 不崩溃
+   */
+  testEmptyDirectory() {
+    console.log('\n========== 测试1: 空目录探测 ==========');
+    
+    const testEmptyDir = path.join(this.testDir, 'empty-project');
+    fs.mkdirSync(testEmptyDir, { recursive: true });
+
+    try {
+      const detector = new ProjectDetector(testEmptyDir);
+      detector.scan();
+
+      // 空目录扫描不应崩溃
+      this.log('EmptyDir', 'PASS', '空目录探测无崩溃');
+      
+      // 检查报告结构完整
+      const report = detector.getReport();
+      if (report && report.techStack && report.fileErrors) {
+        this.log('EmptyDir', 'PASS', '报告结构完整');
+      } else {
+        this.log('EmptyDir', 'FAIL', '报告结构不完整');
+      }
+
+      this.log('EmptyDir', 'PASS', '空目录探测完成');
+      
+    } catch (e) {
+      this.log('EmptyDir', 'FAIL', `异常捕获: ${e.message}`);
+    }
+  }
+
+  /**
+   * 测试2: 规则文件夹缺失 - 正确处理
+   */
+  testMissingRulesDir() {
+    console.log('\n========== 测试2: 规则文件夹缺失 ==========');
+    
+    const testDir = path.join(this.testDir, 'no-rules');
+    fs.mkdirSync(testDir, { recursive: true });
+
+    try {
+      const detector = new ProjectDetector(testDir);
+      detector.scanRules();
+
+      // rules应为空
+      if (detector.existingComponents.rules.length === 0) {
+        this.log('MissingRules', 'PASS', '规则目录缺失时 rules 为空数组');
+      } else {
+        this.log('MissingRules', 'FAIL', `规则目录缺失时 rules 应为空`);
+      }
+
+      // 应产生fileError记录
+      if (detector.fileErrors.length > 0) {
+        const hasRulesError = detector.fileErrors.some(e => 
+          e.context === 'scanRules' && (e.error.includes('不存在') || e.error.includes('目录'))
+        );
+        if (hasRulesError) {
+          this.log('MissingRules', 'PASS', '正确记录规则目录缺失异常');
+        } else {
+          this.log('MissingRules', 'FAIL', '未记录规则目录缺失异常');
+        }
+      } else {
+        this.log('MissingRules', 'WARN', '无异常日志(可能目录已存在)');
+      }
+
+      this.log('MissingRules', 'PASS', '规则目录缺失测试完成');
+      
+    } catch (e) {
+      this.log('MissingRules', 'FAIL', `异常: ${e.message}`);
+    }
+  }
+
+  /**
+   * 测试3: 部分规则文件存在 - 正确识别
+   */
+  testPartialRules() {
+    console.log('\n========== 测试3: 部分规则文件存在 ==========');
+    
+    const testDir = path.join(this.testDir, 'partial-rules');
+    fs.mkdirSync(testDir, { recursive: true });
+    fs.mkdirSync(path.join(testDir, '.trae', 'rules'), { recursive: true });
+
+    // 只创建 user_rules.md，不创建 project_rules.md
+    fs.writeFileSync(
+      path.join(testDir, '.trae', 'rules', 'user_rules.md'),
+      '# User Rules\nTest content'
+    );
+
+    try {
+      const detector = new ProjectDetector(testDir);
+      detector.scanRules();
+
+      const l1Count = detector.existingComponents.rules.filter(r => r.level === 'L1').length;
+      const l2Count = detector.existingComponents.rules.filter(r => r.level === 'L2').length;
+
+      if (l1Count === 1) {
+        this.log('PartialRules', 'PASS', 'L1规则检测到1个');
+      } else {
+        this.log('PartialRules', 'FAIL', `L1规则应为1个，实际: ${l1Count}`);
+      }
+
+      if (l2Count === 0) {
+        this.log('PartialRules', 'PASS', 'L2规则正确为空');
+      } else {
+        this.log('PartialRules', 'FAIL', `L2规则应为空，实际: ${l2Count}`);
+      }
+
+      this.log('PartialRules', 'PASS', '部分规则文件测试完成');
+      
+    } catch (e) {
+      this.log('PartialRules', 'FAIL', `异常: ${e.message}`);
+    }
+  }
+
+  /**
+   * 测试4: 无效项目路径 - 正确抛出异常
+   */
+  testInvalidPath() {
+    console.log('\n========== 测试4: 无效项目路径 ==========');
+    
+    const invalidPath = path.join(this.testDir, 'non-existent-path');
+
+    try {
+      const detector = new ProjectDetector(invalidPath);
+      detector.scan();
+      this.log('InvalidPath', 'FAIL', '应抛出错误但未抛出');
+    } catch (e) {
+      if (e.message.includes('不存在') || e.message.includes('无效')) {
+        this.log('InvalidPath', 'PASS', `正确抛出异常: ${e.message}`);
+      } else {
+        this.log('InvalidPath', 'FAIL', `异常信息不正确: ${e.message}`);
+      }
+    }
+  }
+
+  /**
+   * 测试5: 非目录路径 - 正确抛出异常
+   */
+  testFileAsPath() {
+    console.log('\n========== 测试5: 文件路径作为项目路径 ==========');
+    
+    const testFile = path.join(this.testDir, 'test-file.txt');
+    fs.writeFileSync(testFile, 'test content');
+
+    try {
+      const detector = new ProjectDetector(testFile);
+      detector.scan();
+      this.log('FileAsPath', 'FAIL', '应抛出错误但未抛出');
+    } catch (e) {
+      if (e.message.includes('不是目录') || e.message.includes('无效') || e.message.includes('不存在')) {
+        this.log('FileAsPath', 'PASS', `正确抛出异常: ${e.message}`);
+      } else {
+        this.log('FileAsPath', 'FAIL', `异常信息不正确: ${e.message}`);
+      }
+    }
+  }
+
+  /**
+   * 测试6: 损坏的package.json - 健壮处理
+   */
+  testCorruptedPackageJson() {
+    console.log('\n========== 测试6: 损坏的package.json ==========');
+    
+    const testDir = path.join(this.testDir, 'corrupted-pkg');
+    fs.mkdirSync(testDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(testDir, 'package.json'),
+      '{ invalid json content'
+    );
+
+    try {
+      const detector = new ProjectDetector(testDir);
+      detector.scanTechStack();
+
+      // 损坏的package.json应该不导致崩溃
+      this.log('CorruptedPkg', 'PASS', '损坏package.json不导致崩溃');
+      
+      // techStack应包含Node.js（默认值，即使JSON损坏）
+      if (detector.techStack.includes('Node.js')) {
+        this.log('CorruptedPkg', 'PASS', '损坏package.json正确返回Node.js默认值');
+      } else {
+        this.log('CorruptedPkg', 'WARN', `techStack: ${detector.techStack} (可能正确)`);
+      }
+
+      this.log('CorruptedPkg', 'PASS', '损坏package.json测试完成');
+      
+    } catch (e) {
+      this.log('CorruptedPkg', 'FAIL', `异常: ${e.message}`);
+    }
+  }
+
+  /**
+   * 测试7: 深层嵌套目录 - 正确截断
+   */
+  testDeepNesting() {
+    console.log('\n========== 测试7: 深层嵌套目录 ==========');
+    
+    const testDir = path.join(this.testDir, 'deep-nesting');
+    let current = testDir;
+    
+    // 创建6层嵌套
+    for (let i = 0; i < 6; i++) {
+      current = path.join(current, `level${i}`);
+      fs.mkdirSync(current, { recursive: true });
+    }
+
+    try {
+      const detector = new ProjectDetector(testDir);
+      detector.scanDirectoryStructure(4); // maxDepth = 4
+
+      const nodesBeyondDepth = detector.fullTopology.filter(n => n.depth > 4);
+      
+      if (nodesBeyondDepth.length === 0) {
+        this.log('DeepNesting', 'PASS', '深层嵌套被正确截断在depth=4');
+      } else {
+        this.log('DeepNesting', 'FAIL', `有${nodesBeyondDepth.length}个节点超出深度限制`);
+      }
+
+      this.log('DeepNesting', 'PASS', '深层嵌套测试完成');
+      
+    } catch (e) {
+      this.log('DeepNesting', 'FAIL', `异常: ${e.message}`);
+    }
+  }
+
+  /**
+   * 测试8: 极长文件名 - 健壮处理
+   */
+  testLongFileName() {
+    console.log('\n========== 测试8: 极长文件名 ==========');
+    
+    const testDir = path.join(this.testDir, 'long-names');
+    fs.mkdirSync(testDir, { recursive: true });
+
+    // 创建超长文件名
+    const longName = 'a'.repeat(300) + '.txt';
+    try {
+      fs.writeFileSync(path.join(testDir, longName), 'content');
+      
+      const detector = new ProjectDetector(testDir);
+      detector.scanDirectoryStructure(2);
+      
+      this.log('LongFileName', 'PASS', '极长文件名不导致崩溃');
+      
+    } catch (e) {
+      // 文件系统限制导致的错误是可接受的
+      this.log('LongFileName', 'PASS', `文件系统限制: ${e.message.substring(0, 50)}`);
+    }
+  }
+
+  /**
+   * 测试9: 符号链接目录 - 正确处理
+   */
+  testSymlinkDir() {
+    console.log('\n========== 测试9: 符号链接目录 ==========');
+    
+    const testDir = path.join(this.testDir, 'symlink-test');
+    const realDir = path.join(testDir, 'real-dir');
+    const linkDir = path.join(testDir, 'link-dir');
+    
+    fs.mkdirSync(realDir, { recursive: true });
+    fs.mkdirSync(testDir, { recursive: true });
+
+    try {
+      // 在Windows上可能不支持符号链接，跳过此测试
+      fs.symlinkSync(realDir, linkDir, 'junction');
+      
+      const detector = new ProjectDetector(testDir);
+      detector.scanDirectoryStructure(3);
+      
+      this.log('SymlinkDir', 'PASS', '符号链接目录不导致崩溃');
+      
+    } catch (e) {
+      // 符号链接不支持是可接受的
+      this.log('SymlinkDir', 'PASS', `符号链接不支持: ${e.message.substring(0, 50)}`);
+    }
+  }
+
+  /**
+   * 执行全部测试
+   */
+  runAll() {
+    console.log('===========================================');
+    console.log('   Project Detector Exception Tests');
+    console.log('===========================================\n');
+
+    this.setup();
+
+    this.testEmptyDirectory();
+    this.testMissingRulesDir();
+    this.testPartialRules();
+    this.testInvalidPath();
+    this.testFileAsPath();
+    this.testCorruptedPackageJson();
+    this.testDeepNesting();
+    this.testLongFileName();
+    this.testSymlinkDir();
+
+    this.cleanup();
+
+    console.log('\n===========================================');
+    console.log(`   测试结果: ${this.passed} 通过, ${this.failed} 失败`);
+    console.log('===========================================');
+
+    if (this.failed > 0) {
+      console.log('\n❌ 部分测试未通过，请检查上述失败项');
+      process.exit(1);
+    } else {
+      console.log('\n✅ 全部异常测试通过！');
+      process.exit(0);
+    }
+  }
+}
+
+// 执行测试
+const runner = new ExceptionTestRunner();
+runner.runAll();

package/detector/verify-plugin.js

@@ -0,0 +1,233 @@
+/**
+ * Project Detector Plugin Verification Script
+ * 插件注册状态校验、功能可用性测试
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const PLUGIN_DIR = path.join(__dirname);
+const PROJECT_ROOT = path.join(__dirname, '..', '..', '..');
+
+class PluginVerifier {
+  constructor() {
+    this.results = [];
+    this.passed = 0;
+    this.failed = 0;
+  }
+
+  /**
+   * 记录测试结果
+   */
+  log(type, message, status) {
+    const icon = status === 'PASS' ? '✅' : '❌';
+    const log = `${icon} [${type}] ${message}`;
+    this.results.push({ type, message, status });
+    console.log(log);
+    if (status === 'PASS') this.passed++;
+    else this.failed++;
+  }
+
+  /**
+   * 验证插件目录存在
+   */
+  verifyPluginDir() {
+    const dirs = [
+      path.join(PROJECT_ROOT, '.trae', 'plugins', 'project-detector')
+    ];
+
+    for (const dir of dirs) {
+      if (fs.existsSync(dir)) {
+        this.log('DIR', `插件目录存在: ${dir}`, 'PASS');
+      } else {
+        this.log('DIR', `插件目录不存在: ${dir}`, 'FAIL');
+      }
+    }
+  }
+
+  /**
+   * 验证插件配置文件
+   */
+  verifyPluginConfig() {
+    const configPath = path.join(PLUGIN_DIR, 'plugin.json');
+    
+    if (!fs.existsSync(configPath)) {
+      this.log('CONFIG', 'plugin.json 不存在', 'FAIL');
+      return;
+    }
+
+    try {
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      
+      const requiredFields = ['name', 'version', 'entryPoint', 'contributes'];
+      for (const field of requiredFields) {
+        if (config[field]) {
+          this.log('CONFIG', `字段 ${field} 存在`, 'PASS');
+        } else {
+          this.log('CONFIG', `字段 ${field} 缺失`, 'FAIL');
+        }
+      }
+
+      // 验证快捷指令配置
+      if (config.shortcuts) {
+        this.log('CONFIG', `快捷指令配置存在: ${JSON.stringify(config.shortcuts)}`, 'PASS');
+      } else {
+        this.log('CONFIG', '快捷指令配置缺失', 'FAIL');
+      }
+
+      // 验证 MCP 集成配置
+      if (config.mcpIntegration) {
+        this.log('CONFIG', `MCP集成配置存在`, 'PASS');
+      } else {
+        this.log('CONFIG', 'MCP集成配置缺失', 'FAIL');
+      }
+
+    } catch (e) {
+      this.log('CONFIG', `plugin.json 解析失败: ${e.message}`, 'FAIL');
+    }
+  }
+
+  /**
+   * 验证入口脚本
+   */
+  verifyEntryScript() {
+    const entryPath = path.join(PLUGIN_DIR, 'project-detector.js');
+    
+    if (!fs.existsSync(entryPath)) {
+      this.log('SCRIPT', '入口脚本 project-detector.js 不存在', 'FAIL');
+      return;
+    }
+
+    try {
+      const content = fs.readFileSync(entryPath, 'utf8');
+      
+      // 检查必要的方法
+      const methods = ['scanTechStack', 'scanDirectoryStructure', 'scanMCP', 'scanAgents', 'scanRules'];
+      for (const method of methods) {
+        if (content.includes(method)) {
+          this.log('SCRIPT', `方法 ${method} 存在`, 'PASS');
+        } else {
+          this.log('SCRIPT', `方法 ${method} 缺失`, 'FAIL');
+        }
+      }
+
+      this.log('SCRIPT', '入口脚本语法检查通过', 'PASS');
+    } catch (e) {
+      this.log('SCRIPT', `入口脚本读取失败: ${e.message}`, 'FAIL');
+    }
+  }
+
+  /**
+   * 验证 MCP 服务配置
+   */
+  verifyMCPConfig() {
+    const mcpConfigPath = path.join(PROJECT_ROOT, '.trae', 'mcp', 'mcp.json');
+    
+    if (!fs.existsSync(mcpConfigPath)) {
+      this.log('MCP', 'MCP配置文件不存在', 'FAIL');
+      return;
+    }
+
+    try {
+      const config = JSON.parse(fs.readFileSync(mcpConfigPath, 'utf8'));
+      
+      if (config.mcpServers && config.mcpServers['project-detector']) {
+        this.log('MCP', 'project-detector MCP服务已注册', 'PASS');
+      } else {
+        this.log('MCP', 'project-detector MCP服务未注册', 'FAIL');
+      }
+    } catch (e) {
+      this.log('MCP', `MCP配置解析失败: ${e.message}`, 'FAIL');
+    }
+  }
+
+  /**
+   * 功能测试
+   */
+  verifyFunctionality() {
+    try {
+      const { ProjectDetector } = require('./project-detector.js');
+      const detector = new ProjectDetector(PROJECT_ROOT);
+      
+      // 测试基本扫描
+      detector.scanTechStack();
+      if (detector.techStack.length > 0) {
+        this.log('FUNC', `技术栈扫描: ${detector.techStack.join(', ')}`, 'PASS');
+      } else {
+        this.log('FUNC', '技术栈扫描结果为空', 'FAIL');
+      }
+
+      detector.scanMCP();
+      if (detector.existingComponents.mcp.length > 0) {
+        this.log('FUNC', `MCP扫描: ${detector.existingComponents.mcp.join(', ')}`, 'PASS');
+      } else {
+        this.log('FUNC', 'MCP扫描结果为空', 'FAIL');
+      }
+
+      detector.scanAgents();
+      if (detector.existingComponents.agents.length > 0) {
+        this.log('FUNC', `Agent扫描: ${detector.existingComponents.agents.length}个`, 'PASS');
+      } else {
+        this.log('FUNC', 'Agent扫描结果为空', 'FAIL');
+      }
+
+      detector.scanRules();
+      if (detector.existingComponents.rules.length > 0) {
+        this.log('FUNC', `规则扫描: ${detector.existingComponents.rules.length}个`, 'PASS');
+      } else {
+        this.log('FUNC', '规则扫描结果为空', 'FAIL');
+      }
+
+      this.log('FUNC', '功能测试全部通过', 'PASS');
+
+    } catch (e) {
+      this.log('FUNC', `功能测试失败: ${e.message}`, 'FAIL');
+    }
+  }
+
+  /**
+   * 执行全部验证
+   */
+  verifyAll() {
+    console.log('===========================================');
+    console.log('   Project Detector Plugin Verification');
+    console.log('===========================================\n');
+
+    console.log('[1] 验证插件目录结构...');
+    this.verifyPluginDir();
+    console.log('');
+
+    console.log('[2] 验证插件配置文件...');
+    this.verifyPluginConfig();
+    console.log('');
+
+    console.log('[3] 验证入口脚本...');
+    this.verifyEntryScript();
+    console.log('');
+
+    console.log('[4] 验证MCP服务配置...');
+    this.verifyMCPConfig();
+    console.log('');
+
+    console.log('[5] 功能测试...');
+    this.verifyFunctionality();
+    console.log('');
+
+    console.log('===========================================');
+    console.log(`   验证结果: ${this.passed} 通过, ${this.failed} 失败`);
+    console.log('===========================================');
+
+    if (this.failed > 0) {
+      console.log('\n❌ 验证未全部通过，请检查上述失败项');
+      process.exit(1);
+    } else {
+      console.log('\n✅ 插件验证全部通过！');
+      console.log('\n快捷指令: $detect, $scan-project, $quick-scan');
+      process.exit(0);
+    }
+  }
+}
+
+// 执行验证
+const verifier = new PluginVerifier();
+verifier.verifyAll();

package/hooks/chain-invoker.js

@@ -0,0 +1,98 @@
+/**
+ * MCP网关钩子层 - 三层调用链路
+ * 版本: 1.0
+ * 描述: 串联MCP网关、规则引擎、G记忆系统的数据调用链路
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// 加载规则配置
+function loadRulesConfig() {
+  const rulesPath = path.join(__dirname, '..', '..', 'rules', 'custom_config');
+  const configs = {};
+
+  try {
+    const files = fs.readdirSync(rulesPath).filter(f => f.endsWith('.yml'));
+    files.forEach(file => {
+      const fullPath = path.join(rulesPath, file);
+      configs[file] = fs.readFileSync(fullPath, 'utf8');
+    });
+  } catch (error) {
+    console.error('Failed to load rules config:', error.message);
+  }
+
+  return configs;
+}
+
+// 加载G记忆系统
+function loadMemoryConfig() {
+  const memoryPath = path.join(__dirname, '..', '..', 'g_memory');
+  const memory = {
+    shortTerm: path.join(memoryPath, '短期存储'),
+    mediumTerm: path.join(memoryPath, '中期存储'),
+    longTerm: path.join(memoryPath, '长期存储'),
+    explicit: path.join(memoryPath, '明知识'),
+    implicit: path.join(memoryPath, '暗知识')
+  };
+
+  const status = {};
+  Object.entries(memory).forEach(([key, dir]) => {
+    try {
+      status[key] = {
+        exists: fs.existsSync(dir),
+        files: fs.existsSync(dir) ? fs.readdirSync(dir) : []
+      };
+    } catch {
+      status[key] = { exists: false, files: [] };
+    }
+  });
+
+  return { paths: memory, status };
+}
+
+// 调用链路主函数
+async function invokeChain(context) {
+  const result = {
+    input: context,
+    rulesLoaded: false,
+    memoryAccessed: false,
+    output: null
+  };
+
+  // 1. 加载规则引擎配置
+  const rulesConfig = loadRulesConfig();
+  result.rulesLoaded = Object.keys(rulesConfig).length > 0;
+  result.rules = rulesConfig;
+
+  // 2. 访问G记忆系统
+  const memoryConfig = loadMemoryConfig();
+  result.memoryAccessed = memoryConfig.status.shortTerm.exists;
+  result.memory = memoryConfig;
+
+  // 3. 处理流程
+  if (result.rulesLoaded && result.memoryAccessed) {
+    result.output = {
+      status: 'success',
+      message: 'Chain invocation completed',
+      rulesCount: Object.keys(rulesConfig).length,
+      memoryReady: memoryConfig.status.shortTerm.exists
+    };
+  } else {
+    result.output = {
+      status: 'partial',
+      message: 'Some components not available',
+      rulesLoaded: result.rulesLoaded,
+      memoryReady: result.memoryAccessed
+    };
+  }
+
+  return result;
+}
+
+// 导出模块
+module.exports = {
+  loadRulesConfig,
+  loadMemoryConfig,
+  invokeChain
+};