claude-code-workflow 6.3.18 → 6.3.19

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

@@ -0,0 +1,239 @@
+# Phase 1: Requirements Discovery
+
+收集新 Skill 的需求信息，生成配置文件。
+
+## Objective
+
+- 收集 Skill 基本信息（名称、描述、触发词）
+- 确定执行模式（Sequential / Autonomous）
+- 定义阶段/动作
+- 配置工具依赖和输出格式
+
+## Execution Steps
+
+### Step 1: 基本信息收集
+
+```javascript
+const basicInfo = await AskUserQuestion({
+  questions: [
+    {
+      question: "新 Skill 的名称是什么？（英文，小写-连字符格式，如 'api-docs'）",
+      header: "Skill 名称",
+      multiSelect: false,
+      options: [
+        { label: "自动生成", description: "根据后续描述自动生成名称" },
+        { label: "手动输入", description: "现在输入自定义名称" }
+      ]
+    },
+    {
+      question: "Skill 的主要用途是什么？",
+      header: "用途类型",
+      multiSelect: false,
+      options: [
+        { label: "文档生成", description: "生成 Markdown/HTML 文档（如手册、报告）" },
+        { label: "代码分析", description: "分析代码结构、质量、安全性" },
+        { label: "交互管理", description: "管理 Issue、任务、工作流（CRUD 操作）" },
+        { label: "数据处理", description: "ETL、格式转换、报告生成" }
+      ]
+    }
+  ]
+});
+
+// 如果选择手动输入，进一步询问
+if (basicInfo["Skill 名称"] === "手动输入") {
+  // 用户会在 "Other" 中输入
+}
+
+// 根据用途类型推断描述模板
+const purposeTemplates = {
+  "文档生成": "Generate {type} documents from {source}",
+  "代码分析": "Analyze {target} for {purpose}",
+  "交互管理": "Manage {entity} with interactive operations",
+  "数据处理": "Process {data} and generate {output}"
+};
+```
+
+### Step 2: 执行模式选择
+
+```javascript
+const modeInfo = await AskUserQuestion({
+  questions: [
+    {
+      question: "选择执行模式：",
+      header: "执行模式",
+      multiSelect: false,
+      options: [
+        { 
+          label: "Sequential (顺序模式)", 
+          description: "阶段按固定顺序执行（收集→分析→生成），适合流水线任务（推荐）" 
+        },
+        { 
+          label: "Autonomous (自主模式)", 
+          description: "动态选择执行路径，适合交互式任务（如 Issue 管理）" 
+        },
+        { 
+          label: "Hybrid (混合模式)", 
+          description: "初始化和收尾固定，中间交互灵活" 
+        }
+      ]
+    }
+  ]
+});
+
+const executionMode = modeInfo["执行模式"].includes("Sequential") ? "sequential" :
+                      modeInfo["执行模式"].includes("Autonomous") ? "autonomous" : "hybrid";
+```
+
+### Step 3: 阶段/动作定义
+
+#### Sequential 模式
+
+```javascript
+if (executionMode === "sequential") {
+  const phaseInfo = await AskUserQuestion({
+    questions: [
+      {
+        question: "需要多少个执行阶段？",
+        header: "阶段数量",
+        multiSelect: false,
+        options: [
+          { label: "3 阶段（简单）", description: "收集 → 处理 → 输出" },
+          { label: "5 阶段（标准）", description: "收集 → 探索 → 分析 → 组装 → 验证" },
+          { label: "7 阶段（完整）", description: "含并行处理、汇总、迭代优化" }
+        ]
+      }
+    ]
+  });
+  
+  // 根据选择生成阶段定义
+  const phaseTemplates = {
+    "3 阶段": [
+      { id: "01-collection", name: "Data Collection" },
+      { id: "02-processing", name: "Processing" },
+      { id: "03-output", name: "Output Generation" }
+    ],
+    "5 阶段": [
+      { id: "01-collection", name: "Requirements Collection" },
+      { id: "02-exploration", name: "Project Exploration" },
+      { id: "03-analysis", name: "Deep Analysis" },
+      { id: "04-assembly", name: "Document Assembly" },
+      { id: "05-validation", name: "Validation" }
+    ],
+    "7 阶段": [
+      { id: "01-collection", name: "Requirements Collection" },
+      { id: "02-exploration", name: "Project Exploration" },
+      { id: "03-parallel", name: "Parallel Analysis" },
+      { id: "03.5-consolidation", name: "Consolidation" },
+      { id: "04-assembly", name: "Document Assembly" },
+      { id: "05-refinement", name: "Iterative Refinement" },
+      { id: "06-output", name: "Final Output" }
+    ]
+  };
+}
+```
+
+#### Autonomous 模式
+
+```javascript
+if (executionMode === "autonomous") {
+  const actionInfo = await AskUserQuestion({
+    questions: [
+      {
+        question: "核心动作有哪些？（可多选）",
+        header: "动作定义",
+        multiSelect: true,
+        options: [
+          { label: "初始化 (init)", description: "设置初始状态" },
+          { label: "列表 (list)", description: "显示当前项目列表" },
+          { label: "创建 (create)", description: "创建新项目" },
+          { label: "编辑 (edit)", description: "修改现有项目" },
+          { label: "删除 (delete)", description: "删除项目" },
+          { label: "搜索 (search)", description: "搜索/过滤项目" }
+        ]
+      }
+    ]
+  });
+}
+```
+
+### Step 4: 工具和输出配置
+
+```javascript
+const toolsInfo = await AskUserQuestion({
+  questions: [
+    {
+      question: "需要哪些特殊工具？（基础工具已默认包含）",
+      header: "工具选择",
+      multiSelect: true,
+      options: [
+        { label: "用户交互 (AskUserQuestion)", description: "需要与用户对话" },
+        { label: "Chrome 截图 (mcp__chrome__*)", description: "需要网页截图" },
+        { label: "外部搜索 (mcp__exa__search)", description: "需要搜索外部信息" },
+        { label: "无特殊需求", description: "仅使用基础工具" }
+      ]
+    },
+    {
+      question: "输出格式是什么？",
+      header: "输出格式",
+      multiSelect: false,
+      options: [
+        { label: "Markdown", description: "适合文档和报告" },
+        { label: "HTML", description: "适合交互式文档" },
+        { label: "JSON", description: "适合数据和配置" }
+      ]
+    }
+  ]
+});
+```
+
+### Step 5: 生成配置文件
+
+```javascript
+const config = {
+  skill_name: skillName,
+  display_name: displayName,
+  description: description,
+  triggers: triggers,
+  execution_mode: executionMode,
+  
+  // 模式特定配置
+  ...(executionMode === "sequential" ? {
+    sequential_config: { phases: phases }
+  } : {
+    autonomous_config: { 
+      state_schema: stateSchema,
+      actions: actions,
+      termination_conditions: ["user_exit", "error_limit", "task_completed"]
+    }
+  }),
+  
+  allowed_tools: [
+    "Task", "Read", "Write", "Glob", "Grep", "Bash",
+    ...selectedTools
+  ],
+  
+  output: {
+    format: outputFormat.toLowerCase(),
+    location: `.workflow/.scratchpad/${skillName}-{timestamp}`,
+    filename_pattern: `{name}-output.${outputFormat === "HTML" ? "html" : outputFormat === "JSON" ? "json" : "md"}`
+  },
+  
+  created_at: new Date().toISOString(),
+  version: "1.0.0"
+};
+
+// 写入配置文件
+const workDir = `.workflow/.scratchpad/skill-gen-${timestamp}`;
+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)

package/.claude/skills/skill-generator/phases/02-structure-generation.md

@@ -0,0 +1,207 @@
+# Phase 2: Structure Generation
+
+根据配置创建 Skill 目录结构和入口文件。
+
+## Objective
+
+- 创建标准目录结构
+- 生成 SKILL.md 入口文件
+- 根据执行模式创建对应的子目录
+
+## Input
+
+- 依赖: `skill-config.json` (Phase 1 产出)
+
+## Execution Steps
+
+### Step 1: 读取配置
+
+```javascript
+const config = JSON.parse(Read(`${workDir}/skill-config.json`));
+const skillDir = `.claude/skills/${config.skill_name}`;
+```
+
+### Step 2: 创建目录结构
+
+```javascript
+// 基础目录
+Bash(`mkdir -p "${skillDir}/phases"`);
+Bash(`mkdir -p "${skillDir}/specs"`);
+Bash(`mkdir -p "${skillDir}/templates"`);
+
+// Autonomous 模式额外目录
+if (config.execution_mode === 'autonomous' || config.execution_mode === 'hybrid') {
+  Bash(`mkdir -p "${skillDir}/phases/actions"`);
+}
+
+// scripts 目录（默认创建，用于存放确定性脚本）
+Bash(`mkdir -p "${skillDir}/scripts"`);
+```
+
+### Step 3: 生成 SKILL.md
+
+```javascript
+const skillMdTemplate = `---
+name: ${config.skill_name}
+description: ${config.description}. Triggers on ${config.triggers.map(t => `"${t}"`).join(", ")}.
+allowed-tools: ${config.allowed_tools.join(", ")}
+---
+
+# ${config.display_name}
+
+${config.description}
+
+## Architecture Overview
+
+\`\`\`
+${generateArchitectureDiagram(config)}
+\`\`\`
+
+## Key Design Principles
+
+${generateDesignPrinciples(config)}
+
+## Execution Flow
+
+${generateExecutionFlow(config)}
+
+## Directory Setup
+
+\`\`\`javascript
+const timestamp = new Date().toISOString().slice(0,19).replace(/[-:T]/g, '');
+const workDir = \`${config.output.location.replace('{timestamp}', '${timestamp}')}\`;
+
+Bash(\`mkdir -p "\${workDir}"\`);
+${config.execution_mode === 'sequential' ? 
+  `Bash(\`mkdir -p "\${workDir}/sections"\`);` : 
+  `Bash(\`mkdir -p "\${workDir}/state"\`);`}
+\`\`\`
+
+## Output Structure
+
+\`\`\`
+${generateOutputStructure(config)}
+\`\`\`
+
+## Reference Documents
+
+${generateReferenceTable(config)}
+`;
+
+Write(`${skillDir}/SKILL.md`, skillMdTemplate);
+```
+
+### Step 4: 架构图生成函数
+
+```javascript
+function generateArchitectureDiagram(config) {
+  if (config.execution_mode === 'sequential') {
+    return config.sequential_config.phases.map((p, i) => 
+      `│  Phase ${i+1}: ${p.name.padEnd(15)} → ${p.output || 'output-' + (i+1) + '.json'}${' '.repeat(10)}│`
+    ).join('\n│           ↓' + ' '.repeat(45) + '│\n');
+  } else {
+    return `
+┌─────────────────────────────────────────────────────────────────┐
+│           Orchestrator (状态驱动决策)                             │
+└───────────────┬─────────────────────────────────────────────────┘
+                │
+    ┌───────────┼───────────┐
+    ↓           ↓           ↓
+${config.autonomous_config.actions.slice(0, 3).map(a => 
+  `┌─────────┐  `).join('')}
+${config.autonomous_config.actions.slice(0, 3).map(a => 
+  `│${a.name.slice(0, 7).padEnd(7)}│  `).join('')}
+${config.autonomous_config.actions.slice(0, 3).map(a => 
+  `└─────────┘  `).join('')}`;
+  }
+}
+
+function generateDesignPrinciples(config) {
+  const common = [
+    "1. **规范遵循**: 严格遵循 `_shared/SKILL-DESIGN-SPEC.md`",
+    "2. **简要返回**: Agent 返回路径+摘要，避免上下文溢出"
+  ];
+  
+  if (config.execution_mode === 'sequential') {
+    return [...common,
+      "3. **阶段隔离**: 每个阶段独立可测",
+      "4. **链式输出**: 阶段产出作为下阶段输入"
+    ].join('\n');
+  } else {
+    return [...common,
+      "3. **状态驱动**: 显式状态管理，动态决策",
+      "4. **动作独立**: 每个动作无副作用依赖"
+    ].join('\n');
+  }
+}
+
+function generateExecutionFlow(config) {
+  if (config.execution_mode === 'sequential') {
+    return '```\n' + config.sequential_config.phases.map((p, i) => 
+      `├─ Phase ${i+1}: ${p.name}\n│  → Output: ${p.output || 'output.json'}`
+    ).join('\n') + '\n```';
+  } else {
+    return `\`\`\`
+┌─────────────────────────────────────────────────────────────────┐
+│  Orchestrator Loop                                               │
+│  ┌──────────┐     ┌──────────┐     ┌──────────┐                 │
+│  │ Read     │────▶│ Select   │────▶│ Execute  │                 │
+│  │ State    │     │ Action   │     │ Action   │                 │
+│  └──────────┘     └──────────┘     └──────────┘                 │
+│       ▲                                  │                       │
+│       └──────────── Update State ◀───────┘                       │
+└─────────────────────────────────────────────────────────────────┘
+\`\`\``;
+  }
+}
+
+function generateOutputStructure(config) {
+  const base = `${config.output.location}/
+├── ${config.execution_mode === 'sequential' ? 'sections/' : 'state.json'}`;
+  
+  if (config.execution_mode === 'sequential') {
+    return base + '\n' + config.sequential_config.phases.map(p => 
+      `│   └── ${p.output || 'section-' + p.id + '.md'}`
+    ).join('\n') + `\n└── ${config.output.filename_pattern}`;
+  } else {
+    return base + `
+├── actions-log.json
+└── ${config.output.filename_pattern}`;
+  }
+}
+
+function generateReferenceTable(config) {
+  const rows = [];
+  
+  if (config.execution_mode === 'sequential') {
+    config.sequential_config.phases.forEach(p => {
+      rows.push(`| [phases/${p.id}.md](phases/${p.id}.md) | ${p.name} |`);
+    });
+  } else {
+    rows.push(`| [phases/orchestrator.md](phases/orchestrator.md) | 编排器 |`);
+    rows.push(`| [phases/state-schema.md](phases/state-schema.md) | 状态定义 |`);
+    config.autonomous_config.actions.forEach(a => {
+      rows.push(`| [phases/actions/${a.id}.md](phases/actions/${a.id}.md) | ${a.name} |`);
+    });
+  }
+  
+  rows.push(`| [specs/${config.skill_name}-requirements.md](specs/${config.skill_name}-requirements.md) | 领域规范 |`);
+  rows.push(`| [specs/quality-standards.md](specs/quality-standards.md) | 质量标准 |`);
+  
+  return `| Document | Purpose |\n|----------|---------||\n` + rows.join('\n');
+}
+```
+
+## Output
+
+- **Directory**: `.claude/skills/{skill-name}/`
+- **Files**:
+  - `SKILL.md` (入口文件)
+  - `phases/` (执行阶段目录)
+  - `specs/` (规范文档目录)
+  - `templates/` (模板目录)
+  - `scripts/` (脚本目录，存放 Python/Bash 确定性脚本)
+
+## Next Phase
+
+→ [Phase 3: Phase Generation](03-phase-generation.md)