pdd-skills 3.0.0

package/scripts/linter/activiti-linter.js

@@ -0,0 +1,272 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import xml2js from 'xml2js';
+import yaml from 'yaml';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const RULES_PATH = path.join(__dirname, '..', '..', 'config', 'bpmn-rules.yaml');
+
+export async function runActivitiChecks(projectRoot) {
+  const start = Date.now();
+
+  const rulesContent = fs.existsSync(RULES_PATH)
+    ? fs.readFileSync(RULES_PATH, 'utf-8')
+    : '';
+  const rules = rulesContent ? parseYAML(rulesContent) : getDefaultRules();
+
+  const bpmnFiles = findBPMNFiles(projectRoot);
+
+  if (bpmnFiles.length === 0) {
+    return {
+      runner: 'activiti-linter',
+      success: true,
+      issueCount: 0,
+      errorCount: 0,
+      warningCount: 0,
+      issues: [],
+      message: '未找到BPMN文件',
+      duration: Date.now() - start
+    };
+  }
+
+  const allIssues = [];
+
+  for (const filePath of bpmnFiles) {
+    const fileIssues = await checkBPMNFile(filePath, rules);
+    allIssues.push(...fileIssues);
+  }
+
+  return {
+    runner: 'activiti-linter',
+    success: allIssues.filter(i => i.severity === 'error').length === 0,
+    issueCount: allIssues.length,
+    errorCount: allIssues.filter(i => i.severity === 'error').length,
+    warningCount: allIssues.filter(i => i.severity === 'warn').length,
+    issues: allIssues.slice(0, 100),
+    filesChecked: bpmnFiles.length,
+    duration: Date.now() - start
+  };
+}
+
+function findBPMNFiles(root) {
+  const patterns = ['**/*.bpmn', '**/*.bpmn20.xml', '**/*-process.xml', '**/processes/**/*.xml'];
+  const found = new Set();
+
+  for (const pattern of patterns) {
+    try {
+      const files = fs.globSync(pattern, {
+        cwd: root,
+        ignore: ['**/node_modules/**', '**/.git/**', '**/.pdd/**', '**/target/**']
+      });
+      for (const f of files) found.add(path.join(root, f));
+    } catch {}
+  }
+
+  return Array.from(found).filter(f => {
+    try { const c = fs.readFileSync(f, 'utf-8'); return c.includes('bpmn') || c.includes('definitions'); }
+    catch { return false; }
+  });
+}
+
+async function checkBPMNFile(filePath, rules) {
+  const issues = [];
+  let xmlObj = null;
+
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const parser = new xml2js.Parser({ explicitArray: true });
+    xmlObj = await parser.parseStringPromise(content);
+  } catch (e) {
+    issues.push({
+      ruleId: 'bpmn-parse-error',
+      severity: 'error',
+      message: `XML解析失败: ${e.message}`,
+      file: filePath,
+      line: 0,
+      category: 'structure'
+    });
+    return issues;
+  }
+
+  const definitions = xmlObj.definitions || xmlObj['bpmn:definitions'] || {};
+  const processes = definitions.process || definitions['bpmn:process'] || [];
+  const processList = Array.isArray(processes) ? processes : [processes];
+
+  for (const category of Object.keys(rules.rules || {})) {
+    const catRules = rules.rules[category];
+    if (!catRules.enabled) continue;
+
+    for (const processEl of processList) {
+      if (!processEl || typeof processEl !== 'object') continue;
+
+      for (const rule of (catRules.checks || [])) {
+        const result = applyBPMNRule(rule, processEl, filePath, xmlObj);
+        if (!result.passed) {
+          issues.push({
+            ruleId: rule.id,
+            ruleName: rule.name,
+            severity: rule.severity || 'warn',
+            message: rule.message,
+            file: filePath,
+            line: 0,
+            category
+          });
+        }
+      }
+    }
+  }
+
+  const securityIssues = runSecurityChecks(filePath, fs.readFileSync(filePath, 'utf-8'));
+  issues.push(...securityIssues);
+
+  return issues;
+}
+
+function applyBPMNRule(rule, processEl, filePath, xmlObj) {
+  switch (rule.id) {
+    case 'bpmn-has-start-event':
+      const starts = findElements(processEl, 'startEvent');
+      return { passed: starts.length > 0 };
+
+    case 'bpmn-has-end-event':
+      const ends = findElements(processEl, 'endEvent');
+      return { passed: ends.length > 0 };
+
+    case 'bpmn-single-start-event':
+      const allStarts = findElements(processEl, 'startEvent');
+      return { passed: allStarts.length <= (rule.max_count || 1) };
+
+    case 'bpmn-process-id-required':
+      const procId = getAttr(processEl, 'id');
+      if (!procId) return { passed: false };
+      if (rule.pattern) return { passed: new RegExp(rule.pattern).test(procId) };
+      return { passed: true };
+
+    case 'bpmn-process-name-required':
+      const procName = getAttr(processEl, 'name');
+      return { passed: !!procName };
+
+    case 'bpmn-reasonable-size': {
+      const nodeCount = countAllNodes(processEl);
+      return { passed: nodeCount <= (rule.max_nodes || 50) };
+    }
+
+    case 'bpmn-user-task-has-assignee': {
+      const userTasks = findElements(processEl, 'userTask');
+      for (const t of userTasks) {
+        const assignee = getAttr(t, 'assignee');
+        const candidates = getAttr(t, 'candidateUsers') || getAttr(t, 'candidateGroups');
+        if (!assignee && !candidates) return { passed: false };
+      }
+      return { passed: true };
+    }
+
+    case 'bpmn-service-task-has-class': {
+      const serviceTasks = findElements(processEl, 'serviceTask');
+      for (const t of serviceTasks) {
+        const cls = getAttr(t, 'class');
+        const expr = getAttr(t, 'expression');
+        const delegate = getAttr(t, 'delegateExpression');
+        if (!cls && !expr && !delegate) return { passed: false };
+      }
+      return { passed: true };
+    }
+
+    default:
+      return { passed: true };
+  }
+}
+
+function findElements(el, tagName) {
+  const results = [];
+  const variants = [tagName, `bpmn:${tagName}`];
+
+  for (const variant of variants) {
+    if (el[variant]) {
+      results.push(...(Array.isArray(el[variant]) ? el[variant] : [el[variant]]));
+    }
+  }
+
+  return results.filter(e => e && typeof e === 'object');
+}
+
+function getAttr(el, attrName) {
+  if (!el || typeof el !== 'object') return null;
+
+  if (el.$ && el.$[attrName] !== undefined) return el.$[attrName];
+  if (el[attrName] !== undefined) return el[attrName];
+
+  return null;
+}
+
+function countAllNodes(processEl) {
+  const nodeTypes = [
+    'startEvent', 'endEvent', 'userTask', 'serviceTask', 'scriptTask',
+    'manualTask', 'businessRuleTask', 'sendTask', 'receiveTask',
+    'exclusiveGateway', 'parallelGateway', 'inclusiveGateway',
+    'eventBasedGateway', 'subProcess', 'callActivity'
+  ];
+
+  let count = 0;
+  for (const type of nodeTypes) {
+    count += findElements(processEl, type).length;
+  }
+  return count;
+}
+
+function runSecurityChecks(filePath, content) {
+  const issues = [];
+  const lines = content.split('\n');
+
+  const securityPatterns = [
+    { pattern: /password\s*[:=]\s*["'][^"']+["']/i, severity: 'error', ruleId: 'bpmn-no-hardcoded-passwords', message: '检测到可能的硬编码密码' },
+    { pattern: /\$\{.*(SELECT|INSERT|UPDATE|DELETE|DROP)/i, severity: 'error', ruleId: 'bpmn-no-sql-injection-risk', message: '检测到潜在SQL注入风险' },
+    { pattern: /<script[^>]*>[^<]*(?:eval|exec|Runtime)/i, severity: 'warn', ruleId: 'bpmn-dangerous-script', message: '检测到危险脚本调用' },
+    { pattern: /admin|root|sa\b/i, severity: 'info', ruleId: 'bpmn-default-account', message: '使用了默认管理员账户名' }
+  ];
+
+  for (let idx = 0; idx < lines.length; idx++) {
+    for (const check of securityPatterns) {
+      if (check.pattern.test(lines[idx])) {
+        issues.push({
+          ruleId: check.ruleId,
+          severity: check.severity,
+          message: check.message,
+          file: filePath,
+          line: idx + 1,
+          category: 'security'
+        });
+      }
+    }
+  }
+
+  return issues;
+}
+
+function parseYAML(content) {
+  try {
+    return yaml.parse(content);
+  } catch {
+    return getDefaultRules();
+  }
+}
+
+function getDefaultRules() {
+  return {
+    rules: {
+      structure: { enabled: true, checks: [
+        { id: 'bpmn-has-start-event', name: '流程必须有开始事件', severity: 'error', message: 'BPMN流程缺少开始事件' },
+        { id: 'bpmn-has-end-event', name: '流程必须有结束事件', severity: 'error', message: 'BPMN流程缺少结束事件' },
+        { id: 'bpmn-user-task-has-assignee', name: '用户任务需指定处理人', severity: 'error', message: '用户任务必须指定处理人' },
+        { id: 'bpmn-service-task-has-class', name: '服务任务需指定实现类', severity: 'error', message: '服务任务必须指定实现类' }
+      ]},
+      security: { enabled: true, checks: [] },
+      naming: { enabled: true, checks: [] },
+      best_practices: { enabled: true, checks: [] },
+      documentation: { enabled: true, checks: [] },
+      connectivity: { enabled: true, checks: [] }
+    }
+  };
+}

package/scripts/linter/prd-linter.js

@@ -0,0 +1,162 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import yaml from 'yaml';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const RULES_PATH = path.join(__dirname, '..', '..', 'config', 'prd-rules.yaml');
+
+export async function runPRDChecks(projectRoot) {
+  const start = Date.now();
+
+  const rulesContent = fs.existsSync(RULES_PATH)
+    ? fs.readFileSync(RULES_PATH, 'utf-8')
+    : '';
+  const rules = rulesContent ? yaml.parse(rulesContent) : getDefaultRules();
+
+  const prdFiles = findPRDFiles(projectRoot);
+
+  if (prdFiles.length === 0) {
+    return {
+      runner: 'prd-linter',
+      success: true,
+      issueCount: 0,
+      errorCount: 0,
+      warningCount: 0,
+      issues: [],
+      message: '未找到PRD文件',
+      duration: Date.now() - start
+    };
+  }
+
+  const allIssues = [];
+
+  for (const filePath of prdFiles) {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const fileIssues = checkFile(filePath, content, rules);
+    allIssues.push(...fileIssues);
+  }
+
+  return {
+    runner: 'prd-linter',
+    success: allIssues.filter(i => i.severity === 'error').length === 0,
+    issueCount: allIssues.length,
+    errorCount: allIssues.filter(i => i.severity === 'error').length,
+    warningCount: allIssues.filter(i => i.severity === 'warn').length,
+    issues: allIssues.slice(0, 100),
+    filesChecked: prdFiles.length,
+    duration: Date.now() - start
+  };
+}
+
+function findPRDFiles(root) {
+  const patterns = [
+    '**/*.md',
+    '**/PRD*.md',
+    '**/prd*.md',
+    '**/requirements*.md',
+    '**/spec*.md'
+  ];
+
+  const found = new Set();
+
+  for (const pattern of patterns) {
+    try {
+      const files = fs.globSync(pattern, { cwd: root, ignore: ['**/node_modules/**', '**/.git/**', '**/.pdd/**'] });
+      for (const f of files) found.add(path.join(root, f));
+    } catch {}
+  }
+
+  return Array.from(found).filter(f => isLikelyPRD(f));
+}
+
+function isLikelyPRD(filePath) {
+  const name = path.basename(filePath).toLowerCase();
+  const keywords = ['prd', 'requirement', 'spec', 'feature', '需求', '规格', '功能'];
+  return keywords.some(k => name.includes(k));
+}
+
+function checkFile(filePath, content, rules) {
+  const issues = [];
+  const lines = content.split('\n');
+
+  for (const [category, categoryRules] of Object.entries(rules.rules || {})) {
+    if (!categoryRules.enabled) continue;
+
+    for (const rule of (categoryRules.checks || [])) {
+      const match = applyRule(rule, content, lines);
+      if (!match.passed) {
+        issues.push({
+          ruleId: rule.id,
+          ruleName: rule.name,
+          severity: rule.severity || 'info',
+          message: rule.message,
+          file: filePath,
+          line: match.line || 0,
+          category
+        });
+      }
+    }
+  }
+
+  return issues;
+}
+
+function applyRule(rule, content, lines) {
+  if (rule.pattern) {
+    try {
+      const regex = new RegExp(rule.pattern, 'i');
+      const match = content.match(regex);
+
+      if (match) {
+        const lineNum = content.substring(0, match.index).split('\n').length;
+
+        if (rule.exclude_patterns) {
+          for (const excl of rule.exclude_patterns) {
+            if (new RegExp(excl, 'i').test(match[0])) {
+              return { passed: true };
+            }
+          }
+        }
+
+        return { passed: true, line: lineNum };
+      }
+
+      return { passed: false, line: 0 };
+    } catch {
+      return { passed: true };
+    }
+  }
+
+  if (rule.max_depth) {
+    let maxDepth = 0;
+    for (const line of lines) {
+      const headerMatch = line.match(/^(#{1,6})\s/);
+      if (headerMatch) {
+        maxDepth = Math.max(maxDepth, headerMatch[1].length);
+      }
+    }
+    return { passed: maxDepth <= rule.max_depth };
+  }
+
+  return { passed: true };
+}
+
+function getDefaultRules() {
+  return {
+    rules: {
+      structure: {
+        enabled: true,
+        checks: [
+          { id: 'prd-has-title', name: 'PRD必须有标题', pattern: '^#+\\s+.+', severity: 'error', message: 'PRD文档缺少标题' },
+          { id: 'prd-has-version', name: 'PRD必须包含版本信息', pattern: '(?i)(version|版本|v\\d+\\.\\d+)', severity: 'error', message: 'PRD文档缺少版本号' },
+          { id: 'prd-has-goals', name: 'PRD必须包含目标', pattern: '(?i)(目标|goal)', severity: 'error', message: 'PRD文档缺少目标定义' }
+        ]
+      },
+      content: { enabled: true, checks: [] },
+      format: { enabled: true, checks: [] },
+      consistency: { enabled: true, checks: [] }
+    }
+  };
+}

package/scripts/linter/report-generator.js

@@ -0,0 +1,207 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+
+export class ReportGenerator {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.reportDir = path.join(projectRoot, '.pdd', 'cache', 'reports');
+  }
+
+  async generate(linterResults = [], options = {}) {
+    await fs.ensureDir(this.reportDir);
+
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const format = options.format || 'markdown';
+
+    switch (format) {
+      case 'json':
+        return await this.generateJSONReport(linterResults, timestamp);
+      case 'html':
+        return await this.generateHTMLReport(linterResults, timestamp);
+      case 'markdown':
+      default:
+        return await this.generateMarkdownReport(linterResults, timestamp);
+    }
+  }
+
+  async generateMarkdownReport(results, timestamp) {
+    const summary = this.buildSummary(results);
+    const lines = [
+      '# PDD Linter 检查报告',
+      '',
+      `> 生成时间: ${new Date().toLocaleString('zh-CN')}`,
+      `> 项目: ${path.basename(this.projectRoot)}`,
+      '',
+      '## 执行摘要',
+      '',
+      `| 指标 | 数值 |`,
+      `|------|------|`,
+      `| 总检查项 | ${summary.totalRunners} |`,
+      `| 通过 | ${chalk.green(summary.passed.toString())} |`,
+      `| 失败 | ${chalk.red(summary.failed.toString())} |`,
+      `| 总问题数 | ${summary.totalIssues} |`,
+      `| 错误 | ${chalk.red(summary.totalErrors.toString())} |`,
+      `| 警告 | ${chalk.yellow(summary.totalWarnings.toString())} |`,
+      `| 总耗时 | ${summary.totalDuration}ms |`,
+      ''
+    ];
+
+    if (summary.failed > 0) {
+      lines.push('> ⚠️ **存在未通过检查项，请查看详情**', '');
+    } else {
+      lines.push('> ✅ **所有检查通过**', '');
+    }
+
+    lines.push('## 详细结果', '');
+
+    for (const result of results) {
+      lines.push(`### ${result.runner}`, '');
+      lines.push(`- 状态: ${result.success ? '✅ 通过' : '❌ 失败'}`);
+      lines.push(`- 耗时: ${result.duration || 0}ms`);
+
+      if (result.issueCount !== undefined) {
+        lines.push(`- 问题数: ${result.issueCount} (${result.errorCount || 0} 错误, ${result.warningCount || 0} 警告)`);
+      }
+
+      if (result.filesChecked) {
+        lines.push(`- 检查文件数: ${result.filesChecked}`);
+      }
+
+      if (result.message && result.issueCount === 0) {
+        lines.push(`- 备注: ${result.message}`);
+      }
+
+      if (result.issues && result.issues.length > 0) {
+        lines.push('', '**问题列表:**', '');
+        lines.push('| 严重度 | 规则 | 描述 | 文件 | 行号 |');
+        lines.push('|--------|------|------|------|------|');
+
+        for (const issue of result.issues.slice(0, 50)) {
+          const sevIcon = issue.severity === 'error' ? '🔴' : issue.severity === 'warn' ? '🟡' : '🔵';
+          const file = issue.file ? path.basename(issue.file) : '-';
+          lines.push(`${sevIcon} | ${issue.ruleId || '-'} | ${issue.message || '-'} | ${file} | ${issue.line || '-'}`);
+        }
+      }
+
+      lines.push('');
+    }
+
+    lines.push('---', '', `_由 PDD-Skills v1.0 自动生成_`);
+
+    const reportPath = path.join(this.reportDir, `linter-${timestamp}.md`);
+    await fs.writeFile(reportPath, lines.join('\n'), 'utf-8');
+    console.log(chalk.gray(`  📄 Markdown报告: ${reportPath}`));
+
+    return { path: reportPath, format: 'markdown', summary };
+  }
+
+  async generateJSONReport(results, timestamp) {
+    const summary = this.buildSummary(results);
+    const report = {
+      generated_at: new Date().toISOString(),
+      project: path.basename(this.projectRoot),
+      version: '1.0.0',
+      summary,
+      results
+    };
+
+    const reportPath = path.join(this.reportDir, `linter-${timestamp}.json`);
+    await fs.writeFile(reportPath, JSON.stringify(report, null, 2), 'utf-8');
+    console.log(chalk.gray(`  📄 JSON报告: ${reportPath}`));
+
+    return { path: reportPath, format: 'json', summary };
+  }
+
+  async generateHTMLReport(results, timestamp) {
+    const summary = this.buildSummary(results);
+    const issuesHtml = results.flatMap(r => (r.issues || []).map(i => ({
+      ...i,
+      runner: r.runner
+    })));
+
+    const html = `<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>PDD Linter 报告 - ${path.basename(this.projectRoot)}</title>
+<style>
+*{margin:0;padding:0;box-sizing:border-box}
+body{font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;background:#f5f5f5;color:#333;padding:20px}
+.header{background:#fff;border-radius:8px;padding:24px;margin-bottom:20px;box-shadow:0 1px 3px rgba(0,0,0,.1)}
+.header h1{font-size:24px;color:#1a73e8;margin-bottom:8px}
+.meta{color:#666;font-size:14px}
+.summary{display:grid;grid-template-columns:repeat(auto-fit,minmax(150px,1fr));gap:16px;margin-bottom:20px}
+.card{background:#fff;border-radius:8px;padding:20px;text-align:center;box-shadow:0 1px 3px rgba(0,0,0,.1)}
+.card .value{font-size:32px;font-weight:bold}
+.card .label{color:#666;font-size:14px;margin-top:4px}
+.pass .value{color:#34a853}.fail .value{color:#ea4335}.warn .value{#f9ab00}
+.section{background:#fff;border-radius:8px;padding:24px;margin-bottom:20px;box-shadow:0 1px 3px rgba(0,0,0,.1)}
+.section h2{font-size:18px;margin-bottom:16px;color:#333;border-bottom:1px solid #eee;padding-bottom:8px}
+table{width:100%;border-collapse:collapse}
+th{text-align:left;background:#f8f9fa;padding:10px;font-weight:600;font-size:13px;color:#555}
+td{padding:10px;border-bottom:1px solid #eee;font-size:13px}
+tr:hover{background:#f8f9fa}
+.severity-error{color:#ea4335;font-weight:600}.severity-warn{color:#f9ab00}.severity-info{color:#4285f4}
+</style>
+</head>
+<body>
+<div class="header">
+<h1>🔍 PDD Linter 检查报告</h1>
+<div class="meta">项目: ${path.basename(this.projectRoot)} | 生成时间: ${new Date().toLocaleString('zh-CN')}</div>
+</div>
+<div class="summary">
+<div class="card ${summary.failed === 0 ? 'pass' : 'fail'}"><div class="value">${summary.totalRunners}</div><div class="label">总检查项</div></div>
+<div class="card pass"><div class="value">${summary.passed}</div><div class="label">通过</div></div>
+<div class="card fail"><div class="value">${summary.failed}</div><div class="label">失败</div></div>
+<div class="card warn"><div class="value">${summary.totalIssues}</div><div class="label">总问题</div></div>
+<div class="card"><div class="value">${summary.totalDuration}ms</div><div class="label">耗时</div></div>
+</div>
+${results.map(r => `
+<div class="section">
+<h2>${r.success ? '✅' : '❌'} ${r.runner}</h2>
+<table>
+<tr><th>指标</th><th>数值</th></tr>
+<tr><td>状态</td><td>${r.success ? '通过' : '失败'}</td></tr>
+<tr><td>耗时</td><td>${r.duration || 0}ms</td></tr>
+<tr><td>错误</td><td>${r.errorCount || 0}</td></tr>
+<tr><td>警告</td><td>${r.warningCount || 0}</td></tr>
+${r.filesChecked ? `<tr><td>文件数</td><td>${r.filesChecked}</td></tr>` : ''}
+</table>
+${(r.issues || []).length > 0 ? `
+<table style="margin-top:12px">
+<tr><th>严重度</th><th>规则</th><th>描述</th><th>文件</th><th>行号</th></tr>
+${r.issues.slice(0, 30).map(i => `
+<tr><td class="severity-${i.severity}">${i.severity.toUpperCase()}</td><td>${i.ruleId || '-'}</td><td>${(i.message || '').replace(/</g,'&lt;')}</td><td>${i.file ? path.basename(i.file) : '-'}</td><td>${i.line || '-'}</td></tr>`).join('')}
+</table>` : ''}
+</div>`).join('')}
+</body>
+</html>`;
+
+    const reportPath = path.join(this.reportDir, `linter-${timestamp}.html`);
+    await fs.writeFile(reportPath, html, 'utf-8');
+    console.log(chalk.gray(`  📄 HTML报告: ${reportPath}`));
+
+    return { path: reportPath, format: 'html', summary };
+  }
+
+  buildSummary(results) {
+    let totalRunners = results.length;
+    let passed = results.filter(r => r.success).length;
+    let failed = totalRunners - passed;
+    let totalIssues = 0;
+    let totalErrors = 0;
+    let totalWarnings = 0;
+    let totalDuration = 0;
+
+    for (const r of results) {
+      totalIssues += r.issueCount || 0;
+      totalErrors += r.errorCount || 0;
+      totalWarnings += r.warningCount || 0;
+      totalDuration += r.duration || 0;
+    }
+
+    return { totalRunners, passed, failed, totalIssues, totalErrors, totalWarnings, totalDuration };
+  }
+}