规则检查 (Rule-Based Evaluation)

格式验证、内容规则、代码质量检查

2.1 格式验证

class FormatValidator {
  // 检查 JSON 格式
  validateJSON(output) {
    try {
      JSON.parse(output);
      return { valid: true };
    } catch (e) {
      return { valid: false, error: e.message };
    }
  }

  // 检查代码语法
  async validateTypeScript(code) {
    const ts = require('typescript');

    const result = ts.transpileModule(code, {
      compilerOptions: {
        module: ts.ModuleKind.ESNext,
        target: ts.ScriptTarget.ESNext,
        strict: true
      },
      reportDiagnostics: true
    });

    if (result.diagnostics.length > 0) {
      return {
        valid: false,
        errors: result.diagnostics.map(d => d.messageText)
      };
    }

    return { valid: true };
  }

  // 检查 Markdown 结构
  validateMarkdown(content, requiredSections) {
    const headings = content.match(/^#+\s+.+$/gm) || [];
    const missing = requiredSections.filter(
      section => !headings.some(h => h.toLowerCase().includes(section.toLowerCase()))
    );

    return {
      valid: missing.length === 0,
      missing
    };
  }
}

2.2 内容规则

class ContentValidator {
  constructor(rules) {
    this.rules = rules;
  }

  validate(output) {
    const results = [];

    for (const rule of this.rules) {
      switch (rule.type) {
        case 'contains':
          results.push({
            rule: rule.name,
            passed: output.includes(rule.value),
            message: `应包含 "${rule.value}"`
          });
          break;

        case 'not_contains':
          results.push({
            rule: rule.name,
            passed: !output.includes(rule.value),
            message: `不应包含 "${rule.value}"`
          });
          break;

        case 'matches':
          results.push({
            rule: rule.name,
            passed: new RegExp(rule.pattern).test(output),
            message: `应匹配模式 ${rule.pattern}`
          });
          break;

        case 'length':
          const len = output.length;
          results.push({
            rule: rule.name,
            passed: len >= rule.min && len <= rule.max,
            message: `长度应在 ${rule.min}-${rule.max} 之间,实际 ${len}`
          });
          break;
      }
    }

    return {
      allPassed: results.every(r => r.passed),
      results
    };
  }
}

// 使用示例
const validator = new ContentValidator([
  { type: 'contains', name: 'has_export', value: 'export' },
  { type: 'not_contains', name: 'no_any', value: ': any' },
  { type: 'not_contains', name: 'no_console', value: 'console.log' },
  { type: 'matches', name: 'has_types', pattern: 'interface|type' }
]);

2.3 代码质量检查

async function validateCodeQuality(code) {
  const checks = [];

  // ESLint 检查
  const eslint = new ESLint();
  const lintResults = await eslint.lintText(code, { filePath: 'test.tsx' });
  checks.push({
    name: 'eslint',
    passed: lintResults[0].errorCount === 0,
    errors: lintResults[0].messages
  });

  // TypeScript 类型检查
  const tsResult = await validateTypeScript(code);
  checks.push({
    name: 'typescript',
    passed: tsResult.valid,
    errors: tsResult.errors
  });

  // 安全检查
  const securityIssues = checkSecurityIssues(code);
  checks.push({
    name: 'security',
    passed: securityIssues.length === 0,
    issues: securityIssues
  });

  return checks;
}

function checkSecurityIssues(code) {
  const issues = [];
  const patterns = [
    { pattern: /dangerouslySetInnerHTML/g, message: '使用了 dangerouslySetInnerHTML' },
    { pattern: /eval\(/g, message: '使用了 eval' },
    { pattern: /innerHTML\s*=/g, message: '直接设置 innerHTML' },
    { pattern: /document\.write/g, message: '使用了 document.write' }
  ];

  for (const { pattern, message } of patterns) {
    if (pattern.test(code)) {
      issues.push(message);
    }
  }

  return issues;
}