claude-code-workflow 6.3.2 → 6.3.5

package/.claude/skills/copyright-docs/specs/cpcc-requirements.md

@@ -0,0 +1,121 @@
+# CPCC Compliance Requirements
+
+China Copyright Protection Center (CPCC) requirements for software design specification.
+
+## When to Use
+
+| Phase | Usage | Section |
+|-------|-------|---------|
+| Phase 4 | Check document structure before assembly | Document Requirements, Mandatory Sections |
+| Phase 4 | Apply correct figure numbering | Figure Numbering Convention |
+| Phase 5 | Validate before each iteration | Validation Function |
+| Phase 5 | Handle failures during refinement | Error Handling |
+
+---
+
+## Document Requirements
+
+### Format
+- [ ] 页眉包含软件名称和版本号
+- [ ] 页码位于右上角说明
+- [ ] 每页不少于30行文字（图表页除外）
+- [ ] A4纵向排版，文字从左至右
+
+### Mandatory Sections (7 章节)
+- [ ] 1. 软件概述
+- [ ] 2. 系统架构图
+- [ ] 3. 功能模块设计
+- [ ] 4. 核心算法与流程
+- [ ] 5. 数据结构设计
+- [ ] 6. 接口设计
+- [ ] 7. 异常处理设计
+
+### Content Requirements
+- [ ] 所有内容基于代码分析
+- [ ] 无臆测或未来计划
+- [ ] 无原始指令性文字
+- [ ] Mermaid 语法正确
+- [ ] 图表编号和说明完整
+
+## Validation Function
+
+```javascript
+function validateCPCCCompliance(document, analyses) {
+  const checks = [
+    {name: "软件概述完整性", pass: document.includes("## 1. 软件概述")},
+    {name: "系统架构图存在", pass: document.includes("图2-1 系统架构图")},
+    {name: "功能模块设计完整", pass: document.includes("## 3. 功能模块设计")},
+    {name: "核心算法描述", pass: document.includes("## 4. 核心算法与流程")},
+    {name: "数据结构设计", pass: document.includes("## 5. 数据结构设计")},
+    {name: "接口设计说明", pass: document.includes("## 6. 接口设计")},
+    {name: "异常处理设计", pass: document.includes("## 7. 异常处理设计")},
+    {name: "Mermaid图表语法", pass: !document.includes("mermaid error")},
+    {name: "页眉信息", pass: document.includes("页眉")},
+    {name: "页码说明", pass: document.includes("页码")}
+  ];
+
+  return {
+    passed: checks.filter(c => c.pass).length,
+    total: checks.length,
+    details: checks
+  };
+}
+```
+
+## Software Categories
+
+| Category | Document Focus |
+|----------|----------------|
+| 命令行工具 (CLI) | 命令、参数、使用流程 |
+| 后端服务/API | 端点、协议、数据流 |
+| SDK/库 | 接口、集成、使用示例 |
+| 数据处理系统 | 数据流、转换、ETL |
+| 自动化脚本 | 工作流、触发器、调度 |
+
+## Figure Numbering Convention
+
+| Section | Figure | Title |
+|---------|--------|-------|
+| 2 | 图2-1 | 系统架构图 |
+| 3 | 图3-1 | 功能模块结构图 |
+| 4 | 图4-N | {算法名称}流程图 |
+| 5 | 图5-1 | 数据结构类图 |
+| 6 | 图6-N | {接口名称}时序图 |
+| 7 | 图7-1 | 异常处理流程图 |
+
+## Error Handling
+
+| Error | Recovery |
+|-------|----------|
+| Analysis timeout | Reduce scope, retry |
+| Missing section data | Re-run targeted agent |
+| Diagram validation fails | Regenerate with fixes |
+| User abandons iteration | Save progress, allow resume |
+
+---
+
+## Integration with Phases
+
+**Phase 4 - Document Assembly**:
+```javascript
+// Before assembling document
+const docChecks = [
+  {check: "页眉格式", value: `<!-- 页眉：${metadata.software_name} - 版本号：${metadata.version} -->`},
+  {check: "页码说明", value: `<!-- 注：最终文档页码位于每页右上角 -->`}
+];
+
+// Apply figure numbering from convention table
+const figureNumbers = getFigureNumbers(sectionIndex);
+```
+
+**Phase 5 - Compliance Refinement**:
+```javascript
+// In 05-compliance-refinement.md
+const validation = validateCPCCCompliance(document, analyses);
+
+if (validation.passed < validation.total) {
+  // Failed checks become discovery questions
+  const failedChecks = validation.details.filter(d => !d.pass);
+  discoveries.complianceIssues = failedChecks;
+}
+```

package/.claude/skills/copyright-docs/templates/agent-base.md

@@ -0,0 +1,200 @@
+# Agent Base Template
+
+所有分析 Agent 的基础模板，确保一致性和高效执行。
+
+## 通用提示词结构
+
+```
+[ROLE] 你是{角色}，专注于{职责}。
+
+[TASK]
+分析代码库，生成 CPCC 合规的章节文档。
+- 输出: {output_dir}/sections/{filename}
+- 格式: Markdown + Mermaid
+- 范围: {scope_path}
+
+[CONSTRAINTS]
+- 只描述已实现的代码，不臆测
+- 中文输出，技术术语可用英文
+- Mermaid 图表必须可渲染
+- 文件/类/函数需包含路径引用
+
+[OUTPUT_FORMAT]
+1. 直接写入 MD 文件
+2. 返回 JSON 简要信息
+
+[QUALITY_CHECKLIST]
+- [ ] 包含至少1个 Mermaid 图表
+- [ ] 每个子章节有实质内容 (>100字)
+- [ ] 代码引用格式: `src/path/file.ts:line`
+- [ ] 图表编号正确 (图N-M)
+```
+
+## 变量说明
+
+| 变量 | 来源 | 示例 |
+|------|------|------|
+| {output_dir} | Phase 1 创建 | .workflow/.scratchpad/copyright-xxx |
+| {software_name} | metadata.software_name | 智能数据分析系统 |
+| {scope_path} | metadata.scope_path | src/ |
+| {tech_stack} | metadata.tech_stack | TypeScript/Node.js |
+
+## Agent 提示词模板
+
+### 精简版 (推荐)
+
+```javascript
+const agentPrompt = (agent, meta, outDir) => `
+[ROLE] ${AGENT_ROLES[agent]}
+
+[TASK]
+分析 ${meta.scope_path}，生成 ${AGENT_SECTIONS[agent]}。
+输出: ${outDir}/sections/${AGENT_FILES[agent]}
+
+[TEMPLATE]
+${AGENT_TEMPLATES[agent]}
+
+[FOCUS]
+${AGENT_FOCUS[agent].join('\n')}
+
+[RETURN]
+{"status":"completed","output_file":"${AGENT_FILES[agent]}","summary":"<50字>","cross_module_notes":[],"stats":{}}
+`;
+```
+
+### 配置映射
+
+```javascript
+const AGENT_ROLES = {
+  architecture: "系统架构师，专注于分层设计和模块依赖",
+  functions: "功能分析师，专注于功能点识别和交互",
+  algorithms: "算法工程师，专注于核心逻辑和复杂度",
+  data_structures: "数据建模师，专注于实体关系和类型",
+  interfaces: "API设计师，专注于接口契约和协议",
+  exceptions: "可靠性工程师，专注于异常处理和恢复"
+};
+
+const AGENT_SECTIONS = {
+  architecture: "Section 2: 系统架构图",
+  functions: "Section 3: 功能模块设计",
+  algorithms: "Section 4: 核心算法与流程",
+  data_structures: "Section 5: 数据结构设计",
+  interfaces: "Section 6: 接口设计",
+  exceptions: "Section 7: 异常处理设计"
+};
+
+const AGENT_FILES = {
+  architecture: "section-2-architecture.md",
+  functions: "section-3-functions.md",
+  algorithms: "section-4-algorithms.md",
+  data_structures: "section-5-data-structures.md",
+  interfaces: "section-6-interfaces.md",
+  exceptions: "section-7-exceptions.md"
+};
+
+const AGENT_FOCUS = {
+  architecture: [
+    "1. 分层: 识别代码层次 (Controller/Service/Repository)",
+    "2. 模块: 核心模块及职责边界",
+    "3. 依赖: 模块间依赖方向",
+    "4. 数据流: 请求/数据的流动路径"
+  ],
+  functions: [
+    "1. 功能点: 枚举所有用户可见功能",
+    "2. 模块分组: 按业务域分组",
+    "3. 入口: 每个功能的代码入口",
+    "4. 交互: 功能间的调用关系"
+  ],
+  algorithms: [
+    "1. 核心算法: 业务逻辑的关键算法",
+    "2. 流程步骤: 分支/循环/条件",
+    "3. 复杂度: 时间/空间复杂度",
+    "4. 输入输出: 参数和返回值"
+  ],
+  data_structures: [
+    "1. 实体: class/interface/type 定义",
+    "2. 属性: 字段类型和可见性",
+    "3. 关系: 继承/组合/关联",
+    "4. 枚举: 枚举类型及其值"
+  ],
+  interfaces: [
+    "1. API端点: 路径/方法/说明",
+    "2. 参数: 请求参数类型和校验",
+    "3. 响应: 响应格式和状态码",
+    "4. 时序: 典型调用流程"
+  ],
+  exceptions: [
+    "1. 异常类型: 自定义异常类",
+    "2. 错误码: 错误码定义和含义",
+    "3. 处理模式: try-catch/中间件",
+    "4. 恢复策略: 重试/降级/告警"
+  ]
+};
+```
+
+## 效率优化
+
+### 1. 减少冗余
+
+**Before (冗余)**:
+```
+你是一个专业的系统架构师，具有丰富的软件设计经验。
+你需要分析代码库，识别系统的分层结构...
+```
+
+**After (精简)**:
+```
+[ROLE] 系统架构师，专注于分层设计和模块依赖。
+[TASK] 分析 src/，生成系统架构图章节。
+```
+
+### 2. 模板驱动
+
+**Before (描述性)**:
+```
+请按照以下格式输出:
+首先写一个二级标题...
+然后添加一个Mermaid图...
+```
+
+**After (模板)**:
+```
+[TEMPLATE]
+## 2. 系统架构图
+{intro}
+\`\`\`mermaid
+{diagram}
+\`\`\`
+**图2-1 系统架构图**
+### 2.1 {subsection}
+{content}
+```
+
+### 3. 焦点明确
+
+**Before (模糊)**:
+```
+分析项目的各个方面，包括架构、模块、依赖等
+```
+
+**After (具体)**:
+```
+[FOCUS]
+1. 分层: Controller/Service/Repository
+2. 模块: 职责边界
+3. 依赖: 方向性
+4. 数据流: 路径
+```
+
+### 4. 返回简洁
+
+**Before (冗长)**:
+```
+请返回详细的分析结果，包括所有发现的问题...
+```
+
+**After (结构化)**:
+```
+[RETURN]
+{"status":"completed","output_file":"xxx.md","summary":"<50字>","cross_module_notes":[],"stats":{}}
+```

package/.claude/skills/project-analyze/SKILL.md

@@ -0,0 +1,162 @@
+---
+name: project-analyze
+description: Multi-phase iterative project analysis with Mermaid diagrams. Generates architecture reports, design reports, method analysis reports. Use when analyzing codebases, understanding project structure, reviewing architecture, exploring design patterns, or documenting system components. Triggers on "analyze project", "architecture report", "design analysis", "code structure", "system overview".
+allowed-tools: Task, AskUserQuestion, Read, Bash, Glob, Grep, Write
+---
+
+# Project Analysis Skill
+
+Generate comprehensive project analysis reports through multi-phase iterative workflow.
+
+## Architecture Overview
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  Context-Optimized Architecture                                  │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                  │
+│  Phase 1: Requirements      → analysis-config.json              │
+│           ↓                                                      │
+│  Phase 2: Exploration       → 初步探索，确定范围                  │
+│           ↓                                                      │
+│  Phase 3: Parallel Agents   → sections/section-*.md (直接写MD)   │
+│               ↓ 返回简要JSON                                     │
+│  Phase 3.5: Consolidation   → consolidation-summary.md          │
+│           Agent                 ↓ 返回质量评分+问题列表          │
+│           ↓                                                      │
+│  Phase 4: Assembly          → 合并MD + 质量附录                  │
+│           ↓                                                      │
+│  Phase 5: Refinement        → 最终报告                           │
+│                                                                  │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## Key Design Principles
+
+1. **Agent 直接输出 MD**: 避免 JSON → MD 转换的上下文开销
+2. **简要返回**: Agent 只返回路径+摘要，不返回完整内容
+3. **汇总 Agent**: 独立 Agent 负责跨章节问题检测和质量评分
+4. **引用合并**: Phase 4 读取文件合并，不在上下文中传递
+5. **段落式描述**: 禁止清单罗列，层层递进，客观学术表达
+
+## Execution Flow
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  Phase 1: Requirements Discovery                                │
+│  → Read: phases/01-requirements-discovery.md                    │
+│  → Collect: report type, depth level, scope, focus areas        │
+│  → Output: analysis-config.json                                 │
+├─────────────────────────────────────────────────────────────────┤
+│  Phase 2: Project Exploration                                   │
+│  → Read: phases/02-project-exploration.md                       │
+│  → Launch: parallel exploration agents                          │
+│  → Output: exploration context for Phase 3                      │
+├─────────────────────────────────────────────────────────────────┤
+│  Phase 3: Deep Analysis (Parallel Agents)                       │
+│  → Read: phases/03-deep-analysis.md                             │
+│  → Reference: specs/quality-standards.md                        │
+│  → Each Agent: 分析代码 → 直接写 sections/section-*.md          │
+│  → Return: {"status", "output_file", "summary", "cross_notes"}  │
+├─────────────────────────────────────────────────────────────────┤
+│  Phase 3.5: Consolidation (New!)                                │
+│  → Read: phases/03.5-consolidation.md                           │
+│  → Input: Agent 返回的简要信息 + cross_module_notes             │
+│  → Analyze: 一致性/完整性/关联性/质量检查                        │
+│  → Output: consolidation-summary.md                             │
+│  → Return: {"quality_score", "issues", "stats"}                 │
+├─────────────────────────────────────────────────────────────────┤
+│  Phase 4: Report Generation                                     │
+│  → Read: phases/04-report-generation.md                         │
+│  → Check: 如有 errors，提示用户处理                              │
+│  → Merge: Executive Summary + sections/*.md + 质量附录          │
+│  → Output: {TYPE}-REPORT.md                                     │
+├─────────────────────────────────────────────────────────────────┤
+│  Phase 5: Iterative Refinement                                  │
+│  → Read: phases/05-iterative-refinement.md                      │
+│  → Reference: specs/quality-standards.md                        │
+│  → Loop: 发现问题 → 提问 → 修复 → 重新检查                       │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## Report Types
+
+| Type | Output | Agents | Focus |
+|------|--------|--------|-------|
+| `architecture` | ARCHITECTURE-REPORT.md | 5 | System structure, modules, dependencies |
+| `design` | DESIGN-REPORT.md | 4 | Patterns, classes, interfaces |
+| `methods` | METHODS-REPORT.md | 4 | Algorithms, critical paths, APIs |
+| `comprehensive` | COMPREHENSIVE-REPORT.md | All | All above combined |
+
+## Agent Configuration by Report Type
+
+### Architecture Report
+| Agent | Output File | Section |
+|-------|-------------|---------|
+| overview | section-overview.md | System Overview |
+| layers | section-layers.md | Layer Analysis |
+| dependencies | section-dependencies.md | Module Dependencies |
+| dataflow | section-dataflow.md | Data Flow |
+| entrypoints | section-entrypoints.md | Entry Points |
+
+### Design Report
+| Agent | Output File | Section |
+|-------|-------------|---------|
+| patterns | section-patterns.md | Design Patterns |
+| classes | section-classes.md | Class Relationships |
+| interfaces | section-interfaces.md | Interface Contracts |
+| state | section-state.md | State Management |
+
+### Methods Report
+| Agent | Output File | Section |
+|-------|-------------|---------|
+| algorithms | section-algorithms.md | Core Algorithms |
+| paths | section-paths.md | Critical Code Paths |
+| apis | section-apis.md | Public API Reference |
+| logic | section-logic.md | Complex Logic |
+
+## Directory Setup
+
+```javascript
+// 生成时间戳目录名
+const timestamp = new Date().toISOString().slice(0,19).replace(/[-:T]/g, '');
+const dir = `.workflow/.scratchpad/analyze-${timestamp}`;
+
+// Windows (cmd)
+Bash(`mkdir "${dir}\\sections"`);
+Bash(`mkdir "${dir}\\iterations"`);
+
+// Unix/macOS
+// Bash(`mkdir -p "${dir}/sections" "${dir}/iterations"`);
+```
+
+## Output Structure
+
+```
+.workflow/.scratchpad/analyze-{timestamp}/
+├── analysis-config.json          # Phase 1
+├── sections/                     # Phase 3 (Agent 直接写入)
+│   ├── section-overview.md
+│   ├── section-layers.md
+│   ├── section-dependencies.md
+│   └── ...
+├── consolidation-summary.md      # Phase 3.5
+├── {TYPE}-REPORT.md              # Final Output
+└── iterations/                   # Phase 5
+    ├── v1.md
+    └── v2.md
+```
+
+## Reference Documents
+
+| Document | Purpose |
+|----------|---------|
+| [phases/01-requirements-discovery.md](phases/01-requirements-discovery.md) | User interaction, config collection |
+| [phases/02-project-exploration.md](phases/02-project-exploration.md) | Initial exploration |
+| [phases/03-deep-analysis.md](phases/03-deep-analysis.md) | Parallel agent analysis |
+| [phases/03.5-consolidation.md](phases/03.5-consolidation.md) | Cross-section consolidation |
+| [phases/04-report-generation.md](phases/04-report-generation.md) | Report assembly |
+| [phases/05-iterative-refinement.md](phases/05-iterative-refinement.md) | Quality refinement |
+| [specs/quality-standards.md](specs/quality-standards.md) | Quality gates, standards |
+| [specs/writing-style.md](specs/writing-style.md) | 段落式学术写作规范 |
+| [../_shared/mermaid-utils.md](../_shared/mermaid-utils.md) | Shared Mermaid utilities |

package/.claude/skills/project-analyze/phases/01-requirements-discovery.md

@@ -0,0 +1,79 @@
+# Phase 1: Requirements Discovery
+
+Collect user requirements before analysis begins.
+
+## Execution
+
+### Step 1: Report Type Selection
+
+```javascript
+AskUserQuestion({
+  questions: [{
+    question: "What type of project analysis report would you like?",
+    header: "Report Type",
+    multiSelect: false,
+    options: [
+      {label: "Architecture (Recommended)", description: "System structure, module relationships, layer analysis, dependency graph"},
+      {label: "Design", description: "Design patterns, class relationships, component interactions, abstraction analysis"},
+      {label: "Methods", description: "Key algorithms, critical code paths, core function explanations with examples"},
+      {label: "Comprehensive", description: "All above combined into a complete project analysis"}
+    ]
+  }]
+})
+```
+
+### Step 2: Depth Level Selection
+
+```javascript
+AskUserQuestion({
+  questions: [{
+    question: "What depth level do you need?",
+    header: "Depth",
+    multiSelect: false,
+    options: [
+      {label: "Overview", description: "High-level understanding, suitable for onboarding"},
+      {label: "Detailed", description: "In-depth analysis with code examples"},
+      {label: "Deep-Dive", description: "Exhaustive analysis with implementation details"}
+    ]
+  }]
+})
+```
+
+### Step 3: Scope Definition
+
+```javascript
+AskUserQuestion({
+  questions: [{
+    question: "What scope should the analysis cover?",
+    header: "Scope",
+    multiSelect: false,
+    options: [
+      {label: "Full Project", description: "Analyze entire codebase"},
+      {label: "Specific Module", description: "Focus on a specific module or directory"},
+      {label: "Custom Path", description: "Specify custom path pattern"}
+    ]
+  }]
+})
+```
+
+## Focus Areas Mapping
+
+| Report Type | Focus Areas |
+|-------------|-------------|
+| Architecture | Layer Structure, Module Dependencies, Entry Points, Data Flow |
+| Design | Design Patterns, Class Relationships, Interface Contracts, State Management |
+| Methods | Core Algorithms, Critical Paths, Public APIs, Complex Logic |
+| Comprehensive | All above combined |
+
+## Output
+
+Save configuration to `analysis-config.json`:
+
+```json
+{
+  "type": "architecture|design|methods|comprehensive",
+  "depth": "overview|detailed|deep-dive",
+  "scope": "**/*|src/**/*|custom",
+  "focus_areas": ["..."]
+}
+```

package/.claude/skills/project-analyze/phases/02-project-exploration.md

@@ -0,0 +1,75 @@
+# Phase 2: Project Exploration
+
+Launch parallel exploration agents based on report type.
+
+## Execution
+
+### Step 1: Map Exploration Angles
+
+```javascript
+const angleMapping = {
+  architecture: ["Layer Structure", "Module Dependencies", "Entry Points", "Data Flow"],
+  design: ["Design Patterns", "Class Relationships", "Interface Contracts", "State Management"],
+  methods: ["Core Algorithms", "Critical Paths", "Public APIs", "Complex Logic"],
+  comprehensive: ["Layer Structure", "Design Patterns", "Core Algorithms", "Data Flow"]
+};
+
+const angles = angleMapping[config.type];
+```
+
+### Step 2: Launch Parallel Agents
+
+For each angle, launch an exploration agent:
+
+```javascript
+Task({
+  subagent_type: "cli-explore-agent",
+  run_in_background: false,
+  description: `Explore: ${angle}`,
+  prompt: `
+## Exploration Objective
+Execute **${angle}** exploration for project analysis report.
+
+## Context
+- **Angle**: ${angle}
+- **Report Type**: ${config.type}
+- **Depth**: ${config.depth}
+- **Scope**: ${config.scope}
+
+## Exploration Protocol
+1. Structural Discovery (get_modules_by_depth, rg, glob)
+2. Pattern Recognition (conventions, naming, organization)
+3. Relationship Mapping (dependencies, integration points)
+
+## Output Format
+{
+  "angle": "${angle}",
+  "findings": {
+    "structure": [...],
+    "patterns": [...],
+    "relationships": [...],
+    "key_files": [{path, relevance, rationale}]
+  },
+  "insights": [...]
+}
+`
+})
+```
+
+### Step 3: Aggregate Results
+
+Merge all exploration results into unified findings:
+
+```javascript
+const aggregatedFindings = {
+  structure: [],      // from all angles
+  patterns: [],       // from all angles  
+  relationships: [],  // from all angles
+  key_files: [],      // deduplicated
+  insights: []        // prioritized
+};
+```
+
+## Output
+
+Save exploration results to `exploration-{angle}.json` files.