claude-code-workflow 6.3.48 → 6.3.49

package/.claude/skills/lite-skill-generator/templates/simple-skill.md

@@ -0,0 +1,68 @@
+---
+name: {{SKILL_NAME}}
+description: {{SKILL_DESCRIPTION}}
+allowed-tools: {{ALLOWED_TOOLS}}
+---
+
+# {{SKILL_TITLE}}
+
+{{SKILL_DESCRIPTION}}
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────┐
+│               {{SKILL_TITLE}}                    │
+│                                                 │
+│  Input → {{PHASE_1}} → {{PHASE_2}} → Output    │
+└─────────────────────────────────────────────────┘
+```
+
+## Execution Flow
+
+```javascript
+async function {{SKILL_FUNCTION}}(input) {
+  // Phase 1: {{PHASE_1}}
+  const prepared = await phase1(input);
+
+  // Phase 2: {{PHASE_2}}
+  const result = await phase2(prepared);
+
+  return result;
+}
+```
+
+### Phase 1: {{PHASE_1}}
+
+```javascript
+async function phase1(input) {
+  // TODO: Implement {{PHASE_1_LOWER}} logic
+  return output;
+}
+```
+
+### Phase 2: {{PHASE_2}}
+
+```javascript
+async function phase2(input) {
+  // TODO: Implement {{PHASE_2_LOWER}} logic
+  return output;
+}
+```
+
+## Usage
+
+```bash
+/skill:{{SKILL_NAME}} "input description"
+```
+
+## Examples
+
+**Basic Usage**:
+```
+User: "{{EXAMPLE_INPUT}}"
+{{SKILL_NAME}}:
+  → Phase 1: {{PHASE_1_ACTION}}
+  → Phase 2: {{PHASE_2_ACTION}}
+  → Output: {{EXAMPLE_OUTPUT}}
+```

package/.claude/skills/lite-skill-generator/templates/style-guide.md

@@ -0,0 +1,64 @@
+# Style Guide Template
+
+Generated by lite-skill-generator style analysis phase.
+
+## Detected Patterns
+
+### Structural Patterns
+
+| Pattern | Detected | Recommendation |
+|---------|----------|----------------|
+| YAML Frontmatter | {{HAS_FRONTMATTER}} | {{FRONTMATTER_REC}} |
+| ASCII Diagrams | {{HAS_DIAGRAMS}} | {{DIAGRAMS_REC}} |
+| Code Blocks | {{HAS_CODE_BLOCKS}} | {{CODE_BLOCKS_REC}} |
+| Phase Structure | {{PHASE_STRUCTURE}} | {{PHASE_REC}} |
+
+### Language Patterns
+
+| Pattern | Value | Notes |
+|---------|-------|-------|
+| Instruction Style | {{INSTRUCTION_STYLE}} | imperative/declarative/procedural |
+| Pseudocode Usage | {{PSEUDOCODE_USAGE}} | functional/imperative/none |
+| Verbosity Level | {{VERBOSITY}} | concise/detailed/verbose |
+| Common Terms | {{TERMINOLOGY}} | domain-specific vocabulary |
+
+### Organization Patterns
+
+| Pattern | Value |
+|---------|-------|
+| Phase Count | {{PHASE_COUNT}} |
+| Example Density | {{EXAMPLE_DENSITY}} |
+| Template Usage | {{TEMPLATE_USAGE}} |
+
+## Style Compliance Checklist
+
+- [ ] YAML frontmatter with name, description, allowed-tools
+- [ ] Architecture diagram (if pattern detected)
+- [ ] Execution flow section with pseudocode
+- [ ] Phase sections (sequential numbered)
+- [ ] Usage examples section
+- [ ] README.md for external documentation
+
+## Reference Skills Analyzed
+
+{{#REFERENCES}}
+- `{{REF_PATH}}`: {{REF_NOTES}}
+{{/REFERENCES}}
+
+## Generated Configuration
+
+```json
+{
+  "style": {
+    "structure": "{{STRUCTURE_TYPE}}",
+    "language": "{{LANGUAGE_TYPE}}",
+    "organization": "{{ORG_TYPE}}"
+  },
+  "recommendations": {
+    "usePseudocode": {{USE_PSEUDOCODE}},
+    "includeDiagrams": {{INCLUDE_DIAGRAMS}},
+    "verbosityLevel": "{{VERBOSITY}}",
+    "phaseCount": {{PHASE_COUNT}}
+  }
+}
+```

package/.claude/skills/skill-generator/SKILL.md

@@ -12,26 +12,24 @@ Meta-skill for creating new Claude Code skills with configurable execution modes
 
 ```
 ┌─────────────────────────────────────────────────────────────────┐
-│  Skill Generator Architecture                                    │
-├─────────────────────────────────────────────────────────────────┤
+│                    Skill Generator                               │
 │                                                                  │
-│  ⚠️ Phase 0: Specification  → 阅读并理解设计规范 (强制前置)      │
-│              Study              SKILL-DESIGN-SPEC.md + 模板     │
-│           ↓                                                      │
-│  Phase 1: Requirements    → skill-config.json                   │
-│           Discovery           (name, type, mode, agents)        │
-│           ↓                                                      │
-│  Phase 2: Structure       → 目录结构 + 核心文件骨架              │
-│           Generation                                             │
-│           ↓                                                      │
-│  Phase 3: Phase           → phases/*.md (根据 mode 生成)         │
-│           Generation          Sequential | Autonomous            │
-│           ↓                                                      │
-│  Phase 4: Specs &         → specs/*.md + templates/*.md         │
-│           Templates                                              │
-│           ↓                                                      │
-│  Phase 5: Validation      → 验证完整性 + 生成使用说明            │
-│           & Documentation                                        │
+│  Input: User Request (skill name, purpose, mode)                │
+│                         ↓                                        │
+│  ┌─────────────────────────────────────────────────────────┐    │
+│  │  Phase 0-5: Sequential Pipeline                          │    │
+│  │  ┌────┐ ┌────┐ ┌────┐ ┌────┐ ┌────┐ ┌────┐             │    │
+│  │  │ P0 │→│ P1 │→│ P2 │→│ P3 │→│ P4 │→│ P5 │             │    │
+│  │  │Spec│ │Req │ │Dir │ │Gen │ │Spec│ │Val │             │    │
+│  │  └────┘ └────┘ └────┘ └─┬──┘ └────┘ └────┘             │    │
+│  │                         │                                │    │
+│  │                    ┌────┴────┐                           │    │
+│  │                    ↓         ↓                           │    │
+│  │              Sequential  Autonomous                      │    │
+│  │              (phases/)   (actions/)                      │    │
+│  └─────────────────────────────────────────────────────────┘    │
+│                         ↓                                        │
+│  Output: .claude/skills/{skill-name}/ (complete package)        │
 │                                                                  │
 └─────────────────────────────────────────────────────────────────┘
 ```
@@ -107,8 +105,7 @@ Phase 01 → Phase 02 → Phase 03 → ... → Phase N
 | [templates/autonomous-action.md](templates/autonomous-action.md) | Autonomous Action 模板 |
 | [templates/code-analysis-action.md](templates/code-analysis-action.md) | 代码分析 Action 模板 |
 | [templates/llm-action.md](templates/llm-action.md) | LLM Action 模板 |
-| [templates/script-bash.md](templates/script-bash.md) | Bash 脚本模板 |
-| [templates/script-python.md](templates/script-python.md) | Python 脚本模板 |
+| [templates/script-template.md](templates/script-template.md) | 统一脚本模板 (Bash + Python) |
 
 ### 规范文档 (按需阅读)
 
@@ -134,93 +131,288 @@ Phase 01 → Phase 02 → Phase 03 → ... → Phase N
 ## Execution Flow
 
 ```
-┌─────────────────────────────────────────────────────────────────┐
-│  ⚠️ Phase 0: Specification Study (强制前置 - 禁止跳过)           │
-│  → Read: ../_shared/SKILL-DESIGN-SPEC.md (通用设计规范)         │
-│  → Read: templates/*.md (所有相关模板文件)                       │
-│  → 理解: Skill 结构规范、命名约定、质量标准                      │
-│  → Output: 内化规范要求，确保后续生成符合标准                    │
-│  ⛔ 未完成 Phase 0 禁止进入 Phase 1                              │
-├─────────────────────────────────────────────────────────────────┤
-│  Phase 1: Requirements Discovery                                 │
-│  → AskUserQuestion: Skill 名称、目标、执行模式                   │
-│  → Output: skill-config.json                                    │
-├─────────────────────────────────────────────────────────────────┤
-│  Phase 2: Structure Generation                                   │
-│  → 创建目录结构: phases/, specs/, templates/, scripts/          │
-│  → 生成 SKILL.md 入口文件                                        │
-│  → Output: 完整目录结构                                          │
-├─────────────────────────────────────────────────────────────────┤
-│  Phase 3: Phase Generation                                       │
-│  → Sequential: 生成 01-xx.md, 02-xx.md, ...                     │
-│  → Autonomous: 生成 orchestrator.md + actions/*.md              │
-│  → Output: phases/*.md                                          │
-├─────────────────────────────────────────────────────────────────┤
-│  Phase 4: Specs & Templates                                      │
-│  → 生成领域规范: specs/{domain}-requirements.md                  │
-│  → 生成质量标准: specs/quality-standards.md                      │
-│  → 生成模板: templates/agent-base.md                             │
-│  → Output: specs/*.md, templates/*.md                           │
-├─────────────────────────────────────────────────────────────────┤
-│  Phase 5: Validation & Documentation                             │
-│  → 验证文件完整性                                                 │
-│  → 生成 README.md 使用说明                                       │
-│  → Output: 验证报告 + README.md                                  │
-└─────────────────────────────────────────────────────────────────┘
+Input Parsing:
+   └─ Convert user request to structured format (skill-name/purpose/mode)
+
+Phase 0: Specification Study (⚠️ MANDATORY - 禁止跳过)
+   └─ Read specification documents
+      ├─ Load: ../_shared/SKILL-DESIGN-SPEC.md
+      ├─ Load: All templates/*.md files
+      ├─ Understand: Structure rules, naming conventions, quality standards
+      └─ Output: Internalized requirements (in-memory, no file output)
+      └─ Validation: ⛔ MUST complete before Phase 1
+
+Phase 1: Requirements Discovery
+   └─ Gather skill requirements via user interaction
+      ├─ Tool: AskUserQuestion
+      │   ├─ Prompt: Skill name, purpose, execution mode
+      │   ├─ Prompt: Phase/Action definition
+      │   └─ Prompt: Tool dependencies, output format
+      ├─ Process: Generate configuration object
+      └─ Output: skill-config.json → ${workDir}/
+          ├─ skill_name: string
+          ├─ execution_mode: "sequential" | "autonomous"
+          ├─ phases/actions: array
+          └─ allowed_tools: array
+
+Phase 2: Structure Generation
+   └─ Create directory structure and entry file
+      ├─ Input: skill-config.json (from Phase 1)
+      ├─ Tool: Bash
+      │   └─ Execute: mkdir -p .claude/skills/{skill-name}/{phases,specs,templates,scripts}
+      ├─ Tool: Write
+      │   └─ Generate: SKILL.md (entry point with architecture diagram)
+      └─ Output: Complete directory structure
+          ├─ .claude/skills/{skill-name}/SKILL.md
+          ├─ .claude/skills/{skill-name}/phases/
+          ├─ .claude/skills/{skill-name}/specs/
+          ├─ .claude/skills/{skill-name}/templates/
+          └─ .claude/skills/{skill-name}/scripts/
+
+Phase 3: Phase/Action Generation
+   └─ Decision (execution_mode check):
+      ├─ execution_mode === "sequential" → Generate Sequential Phases
+      │   ├─ Tool: Read (template: templates/sequential-phase.md)
+      │   ├─ Loop: For each phase in config.sequential_config.phases
+      │   │   ├─ Generate: phases/{phase-id}.md
+      │   │   └─ Link: Previous phase output → Current phase input
+      │   ├─ Tool: Write (orchestrator: phases/_orchestrator.md)
+      │   ├─ Tool: Write (workflow definition: workflow.json)
+      │   └─ Output: phases/01-{name}.md, phases/02-{name}.md, ...
+      │
+      └─ execution_mode === "autonomous" → Generate Orchestrator + Actions
+          ├─ Tool: Read (template: templates/autonomous-orchestrator.md)
+          ├─ Tool: Write (state schema: phases/state-schema.md)
+          ├─ Tool: Write (orchestrator: phases/orchestrator.md)
+          ├─ Tool: Write (action catalog: specs/action-catalog.md)
+          ├─ Loop: For each action in config.autonomous_config.actions
+          │   ├─ Tool: Read (template: templates/autonomous-action.md)
+          │   └─ Generate: phases/actions/{action-id}.md
+          └─ Output: phases/orchestrator.md, phases/actions/*.md
+
+Phase 4: Specs & Templates
+   └─ Generate domain specifications and templates
+      ├─ Input: skill-config.json (domain context)
+      ├─ Tool: Write
+      │   ├─ Generate: specs/{domain}-requirements.md
+      │   ├─ Generate: specs/quality-standards.md
+      │   └─ Generate: templates/agent-base.md (if needed)
+      └─ Output: Domain-specific documentation
+          ├─ specs/{skill-name}-requirements.md
+          ├─ specs/quality-standards.md
+          └─ templates/agent-base.md
+
+Phase 5: Validation & Documentation
+   └─ Verify completeness and generate usage guide
+      ├─ Input: All generated files from previous phases
+      ├─ Tool: Glob + Read
+      │   └─ Check: Required files exist and contain proper structure
+      ├─ Tool: Write
+      │   ├─ Generate: README.md (usage instructions)
+      │   └─ Generate: validation-report.json (completeness check)
+      └─ Output: Final documentation
+          ├─ README.md (how to use this skill)
+          └─ validation-report.json (quality gate results)
+
+Return:
+   └─ Summary with skill location and next steps
+      ├─ Skill path: .claude/skills/{skill-name}/
+      ├─ Status: ✅ All phases completed
+      └─ Suggestion: "Review SKILL.md and customize phase files as needed"
 ```
 
-## Directory Setup
+**Execution Protocol**:
 
 ```javascript
-const skillName = config.skill_name;
-const skillDir = `.claude/skills/${skillName}`;
+// Phase 0: Read specifications (in-memory)
+Read('.claude/skills/_shared/SKILL-DESIGN-SPEC.md');
+Read('.claude/skills/skill-generator/templates/*.md'); // All templates
+
+// Phase 1: Gather requirements
+const answers = AskUserQuestion({
+  questions: [
+    { question: "Skill name?", header: "Name", options: [...] },
+    { question: "Execution mode?", header: "Mode", options: ["Sequential", "Autonomous"] }
+  ]
+});
+
+const config = generateConfig(answers);
+const workDir = `.workflow/.scratchpad/skill-gen-${timestamp}`;
+Write(`${workDir}/skill-config.json`, JSON.stringify(config));
+
+// Phase 2: Create structure
+const skillDir = `.claude/skills/${config.skill_name}`;
+Bash(`mkdir -p "${skillDir}/phases" "${skillDir}/specs" "${skillDir}/templates"`);
+Write(`${skillDir}/SKILL.md`, generateSkillEntry(config));
+
+// Phase 3: Generate phases (mode-dependent)
+if (config.execution_mode === 'sequential') {
+  Write(`${skillDir}/phases/_orchestrator.md`, generateOrchestrator(config));
+  Write(`${skillDir}/workflow.json`, generateWorkflowDef(config));
+  config.sequential_config.phases.forEach(phase => {
+    Write(`${skillDir}/phases/${phase.id}.md`, generatePhase(phase, config));
+  });
+} else {
+  Write(`${skillDir}/phases/orchestrator.md`, generateAutonomousOrchestrator(config));
+  Write(`${skillDir}/phases/state-schema.md`, generateStateSchema(config));
+  config.autonomous_config.actions.forEach(action => {
+    Write(`${skillDir}/phases/actions/${action.id}.md`, generateAction(action, config));
+  });
+}
 
-// 创建目录结构
-Bash(`mkdir -p "${skillDir}/phases"`);
-Bash(`mkdir -p "${skillDir}/specs"`);
-Bash(`mkdir -p "${skillDir}/templates"`);
+// Phase 4: Generate specs
+Write(`${skillDir}/specs/${config.skill_name}-requirements.md`, generateRequirements(config));
+Write(`${skillDir}/specs/quality-standards.md`, generateQualityStandards(config));
 
-// Autonomous 模式额外目录
-if (config.execution_mode === 'autonomous') {
-  Bash(`mkdir -p "${skillDir}/phases/actions"`);
-}
+
+// Phase 5: Validate & Document
+const validation = validateStructure(skillDir);
+Write(`${skillDir}/validation-report.json`, JSON.stringify(validation));
+Write(`${skillDir}/README.md`, generateReadme(config, validation));
+```
+
+---
+
+## Phase Reference Guide
+
+Navigation and entry points for each execution phase:
+
+### Phase 0: Specification Study (Mandatory)
+
+**Document**: 🔗 [SKILL-DESIGN-SPEC.md](../_shared/SKILL-DESIGN-SPEC.md)
+
+**Purpose**: Understand skill design standards before generating
+
+**What to Read**:
+- Skill structure conventions
+- Naming standards
+- Quality criteria
+- Output format specifications
+
+---
+
+### Phase 1: Requirements Discovery
+
+**Document**: 🔗 [phases/01-requirements-discovery.md](phases/01-requirements-discovery.md)
+
+| Attribute | Value |
+|-----------|-------|
+| **Purpose** | Gather configuration from user via interactive prompts |
+| **Input** | User responses (Skill name, purpose, execution mode) |
+| **Output** | `skill-config.json` (configuration file) |
+| **Key Decision** | Execution mode: Sequential vs Autonomous vs Hybrid |
+
+---
+
+### Phase 2: Structure Generation
+
+**Document**: 🔗 [phases/02-structure-generation.md](phases/02-structure-generation.md)
+
+| Attribute | Value |
+|-----------|-------|
+| **Purpose** | Create directory structure and entry file |
+| **Input** | `skill-config.json` (from Phase 1) |
+| **Output** | `.claude/skills/{skill-name}/` directory + `SKILL.md` |
+
+---
+
+### Phase 3: Phase/Action Generation
+
+**Document**: 🔗 [phases/03-phase-generation.md](phases/03-phase-generation.md)
+
+| Attribute | Value |
+|-----------|-------|
+| **Purpose** | Generate execution phases or actions based on mode |
+| **Input** | `skill-config.json` + Templates |
+| **Output** | Sequential: `phases/01-*.md` ... OR Autonomous: `phases/orchestrator.md` + `actions/*.md` |
+
+**Decision Logic**:
+```
+IF execution_mode === "sequential":
+  └─ Generate sequential phases with linear flow
+ELSE IF execution_mode === "autonomous":
+  └─ Generate orchestrator + independent actions
 ```
 
+---
+
+### Phase 4: Specs & Templates
+
+**Document**: 🔗 [phases/04-specs-templates.md](phases/04-specs-templates.md)
+
+| Attribute | Value |
+|-----------|-------|
+| **Purpose** | Generate domain specifications and template files |
+| **Input** | `skill-config.json` (domain context) |
+| **Output** | `specs/{skill-name}-requirements.md`, `specs/quality-standards.md` |
+
+---
+
+### Phase 5: Validation & Documentation
+
+**Document**: 🔗 [phases/05-validation.md](phases/05-validation.md)
+
+| Attribute | Value |
+|-----------|-------|
+| **Purpose** | Verify completeness and generate usage documentation |
+| **Input** | All files from previous phases |
+| **Output** | `README.md`, `validation-report.json` |
+
+---
+
+## Template Reference
+
+| Template | Generated For | When Used |
+|----------|--------------|-----------|
+| [skill-md.md](templates/skill-md.md) | SKILL.md entry file | Phase 2 |
+| [sequential-phase.md](templates/sequential-phase.md) | Sequential phase files | Phase 3 |
+| [autonomous-orchestrator.md](templates/autonomous-orchestrator.md) | Orchestrator (autonomous) | Phase 3 |
+| [autonomous-action.md](templates/autonomous-action.md) | Action files | Phase 3 |
+| [code-analysis-action.md](templates/code-analysis-action.md) | Code analysis actions | Phase 3 |
+| [llm-action.md](templates/llm-action.md) | LLM-powered actions | Phase 3 |
+| [script-template.md](templates/script-template.md) | Bash + Python scripts | Phase 3/4 |
+
 ## Output Structure
 
 ### Sequential Mode
 
 ```
 .claude/skills/{skill-name}/
-├── SKILL.md
+├── SKILL.md                        # 入口文件
 ├── phases/
-│   ├── 01-{step-one}.md
-│   ├── 02-{step-two}.md
-│   └── 03-{step-three}.md
+│   ├── _orchestrator.md            # 声明式编排器
+│   ├── workflow.json               # 工作流定义
+│   ├── 01-{step-one}.md           # 阶段 1
+│   ├── 02-{step-two}.md           # 阶段 2
+│   └── 03-{step-three}.md         # 阶段 3
 ├── specs/
-│   ├── {domain}-requirements.md
+│   ├── {skill-name}-requirements.md
 │   └── quality-standards.md
-└── templates/
-    └── agent-base.md
+├── templates/
+│   └── agent-base.md
+├── scripts/
+└── README.md
 ```
 
 ### Autonomous Mode
 
 ```
 .claude/skills/{skill-name}/
-├── SKILL.md
+├── SKILL.md                        # 入口文件
 ├── phases/
-│   ├── orchestrator.md          # 编排器：读取状态 → 选择动作
-│   ├── state-schema.md          # 状态结构定义
-│   └── actions/                 # 独立动作（无顺序）
-│       ├── action-{a}.md
-│       ├── action-{b}.md
-│       └── action-{c}.md
+│   ├── orchestrator.md             # 编排器 (状态驱动)
+│   ├── state-schema.md             # 状态结构定义
+│   └── actions/
+│       ├── action-init.md
+│       ├── action-create.md
+│       └── action-list.md
 ├── specs/
-│   ├── {domain}-requirements.md
-│   ├── action-catalog.md        # 动作目录（描述、前置条件、效果）
+│   ├── {skill-name}-requirements.md
+│   ├── action-catalog.md
 │   └── quality-standards.md
-└── templates/
-    ├── orchestrator-base.md     # 编排器模板
-    └── action-base.md           # 动作模板
-```
+├── templates/
+│   ├── orchestrator-base.md
+│   └── action-base.md
+├── scripts/
+└── README.md
+```

package/.claude/skills/skill-generator/phases/01-requirements-discovery.md

@@ -1,15 +1,4 @@
-# Phase 1: Requirements Discovery
 
-收集新 Skill 的需求信息，生成配置文件。
-
-## Objective
-
-- 收集 Skill 基本信息（名称、描述、触发词）
-- 确定执行模式（Sequential / Autonomous）
-- 定义阶段/动作
-- 配置工具依赖和输出格式
-
-## Execution Steps
 
 ### Step 1: 基本信息收集
 
@@ -228,12 +217,12 @@ Bash(`mkdir -p "${workDir}"`);
 Write(`${workDir}/skill-config.json`, JSON.stringify(config, null, 2));
 ```
 
-## Output
 
-- **File**: `skill-config.json`
-- **Location**: `.workflow/.scratchpad/skill-gen-{timestamp}/`
-- **Format**: JSON
 
 ## Next Phase
 
 → [Phase 2: Structure Generation](02-structure-generation.md)
+
+**Data Flow to Phase 2**:
+- skill-config.json with all configuration parameters
+- Execution mode decision drives directory structure creation