rules-enforcer 1.0.0

package/detector/render-engine/render-verify.js

@@ -0,0 +1,282 @@
+/**
+ * Render Verify - 渲染验证脚本
+ * 三项校验：语法校验 + 目录层级校验 + 优先级合规校验
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Promise化的fs方法
+ */
+const _fsPromises = {
+  pathExists: (p) => fs.promises.access(p).then(() => true).catch(() => false),
+  readdir: (p) => fs.promises.readdir(p),
+  stat: (p) => fs.promises.stat(p),
+  readFile: (p, encoding) => fs.promises.readFile(p, encoding)
+};
+
+class RenderVerify {
+  constructor() {
+    this.results = [];
+    this.passed = 0;
+    this.failed = 0;
+    this.baseDir = process.cwd();
+  }
+
+  /**
+   * 记录测试结果
+   */
+  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++;
+  }
+
+  /**
+   * 简单的YAML语法检查
+   */
+  validateYamlSyntax(content) {
+    // 基本YAML语法检查
+    const lines = content.split('\n');
+    let inMultilineString = false;
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+
+      // 处理多行字符串
+      if (line.includes('|-')) {
+        inMultilineString = true;
+        continue;
+      }
+      if (inMultilineString && line.match(/^\s+\S/)) {
+        continue;
+      }
+      inMultilineString = false;
+
+      // 检查基本YAML语法
+      const trimmed = line.trim();
+      if (trimmed === '' || trimmed.startsWith('#')) continue;
+
+      // 检查键值对格式
+      if (trimmed.includes(':')) {
+        const key = trimmed.split(':')[0].trim();
+        if (!/^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(key)) {
+          // 可能是带引号的键
+          if (!key.startsWith('"') && !key.startsWith("'")) {
+            return false;
+          }
+        }
+      }
+    }
+    return true;
+  }
+
+  /**
+   * 校验1：语法校验
+   */
+  async verifySyntax() {
+    console.log('\n========== 校验1: 语法校验 ==========');
+
+    try {
+      // 检查YAML语法（只检查渲染引擎新生成的文件：L1-、L2-、L3-开头）
+      const rulesDir = path.join(this.baseDir, '.trae', 'rules');
+      const generatedPrefixes = ['L1-', 'L2-', 'L3-'];
+
+      if (await _fsPromises.pathExists(rulesDir)) {
+        // 递归检查所有YAML文件
+        const checkDir = async (dirPath, relativePath = '') => {
+          const files = await _fsPromises.readdir(dirPath);
+          for (const file of files) {
+            const fullPath = path.join(dirPath, file);
+            const stat = await _fsPromises.stat(fullPath);
+            if (stat.isDirectory()) {
+              await checkDir(fullPath, `${relativePath}${file}/`);
+            } else if (file.endsWith('.yml') || file.endsWith('.yaml')) {
+              // 只检查渲染引擎生成的文件
+              if (generatedPrefixes.some(p => file.startsWith(p))) {
+                const content = await _fsPromises.readFile(fullPath, 'utf-8');
+                if (this.validateYamlSyntax(content)) {
+                  this.log('SYNTAX', `YAML语法正确: ${relativePath}${file}`, 'PASS');
+                } else {
+                  this.log('SYNTAX', `YAML语法错误: ${relativePath}${file}`, 'FAIL');
+                }
+              }
+            }
+          }
+        };
+        await checkDir(rulesDir);
+      }
+
+      // 检查Markdown语法（基本检查）
+      const agentsPath = path.join(this.baseDir, 'AGENTS.md');
+      const claudePath = path.join(this.baseDir, 'CLAUDE.md');
+
+      if (await _fsPromises.pathExists(agentsPath)) {
+        const content = await _fsPromises.readFile(agentsPath, 'utf-8');
+        if (content.includes('# AGENTS.md') && content.length > 100) {
+          this.log('SYNTAX', 'AGENTS.md 格式正确', 'PASS');
+        } else {
+          this.log('SYNTAX', 'AGENTS.md 格式异常', 'FAIL');
+        }
+      }
+
+      if (await _fsPromises.pathExists(claudePath)) {
+        const content = await _fsPromises.readFile(claudePath, 'utf-8');
+        if (content.includes('# CLAUDE.md') && content.length > 100) {
+          this.log('SYNTAX', 'CLAUDE.md 格式正确', 'PASS');
+        } else {
+          this.log('SYNTAX', 'CLAUDE.md 格式异常', 'FAIL');
+        }
+      }
+
+    } catch (e) {
+      this.log('SYNTAX', `语法校验失败: ${e.message}`, 'FAIL');
+    }
+  }
+
+  /**
+   * 校验2：目录层级校验
+   */
+  async verifyDirectoryHierarchy() {
+    console.log('\n========== 校验2: 目录层级校验 ==========');
+
+    try {
+      const rulesDir = path.join(this.baseDir, '.trae', 'rules');
+
+      // 检查顶级目录
+      if (await _fsPromises.pathExists(rulesDir)) {
+        this.log('HIERARCHY', '.trae/rules 目录存在', 'PASS');
+      } else {
+        this.log('HIERARCHY', '.trae/rules 目录不存在', 'FAIL');
+        return;
+      }
+
+      // 检查L1/L2/L3层级
+      const l1Dir = path.join(rulesDir, 'L1');
+      const l2Dir = path.join(rulesDir, 'L2');
+      const l3Dir = path.join(rulesDir, 'L3');
+
+      if (await _fsPromises.pathExists(l1Dir)) {
+        this.log('HIERARCHY', 'L1 目录存在', 'PASS');
+      } else {
+        this.log('HIERARCHY', 'L1 目录不存在', 'FAIL');
+      }
+
+      if (await _fsPromises.pathExists(l2Dir)) {
+        this.log('HIERARCHY', 'L2 目录存在', 'PASS');
+      } else {
+        this.log('HIERARCHY', 'L2 目录不存在', 'FAIL');
+      }
+
+      if (await _fsPromises.pathExists(l3Dir)) {
+        this.log('HIERARCHY', 'L3 目录存在', 'PASS');
+      } else {
+        this.log('HIERARCHY', 'L3 目录不存在', 'FAIL');
+      }
+
+      // 检查L3子目录递归（如RZero模块目录）
+      const l3Contents = await _fsPromises.readdir(l3Dir);
+      for (const item of l3Contents) {
+        const itemPath = path.join(l3Dir, item);
+        const stat = await _fsPromises.stat(itemPath);
+        if (stat.isDirectory()) {
+          this.log('HIERARCHY', `L3 子目录存在: ${item}`, 'PASS');
+        }
+      }
+
+    } catch (e) {
+      this.log('HIERARCHY', `目录层级校验失败: ${e.message}`, 'FAIL');
+    }
+  }
+
+  /**
+   * 校验3：优先级合规校验
+   */
+  async verifyPriorityCompliance() {
+    console.log('\n========== 校验3: 优先级合规校验 ==========');
+
+    try {
+      // 检查优先级：AGENTS.md > CLAUDE.md > .trae/rules
+      const agentsPath = path.join(this.baseDir, 'AGENTS.md');
+      const claudePath = path.join(this.baseDir, 'CLAUDE.md');
+      const rulesDir = path.join(this.baseDir, '.trae', 'rules');
+
+      const agentsExists = await _fsPromises.pathExists(agentsPath);
+      const claudeExists = await _fsPromises.pathExists(claudePath);
+      const rulesExists = await _fsPromises.pathExists(rulesDir);
+
+      // 校验1：AGENTS.md必须存在（最高优先级）
+      if (agentsExists) {
+        this.log('PRIORITY', 'AGENTS.md 存在（最高优先级）', 'PASS');
+      } else {
+        this.log('PRIORITY', 'AGENTS.md 不存在（违反最高优先级要求）', 'FAIL');
+      }
+
+      // 校验2：CLAUDE.md必须存在
+      if (claudeExists) {
+        this.log('PRIORITY', 'CLAUDE.md 存在（次优先级）', 'PASS');
+      } else {
+        this.log('PRIORITY', 'CLAUDE.md 不存在', 'FAIL');
+      }
+
+      // 校验3：.trae/rules目录必须存在（最低优先级）
+      if (rulesExists) {
+        this.log('PRIORITY', '.trae/rules 存在（最低优先级）', 'PASS');
+      } else {
+        this.log('PRIORITY', '.trae/rules 不存在', 'FAIL');
+      }
+
+      // 校验4：优先级顺序文档必须在CLAUDE.md中体现
+      if (claudeExists) {
+        const claudeContent = await _fsPromises.readFile(claudePath, 'utf-8');
+        if (claudeContent.includes('AGENTS.md') &&
+            claudeContent.includes('CLAUDE.md') &&
+            claudeContent.includes('.trae/rules')) {
+          this.log('PRIORITY', 'CLAUDE.md 包含优先级顺序说明', 'PASS');
+        } else {
+          this.log('PRIORITY', 'CLAUDE.md 缺少优先级顺序说明', 'FAIL');
+        }
+      }
+
+    } catch (e) {
+      this.log('PRIORITY', `优先级校验失败: ${e.message}`, 'FAIL');
+    }
+  }
+
+  /**
+   * 执行全部校验
+   */
+  async verifyAll() {
+    console.log('===========================================');
+    console.log('   Render Engine Verification');
+    console.log('===========================================');
+
+    await this.verifySyntax();
+    await this.verifyDirectoryHierarchy();
+    await this.verifyPriorityCompliance();
+
+    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);
+    }
+  }
+}
+
+// CLI入口
+if (require.main === module) {
+  const verifier = new RenderVerify();
+  verifier.verifyAll();
+}
+
+module.exports = { RenderVerify };

package/detector/render-engine/rule-render.js

@@ -0,0 +1,231 @@
+/**
+ * Rule Render - 规则文件渲染器
+ * 生成标准YAML格式规则文件
+ */
+
+class RuleRender {
+  constructor() {
+    this.indent = '  ';
+  }
+
+  /**
+   * 渲染单条规则为YAML
+   */
+  renderRule(rule, level) {
+    const doc = {
+      id: rule.id || `rule-${Date.now()}`,
+      name: rule.name || 'Unnamed Rule',
+      level: level,
+      version: '1.0.0',
+      enabled: true,
+      description: rule.description || `Generated rule: ${rule.name}`,
+      priority: this.getPriorityByLevel(level),
+      rules: this.generateRuleContent(rule, level)
+    };
+
+    // 根据level添加特定配置
+    if (level === 'L1') {
+      doc.scope = 'global';
+      doc.appliesTo = ['all'];
+    } else if (level === 'L2') {
+      doc.scope = 'project';
+      doc.appliesTo = [rule.projectPattern || '*'];
+    } else if (level === 'L3') {
+      doc.scope = 'module';
+      doc.module = rule.module || 'default';
+    }
+
+    return this.toYaml(doc, 0);
+  }
+
+  /**
+   * 简单YAML生成器
+   */
+  toYaml(obj, depth) {
+    const indentStr = this.indent.repeat(depth);
+    let result = '';
+
+    for (const [key, value] of Object.entries(obj)) {
+      if (value === null || value === undefined) continue;
+
+      if (typeof value === 'object' && !Array.isArray(value)) {
+        result += `${indentStr}${key}:\n`;
+        result += this.toYaml(value, depth + 1);
+      } else if (Array.isArray(value)) {
+        if (value.length === 0) {
+          result += `${indentStr}${key}: []\n`;
+        } else {
+          result += `${indentStr}${key}:\n`;
+          for (const item of value) {
+            if (typeof item === 'object') {
+              result += `${indentStr}${this.indent}- \n`;
+              result += this.toYaml(item, depth + 2);
+            } else {
+              result += `${indentStr}${this.indent}- ${item}\n`;
+            }
+          }
+        }
+      } else if (typeof value === 'string') {
+        // 处理可能包含特殊字符的字符串
+        if (value.includes('\n') || value.includes(':') || value.includes('#')) {
+          result += `${indentStr}${key}: |-\n`;
+          for (const line of value.split('\n')) {
+            result += `${indentStr}${this.indent}${line}\n`;
+          }
+        } else {
+          result += `${indentStr}${key}: ${value}\n`;
+        }
+      } else if (typeof value === 'boolean') {
+        result += `${indentStr}${key}: ${value}\n`;
+      } else if (typeof value === 'number') {
+        result += `${indentStr}${key}: ${value}\n`;
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * 根据level获取优先级
+   */
+  getPriorityByLevel(level) {
+    const priorities = {
+      'L1': 100,  // 最高优先级
+      'L2': 80,
+      'L3': 60,
+      'custom': 40
+    };
+    return priorities[level] || 50;
+  }
+
+  /**
+   * 生成规则内容
+   */
+  generateRuleContent(rule, level) {
+    const baseRules = [];
+
+    // 基础规则
+    baseRules.push({
+      name: 'base-rule',
+      description: rule.description || `Base rule for ${rule.name}`,
+      action: 'enforce',
+      conditions: this.generateConditions(rule),
+      effects: this.generateEffects(rule)
+    });
+
+    // 根据level添加特定规则
+    if (level === 'L1') {
+      baseRules.push(this.generateGlobalConstraints(rule));
+    } else if (level === 'L2') {
+      baseRules.push(this.generateProjectConstraints(rule));
+    } else if (level === 'L3') {
+      baseRules.push(this.generateModuleConstraints(rule));
+    }
+
+    return baseRules;
+  }
+
+  /**
+   * 生成条件
+   */
+  generateConditions(rule) {
+    return {
+      fileTypes: rule.techStackMatch || ['*'],
+      projectSize: rule.complexity || 'medium',
+      dependencies: rule.dependencies || []
+    };
+  }
+
+  /**
+   * 生成效果
+   */
+  generateEffects(rule) {
+    return {
+      output: 'enforced',
+      logging: true,
+      blocking: rule.level === 'L1'  // L1规则阻塞执行
+    };
+  }
+
+  /**
+   * 生成全局约束（L1）
+   */
+  generateGlobalConstraints(rule) {
+    return {
+      name: 'global-constraints',
+      description: '全局行为约束',
+      action: 'enforce',
+      constraints: {
+        codeStyle: {
+          formatter: 'prettier',
+          eslint: 'strict'
+        },
+        security: {
+          noHardcodedCredentials: true,
+          useEnvironmentVariables: true
+        },
+        quality: {
+          maxComplexity: 15,
+          minTestCoverage: 0.8
+        }
+      }
+    };
+  }
+
+  /**
+   * 生成项目约束（L2）
+   */
+  generateProjectConstraints(rule) {
+    return {
+      name: 'project-constraints',
+      description: '项目特定约束',
+      action: 'enforce',
+      constraints: {
+        projectStructure: {
+          srcDirectory: 'src',
+          testDirectory: 'test',
+          docsDirectory: 'docs'
+        },
+        naming: {
+          files: 'kebab-case',
+          classes: 'PascalCase',
+          functions: 'camelCase'
+        },
+        techStack: rule.techStackMatch || []
+      }
+    };
+  }
+
+  /**
+   * 生成模块约束（L3）
+   */
+  generateModuleConstraints(rule) {
+    return {
+      name: 'module-constraints',
+      description: `模块 ${rule.module || 'default'} 特定约束`,
+      action: 'enforce',
+      constraints: {
+        module: rule.module || 'default',
+        dependencies: rule.dependencies || [],
+        patterns: rule.patterns || []
+      }
+    };
+  }
+
+  /**
+   * 批量渲染规则
+   */
+  renderRulesBatch(rules, level) {
+    const results = [];
+    for (const rule of rules) {
+      results.push({
+        level,
+        id: rule.id,
+        content: this.renderRule(rule, level)
+      });
+    }
+    return results;
+  }
+}
+
+module.exports = { RuleRender };