pdd-skills 3.0.0

package/skills/entropy/expert-arch-enforcer/SKILL.md

@@ -0,0 +1,292 @@
+---
+name: expert-arch-enforcer
+description: 架构约束强制技能，监控代码是否违反预设的不变量和架构边界。当用户需要架构检查或依赖检查时自动触发。支持中文触发：架构检查、依赖检查、模块边界检查。
+  
+  核心职责：确保架构连贯性，防止架构漂移。
+license: MIT
+compatibility: 需要架构约束配置
+metadata:
+  author: "neuqik@hotmail.com"
+  version: "1.0"
+---
+
+# 架构约束强制 (expert-arch-enforcer)
+
+## 核心理念
+
+> "在智能体优先的世界中，架构连贯性容易随时间漂移。约束是速度的保障，不是束缚。" —— Harness Engineering
+
+架构约束强制技能负责监控代码是否违反了预设的不变量和架构边界，确保代码结构保持一致性。
+
+## 架构约束模型
+
+### 六层依赖模型
+
+```
+Types → Config → Repo → Service → Runtime → UI
+
+规则：只能向前依赖，不能反向依赖
+```
+
+| 层级 | 职责 | 允许依赖 |
+|------|------|---------|
+| Types | 类型定义、数据模型 | 无 |
+| Config | 配置管理、常量定义 | Types |
+| Repo | 数据访问、外部服务调用 | Types, Config |
+| Service | 业务逻辑、领域服务 | Types, Config, Repo |
+| Runtime | 运行时、应用入口 | Types, Config, Repo, Service |
+| UI | 用户界面、展示层 | 所有层 |
+
+### 边界约束
+
+**数据边界**：
+- 所有外部数据必须验证
+- API 入口参数必须有 Schema 验证
+- 不允许猜测数据结构
+
+**模块边界**：
+- 模块间通过接口通信
+- 禁止跨层直接访问
+- 共享状态必须显式声明
+
+---
+
+## 检测项
+
+### 1. 模块依赖方向违规
+
+**检测方法**：
+- 解析 import/require 语句
+- 构建依赖图
+- 检查是否违反依赖方向
+
+**示例**：
+```
+文件：src/types/User.ts
+import: import { UserService } from '../service/UserService'
+→ 检测结果：Types 层依赖 Service 层，违反依赖方向
+```
+
+### 2. 边界数据验证缺失
+
+**检测方法**：
+- 扫描 API 入口函数
+- 检查是否有 Schema 验证
+- 标记缺失验证的入口
+
+**示例**：
+```
+API 入口：POST /api/users
+参数验证：无
+→ 检测结果：缺少参数验证 Schema
+```
+
+### 3. 文件大小超限
+
+**检测方法**：
+- 统计文件行数
+- 对比配置的最大行数
+- 标记超限文件
+
+**示例**：
+```
+文件：src/service/UserService.ts
+行数：450 行
+限制：300 行
+→ 检测结果：文件过大，建议拆分
+```
+
+### 4. 命名规范违反
+
+**检测方法**：
+- 检查文件名、函数名、变量名
+- 对比命名规范
+- 标记违规命名
+
+**示例**：
+```
+函数名：get_data
+规范：camelCase
+→ 检测结果：命名不规范，应为 getData
+```
+
+---
+
+## 执行流程
+
+```
+┌─────────────┐     ┌─────────────┐     ┌─────────────┐     ┌─────────────┐
+│   解析      │ ──→ │   构建      │ ──→ │   检测      │ ──→ │   报告      │
+│             │     │             │     │             │     │             │
+│ • 代码文件  │     │ • 依赖图    │     │ • 依赖违规  │     │ • 问题清单  │
+│ • import    │     │ • 调用关系  │     │ • 边界违规  │     │ • 修复建议  │
+│ • 函数签名  │     │ • 模块结构  │     │ • 大小违规  │     │ • PR 创建   │
+└─────────────┘     └─────────────┘     └─────────────┘     └─────────────┘
+```
+
+---
+
+## 工具集成
+
+### 自定义 Linter
+
+```javascript
+// custom-linter.js
+module.exports = {
+  rules: {
+    'layer-dependency': {
+      meta: {
+        docs: { description: '强制六层依赖方向' }
+      },
+      create(context) {
+        const layers = ['types', 'config', 'repo', 'service', 'runtime', 'ui'];
+        return {
+          ImportDeclaration(node) {
+            const source = node.source.value;
+            const currentLayer = getCurrentLayer(context.getFilename());
+            const targetLayer = getLayerFromPath(source);
+            
+            if (layers.indexOf(targetLayer) < layers.indexOf(currentLayer)) {
+              context.report({
+                node,
+                message: `违反依赖方向: ${currentLayer} 不能依赖 ${targetLayer}`
+              });
+            }
+          }
+        };
+      }
+    }
+  }
+};
+```
+
+### ArchUnit 测试
+
+```java
+// ArchitectureTest.java
+@AnalyzeClasses(packages = "com.example")
+public class ArchitectureTest {
+    
+    @ArchTest
+    static final ArchRule layer_dependency_rule = layeredArchitecture()
+        .layer("Types").definedBy("..types..")
+        .layer("Config").definedBy("..config..")
+        .layer("Repo").definedBy("..repo..")
+        .layer("Service").definedBy("..service..")
+        .layer("Runtime").definedBy("..runtime..")
+        .layer("UI").definedBy("..ui..")
+        .whereLayer("Types").mayNotBeAccessedByAnyLayer()
+        .whereLayer("Config").mayOnlyBeAccessedByLayers("Repo", "Service", "Runtime", "UI")
+        .whereLayer("Repo").mayOnlyBeAccessedByLayers("Service", "Runtime", "UI");
+}
+```
+
+---
+
+## 输出格式
+
+### 架构约束报告
+
+```markdown
+# 架构约束报告 - YYYY-MM-DD
+
+## 架构健康度：XX/100
+
+## 依赖图
+
+[依赖关系可视化图]
+
+## 发现问题
+
+### Critical（必须修复）
+| 文件 | 问题 | 违规类型 |
+|------|------|---------|
+| src/types/User.ts | 依赖 Service 层 | 依赖方向违规 |
+
+### Warning（建议修复）
+| 文件 | 问题 | 违规类型 |
+|------|------|---------|
+| src/api/users.ts | 缺少参数验证 | 边界验证缺失 |
+
+### Info（可选修复）
+| 文件 | 问题 | 违规类型 |
+|------|------|---------|
+| src/service/UserService.ts | 文件 450 行 | 大小超限 |
+
+## 修复建议
+
+### Critical 修复
+1. 移除 User.ts 中对 UserService 的依赖
+2. 将共享逻辑提取到 Types 层
+```
+
+---
+
+## 配置选项
+
+```yaml
+# arch-enforcer-config.yaml
+arch_enforcer:
+  # 层级定义
+  layers:
+    - name: types
+      paths: ["src/types/", "src/models/"]
+    - name: config
+      paths: ["src/config/", "src/constants/"]
+    - name: repo
+      paths: ["src/repo/", "src/data/"]
+    - name: service
+      paths: ["src/service/", "src/domain/"]
+    - name: runtime
+      paths: ["src/runtime/", "src/app/"]
+    - name: ui
+      paths: ["src/ui/", "src/components/"]
+  
+  # 约束规则
+  constraints:
+    max_file_lines: 300
+    max_function_lines: 50
+    require_schema_validation: true
+  
+  # 执行配置
+  execution:
+    run_linter: true
+    run_arch_test: true
+    create_pr: true
+```
+
+---
+
+## 使用示例
+
+### 示例 1：全面架构检查
+
+```
+用户：检查架构约束
+
+AI：
+1. 解析代码文件
+2. 构建依赖图
+3. 运行 Linter 和 ArchUnit
+4. 生成报告
+```
+
+### 示例 2：依赖方向检查
+
+```
+用户：检查模块依赖方向
+
+AI：
+1. 解析 import 语句
+2. 构建依赖图
+3. 检查是否违反六层模型
+4. 生成违规报告
+```
+
+---
+
+## 与其他技能的协作
+
+- **pdd-entropy-reduction**：作为子技能被协调调用
+- **expert-auto-refactor**：接收架构违规，执行重构
+- **pdd-code-reviewer**：集成架构检查到代码审查

package/skills/entropy/expert-arch-enforcer/_meta.json

@@ -0,0 +1 @@
+{"name": "expert-arch-enforcer", "version": "1.0.0", "category": "entropy", "description": "Architecture constraint enforcer monitoring code for violations of preset invariants and boundaries. Invoke when checking architecture compliance, dependency direction, or module boundary violations.", "triggers": ["架构检查", "依赖检查", "模块边界"]}

package/skills/entropy/expert-arch-enforcer/evals/default-evals.json

@@ -0,0 +1 @@
+[{"name": "SKILL.md-exists", "description": "技能文件存在且格式正确", "type": "structure", "expect": {"exists": true, "hasDescription": true}, "checks": {"file_exists": "SKILL.md"}}, {"name": "_meta.json-valid", "description": "元数据文件格式正确", "type": "structure", "expect": {"exists": true, "hasName": true, "hasVersion": true, "hasTriggers": true}, "checks": {"file_exists": "_meta.json"}}, {"name": "constraints-defined", "description": "定义了架构约束规则(不变量/依赖方向/模块边界)", "type": "content", "contains": ["约束", "不变量", "依赖", "模块边界", "架构漂移"]}, {"name": "violation-types-defined", "description": "定义了违规类型和严重级别", "type": "content", "contains": ["违规", "CRITICAL", "WARN", "INFO", "检测"]}, {"name": "enforcement-actions-defined", "description": "定义了强制执行动作(阻止/警告/记录)", "type": "content", "contains": ["执行", "阻止", "警告", "记录", "CI"]}]

package/skills/entropy/expert-auto-refactor/SKILL.md

@@ -0,0 +1,327 @@
+---
+name: expert-auto-refactor
+description: Automated refactoring expert transforming quality improvements into concrete code operations. Call when eliminating duplication or simplifying complexity systematically. 支持中文触发：重构代码、消除重复、简化代码。
+  
+  Core responsibility: Initiate targeted refactoring PRs regularly in a "small debt repayment" manner to prevent technical debt accumulation.
+  
+  Trigger scenarios:
+  - User requests "refactor code", "eliminate duplicates", "simplify code"
+  - Called by pdd-entropy-reduction coordinator
+  - Refactoring suggestions passed from expert-entropy-auditor
+  
+  支持中文触发：自动重构、代码重构、消除重复、简化代码、重构专家、PDD重构。
+author: neuqik@hotmail.com
+license: MIT
+---
+
+# Automated Refactoring Expert (expert-auto-refactor)
+
+## Core Philosophy
+
+> "Initiate targeted refactoring PRs regularly in a 'small debt repayment' manner to prevent technical debt from accumulating into unmanageable 'painful interest'." —— Harness Engineering
+
+The automated refactoring expert is an upgraded version of `expert-code-quality`, not just recording issues but actively executing refactoring operations.
+
+## Refactoring Types
+
+### 1. Extract Common Methods
+
+**Scenario**: Similar code logic in multiple places
+
+**Refactoring Method**:
+1. Identify similar code
+2. Extract common methods
+3. Replace original calls
+
+**Example**:
+
+Before refactoring:
+```javascript
+// File A
+function formatDate(date) {
+  return `${date.getFullYear()}-${date.getMonth() + 1}-${date.getDate()}`;
+}
+
+// File B
+function formatDateString(d) {
+  return `${d.getFullYear()}-${d.getMonth() + 1}-${d.getDate()}`;
+}
+```
+
+After refactoring:
+```javascript
+// utils/dateUtils.ts
+export function formatDate(date: Date): string {
+  return `${date.getFullYear()}-${date.getMonth() + 1}-${date.getDate()}`;
+}
+
+// File A
+import { formatDate } from '../utils/dateUtils';
+
+// File B
+import { formatDate } from '../utils/dateUtils';
+```
+
+### 2. Eliminate Duplicate Code
+
+**Scenario**: Identical or highly similar code blocks
+
+**Refactoring Method**:
+1. Detect duplicate code
+2. Extract to shared module
+3. Update references
+
+**Example**:
+
+Before refactoring:
+```javascript
+// Repeated validation logic in multiple places
+if (!user.email || !user.email.includes('@')) {
+  throw new Error('Invalid email');
+}
+```
+
+After refactoring:
+```javascript
+// utils/validators.ts
+export function validateEmail(email: string): boolean {
+  return email && email.includes('@');
+}
+
+// Usage
+if (!validateEmail(user.email)) {
+  throw new Error('Invalid email');
+}
+```
+
+### 3. Simplify Complex Logic
+
+**Scenario**: Functions that are too long, deeply nested, or have complex logic
+
+**Refactoring Method**:
+1. Split long functions
+2. Extract sub-functions
+3. Simplify conditional logic
+
+**Example**:
+
+Before refactoring:
+```javascript
+function processOrder(order) {
+  if (order.status === 'pending') {
+    if (order.items.length > 0) {
+      if (order.payment) {
+        // Processing logic...
+        if (order.shipping) {
+          // More processing...
+        }
+      }
+    }
+  }
+}
+```
+
+After refactoring:
+```javascript
+function processOrder(order) {
+  if (!canProcessOrder(order)) return;
+  
+  processPayment(order);
+  processShipping(order);
+  updateOrderStatus(order);
+}
+
+function canProcessOrder(order) {
+  return order.status === 'pending' 
+    && order.items.length > 0 
+    && order.payment;
+}
+```
+
+### 4. Optimize Naming
+
+**Scenario**: Non-standard naming, unclear meaning
+
+**Refactoring Method**:
+1. Analyze naming context
+2. Generate better naming
+3. Batch replacement
+
+**Example**:
+
+Before refactoring:
+```javascript
+function calc(a, b) {
+  return a * b * 0.1;
+}
+```
+
+After refactoring:
+```javascript
+function calculateTax(basePrice: number, quantity: number): number {
+  const TAX_RATE = 0.1;
+  return basePrice * quantity * TAX_RATE;
+}
+```
+
+---
+
+## Refactoring Process
+
+```
+┌─────────────┐     ┌─────────────┐     ┌─────────────┐     ┌─────────────┐
+│   Analyze   │ ──→ │    Plan     │ ──→ │   Execute   │ ──→ │   Verify    │
+│             │     │             │     │             │     │             │
+│ • Code      │     │ • Refactor  │     │ • Code      │     │ • Test      │
+│   structure │     │   strategy  │     │   changes   │     │   execution │
+│ •           │     │ • Impact    │     │ • Reference │     │ • Function  │
+│ Dependencies│     │   scope     │     │   updates   │     │   validation│
+│ • Test      │     │ • Risk      │     │ • Document  │     │ • PR        │
+│   coverage  │     │   assessment│     │   sync      │     │   creation  │
+└─────────────┘     └─────────────┘     └─────────────┘     └─────────────┘
+```
+
+---
+
+## Refactoring Strategy
+
+### Small Debt Repayment Principle
+
+Each refactoring should:
+1. **Small steps**: Only change a small part each time
+2. **Maintain tests**: Ensure tests always pass
+3. **Frequent commits**: Commit after each small step
+4. **Rollback capable**: Keep each commit independently rollbackable
+
+### Risk Assessment
+
+| Risk Level | Condition | Strategy |
+|---------|------|------|
+| Low | Complete test coverage | Auto execute |
+| Medium | Partial test coverage | Create PR |
+| High | No test coverage | Add tests first then refactor |
+
+---
+
+## Output Format
+
+### Refactoring Report
+
+```markdown
+# Refactoring Report - YYYY-MM-DD
+
+## Refactoring Scope
+- Target files: X
+- Affected files: X
+- Test coverage: X%
+
+## Refactoring Operations
+
+### Extract Common Methods
+| Original File | New File | Method Name | Status |
+|-------|-------|-------|------|
+| utils/formatDate.js | utils/dateUtils.ts | formatDate | ✅ Completed |
+
+### Eliminate Duplicate Code
+| File A | File B | Duplicate Lines | Status |
+|-------|-------|---------|------|
+| service/UserService.ts | service/OrderService.ts | 25 lines | ✅ Completed |
+
+### Simplify Complex Logic
+| File | Function Name | Original Lines | New Lines | Status |
+|------|-------|-------|-------|------|
+| service/OrderService.ts | processOrder | 80 | 35 | ✅ Completed |
+
+## Verification Results
+- Unit tests: ✅ All passed
+- Integration tests: ✅ All passed
+- Functional verification: ✅ No anomalies
+
+## PR Information
+- PR number: #XXX
+- Branch: refactor/entropy-reduction-YYYYMMDD
+- Status: Pending review
+```
+
+---
+
+## Configuration Options
+
+```yaml
+# auto-refactor-config.yaml
+auto_refactor:
+  # Refactoring scope
+  scope:
+    code_paths: ["src/"]
+    exclude: ["node_modules/", "dist/", "build/"]
+  
+  # Refactoring rules
+  rules:
+    max_file_lines: 300
+    max_function_lines: 50
+    min_similarity: 0.8
+  
+  # Execution strategy
+  execution:
+    auto_fix_low_risk: true   # Auto fix low risk
+    create_pr: true           # Create PR
+    max_changes_per_run: 10   # Max changes per run
+  
+  # Testing requirements
+  testing:
+    require_tests: true       # Require tests
+    min_coverage: 80          # Minimum coverage
+```
+
+---
+
+## Usage Examples
+
+### Example 1: Extract Duplicate Code
+
+```
+User: Eliminate duplicates in code
+
+AI:
+1. Detect duplicate code
+2. Analyze similarity
+3. Extract to shared module
+4. Update all references
+5. Create PR
+```
+
+### Example 2: Simplify Complex Function
+
+```
+User: Simplify processOrder function
+
+AI:
+1. Analyze function structure
+2. Identify extractable sub-functions
+3. Execute split refactoring
+4. Run test verification
+5. Create PR
+```
+
+### Example 3: Optimize Naming
+
+```
+User: Optimize code naming
+
+AI:
+1. Scan non-standard naming
+2. Analyze context
+3. Generate better naming
+4. Batch replacement
+5. Create PR
+```
+
+---
+
+## Collaboration with Other Skills
+
+- **pdd-entropy-reduction**: Called as a sub-skill by the coordinator
+- **expert-entropy-auditor**: Receive refactoring suggestions
+- **expert-arch-enforcer**: Receive architecture violation fixes
+- **pdd-code-reviewer**: Trigger code review after refactoring
+- **pdd-doc-change**: Synchronously update related documentation

package/skills/entropy/expert-auto-refactor/_meta.json

@@ -0,0 +1 @@
+{"name": "expert-auto-refactor", "version": "1.0.0", "category": "entropy", "description": "Automated refactoring expert transforming collected quality improvements into concrete code operations. Call when eliminating code duplication, simplifying complexity, or applying design patterns systematically.", "triggers": ["重构代码", "消除重复", "简化代码"]}

package/skills/entropy/expert-auto-refactor/evals/default-evals.json

@@ -0,0 +1 @@
+[{"name": "SKILL.md-exists", "description": "技能文件存在且格式正确", "type": "structure", "expect": {"exists": true, "hasDescription": true}, "checks": {"file_exists": "SKILL.md"}}, {"name": "_meta.json-valid", "description": "元数据文件格式正确", "type": "structure", "expect": {"exists": true, "hasName": true, "hasVersion": true, "hasTriggers": true}, "checks": {"file_exists": "_meta.json"}}, {"name": "refactor-types-defined", "description": "定义了自动化重构类型(提取方法/内联/重命名等)", "type": "content", "contains": ["重构", "Extract", "Inline", "重复", "simplify"]}, {"name": "debt-repayment-strategy", "description": "定义了小额还贷策略", "type": "content", "contains": ["小额还贷", "定期", "技术债务", "偿还", "repayment"]}, {"name": "safe-operations-defined", "description": "定义了安全重构操作边界", "type": "content", "contains": ["安全", "测试", "验证", "targeted"]}]