pdd-skills 3.0.0

package/package.json

@@ -0,0 +1 @@
+{"name": "pdd-skills", "version": "3.0.0", "description": "PRD Driven Development Skills - AI原生软件开发工作流", "type": "module", "main": "index.js", "bin": {"pdd": "./bin/pdd.js", "pdd-skills": "./bin/pdd.js"}, "files": ["bin/", "lib/", "skills/", "templates/", "scripts/", "config/", "hooks/", "index.js"], "scripts": {"start": "node bin/pdd.js", "list": "node bin/pdd.js list", "lint": "node bin/pdd.js linter --type code prd sql activiti", "generate": "node bin/pdd.js generate", "verify": "node bin/pdd.js verify", "report": "node bin/pdd.js report", "config": "node bin/pdd.js config --list", "api": "node bin/pdd.js api", "api:dev": "node bin/pdd.js api -p 3000 --cors", "init": "node bin/pdd.js init", "update": "node bin/pdd.js update", "cso": "node bin/pdd.js cso", "eval": "node bin/pdd.js eval", "token": "node bin/pdd.js token", "i18n": "node bin/pdd.js i18n"}, "keywords": ["pdd", "prd-driven-development", "ai", "claude", "skills", "tdd", "code-generation", "linter", "api-server", "cli"], "author": "PDD Team", "license": "MIT", "engines": {"node": ">=18.0.0"}, "dependencies": {"commander": "^12.0.0", "chalk": "^5.3.0", "fs-extra": "^11.2.0", "yaml": "^2.3.0"}}

package/scripts/cso-analyzer.js

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const SKILLS_ROOT = path.join(__dirname, '..', 'skills');
+
+const CSO_RULES = {
+  description: {
+    minLength: 20,
+    maxLength: 200,
+    mustContain: ['trigger', 'invoke', 'call', 'when', '触发', '调用', '当用户'],
+    shouldAvoid: ['very', 'really', 'basically', 'stuff', 'things', 'etc']
+  },
+  triggers: {
+    minCount: 3,
+    maxCount: 8,
+    avoidGeneric: ['help', 'do', 'make', 'create', 'fix', 'check', 'run']
+  }
+};
+
+export async function analyzeSkillCSO(skillDir) {
+  const skillMd = path.join(skillDir, 'SKILL.md');
+  const metaJson = path.join(skillDir, '_meta.json');
+
+  if (!fs.existsSync(skillMd)) return { error: 'SKILL.md not found' };
+
+  const content = fs.readFileSync(skillMd, 'utf-8');
+  let meta = {};
+  if (fs.existsSync(metaJson)) {
+    try { meta = JSON.parse(fs.readFileSync(metaJson, 'utf-8')); } catch {}
+  }
+
+  const issues = [];
+  const scores = { description: 0, triggers: 0, overall: 0 };
+  const suggestions = [];
+
+  const descMatch = content.match(/^description:\s*(.+)$/m);
+  let description = '';
+  if (descMatch) {
+    const raw = descMatch[1].trim();
+    if (raw === '|' || raw === '>') {
+      const lines = content.split('\n');
+      const descLineIdx = lines.findIndex(l => l.startsWith('description:'));
+      if (descLineIdx >= 0) {
+        const mlLines = [];
+        for (let i = descLineIdx + 1; i < lines.length; i++) {
+          if (lines[i].match(/^[a-zA-Z_-]+:/) || (!lines[i].startsWith(' ') && !lines[i].startsWith('\t') && lines[i].trim() !== '')) break;
+          mlLines.push(lines[i].trim());
+        }
+        description = mlLines.join(' ');
+      }
+    } else {
+      description = raw.replace(/^["']|["']$/g, '');
+    }
+  }
+  if (!description) description = meta.description || '';
+
+  if (!description) {
+    issues.push({ level: 'error', rule: 'CSO-D001', message: '缺少description字段' });
+  } else {
+    if (description.length < CSO_RULES.description.minLength) {
+      issues.push({ level: 'warn', rule: 'CSO-D002', message: `description过短(${description.length}字)，建议至少${CSO_RULES.description.minLength}字` });
+      scores.description -= 20;
+    } else {
+      scores.description += 30;
+    }
+
+    if (description.length > CSO_RULES.description.maxLength) {
+      issues.push({ level: 'warn', rule: 'CSO-D003', message: `description过长(${description.length}字)，建议不超过${CSO_RULES.description.maxLength}字` });
+      scores.description -= 10;
+    }
+
+    const hasTriggerWords = CSO_RULES.description.mustContain.some(w =>
+      description.toLowerCase().includes(w.toLowerCase())
+    );
+    if (!hasTriggerWords) {
+      issues.push({ level: 'warn', rule: 'CSO-D004', message: 'description缺少触发词(when/invoke/call/trigger等)' });
+      scores.description -= 15;
+    } else {
+      scores.description += 20;
+    }
+
+    const vagueWords = CSO_RULES.description.shouldAvoid.filter(w =>
+      new RegExp(`\\b${w}\\b`, 'i').test(description)
+    );
+    if (vagueWords.length > 0) {
+      issues.push({ level: 'info', rule: 'CSO-D005', message: `检测到模糊词汇: ${vagueWords.join(', ')}` });
+      scores.description -= vagueWords.length * 5;
+    }
+  }
+
+  const triggers = meta.triggers || [];
+  const allTriggers = [...triggers];
+
+  if (allTriggers.length === 0) {
+    issues.push({ level: 'warn', rule: 'CSO-T001', message: '未定义触发词(triggers)' });
+  } else {
+    if (allTriggers.length < CSO_RULES.triggers.minCount) {
+      issues.push({ level: 'warn', rule: 'CSO-T002', message: `触发词数量不足(${allTriggers.length})，建议至少${CSO_RULES.triggers.minCount}个` });
+    } else {
+      scores.triggers += 25;
+    }
+
+    if (allTriggers.length > CSO_RULES.triggers.maxCount) {
+      issues.push({ level: 'info', rule: 'CSO-T003', message: `触发词过多(${allTriggers.length})，可能降低精确度` });
+    }
+
+    const genericTriggers = allTriggers.filter(t =>
+      CSO_RULES.triggers.avoidGeneric.includes(t.toLowerCase())
+    );
+    if (genericTriggers.length > 0) {
+      issues.push({ level: 'warn', rule: 'CSO-T004', message: `触发词过于通用: ${genericTriggers.join(', ')}` });
+      scores.triggers -= genericTriggers.length * 8;
+    }
+
+    const specificTriggers = allTriggers.filter(t => t.length >= 4);
+    if (specificTriggers.length > 0) {
+      scores.triggers += Math.min(specificTriggers.length * 5, 25);
+    }
+  }
+
+  scores.overall = Math.max(0, Math.min(100, (scores.description + scores.triggers) / 2));
+
+  return {
+    skillName: path.basename(skillDir),
+    description: description.substring(0, 100),
+    triggers: allTriggers,
+    scores,
+    score: scores.overall,
+    grade: scores.overall >= 80 ? 'A' : scores.overall >= 60 ? 'B' : scores.overall >= 40 ? 'C' : 'D',
+    issues,
+    suggestions
+  };
+}
+
+export async function analyzeAllSkills(category) {
+  const categories = category ? [category] : ['core', 'entropy', 'expert', 'openspec', 'pr'];
+  const results = [];
+
+  for (const cat of categories) {
+    const catPath = path.join(SKILLS_ROOT, cat);
+    if (!fs.existsSync(catPath)) continue;
+
+    const entries = fs.readdirSync(catPath).filter(f => {
+      const p = path.join(catPath, f);
+      return fs.statSync(p).isDirectory();
+    });
+
+    for (const entry of entries) {
+      const result = await analyzeSkillCSO(path.join(catPath, entry));
+      results.push(result);
+    }
+  }
+
+  return results;
+}
+
+export function printCSOReport(results) {
+  const avgScore = results.reduce((s, r) => s + r.score, 0) / results.length;
+  const gradeDist = { A: 0, B: 0, C: 0, D: 0 };
+  results.forEach(r => gradeDist[r.grade]++);
+
+  console.log('\n📊 CSO (Claude Search Optimization) 分析报告\n');
+  console.log(`  总技能数: ${results.length}`);
+  console.log(`  平均分: ${avgScore.toFixed(1)}/100`);
+  console.log(`  等级分布: A:${gradeDist.A} B:${gradeDist.B} C:${gradeDist.C} D:${gradeDist.D}\n`);
+
+  const sorted = [...results].sort((a, b) => a.score - b.score);
+
+  console.log('  ┌────────────────────────┬───────┬────────┬──────────┐');
+  console.log('  │ 技能名称               │ 等级  │ 分数   │ 问题数   │');
+  console.log('  ├────────────────────────┼───────┼────────┼──────────┤');
+
+  for (const r of sorted) {
+    const icon = r.grade === 'A' ? '🟢' : r.grade === 'B' ? '🟡' : r.grade === 'C' ? '🟠' : '🔴';
+    const name = r.skillName.padEnd(24).substring(0, 24);
+    console.log(`  │ ${icon} ${name} │  ${r.grade}  │ ${r.score.toString().padStart(5)} │ ${r.issues.length.toString().padStart(6)} │`);
+  }
+
+  console.log('  └────────────────────────┴───────┴────────┴──────────┘');
+
+  if (results.some(r => r.issues.length > 0)) {
+    console.log('\n  主要问题:');
+    const allIssues = results.flatMap(r => r.issues.map(i => ({ ...i, skill: r.skillName })));
+    const byRule = {};
+    for (const issue of allIssues) {
+      byRule[issue.rule] = (byRule[issue.rule] || 0) + 1;
+    }
+    Object.entries(byRule)
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 10)
+      .forEach(([rule, count]) => {
+        console.log(`    ${rule}: ${count}次`);
+      });
+  }
+}

package/scripts/eval-runner.js

@@ -0,0 +1,359 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const SKILLS_ROOT = path.join(__dirname, '..', 'skills');
+
+const EVAL_RESULT = {
+  PASS: 'pass',
+  FAIL: 'fail',
+  SKIP: 'skip',
+  ERROR: 'error'
+};
+
+export async function runEvals(options = {}) {
+  const skillName = options.skill;
+  const category = options.category;
+  const verbose = options.verbose || false;
+
+  console.log(chalk.blue.bold('\n🧪 PDD Evals - 技能评估测试\n'));
+
+  const targets = findEvalTargets(skillName, category);
+
+  if (targets.length === 0) {
+    console.log(chalk.yellow('  未找到可测试的目标'));
+    return;
+  }
+
+  const results = [];
+
+  for (const target of targets) {
+    const result = await runSkillEvals(target, verbose);
+    results.push(result);
+    printSkillResult(result, verbose);
+  }
+
+  printSummary(results);
+  return results;
+}
+
+function findEvalTargets(skillName, category) {
+  if (skillName) {
+    for (const cat of ['core', 'entropy', 'expert', 'openspec', 'pr']) {
+      const p = path.join(SKILLS_ROOT, cat, skillName);
+      if (fs.existsSync(p)) return [{ name: skillName, path: p }];
+    }
+    return [];
+  }
+
+  if (category) {
+    const catPath = path.join(SKILLS_ROOT, category);
+    if (!fs.existsSync(catPath)) return [];
+    return fs.readdirSync(catPath)
+      .filter(f => fs.statSync(path.join(catPath, f)).isDirectory())
+      .map(f => ({ name: f, path: path.join(catPath, f) }));
+  }
+
+  const all = [];
+  for (const cat of ['core', 'entropy', 'expert']) {
+    const catPath = path.join(SKILLS_ROOT, cat);
+    if (!fs.existsSync(catPath)) continue;
+    for (const entry of fs.readdirSync(catPath).filter(f =>
+      fs.statSync(path.join(catPath, f)).isDirectory()
+    )) {
+      all.push({ name: entry, path: path.join(catPath, entry) });
+    }
+  }
+  return all;
+}
+
+async function runSkillEvals(target, verbose) {
+  const start = Date.now();
+  const evalDir = path.join(target.path, 'evals');
+  const testCases = loadTestCases(evalDir);
+
+  const skillResult = {
+    skill: target.name,
+    totalTests: 0,
+    passed: 0,
+    failed: 0,
+    skipped: 0,
+    errors: 0,
+    duration: 0,
+    cases: []
+  };
+
+  if (testCases.length === 0) {
+    skillResult.totalTests = 1;
+    skillResult.skipped = 1;
+    skillResult.cases.push({
+      name: 'evals-not-found',
+      status: EVAL_RESULT.SKIP,
+      message: '该技能暂无evals定义',
+      duration: 0
+    });
+    skillResult.duration = Date.now() - start;
+    return skillResult;
+  }
+
+  for (const tc of testCases) {
+    const caseStart = Date.now();
+    try {
+      const result = await executeTestCase(tc, target.path);
+      const caseDuration = Date.now() - caseStart;
+
+      skillResult.totalTests++;
+      skillResult.cases.push({
+        name: tc.name,
+        status: result.pass ? EVAL_RESULT.PASS : EVAL_RESULT.FAIL,
+        message: result.message,
+        details: result.details,
+        duration: caseDuration
+      });
+
+      if (result.pass) skillResult.passed++;
+      else skillResult.failed++;
+
+    } catch (e) {
+      skillResult.totalTests++;
+      skillResult.errors++;
+      skillResult.cases.push({
+        name: tc.name,
+        status: EVAL_RESULT.ERROR,
+        message: e.message,
+        duration: Date.now() - caseStart
+      });
+    }
+  }
+
+  skillResult.duration = Date.now() - start;
+  return skillResult;
+}
+
+function loadTestCases(evalDir) {
+  if (!fs.existsSync(evalDir)) return [];
+
+  const cases = [];
+  const files = fs.readdirSync(evalDir).filter(f => f.endsWith('.json'));
+
+  for (const file of files) {
+    try {
+      const content = JSON.parse(fs.readFileSync(path.join(evalDir, file), 'utf-8'));
+      if (Array.isArray(content)) {
+        cases.push(...content.map(c => ({ ...c, _source: file })));
+      } else if (content.name && content.expect) {
+        cases.push({ ...content, _source: file });
+      }
+    } catch {}
+  }
+
+  return cases.length > 0 ? cases : getDefaultTestCases();
+}
+
+function getDefaultTestCases() {
+  return [
+    {
+      name: 'SKILL.md-exists',
+      description: '技能文件存在且格式正确',
+      type: 'structure',
+      expect: { exists: true, hasDescription: true, hasIronLaw: false },
+      check: (skillPath) => {
+        const mdPath = path.join(skillPath, 'SKILL.md');
+        if (!fs.existsSync(mdPath)) return { pass: false, message: 'SKILL.md不存在' };
+        const content = fs.readFileSync(mdPath, 'utf-8');
+        const hasDesc = /^description:/m.test(content);
+        const hasIronLaw = /##\s*Iron\s*Law/mi.test(content);
+        return {
+          pass: hasDesc,
+          message: hasDesc ? 'description字段存在' : '缺少description字段',
+          details: { hasDescription: hasDesc, hasIronLaw: hasIronLaw }
+        };
+      }
+    },
+    {
+      name: '_meta.json-valid',
+      description: '元数据文件格式正确',
+      type: 'structure',
+      expect: { exists: true, hasTriggers: true },
+      check: (skillPath) => {
+        const metaPath = path.join(skillPath, '_meta.json');
+        if (!fs.existsSync(metaPath)) return { pass: false, message: '_meta.json不存在' };
+        try {
+          const meta = JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
+          const valid = meta.name && meta.version;
+          const hasTriggers = Array.isArray(meta.triggers) && meta.triggers.length > 0;
+          return {
+            pass: valid,
+            message: valid ? '元数据格式正确' : '元数据缺少必要字段',
+            details: { name: !!meta.name, version: !!meta.version, triggersCount: meta.triggers?.length || 0 }
+          };
+        } catch (e) {
+          return { pass: false, message: `JSON解析失败: ${e.message}` };
+        }
+      }
+    },
+    {
+      name: 'triggers-effective',
+      description: '触发词有效且不冲突',
+      type: 'cso',
+      expect: { minTriggers: 3, maxGeneric: 1 },
+      check: (skillPath) => {
+        const metaPath = path.join(skillPath, '_meta.json');
+        if (!fs.existsSync(metaPath)) return { pass: false, skip: true, message: '无_meta.json' };
+        const meta = JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
+        const triggers = meta.triggers || [];
+        const generic = ['help', 'do', 'make', 'create'].filter(t =>
+          triggers.includes(t)
+        );
+        return {
+          pass: triggers.length >= 3 && generic.length === 0,
+          message: `${triggers.length}个触发词${generic.length > 0 ? `, ${generic.length}个过于通用` : ''}`,
+          details: { triggerCount: triggers.length, genericTriggers: generic }
+        };
+      }
+    },
+    {
+      name: 'behavior-shaping-complete',
+      description: '行为塑造章节完整(Iron Law + Rationalization + Red Flags)',
+      type: 'quality',
+      expect: { ironLaw: true, rationalization: true, redFlags: true },
+      check: (skillPath) => {
+        const mdPath = path.join(skillPath, 'SKILL.md');
+        if (!fs.existsSync(mdPath)) return { pass: false, message: 'SKILL.md不存在' };
+        const content = fs.readFileSync(mdPath, 'utf-8');
+        const hasIronLaw = /##\s*Iron\s*Law/mi.test(content);
+        const hasRationalization = /##\s*Rationalization/mi.test(content);
+        const hasRedFlags = /##\s*Red\s*Flags/mi.test(content);
+        const allPresent = hasIronLaw && hasRationalization && hasRedFlags;
+        return {
+          pass: allPresent,
+          message: allPresent ? '行为塑造完整' : `缺少: ${[
+            !hasIronLaw ? 'Iron Law' : null,
+            !hasRationalization ? 'Rationalization Table' : null,
+            !hasRedFlags ? 'Red Flags' : null
+          ].filter(Boolean).join(', ')}`,
+          details: { ironLaw: hasIronLaw, rationalization: hasRationalization, redFlags: hasRedFlags }
+        };
+      }
+    }
+  ];
+}
+
+async function executeTestCase(tc, skillPath) {
+  if (typeof tc.check === 'function') {
+    return tc.check(skillPath);
+  }
+
+  if (tc.type === 'structure') {
+    return runStructureCheck(tc, skillPath);
+  }
+
+  if (tc.type === 'content') {
+    return runContentCheck(tc, skillPath);
+  }
+
+  return { pass: true, message: `未实现的测试类型: ${tc.type}` };
+}
+
+function runStructureCheck(tc, skillPath) {
+  const checks = tc.checks || {};
+  const results = {};
+  let allPass = true;
+
+  for (const [key, expected] of Object.entries(checks)) {
+    switch (key) {
+      case 'file_exists': {
+        const p = path.join(skillPath, expected);
+        results[key] = fs.existsSync(p);
+        break;
+      }
+      case 'dir_exists': {
+        const d = path.join(skillPath, expected);
+        results[key] = fs.existsSync(d) && fs.statSync(d).isDirectory();
+        break;
+      }
+      default:
+        results[key] = null;
+    }
+    if (results[key] === false) allPass = false;
+  }
+
+  return {
+    pass: allPass,
+    message: allPass ? '结构检查通过' : Object.entries(results).filter(([, v]) => v === false).map(([k]) => `${k}失败`).join(', '),
+    details: results
+  };
+}
+
+function runContentCheck(tc, skillPath) {
+  const filePath = tc.file ? path.join(skillPath, tc.file) : path.join(skillPath, 'SKILL.md');
+
+  if (!fs.existsSync(filePath)) {
+    return { pass: false, message: `文件不存在: ${tc.file || 'SKILL.md'}` };
+  }
+
+  const content = fs.readFileSync(filePath, 'utf-8');
+  let matchCount = 0;
+  let totalPatterns = 0;
+
+  if (tc.contains) {
+    const patterns = Array.isArray(tc.contains) ? tc.contains : [tc.contains];
+    totalPatterns = patterns.length;
+    for (const pattern of patterns) {
+      if (new RegExp(pattern, tc.flags || 'i').test(content)) matchCount++;
+    }
+  }
+
+  if (tc.notContains) {
+    const npatterns = Array.isArray(tc.notContains) ? tc.notContains : [tc.notContains];
+    for (const pattern of npatterns) {
+      if (new RegExp(pattern, tc.flags || 'i').test(content)) {
+        return { pass: false, message: `不应包含: ${pattern}` };
+      }
+    }
+  }
+
+  const requiredMatches = tc.minMatches || 1;
+  return {
+    pass: matchCount >= requiredMatches,
+    message: matchCount >= requiredMatches
+      ? `内容匹配通过 (${matchCount}/${totalPatterns || '?'})`
+      : `匹配不足 (${matchCount}/${requiredMatches})`,
+    details: { matchCount, requiredMatches }
+  };
+}
+
+function printSkillResult(result, verbose) {
+  const icon = result.failed === 0 && result.errors === 0
+    ? chalk.green('✅')
+    : result.errors > 0
+      ? chalk.red('💥')
+      : chalk.yellow('⚠️');
+
+  console.log(`  ${icon} ${result.skill} (${result.passed}/${result.totalTests}) [${result.duration}ms]`);
+
+  if (verbose) {
+    for (const c of result.cases) {
+      const ci = c.status === EVAL_RESULT.PASS ? chalk.green('✓')
+        : c.status === EVAL_RESULT.FAIL ? chalk.red('✗')
+          : c.status === EVAL_RESULT.ERROR ? chalk.red('💥') : chalk.gray('·');
+      console.log(`    ${ci} ${c.name}${c.message ? ` — ${c.message}` : ''}`);
+    }
+  }
+}
+
+function printSummary(results) {
+  const total = results.reduce((s, r) => s + r.totalTests, 0);
+  const passed = results.reduce((s, r) => s + r.passed, 0);
+  const failed = results.reduce((s, r) => s + r.failed, 0);
+  const errors = results.reduce((s, r) => s + r.errors, 0);
+  const skipped = results.reduce((s, r) => s + r.skipped, 0);
+  const duration = results.reduce((s, r) => s + r.duration, 0);
+
+  console.log(chalk.bold('\n━━━ Eval Summary ━━━'));
+  console.log(`  总测试: ${total} | 通过: ${chalk.green(passed.toString())} | 失败: ${chalk.red(failed.toString())} | 错误: ${chalk.red(errors.toString())} | 跳过: ${skipped}`);
+  console.log(`  总耗时: ${duration}ms`);
+  console.log(`  通过率: ${total > 0 ? ((passed / total) * 100).toFixed(1) : 0}%`);
+}

package/scripts/i18n-checker.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const SKILLS_ROOT = path.join(__dirname, '..', 'skills');
+
+const I18N_RULES = {
+  meta: {
+    hasZhDescription: { desc: '_meta.json description contains zh field', check: (m) => m.description && (m.description.includes('zh:') || /[\u4e00-\u9fa5]/.test(m.description)) },
+    hasEnDescription: { desc: '_meta.json description contains en content', check: (m) => m.description && /[a-zA-Z]{10,}/.test(m.description) },
+    minZhTriggers: { desc: 'At least 3 Chinese triggers', minCount: 3, pattern: /[\u4e00-\u9fa5]/ },
+    minEnTriggers: { desc: 'At least 3 English triggers', minCount: 3, pattern: /^[a-zA-Z\s-]{3,}$/ }
+  },
+  skillMd: {
+    hasCnSection: { desc: 'SKILL.md contains ## 🇨🇳 section', pattern: /##\s*🇨🇳/ },
+    hasEnSection: { desc: 'SKILL.md contains ## 🇺🇸 section', pattern: /##\s*🇺🇸/ },
+    hasBilingualIronLaw: { desc: 'Iron Law has bilingual content', pattern: /Iron Law.*铁律|铁律.*Iron Law|🇺🇸/s },
+    hasBilingualRedFlags: { desc: 'Red Flags have bilingual content', pattern: /Red Flags.*[红旗警告三层防御]|🇺🇸.*Red Flag|Layer \d:.*Guards/s }
+  }
+};
+
+export async function analyzeI18N(skillDir) {
+  const name = path.basename(skillDir);
+  const metaPath = path.join(skillDir, '_meta.json');
+  const skillPath = path.join(skillDir, 'SKILL.md');
+  
+  const result = { name, score: 0, maxScore: 100, issues: [], checks: {} };
+  
+  if (!fs.existsSync(metaPath)) { result.issues.push({ rule: 'META-001', msg: '_meta.json missing' }); return result; }
+  if (!fs.existsSync(skillPath)) { result.issues.push({ rule: 'SKILL-001', msg: 'SKILL.md missing' }); return result; }
+  
+  const meta = JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
+  const content = fs.readFileSync(skillPath, 'utf-8');
+  
+  // Meta checks (50 points)
+  let metaScore = 0;
+  if (I18N_RULES.meta.hasZhDescription.check(meta)) { metaScore += 15; result.checks.zhDesc = true; } else { result.issues.push({ rule: 'META-ZH', msg: 'No Chinese in description' }); }
+  if (I18N_RULES.meta.hasEnDescription.check(meta)) { metaScore += 15; result.checks.enDesc = true; } else { result.issues.push({ rule: 'META-EN', msg: 'No English in description' }); }
+  
+  const zhTriggers = (meta.triggers || []).filter(t => I18N_RULES.meta.minZhTriggers.pattern.test(t)).length;
+  const enTriggers = (meta.triggers || []).filter(t => I18N_RULES.meta.minEnTriggers.pattern.test(t)).length;
+  if (zhTriggers >= 3) { metaScore += 10; result.checks.zhTriggers = zhTriggers; } else { result.issues.push({ rule: 'META-TZ', msg: `Only ${zhTriggers} Chinese triggers (need >=3)` }); }
+  if (enTriggers >= 3) { metaScore += 10; result.checks.enTriggers = enTriggers; } else { result.issues.push({ rule: 'META-TE', msg: `Only ${enTriggers} English triggers (need >=3)` }); }
+  result.metaScore = metaScore;
+  result.score += metaScore;
+  
+  // SKILL.md checks (50 points)
+  let mdScore = 0;
+  if (I18N_RULES.skillMd.hasCnSection.pattern.test(content)) { mdScore += 15; result.checks.cnSection = true; } else { result.issues.push({ rule: 'MD-CN', msg: 'Missing ## 🇨🇳 section' }); }
+  if (I18N_RULES.skillMd.hasEnSection.pattern.test(content)) { mdScore += 15; result.checks.enSection = true; } else { result.issues.push({ rule: 'MD-EN', msg: 'Missing ## 🇺🇸 section' }); }
+  if (I18N_RULES.skillMd.hasBilingualIronLaw.pattern.test(content)) { mdScore += 10; result.checks.bilingualIL = true; } else { result.issues.push({ rule: 'MD-IL', msg: 'Iron Law not bilingual' }); }
+  if (I18N_RULES.skillMd.hasBilingualRedFlags.pattern.test(content)) { mdScore += 10; result.checks.bilingualRF = true; } else { result.issues.push({ rule: 'MD-RF', msg: 'Red Flags not bilingual' }); }
+  result.mdScore = mdScore;
+  result.score += mdScore;
+  
+  // Grade
+  if (result.score >= 90) result.grade = 'A';
+  else if (result.score >= 70) result.grade = 'B';
+  else if (result.score >= 50) result.grade = 'C';
+  else result.grade = 'D';
+  
+  return result;
+}
+
+export async function analyzeAllI18N(category) {
+  const categories = category ? [category] : ['core', 'expert', 'entropy', 'pr', 'openspec'];
+  const results = [];
+  for (const cat of categories) {
+    const catDir = path.join(SKILLS_ROOT, cat);
+    if (!fs.existsSync(catDir)) continue;
+    const skills = fs.readdirSync(catDir).filter(f => fs.statSync(path.join(catDir, f)).isDirectory());
+    for (const skill of skills) {
+      const r = await analyzeI18N(path.join(catDir, skill));
+      r.category = cat;
+      results.push(r);
+    }
+  }
+  return results;
+}
+
+export function printI18NReport(results) {
+  console.log('\n━━━ i18n Bilingual Report ━━━');
+  console.log(`  Total Skills: ${results.length}`);
+  const avg = results.reduce((s, r) => s + r.score, 0) / results.length;
+  console.log(`  Average Score: ${avg.toFixed(1)}/100`);
+  const grades = { A: 0, B: 0, C: 0, D: 0 };
+  results.forEach(r => grades[r.grade]++);
+  console.log(`  Grades: A:${grades.A} B:${grades.B} C:${grades.C} D:${grades.D}`);
+  console.log('\n' + '─'.repeat(65));
+  console.log(`  ${'Skill'.padEnd(30)} ${'Score'.padStart(6)} ${'Grade'.padStart(6)} Issues`);
+  console.log('─'.repeat(65));
+  for (const r of results.sort((a, b) => b.score - a.score)) {
+    const issues = r.issues.length > 0 ? ` (${r.issues.length})` : '';
+    console.log(`${r.name.padEnd(30)} ${String(r.score).padStart(6)} ${r.grade.padStart(6)}${issues}`);
+    if (r.issues.length > 0) {
+      for (const issue of r.issues) {
+        console.log(`    ⚠ ${issue.rule}: ${issue.msg}`);
+      }
+    }
+  }
+  if (results.some(r => r.issues.length > 0)) {
+    console.log('\n  Main Issues:');
+    const issueCounts = {};
+    results.forEach(r => r.issues.forEach(i => { issueCounts[i.rule] = (issueCounts[i.rule] || 0) + 1; }));
+    Object.entries(issueCounts).sort((a, b) => b[1] - a[1]).forEach(([k, v]) => console.log(`    ${k}: ${v}x`));
+  }
+}