pdd-skills 3.0.0

package/config/pmd.xml

@@ -0,0 +1,91 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ruleset name="PDD-PMD-Rules" xmlns="http://pmd.sourceforge.net/ruleset/2.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://pmd.sourceforge.net/ruleset/2.0.0 https://pmd.sourceforge.io/ruleset_2_0_0.xsd">
+
+  <description>PDD-Skills PMD规则集 - Java代码质量检查</description>
+
+  <rule ref="category/java/bestpractices.xml">
+    <exclude name="GuardLogStatement"/>
+    <exclude name="GuardLogStatementJavaUtil"/>
+  </rule>
+
+  <rule ref="category/java/codestyle.xml">
+    <exclude name="CommentRequired"/>
+    <exclude name="ConfusingTernary"/>
+    <exclude name="OnlyOneReturn"/>
+    <exclude name="ShortClassName"/>
+    <exclude name="ShortVariable"/>
+  </rule>
+
+  <rule ref="category/java/design.xml">
+    <exclude name="CouplingBetweenObjects"/>
+    <exclude name="DataClass"/>
+    <exclude name="LawOfDemeter"/>
+    <exclude name="LoosePackageCoupling"/>
+  </rule>
+
+  <rule ref="category/java/errorprone.xml"/>
+
+  <rule ref="category/java/multithreading.xml">
+    <exclude name="DoNotUseThreads"/>
+    <exclude name="UseConcurrentHashMap"/>
+  </rule>
+
+  <rule ref="category/java/performance.xml">
+    <exclude name="AvoidInstantiatingObjectsInLoops"/>
+  </rule>
+
+  <rule ref="category/java/security.xml"/>
+
+  <rule ref="category/java/codestyle.xml/LongVariable">
+    <properties>
+      <property name="minimum" value="40"/>
+    </properties>
+  </rule>
+
+  <rule ref="category/java/design.xml/CyclomaticComplexity">
+    <properties>
+      <property name="classReportLevel" value="80"/>
+      <property name="methodReportLevel" value="15"/>
+      <property name="cycloOptions" value="{statementSwitchAsDecision:false}"/>
+    </properties>
+  </rule>
+
+  <rule ref="category/java/design.xml/NcssTypeCount">
+    <properties>
+      <property name="maximum" value="800"/>
+    </properties>
+  </rule>
+
+  <rule ref="category/java/design.xml/NcssMethodCount">
+    <properties>
+      <property name="maximum" value="60"/>
+    </properties>
+  </rule>
+
+  <rule ref="category/java/design.xml/NcssConstructorCount">
+    <properties>
+      <property name="maximum" value="10"/>
+    </properties>
+  </rule>
+
+  <rule ref="category/java/design.xml/TooManyFields">
+    <properties>
+      <property name="maxfields" value="15"/>
+    </properties>
+  </rule>
+
+  <rule ref="category/java/design.xml/TooManyMethods">
+    <properties>
+      <property name="maxmethods" value="30"/>
+    </properties>
+  </rule>
+
+  <rule ref="category/java/codestyle.xml/MethodNamingConventions">
+    <properties>
+      <property name="methodPattern" value="^[a-z][a-zA-Z0-9_]*$"/>
+    </properties>
+  </rule>
+
+</ruleset>

package/config/prd-rules.yaml

@@ -0,0 +1,113 @@
+# PRD Linter 规则配置
+#
+# 用于检查PRD文档的完整性和规范性
+
+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-background
+        name: "PRD必须包含背景说明"
+        pattern: "(?i)(背景|background|项目背景|业务背景)"
+        severity: error
+        message: "PRD文档缺少背景说明章节"
+
+      - id: prd-has-goals
+        name: "PRD必须包含目标"
+        pattern: "(?i)(目标|goals?| objectives?)"
+        severity: error
+        message: "PRD文档缺少目标定义章节"
+
+      - id: prd-has-scope
+        name: "PRD必须包含范围定义"
+        pattern: "(?i)(范围|scope| in scope| out of scope|边界)"
+        severity: warn
+        message: "建议添加范围/边界定义章节"
+
+      - id: prd-has-user-stories
+        name: "PRD应包含用户故事"
+        pattern: "(?i)(用户故事|user story|功能需求|需求列表)"
+        severity: warn
+        message: "建议包含用户故事或需求列表"
+
+      - id: prd-has-acceptance-criteria
+        name: "PRD应包含验收标准"
+        pattern: "(?i)(验收标准|acceptance criteria|ac)"
+        severity: warn
+        message: "建议为每个需求添加验收标准"
+
+  content:
+    enabled: true
+    checks:
+      - id: prd-no-vague-language
+        name: "避免模糊语言"
+        pattern: "(大概|可能|也许|适当|合理|优化|改善|提升)"
+        severity: warn
+        message: "检测到模糊语言，建议使用具体可量化的描述"
+        exclude_patterns:
+          - "作为.*参考"
+          - "示例"
+
+      - id: prd-has-metrics
+        name: "关键指标应量化"
+        pattern: "(?i)(指标|kpi|性能|响应时间|并发|吞吐量)"
+        severity: info
+        message: "涉及指标的描述应尽量量化（如：<100ms, >99.9%）"
+
+      - id: prd-smart-goals
+        name: "目标应符合SMART原则"
+        pattern: "(?i)(目标|goal).*:.*"
+        severity: info
+        message: "目标描述应符合SMART原则（具体、可衡量、可实现、相关、有时限）"
+
+  format:
+    enabled: true
+    checks:
+      - id: prd-max-section-depth
+        name: "标题层级不超过5级"
+        max_depth: 5
+        severity: warn
+        message: "文档层级过深，建议控制在5级以内"
+
+      - id: prd-table-format
+        name: "表格格式正确性"
+        check_table_borders: true
+        severity: info
+        message: "表格格式不规范"
+
+      - id: prd-code-blocks
+        name: "代码块应有语言标注"
+        pattern: "```(?!\\w+)"
+        severity: info
+        message: "代码块缺少语言标注，建议使用 ```语言名 格式"
+
+  consistency:
+    enabled: true
+    checks:
+      - id: prd-consistent-terminology
+        name: "术语一致性"
+        severity: warn
+        message: "同一概念使用了不同的术语表达"
+
+      - id: prd-id-format
+        name: "需求ID格式统一"
+        pattern: "[A-Z]+-\\d{3,}"
+        severity: info
+        message: "需求ID建议采用统一的编号格式（如：REQ-001）"
+
+      - id: prd-reference-exists
+        name: "引用完整性"
+        severity: error
+        message: "文档中引用了不存在的章节或外部链接失效"

package/config/ruff.toml

@@ -0,0 +1,45 @@
+[tool.ruff]
+target-version = "py39"
+line-length = 120
+
+[tool.ruff.lint]
+select = [
+  "E",      # pycodestyle errors
+  "W",      # pycodestyle warnings
+  "F",      # Pyflakes
+  "I",      # isort
+  "N",      # pep8-naming
+  "UP",     # pyupgrade
+  "B",      # flake8-bugbear
+  "SIM",    # flake8-simplify
+  "C90",    # mccabe complexity
+  "A",      # flake8-builtins
+  "COM",    # flake8-commas
+  "T20",    # flake8-print
+  "ARG",    # flake8-unused-arguments
+  "RUF",    # Ruff-specific rules
+]
+ignore = [
+  "E501",   # line too long (handled by formatter)
+  "B008",   # do not perform function calls in argument defaults
+  "N802",   # function name should be lowercase
+  "N806",   # variable in function should be lowercase
+  "ARG001", # unused-function-argument
+  "COM812", # trailing comma missing (conflicts with formatter)
+]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = ["T20", "ARG"]
+"__init__.py" = ["F401"]
+"*_test.py" = ["T20", "ARG"]
+
+[tool.ruff.lint.mccabe]
+max-complexity = 12
+
+[tool.ruff.lint.pycodestyle]
+max-doc-length = 100
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+docstring-code-format = true

package/config/sqlfluff.cfg

@@ -0,0 +1,82 @@
+[sqlfluff]
+dialect = ansi
+templater = pure
+exclude_rules = L031,L042
+
+[sqlfluff:indentation]
+indented_joins = false
+tab_space_size = 2
+allow_implicit_indents = True
+
+[sqlfluff:layout]
+type = jinja
+max_line_length = 120
+
+[sqlfluff:rules]
+tab_space_size = 2
+indent_unit = space
+comma_style = trailing
+allow_scalar = True
+single_table_references = consistent
+unquoted_identifiers_policy = aliases
+
+[sqlfluff:rules:L010]  # Keywords
+capitalisation_policy = upper
+
+[sqlfluff:rules:L014]  # Unquoted identifiers
+extended_capitalisation_policy = lower
+
+[sqlfluff:rules:L030]  # Function names
+capitalisation_policy = upper
+
+[sqlfluff:rules:L040]  # Null & Boolean Literals
+capitalisation_policy = upper
+
+[sqlfluff:rules:L063]  # Consistent data types
+extended_capitalisation_policy = upper
+
+[sqlfluff:rules:L057]  # Special characters
+allow_space_in_identifier = False
+additional_allowed_characters = ""
+
+[sqlfluff:rules:L016]  # Line length
+max_line_length = 120
+indent_unit = space
+tab_space_size = 2
+
+[sqlfluff:rules:L019]  # Comma presence
+comma_style = trailing
+
+[sqlfluff:rules:L029]  # Keyword identifiers
+unquoted_identifying_policy = aliases
+
+[sqlfluff:rules:L044]  # Query folding
+collapse_keyword_suffixes = True
+
+[sqlfluff:rules:L052]  # Lines after semicolons
+multiline_newline = True
+require_final_semicolon = False
+
+[sqlfluff:rules:L061]  # Trailing commas - include in CASE statements
+include_case_statements = True
+
+[sqlfluff:rules:L062]  # COUNT(*)
+prefer_count_0 = True
+prefer_count_nonnull = False
+
+[sqlfluff:rules:L050]  # Built-in functions
+fully_qualify_all_types = True
+allow_double_qualified_references = True
+capitalisation_policy = upper
+
+[sqlfluff:rules:L003]  # Indentation
+indent_unit = space
+tab_space_size = 2
+
+[sqlfluff:rules:L007]  # Operators near newlines
+operator_new_lines = before
+align_within = off
+align_scope = column_def
+
+[sqlfluff:rules:L009]  # Files end with newlines
+files_end_with_newline = True

package/hooks/hook-executor.js

@@ -0,0 +1,332 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import { execSync } from 'child_process';
+import { log } from '../lib/utils/logger.js';
+
+const HOOK_EVENTS = {
+  session_start: {
+    description: '会话启动时触发',
+    phase: 'pre'
+  },
+  pre_feature: {
+    description: '功能开发前触发',
+    phase: 'pre'
+  },
+  post_feature: {
+    description: '功能开发后触发',
+    phase: 'post'
+  },
+  pre_commit: {
+    description: '提交代码前触发',
+    phase: 'pre'
+  },
+  post_commit: {
+    description: '提交代码后触发',
+    phase: 'post'
+  },
+  linter_fail: {
+    description: 'Linter检查失败时触发',
+    phase: 'post'
+  }
+};
+
+export class HookExecutor {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.hooksConfig = null;
+    this.hooksDir = path.join(projectRoot, '.pdd', 'hooks.d');
+  }
+
+  async load() {
+    const configPath = path.join(this.projectRoot, '.pdd', 'hooks.yaml');
+
+    if (fs.existsSync(configPath)) {
+      try {
+        const content = fs.readFileSync(configPath, 'utf-8');
+        const yaml = await import('yaml');
+        this.hooksConfig = yaml.parse(content);
+        log('info', 'Hook配置加载完成');
+      } catch (e) {
+        log('warn', `Hook配置解析失败: ${e.message}`);
+        this.hooksConfig = {};
+      }
+    } else {
+      this.hooksConfig = {};
+    }
+  }
+
+  async trigger(eventName, context = {}) {
+    if (!this.hooksConfig) await this.load();
+
+    const eventConfig = this.hooksConfig[eventName];
+    if (!eventConfig || eventConfig.enabled === false) {
+      return { skipped: true, reason: '事件未启用或未配置' };
+    }
+
+    log('info', `触发Hook事件: ${eventName}`);
+    console.log(chalk.gray(`  🪝 ${HOOK_EVENTS[eventName]?.description || eventName}`));
+
+    const results = [];
+
+    if (eventConfig.checks) {
+      for (const check of eventConfig.checks) {
+        const result = await this.executeCheck(check, eventName, context);
+        results.push(result);
+
+        if (!result.passed && eventConfig.fail_fast !== false) {
+          break;
+        }
+      }
+    }
+
+    if (eventConfig.actions) {
+      for (const action of eventConfig.actions) {
+        const result = await this.executeAction(action, eventName, context);
+        results.push(result);
+      }
+    }
+
+    const customHooks = await this.loadCustomHooks(eventName);
+    for (const hook of customHooks) {
+      const result = await this.executeCustomHook(hook, context);
+      results.push(result);
+    }
+
+    const allPassed = results.every(r => r.passed !== false);
+    return { success: allPassed, results, eventName };
+  }
+
+  async executeCheck(checkName, eventName, context) {
+    const checkHandlers = {
+      spec_exists: () => this.checkSpecExists(context),
+      dependencies_met: () => this.checkDependenciesMet(context),
+      linter_pass: () => this.checkLinterPass(context),
+      tests_pass: () => this.checkTestsPass(context)
+    };
+
+    const handler = checkHandlers[checkName];
+    if (!handler) {
+      return { check: checkName, passed: true, skipped: true, message: `未知检查项: ${checkName}` };
+    }
+
+    try {
+      const result = await handler();
+      log(result.passed ? 'info' : 'warn', `  Check [${checkName}]: ${result.message}`);
+      return { check: checkName, ...result };
+    } catch (e) {
+      return { check: checkName, passed: false, error: e.message };
+    }
+  }
+
+  async executeAction(actionName, eventName, context) {
+    const actionHandlers = {
+      run_linter: () => this.actionRunLinter(context),
+      run_tests: () => this.actionRunTests(context),
+      generate_report: () => this.actionGenerateReport(context),
+      cache_clear: () => this.actionCacheClear(context)
+    };
+
+    const handler = actionHandlers[actionName];
+    if (!handler) {
+      return { action: actionName, passed: true, skipped: true, message: `未知动作: ${actionName}` };
+    }
+
+    try {
+      const result = await handler();
+      log('info', `  Action [${actionName}]: ${result.message}`);
+      return { action: actionName, ...result };
+    } catch (e) {
+      return { action: actionName, passed: false, error: e.message };
+    }
+  }
+
+  async loadCustomHooks(eventName) {
+    const hooks = [];
+
+    if (!fs.existsSync(this.hooksDir)) return hooks;
+
+    try {
+      const files = fs.readdirSync(this.hooksDir)
+        .filter(f => f.startsWith(`${eventName}.`) || f.startsWith(`${eventName}_`));
+
+      for (const file of files) {
+        const hookPath = path.join(this.hooksDir, file);
+        const ext = path.extname(file);
+
+        if (ext === '.js') {
+          hooks.push({ type: 'script', path: hookPath, language: 'javascript' });
+        } else if (ext === '.py') {
+          hooks.push({ type: 'script', path: hookPath, language: 'python' });
+        } else if (ext === '.sh' || ext === '.cmd') {
+          hooks.push({ type: 'command', path: hookPath });
+        }
+      }
+    } catch {}
+
+    return hooks;
+  }
+
+  async executeCustomHook(hook, context) {
+    try {
+      let output = '';
+
+      if (hook.type === 'script' && hook.language === 'javascript') {
+        output = execSync(`node "${hook.path}"`, {
+          cwd: this.projectRoot,
+          encoding: 'utf-8',
+          timeout: 30000,
+          env: { ...process.env, ...this.buildEnvContext(context) }
+        });
+      } else if (hook.type === 'script' && hook.language === 'python') {
+        output = execSync(`python "${hook.path}"`, {
+          cwd: this.projectRoot,
+          encoding: 'utf-8',
+          timeout: 30000,
+          env: { ...process.env, ...this.buildEnvContext(context) }
+        });
+      } else if (hook.type === 'command') {
+        output = execSync(`"${hook.path}"`, {
+          cwd: this.projectRoot,
+          encoding: 'utf-8',
+          timeout: 30000,
+          env: { ...process.env, ...this.buildEnvContext(context) }
+        });
+      }
+
+      return {
+        hook: path.basename(hook.path),
+        passed: true,
+        output: output.trim()
+      };
+    } catch (e) {
+      return {
+        hook: path.basename(hook.path),
+        passed: false,
+        error: e.message,
+        output: e.stdout?.trim() || ''
+      };
+    }
+  }
+
+  buildEnvContext(context) {
+    return {
+      PDD_EVENT: context.event || '',
+      PDD_FEATURE_ID: context.featureId || '',
+      PDD_PROJECT_DIR: this.projectRoot || '',
+      PDD_SPEC_DIR: path.join(this.projectRoot, 'specs') || ''
+    };
+  }
+
+  async checkSpecExists(context) {
+    const specDir = path.join(this.projectRoot, 'specs');
+    const hasSpecs = fs.existsSync(specDir) && fs.readdirSync(specDir).some(
+      f => f.endsWith('.md') || f.endsWith('.yaml')
+    );
+
+    return {
+      passed: hasSpecs,
+      message: hasSpecs ? '规格文件已存在' : '⚠ 未找到规格文件'
+    };
+  }
+
+  async checkDependenciesMet(context) {
+    const pkgPath = path.join(this.projectRoot, 'package.json');
+    if (!fs.existsSync(pkgPath)) {
+      return { passed: true, message: '非Node.js项目，跳过依赖检查' };
+    }
+
+    try {
+      execSync('npm ls --depth=0', { cwd: this.projectRoot, encoding: 'utf-8', timeout: 30000 });
+      return { passed: true, message: '依赖检查通过' };
+    } catch (e) {
+      return { passed: false, message: '依赖安装不完整' };
+    }
+  }
+
+  async checkLinterPass(context) {
+    try {
+      const { default: runLinters } = await import('../scripts/linter/run-linters.js');
+      const results = await runLinters({ type: ['code'], incremental: true });
+      const allPassed = results.every(r => r.success);
+      return {
+        passed: allPassed,
+        message: allPassed ? 'Linter检查通过' : 'Linter检查发现问题'
+      };
+    } catch (e) {
+      return { passed: false, message: `Linter执行异常: ${e.message}` };
+    }
+  }
+
+  async checkTestsPass(context) {
+    const testCommands = [
+      { cmd: 'npm test', pkg: 'package.json' },
+      { cmd: 'pytest', file: 'pytest.ini' },
+      { cmd: 'mvn test', file: 'pom.xml' }
+    ];
+
+    for (const tc of testCommands) {
+      if (tc.pkg && fs.existsSync(path.join(this.projectRoot, tc.pkg))) {
+        try {
+          execSync(tc.cmd, { cwd: this.projectRoot, encoding: 'utf-8', timeout: 120000 });
+          return { passed: true, message: '测试通过' };
+        } catch (e) {
+          return { passed: false, message: '测试未通过' };
+        }
+      }
+      if (tc.file && fs.existsSync(path.join(this.projectRoot, tc.file))) {
+        try {
+          execSync(tc.cmd, { cwd: this.projectRoot, encoding: 'utf-8', timeout: 120000 });
+          return { passed: true, message: '测试通过' };
+        } catch (e) {
+          return { passed: false, message: '测试未通过' };
+        }
+      }
+    }
+
+    return { passed: true, skipped: true, message: '未找到测试配置，跳过' };
+  }
+
+  async actionRunLinter(context) {
+    try {
+      const { default: runLinters } = await import('../scripts/linter/run-linters.js');
+      await runLinters({ type: ['code'] });
+      return { passed: true, message: 'Linter执行完成' };
+    } catch (e) {
+      return { passed: false, message: e.message };
+    }
+  }
+
+  async actionRunTests(context) {
+    const testResult = await this.checkTestsPass(context);
+    return { passed: testResult.passed, message: testResult.message };
+  }
+
+  async actionGenerateReport(context) {
+    const reportDir = path.join(this.projectRoot, '.pdd', 'cache', 'reports');
+    await fs.ensureDir(reportDir);
+
+    const reportPath = path.join(reportDir, `hook-report-${Date.now()}.md`);
+    const content = [
+      '# Hook 执行报告',
+      '',
+      `- 时间: ${new Date().toISOString()}`,
+      `- 项目: ${path.basename(this.projectRoot)}`,
+      ''
+    ].join('\n');
+
+    await fs.writeFile(reportPath, content, 'utf-8');
+    return { passed: true, message: `报告生成: ${reportPath}` };
+  }
+
+  async actionCacheClear(context) {
+    const cacheDir = path.join(this.projectRoot, '.pdd', 'cache');
+    if (fs.existsSync(cacheDir)) {
+      const specsCache = path.join(cacheDir, 'specs');
+      if (fs.existsSync(specsCache)) {
+        fs.emptyDirSync(specsCache);
+      }
+    }
+    return { passed: true, message: '缓存已清理' };
+  }
+}