Claude-Code-Workflow/.claude/skills/skill-generator/phases/01-requirements-discovery.md

Phase 1: Requirements Discovery

Collect basic skill information, configuration, and execution mode based on user input.

Objective

• Collect skill basic information (name, description, trigger words)
• Determine execution mode (Sequential/Autonomous/Hybrid)
• Define phases or actions
• Generate initial configuration file

Execution Steps

Step 1: Basic Information Collection

const basicInfo = await AskUserQuestion({
  questions: [
    {
      question: "What is the name of the new Skill? (English, lowercase with hyphens, e.g., 'api-docs')",
      header: "Skill Name",
      multiSelect: false,
      options: [
        { label: "Auto-generate", description: "Generate name automatically based on description" },
        { label: "Manual Input", description: "Enter custom name now" }
      ]
    },
    {
      question: "What is the primary purpose of the Skill?",
      header: "Purpose Type",
      multiSelect: false,
      options: [
        { label: "Document Generation", description: "Generate Markdown/HTML documents (manuals, reports)" },
        { label: "Code Analysis", description: "Analyze code structure, quality, security" },
        { label: "Interactive Management", description: "Manage Issues, tasks, workflows (CRUD operations)" },
        { label: "Data Processing", description: "ETL, format conversion, report generation" }
      ]
    }
  ]
});

// If manual input is selected, prompt further
if (basicInfo["Skill Name"] === "Manual Input") {
  // User will input in "Other"
}

// Infer description template based on purpose type
const purposeTemplates = {
  "Document Generation": "Generate {type} documents from {source}",
  "Code Analysis": "Analyze {target} for {purpose}",
  "Interactive Management": "Manage {entity} with interactive operations",
  "Data Processing": "Process {data} and generate {output}"
};

Step 2: Execution Mode Selection

const modeInfo = await AskUserQuestion({
  questions: [
    {
      question: "Select execution mode:",
      header: "Execution Mode",
      multiSelect: false,
      options: [
        {
          label: "Sequential (Sequential Mode)",
          description: "Phases execute in fixed order (collect→analyze→generate), suitable for pipeline tasks (recommended)"
        },
        {
          label: "Autonomous (Autonomous Mode)",
          description: "Dynamically select execution path, suitable for interactive tasks (e.g., Issue management)"
        },
        {
          label: "Hybrid (Hybrid Mode)",
          description: "Fixed initialization and finalization, flexible interaction in the middle"
        }
      ]
    }
  ]
});

const executionMode = modeInfo["Execution Mode"].includes("Sequential") ? "sequential" :
                      modeInfo["Execution Mode"].includes("Autonomous") ? "autonomous" : "hybrid";

Step 3: Phase/Action Definition

Sequential Mode

if (executionMode === "sequential") {
  const phaseInfo = await AskUserQuestion({
    questions: [
      {
        question: "How many execution phases are needed?",
        header: "Phase Count",
        multiSelect: false,
        options: [
          { label: "3 Phases (Simple)", description: "Collection → Processing → Output" },
          { label: "5 Phases (Standard)", description: "Collection → Exploration → Analysis → Assembly → Validation" },
          { label: "7 Phases (Complete)", description: "Includes parallel processing, consolidation, iterative optimization" }
        ]
      }
    ]
  });

  // Generate phase definitions based on selection
  const phaseTemplates = {
    "3 Phases": [
      { id: "01-collection", name: "Data Collection" },
      { id: "02-processing", name: "Processing" },
      { id: "03-output", name: "Output Generation" }
    ],
    "5 Phases": [
      { 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 Phases": [
      { 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 Mode

if (executionMode === "autonomous") {
  const actionInfo = await AskUserQuestion({
    questions: [
      {
        question: "What are the core actions? (Multiple selection allowed)",
        header: "Action Definition",
        multiSelect: true,
        options: [
          { label: "Initialize (init)", description: "Set initial state" },
          { label: "List (list)", description: "Display current item list" },
          { label: "Create (create)", description: "Create new item" },
          { label: "Edit (edit)", description: "Modify existing item" },
          { label: "Delete (delete)", description: "Delete item" },
          { label: "Search (search)", description: "Search/filter items" }
        ]
      }
    ]
  });
}

Step 4: Tool and Output Configuration

const toolsInfo = await AskUserQuestion({
  questions: [
    {
      question: "Which special tools are needed? (Basic tools are included by default)",
      header: "Tool Selection",
      multiSelect: true,
      options: [
        { label: "User Interaction (AskUserQuestion)", description: "Need to dialog with user" },
        { label: "Chrome Screenshot (mcp__chrome__*)", description: "Need web page screenshots" },
        { label: "External Search (mcp__exa__search)", description: "Need to search external information" },
        { label: "No Special Requirements", description: "Use basic tools only" }
      ]
    },
    {
      question: "What is the output format?",
      header: "Output Format",
      multiSelect: false,
      options: [
        { label: "Markdown", description: "Suitable for documents and reports" },
        { label: "HTML", description: "Suitable for interactive documents" },
        { label: "JSON", description: "Suitable for data and configuration" }
      ]
    }
  ]
});

Step 5: Generate Configuration File

const config = {
  skill_name: skillName,
  display_name: displayName,
  description: description,
  triggers: triggers,
  execution_mode: executionMode,

  // Mode-specific configuration
  ...(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"
};

// Write configuration file
const workDir = `.workflow/.scratchpad/skill-gen-${timestamp}`;
Bash(`mkdir -p "${workDir}"`);
Write(`${workDir}/skill-config.json`, JSON.stringify(config, null, 2));

Next Phase

→ Phase 2: Structure Generation

Data Flow to Phase 2:

• skill-config.json with all configuration parameters
• Execution mode decision drives directory structure creation