pdd-skills 3.0.0

package/scripts/linter/run-linters.js

@@ -0,0 +1,285 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+import { log, findProjectRoot, loadConfig } from '../../lib/utils/logger.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const CONFIG_ROOT = path.join(__dirname, '..', '..', 'config');
+
+const LINTER_REGISTRY = {
+  code: {
+    name: 'Code Linter',
+    description: '代码质量检查 (Checkstyle/PMD/ESLint/Ruff)',
+    runners: ['checkstyle', 'pmd', 'eslint', 'ruff']
+  },
+  prd: {
+    name: 'PRD Linter',
+    description: 'PRD文档规范检查',
+    runners: ['prd']
+  },
+  sql: {
+    name: 'SQL Linter',
+    description: 'SQL脚本规范检查 (SQLFluff)',
+    runners: ['sql']
+  },
+  activiti: {
+    name: 'Activiti Linter',
+    description: 'BPMN流程文件规范检查',
+    runners: ['activiti']
+  }
+};
+
+export default async function runLinters(options = {}) {
+  const startTime = Date.now();
+  const types = options.type || ['code'];
+  const incremental = options.incremental || false;
+  const outputFormat = options.output || 'text';
+
+  console.log(chalk.blue.bold('\n🔍 PDD Linter - 代码与文档质量检查\n'));
+
+  const projectRoot = await findProjectRoot(process.cwd());
+  log('info', `项目根目录: ${projectRoot}`);
+  const config = await loadConfig(projectRoot);
+
+  if (!config.linter.enabled) {
+    console.log(chalk.yellow('⚠️  Linter未启用，请检查 .pdd/config.yaml'));
+    return;
+  }
+
+  const results = [];
+
+  for (const type of types) {
+    const linterDef = LINTER_REGISTRY[type];
+    if (!linterDef) {
+      log('warn', `未知Linter类型: ${type}, 跳过`);
+      continue;
+    }
+
+    console.log(chalk.cyan(`\n━━━ ${linterDef.name} ━━━`));
+    console.log(chalk.gray(`  ${linterDef.description}\n`));
+
+    for (const runner of linterDef.runners) {
+      try {
+        const result = await executeLinter(runner, projectRoot, config, incremental);
+        results.push(result);
+        printResult(result, outputFormat);
+      } catch (e) {
+        results.push({
+          runner,
+          type,
+          success: false,
+          error: e.message,
+          duration: 0
+        });
+        log('error', `${runner} 执行失败`, e.message);
+      }
+    }
+  }
+
+  await generateSummary(results, startTime, outputFormat);
+
+  return results;
+}
+
+async function executeLinter(runner, projectRoot, config, incremental) {
+  const start = Date.now();
+
+  switch (runner) {
+    case 'checkstyle':
+      return runCheckstyle(projectRoot, incremental);
+    case 'pmd':
+      return runPMD(projectRoot, incremental);
+    case 'eslint':
+      return runESLint(projectRoot, incremental);
+    case 'ruff':
+      return runRuff(projectRoot, incremental);
+    case 'prd':
+      return runPRDLinter(projectRoot);
+    case 'sql':
+      return runSQLLinter(projectRoot);
+    case 'activiti':
+      return runActivitiLinter(projectRoot);
+    default:
+      throw new Error(`未知linter runner: ${runner}`);
+  }
+}
+
+function runCheckstyle(projectRoot, incremental) {
+  const configPath = path.join(CONFIG_ROOT, 'checkstyle.xml');
+  if (!fs.existsSync(configPath)) {
+    return { runner: 'checkstyle', success: false, error: '配置文件不存在', duration: 0 };
+  }
+
+  let cmd = 'java -jar checkstyle-' + getVersion('checkstyle') + '-all.jar -c "' + configPath + '"';
+  if (incremental) cmd += ' -r "$(git diff --name-only --diff-filter=ACMR | grep .java$)"';
+
+  try {
+    const output = execSync(cmd, { cwd: projectRoot, encoding: 'utf-8', timeout: 60000 });
+    return parseLinterOutput('checkstyle', output, Date.now());
+  } catch (e) {
+    return parseLinterOutput('checkstyle', e.stdout || e.stderr || '', Date.now(), e.status !== 0);
+  }
+}
+
+function runPMD(projectRoot, incremental) {
+  const configPath = path.join(CONFIG_ROOT, 'pmd.xml');
+  if (!fs.existsSync(configPath)) {
+    return { runner: 'pmd', success: false, error: '配置文件不存在', duration: 0 };
+  }
+
+  try {
+    const output = execSync(
+      `run.sh pmd -d . -rulesets "${configPath}" -f json -language java`,
+      { cwd: projectRoot, encoding: 'utf-8', timeout: 120000 }
+    );
+    return parseLinterOutput('pmd', output, Date.now());
+  } catch (e) {
+    return parseLinterOutput('pmd', e.stdout || '', Date.now(), e.status !== 0);
+  }
+}
+
+function runESLint(projectRoot, incremental) {
+  const configPath = path.join(CONFIG_ROOT, 'eslint.config.js');
+
+  let cmd = `npx eslint --config "${configPath}" "**/*.{js,jsx,vue,ts,tsx}"`;
+  if (incremental) cmd += ' $(git diff --name-only --diff-filter=ACMR | grep -E "\\.(js|jsx|vue|ts|tsx)$")';
+
+  try {
+    const output = execSync(cmd, { cwd: projectRoot, encoding: 'utf-8', timeout: 60000 });
+    return parseLinterOutput('eslint', output, Date.now());
+  } catch (e) {
+    return parseLinterOutput('eslint', e.stdout || '', Date.now(), e.status !== 0);
+  }
+}
+
+function runRuff(projectRoot, incremental) {
+  const configPath = path.join(CONFIG_ROOT, 'ruff.toml');
+
+  let cmd = `ruff check --config "${configPath}" .`;
+  if (incremental) cmd += ' $(git diff --name-only --diff-filter=ACMR | grep "\\.py$")';
+
+  try {
+    const output = execSync(cmd, { cwd: projectRoot, encoding: 'utf-8', timeout: 60000 });
+    return parseLinterOutput('ruff', output, Date.now());
+  } catch (e) {
+    return parseLinterOutput('ruff', e.stdout || '', Date.now(), e.status !== 0);
+  }
+}
+
+async function runPRDLinter(projectRoot) {
+  const { runPRDChecks } = await import('./prd-linter.js');
+  return runPRDChecks(projectRoot);
+}
+
+async function runSQLLinter(projectRoot) {
+  const { runSQLChecks } = await import('./sql-linter.js');
+  return runSQLChecks(projectRoot);
+}
+
+async function runActivitiLinter(projectRoot) {
+  const { runActivitiChecks } = await import('./activiti-linter.js');
+  return runActivitiChecks(projectRoot);
+}
+
+function parseLinterOutput(runner, rawOutput, startTime, hasErrors = false) {
+  const issues = [];
+  const lines = rawOutput.split('\n').filter(l => l.trim());
+
+  for (const line of lines) {
+    if (line.includes('[ERROR]') || line.includes('[WARN]')) {
+      issues.push({
+        severity: line.includes('[ERROR]') ? 'error' : 'warning',
+        message: line.replace(/^\[.*?\]\s*/, '').trim()
+      });
+    }
+  }
+
+  return {
+    runner,
+    success: !hasErrors && issues.filter(i => i.severity === 'error').length === 0,
+    issueCount: issues.length,
+    errorCount: issues.filter(i => i.severity === 'error').length,
+    warningCount: issues.filter(i => i.severity === 'warning').length,
+    issues: issues.slice(0, 50),
+    duration: Date.now() - startTime
+  };
+}
+
+function printResult(result, format) {
+  if (format === 'json') return;
+
+  const icon = result.success ? chalk.green('✓') : chalk.red('✗');
+  const timeStr = `${result.duration}ms`;
+
+  console.log(`  ${icon} ${chalk.white(result.runner)} (${timeStr})`);
+
+  if (result.issueCount > 0) {
+    console.log(`     ${chalk.yellow(`${result.errorCount} 错误, ${result.warningCount} 警告`)}`);
+
+    for (const issue of (result.issues || []).slice(0, 10)) {
+      const color = issue.severity === 'error' ? chalk.red : chalk.yellow;
+      console.log(`     ${color('•')} ${issue.message}`);
+    }
+
+    if (result.issueCount > 10) {
+      console.log(`     ... 还有 ${result.issueCount - 10} 个问题`);
+    }
+  } else {
+    console.log(chalk.gray('     无问题发现'));
+  }
+}
+
+async function generateSummary(results, startTime, format) {
+  const totalDuration = Date.now() - startTime;
+  const totalErrors = results.reduce((s, r) => s + (r.errorCount || 0), 0);
+  const totalWarnings = results.reduce((s, r) => s + (r.warningCount || 0), 0);
+  const allPassed = results.every(r => r.success);
+
+  if (format === 'json') {
+    console.log(JSON.stringify({ summary: { totalErrors, totalWarnings, allPassed, duration: totalDuration }, results }, null, 2));
+    return;
+  }
+
+  console.log(chalk.bold('\n━━━ 检查摘要 ━━━'));
+  console.log(allPassed ? chalk.green('  ✅ 所有检查通过') : chalk.red(`  ❌ 发现 ${totalErrors} 个错误`));
+  console.log(chalk.gray(`  ⏱ 总耗时: ${totalDuration}ms`));
+
+  const reportDir = path.join(await findProjectRoot(process.cwd()), '.pdd', 'cache', 'reports');
+  await fs.ensureDir(reportDir);
+  const reportPath = path.join(reportDir, `linter-report-${Date.now()}.md`);
+  await generateMarkdownReport(reportPath, results, totalErrors, totalWarnings, totalDuration);
+  console.log(chalk.gray(`  📄 报告已保存: ${reportPath}`));
+}
+
+async function generateMarkdownReport(reportPath, results, errors, warnings, duration) {
+  const lines = [
+    '# PDD Linter 报告',
+    '',
+    `- 生成时间: ${new Date().toISOString()}`,
+    `- 总错误数: ${errors}`,
+    `- 总警告数: ${warnings}`,
+    `- 耗时: ${duration}ms`,
+    ''
+  ];
+
+  for (const r of results) {
+    lines.push(`## ${r.runner}`, '');
+    if (r.issues && r.issues.length > 0) {
+      for (const issue of r.issues) {
+        lines.push(`- [${issue.severity.toUpperCase()}] ${issue.message}`);
+      }
+    } else {
+      lines.push('- 无问题');
+    }
+    lines.push('');
+  }
+
+  await fs.writeFile(reportPath, lines.join('\n'), 'utf-8');
+}
+
+function getVersion(tool) {
+  const versions = { checkstyle: '10.12.0', pmd: '6.55.0' };
+  return versions[tool] || 'latest';
+}

package/scripts/linter/sql-linter.js

@@ -0,0 +1,166 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const CONFIG_PATH = path.join(__dirname, '..', '..', 'config', 'sqlfluff.cfg');
+
+export async function runSQLChecks(projectRoot) {
+  const start = Date.now();
+
+  if (!fs.existsSync(CONFIG_PATH)) {
+    return {
+      runner: 'sql-linter',
+      success: false,
+      error: 'SQLFluff配置文件不存在',
+      duration: Date.now() - start
+    };
+  }
+
+  const sqlFiles = findSQLFiles(projectRoot);
+
+  if (sqlFiles.length === 0) {
+    return {
+      runner: 'sql-linter',
+      success: true,
+      issueCount: 0,
+      errorCount: 0,
+      warningCount: 0,
+      issues: [],
+      message: '未找到SQL文件',
+      duration: Date.now() - start
+    };
+  }
+
+  try {
+    const fileList = sqlFiles.map(f => `"${f}"`).join(' ');
+    const cmd = `sqlfluff lint --config "${CONFIG_PATH}" ${fileList} --format json`;
+    const output = execSync(cmd, { cwd: projectRoot, encoding: 'utf-8', timeout: 120000 });
+
+    return parseSQLFluffOutput(output, start, sqlFiles.length);
+  } catch (e) {
+    const stdout = e.stdout || '';
+    const stderr = e.stderr || '';
+
+    if (stdout.startsWith('{') || stdout.startsWith('[')) {
+      return parseSQLFluffOutput(stdout, start, sqlFiles.length);
+    }
+
+    const fallbackOutput = runFallbackChecks(sqlFiles, projectRoot);
+    return {
+      runner: 'sql-linter',
+      success: fallbackOutput.errors === 0,
+      issueCount: fallbackOutput.warnings + fallbackOutput.errors,
+      errorCount: fallbackOutput.errors,
+      warningCount: fallbackOutput.warnings,
+      issues: fallbackOutput.issues,
+      filesChecked: sqlFiles.length,
+      duration: Date.now() - start
+    };
+  }
+}
+
+function findSQLFiles(root) {
+  const exts = ['.sql', '.hql', '.q'];
+  const found = [];
+
+  for (const ext of exts) {
+    try {
+      const files = fs.globSync(`**/*${ext}`, {
+        cwd: root,
+        ignore: ['**/node_modules/**', '**/.git/**', '**/.pdd/**', '**/vendor/**', '**/migrations/__pycache__/**']
+      });
+      for (const f of files) found.push(path.join(root, f));
+    } catch {}
+  }
+
+  return [...new Set(found)];
+}
+
+function parseSQLFluffOutput(rawOutput, startTime, fileCount) {
+  try {
+    const data = JSON.parse(rawOutput);
+    const violations = Array.isArray(data) ? data : (data.violations || []);
+    const issues = violations.map(v => ({
+      ruleId: v.rule || v.code || 'unknown',
+      severity: v.level === 'VIOLATION' ? 'error' : 'warn',
+      message: v.description || v.message || '',
+      file: v.path || v.file_path || '',
+      line: v.line_no || v.line || 0,
+      col: v.line_pos || v.col || 0
+    }));
+
+    return {
+      runner: 'sql-linter',
+      success: issues.filter(i => i.severity === 'error').length === 0,
+      issueCount: issues.length,
+      errorCount: issues.filter(i => i.severity === 'error').length,
+      warningCount: issues.filter(i => i.severity === 'warn').length,
+      issues: issues.slice(0, 100),
+      filesChecked: fileCount,
+      duration: Date.now() - startTime
+    };
+  } catch {
+    return {
+      runner: 'sql-linter',
+      success: false,
+      error: '无法解析SQLFluff输出',
+      duration: Date.now() - startTime
+    };
+  }
+}
+
+function runFallbackChecks(sqlFiles, root) {
+  const issues = [];
+  let errors = 0;
+  let warnings = 0;
+
+  const dangerousPatterns = [
+    { pattern: /\bSELECT\s+\*\s+FROM/i, severity: 'warn', rule: 'no-select-star', message: '避免使用 SELECT *，明确指定所需列' },
+    { pattern: /\bDROP\s+(TABLE|DATABASE)\b/i, severity: 'error', rule: 'dangerous-drop', message: '检测到危险操作 DROP，请确认是否必要' },
+    { pattern: /\bDELETE\s+FROM\b(?!\s+WHERE)/i, severity: 'error', rule: 'delete-without-where', message: 'DELETE语句缺少WHERE条件' },
+    { pattern: /\bUPDATE\b.*\bSET\b(?!(.*WHERE|\s*$))/is, severity: 'error', rule: 'update-without-where', message: 'UPDATE语句缺少WHERE条件' },
+    { pattern: /--\s*TODO|FIXME|HACK|XXX/i, severity: 'info', rule: 'todo-comments', message: 'SQL中存在待办注释' },
+    { pattern: /\bINSERT\s+INTO\b.*VALUES\s*\([^)]*\)\s*;\s*$/im, severity: 'warn', rule: 'explicit-columns', message: 'INSERT语句建议显式指定列名' },
+    { pattern: /\b(?:UNION\s+ALL)\b/i, severity: 'info', rule: 'union-all-check', message: '使用 UNION ALL 时确认是否需要去重' },
+    { pattern: /;\s*$/m, severity: 'info', rule: 'trailing-semicolon', message: '建议每条SQL语句以分号结尾' }
+  ];
+
+  for (const filePath of sqlFiles) {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const lines = content.split('\n');
+
+    for (let idx = 0; idx < lines.length; idx++) {
+      const line = lines[idx];
+      for (const check of dangerousPatterns) {
+        if (check.pattern.test(line)) {
+          if (check.severity === 'error') errors++;
+          else if (check.severity === 'warn') warnings++;
+
+          issues.push({
+            ruleId: check.rule,
+            severity: check.severity,
+            message: check.message,
+            file: filePath,
+            line: idx + 1
+          });
+        }
+      }
+    }
+
+    if (content.length > 5000) {
+      warnings++;
+      issues.push({
+        ruleId: 'long-file',
+        severity: 'warn',
+        message: `SQL文件过大(${Math.round(content.length / 1024)}KB)，建议拆分`,
+        file: filePath,
+        line: 0
+      });
+    }
+  }
+
+  return { errors, warnings, issues: issues.slice(0, 100) };
+}

package/scripts/token-analyzer.js

@@ -0,0 +1,162 @@
+#!/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');
+
+export async function analyzeTokenEfficiency(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 =>
+      fs.statSync(path.join(catPath, f)).isDirectory()
+    );
+
+    for (const entry of entries) {
+      const skillPath = path.join(catPath, entry);
+      const analysis = analyzeSkillTokens(entry, skillPath);
+      results.push({ ...analysis, category: cat });
+    }
+  }
+
+  printTokenReport(results);
+  return results;
+}
+
+function estimateTokenCount(text) {
+  if (!text) return 0;
+  const chineseChars = (text.match(/[\u4e00-\u9fff]/g) || []).length;
+  const englishWords = text
+    .replace(/[\u4e00-\u9fff]/g, ' ')
+    .split(/\s+/)
+    .filter(w => w.length > 0).length;
+  return Math.ceil(chineseChars * 1.5 + englishWords * 1.3);
+}
+
+function analyzeSkillTokens(name, skillPath) {
+  const skillMd = path.join(skillPath, 'SKILL.md');
+  const metaJson = path.join(skillPath, '_meta.json');
+
+  if (!fs.existsSync(skillMd)) {
+    return { name, error: 'SKILL.md not found', tokens: 0, grade: 'F' };
+  }
+
+  const content = fs.readFileSync(skillMd, 'utf-8');
+  const totalTokens = estimateTokenCount(content);
+  const fileSizeKB = Buffer.byteLength(content, 'utf-8') / 1024;
+
+  const lines = content.split('\n');
+  const lineCount = lines.length;
+  const maxSectionLength = getMaxSectionLength(lines);
+
+  const sections = countSections(content);
+  const codeBlocks = (content.match(/```[\s\S]*?```/g) || []).length;
+  const tables = (content.match(/\|.+\|/g) || []).length / 2;
+
+  const descMatch = content.match(/^description:\s*(.+)$/m);
+  const descLen = descMatch ? descMatch[1].trim().length : 0;
+
+  const hasLayering = /layer/i.test(content) || /##\s*\d+/i.test(content);
+  const hasBehaviorShaping = /iron\s*law|red\s*flags|rationalization/i.test(content);
+
+  let score = 100;
+  if (totalTokens > 8000) score -= Math.min(30, (totalTokens - 8000) / 200);
+  if (totalTokens > 5000) score -= Math.min(15, (totalTokens - 5000) / 400);
+  if (descLen > 200) score -= Math.min(10, (descLen - 200) / 20);
+  if (maxSectionLength > 150) score -= Math.min(10, (maxSectionLength - 150) / 10);
+  if (!hasLayering) score -= 5;
+  if (!hasBehaviorShaping) score -= 10;
+  if (lineCount > 300) score -= Math.min(10, (lineCount - 300) / 30);
+
+  score = Math.max(0, Math.min(100, score));
+
+  return {
+    name,
+    tokens: totalTokens,
+    fileSizeKB: Math.round(fileSizeKB * 10) / 10,
+    lineCount,
+    sections,
+    codeBlocks,
+    tables: Math.round(tables),
+    descLength: descLen,
+    maxSectionLines: maxSectionLength,
+    hasLayering,
+    hasBehaviorShaping,
+    score,
+    grade: score >= 80 ? 'A' : score >= 60 ? 'B' : score >= 40 ? 'C' : 'D',
+    suggestions: generateSuggestions(totalTokens, descLen, maxSectionLength, hasLayering, hasBehaviorShaping)
+  };
+}
+
+function getMaxSectionLength(lines) {
+  let maxLength = 0;
+  let currentLength = 0;
+  for (const line of lines) {
+    if (/^#{1,3}\s/.test(line)) {
+      maxLength = Math.max(maxLength, currentLength);
+      currentLength = 0;
+    }
+    currentLength++;
+  }
+  return Math.max(maxLength, currentLength);
+}
+
+function countSections(content) {
+  return (content.match(/^#{1,3}\s+.+$/gm) || []).length;
+}
+
+function generateSuggestions(tokens, descLen, maxSec, hasLayering, hasBS) {
+  const suggestions = [];
+  if (tokens > 8000) suggestions.push('⚠️ 文件过大，建议拆分为 Layer 1/2/3 渐进式加载');
+  if (tokens > 5000) suggestions.push('📝 文件较大，考虑将参考文档移至 references/ 目录');
+  if (descLen > 200) suggestions.push('✂️ description 过长，建议精简至200字以内');
+  if (maxSec > 150) suggestions.push('📐 存在超长章节(>' + maxSec + '行)，建议拆分');
+  if (!hasLayering) suggestions.push('📚 缺少分层结构，建议添加 Layer 1/2/3 标记');
+  if (!hasBS) suggestions.push('🛡️ 缺少行为塑造章节(Iron Law/Red Flags)');
+  return suggestions;
+}
+
+function printTokenReport(results) {
+  const avgTokens = results.reduce((s, r) => s + (r.tokens || 0), 0) / results.length;
+  const avgScore = results.reduce((s, r) => s + r.score, 0) / results.length;
+  const gradeDist = { A: 0, B: 0, C: 0, D: 0, F: 0 };
+  results.forEach(r => gradeDist[r.grade]++);
+
+  console.log('\n📊 Token 效率分析报告\n');
+  console.log(`  总技能数: ${results.length}`);
+  console.log(`  平均Token数: ${Math.round(avgTokens)}`);
+  console.log(`  平均效率分: ${avgScore.toFixed(1)}/100`);
+  console.log(`  等级分布: A:${gradeDist.A} B:${gradeDist.B} C:${gradeDist.C} D:${gradeDist.D} F:${gradeDist.F}\n`);
+
+  console.log('  ┌────────────────────────┬────────┬───────┬──────┬────────┐');
+  console.log('  │ 技能名称               │ Tokens │ 大小  │ 等级  │ 建议   │');
+  console.log('  ├────────────────────────┼────────┼───────┼──────┼────────┤');
+
+  const sorted = [...results].sort((a, b) => a.tokens - b.tokens);
+  for (const r of sorted) {
+    const icon = r.grade === 'A' ? '🟢' : r.grade === 'B' ? '🟡' : r.grade === 'C' ? '🟠' : r.grade === 'D' ? '🔴' : '⬛';
+    const name = r.name.padEnd(24).substring(0, 24);
+    const size = (r.fileSizeKB + 'KB').padStart(6);
+    const suggestCount = r.suggestions ? r.suggestions.length : 0;
+    console.log(`  │ ${icon} ${name} │ ${(r.tokens || 0).toString().padStart(6)} │ ${size} │  ${r.grade}   │ ${suggestCount.toString().padStart(4)} │`);
+  }
+
+  console.log('  └────────────────────────┴────────┴───────┴──────┴────────┘');
+
+  const needOptimization = results.filter(r => r.score < 60);
+  if (needOptimization.length > 0) {
+    console.log('\n  ⚠️ 需要优化的技能:');
+    for (const r of needOptimization) {
+      console.log(`    ${r.name} (${r.tokens} tokens, ${r.grade}级)`);
+      for (const s of (r.suggestions || [])) {
+        console.log(`      ${s}`);
+      }
+    }
+  }
+}