@waoooo/claude-skills 1.0.0

package/skills/requirement-parse/scripts/parse-docs.ts

@@ -0,0 +1,206 @@
+/**
+ * Parse MDX Planning Documents to Unified Requirements
+ * 
+ * This script extracts requirements from MDX planning documents.
+ * It looks for structured markers and extracts requirement information.
+ * Keywords are read from frontmatter (not auto-generated).
+ */
+
+import fs from 'fs';
+import path from 'path';
+import matter from 'gray-matter';
+import type { UnifiedRequirement, UnifiedRequirements, RequirementBlock } from '../types/unified-requirements';
+
+/**
+ * Parse a single MDX file
+ */
+function parseMdxFile(filePath: string): { blocks: RequirementBlock[]; keywords: string[] } {
+  const fileContent = fs.readFileSync(filePath, 'utf-8');
+  
+  // Parse frontmatter
+  const { data, content } = matter(fileContent);
+  
+  // Extract keywords from frontmatter
+  const keywords = data.keywords || [];
+  
+  const blocks: RequirementBlock[] = [];
+  
+  // Extract requirement blocks using markers
+  // Format: <!-- REQ-PRICING-021 | P0 | L1 | pricing -->
+  const markerPattern = /<!-- (REQ-[\w-]+)(?:\s*\|\s*(P\d))? -->\s*###\s+(.+?)(?:\n|$)/g;
+  
+  let match;
+  while ((match = markerPattern.exec(content)) !== null) {
+    const reqId = match[1];
+    const priority = match[2];
+    const title = match[3].replace(/🔴|🟡|🟢|✅|🚧|📅|🔮/g, '').trim();
+    
+    // Find the section content
+    const sectionStart = match.index + match[0].length;
+    const nextMarkerMatch = content.slice(sectionStart).match(/<!-- REQ-[\w-]+ -->/);
+    const sectionEnd = nextMarkerMatch 
+      ? sectionStart + nextMarkerMatch.index 
+      : content.length;
+    
+    const sectionContent = content.slice(sectionStart, sectionEnd);
+    
+    // Extract description (first paragraph)
+    const descMatch = sectionContent.match(/^(.+?)(?:\n\n|\n###|\n-)/s);
+    const description = descMatch ? descMatch[1].trim() : '';
+    
+    // Extract tasks (checkbox items)
+    const tasks: string[] = [];
+    const taskPattern = /- \[ \] (.+)/g;
+    let taskMatch;
+    while ((taskMatch = taskPattern.exec(sectionContent)) !== null) {
+      tasks.push(taskMatch[1].trim());
+    }
+    
+    // Extract acceptance criteria
+    const acceptance: string[] = [];
+    const acceptanceSection = sectionContent.match(/\*\*验收标准[：:]\*\*\s*\n([\s\S]+?)(?:\n\n|\n###|$)/);
+    if (acceptanceSection) {
+      const criteriaPattern = /[-•]\s*(.+)/g;
+      let criteriaMatch;
+      while ((criteriaMatch = criteriaPattern.exec(acceptanceSection[1])) !== null) {
+        acceptance.push(criteriaMatch[1].trim());
+      }
+    }
+    
+    // Extract phase
+    const phaseMatch = title.match(/Phase\s+([\d.]+)/i);
+    const phase = phaseMatch ? `Phase ${phaseMatch[1]}` : undefined;
+    
+    // Extract estimated days
+    const daysMatch = sectionContent.match(/预计[：:]\s*(\d+)\s*天/);
+    const estimatedDays = daysMatch ? parseInt(daysMatch[1]) : undefined;
+    
+    blocks.push({
+      reqId,
+      title,
+      description,
+      phase,
+      tasks,
+      acceptance,
+      estimatedDays,
+    });
+  }
+  
+  return { blocks, keywords };
+}
+
+/**
+ * Convert requirement blocks to unified format
+ */
+function blocksToUnified(
+  blocks: RequirementBlock[],
+  sourceFile: string
+): UnifiedRequirement[] {
+  return blocks.map(block => ({
+    reqId: block.reqId || `REQ-${Date.now()}`,
+    title: block.title,
+    description: block.description,
+    source: 'docs' as const,
+    sourceFiles: [sourceFile],
+    type: inferType(block),
+    status: block.status || 'draft',
+    phase: block.phase,
+    acceptance: block.acceptance,
+    tasks: block.tasks,
+    dependsOn: block.dependsOn,
+    estimatedDays: block.estimatedDays,
+    createdAt: new Date().toISOString(),
+  }));
+}
+
+/**
+ * Infer requirement type from block
+ */
+function inferType(block: RequirementBlock): 'epic' | 'feature' | 'task' {
+  // If has sub-tasks, it's at least a feature
+  if (block.tasks && block.tasks.length > 5) {
+    return 'epic';
+  }
+  if (block.tasks && block.tasks.length > 0) {
+    return 'feature';
+  }
+  return 'task';
+}
+
+/**
+ * Parse all MDX files in a directory or a single file
+ */
+export function parseMdxDirectory(inputPath: string): UnifiedRequirements {
+  const requirements: UnifiedRequirement[] = [];
+  const sourceFiles: string[] = [];
+  const allKeywords = new Set<string>();
+  
+  // Check if input is a file or directory
+  const stat = fs.statSync(inputPath);
+  
+  let files: string[];
+  if (stat.isFile()) {
+    // Single file
+    files = [inputPath];
+  } else {
+    // Directory - find all .mdx files
+    files = fs.readdirSync(inputPath, { recursive: true })
+      .filter(file => typeof file === 'string' && file.endsWith('.mdx'))
+      .map(file => path.join(inputPath, file as string));
+  }
+  
+  // Parse each file
+  for (const file of files) {
+    try {
+      const { blocks, keywords } = parseMdxFile(file);
+      keywords.forEach(k => allKeywords.add(k));
+      
+      const unified = blocksToUnified(blocks, file);
+      requirements.push(...unified);
+      sourceFiles.push(file);
+    } catch (error) {
+      console.error(`Error parsing ${file}:`, error);
+    }
+  }
+  
+  const keywords = Array.from(allKeywords);
+  
+  if (keywords.length > 0) {
+    console.log(`\n📝 Found ${keywords.length} keywords from frontmatter:`, keywords.join(', '));
+  } else {
+    console.log(`\n⚠️  No keywords found in frontmatter. Please add keywords to MDX files.`);
+  }
+  
+  return {
+    version: '1.0.0',
+    generatedAt: new Date().toISOString(),
+    sources: {
+      docs: {
+        files: sourceFiles,
+        extractedAt: new Date().toISOString(),
+        keywords, // Add keywords to output
+      },
+    },
+    requirements,
+  };
+}
+
+/**
+ * CLI entry point
+ */
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const args = process.argv.slice(2);
+  const inputDir = args[0] || '../../../waoooo-docs/developer-docs/planning';
+  const outputFile = args[1] || './exports/temp/requirements-from-docs.json';
+  
+  console.log('Parsing MDX documents...');
+  console.log('Input:', inputDir);
+  
+  const result = parseMdxDirectory(inputDir);
+  
+  console.log(`Found ${result.requirements.length} requirements`);
+  
+  // Write output
+  fs.writeFileSync(outputFile, JSON.stringify(result, null, 2));
+  console.log('Output:', outputFile);
+}

package/skills/requirement-parse/scripts/parse-openspec.ts

@@ -0,0 +1,168 @@
+/**
+ * Parse OpenSpec Changes to Unified Requirements
+ * 
+ * This script extracts requirements from OpenSpec change proposals.
+ * Reads proposal.md, design.md, and tasks.md
+ */
+
+import fs from 'fs';
+import path from 'path';
+import matter from 'gray-matter';
+import type { UnifiedRequirement, UnifiedRequirements } from '../types/unified-requirements';
+
+/**
+ * Parse OpenSpec change directory
+ */
+export function parseOpenSpec(changeDir: string): UnifiedRequirements {
+  console.log('📋 Parsing OpenSpec change...');
+  console.log('   Input:', changeDir);
+  
+  if (!fs.existsSync(changeDir)) {
+    throw new Error(`OpenSpec change directory not found: ${changeDir}`);
+  }
+  
+  const changeId = path.basename(changeDir);
+  const requirements: UnifiedRequirement[] = [];
+  const keywords: string[] = [];
+  
+  // Read proposal.md
+  const proposalPath = path.join(changeDir, 'proposal.md');
+  if (fs.existsSync(proposalPath)) {
+    const proposalContent = fs.readFileSync(proposalPath, 'utf-8');
+    const { data } = matter(proposalContent);
+    
+    // Extract keywords from frontmatter
+    if (data.keywords && Array.isArray(data.keywords)) {
+      keywords.push(...data.keywords);
+    }
+    
+    console.log('   ✅ Read proposal.md');
+  }
+  
+  // Read tasks.md
+  const tasksPath = path.join(changeDir, 'tasks.md');
+  if (fs.existsSync(tasksPath)) {
+    const tasksContent = fs.readFileSync(tasksPath, 'utf-8');
+    const { data, content } = matter(tasksContent);
+    
+    // Parse tasks from markdown
+    const taskMatches = content.matchAll(/^[-*]\s+\[([x\s])\]\s+(.+)$/gm);
+    
+    let currentPhase = 0;
+    let lastTaskInPhase: string | null = null;
+    const phaseFirstTasks: Record<number, string> = {};
+    
+    // First pass: extract all tasks
+    for (const match of taskMatches) {
+      const status = match[1] === 'x' ? 'done' : 'draft';
+      const title = match[2].trim();
+      const reqId = `REQ-${changeId.toUpperCase()}-${requirements.length + 1}`;
+      
+      // Detect phase number from task title (e.g., "1.1", "2.1")
+      const phaseMatch = title.match(/^(\d+)\.(\d+)/);
+      const phase = phaseMatch ? parseInt(phaseMatch[1]) : 0;
+      const taskNum = phaseMatch ? parseInt(phaseMatch[2]) : 0;
+      
+      // Track phase changes
+      if (phase !== currentPhase) {
+        currentPhase = phase;
+        lastTaskInPhase = null;
+        if (taskNum === 1) {
+          phaseFirstTasks[phase] = reqId;
+        }
+      }
+      
+      // Infer dependencies
+      const blockedBy: string[] = [];
+      
+      // Rule 1: Sequential dependency within same phase
+      // Each task depends on the previous task in the same phase
+      if (lastTaskInPhase && taskNum > 1) {
+        blockedBy.push(lastTaskInPhase);
+      }
+      
+      // Rule 2: Phase dependency
+      // First task of each phase depends on last task of previous phase
+      if (taskNum === 1 && phase > 1 && requirements.length > 0) {
+        // Find last task of previous phase
+        for (let i = requirements.length - 1; i >= 0; i--) {
+          const prevReq = requirements[i];
+          const prevMatch = prevReq.title.match(/^(\d+)\.(\d+)/);
+          if (prevMatch && parseInt(prevMatch[1]) === phase - 1) {
+            blockedBy.push(prevReq.reqId);
+            break;
+          }
+        }
+      }
+      
+      requirements.push({
+        reqId,
+        title,
+        description: '',
+        source: 'openspec',
+        sourceFiles: [tasksPath],
+        type: 'task',
+        status,
+        acceptance: [],
+        tasks: [],
+        blockedBy,
+        blocks: [],
+        createdAt: new Date().toISOString(),
+      });
+      
+      lastTaskInPhase = reqId;
+    }
+    
+    console.log(`   ✅ Read tasks.md (${requirements.length} tasks)`);
+  }
+  
+  if (keywords.length > 0) {
+    console.log(`\n📝 Found ${keywords.length} keywords from OpenSpec:`, keywords.join(', '));
+  } else {
+    console.log(`\n⚠️  No keywords found in OpenSpec. Please add keywords to proposal.md frontmatter.`);
+  }
+  
+  return {
+    version: '1.0.0',
+    generatedAt: new Date().toISOString(),
+    sources: {
+      openspec: {
+        changeId,
+        files: ['proposal.md', 'design.md', 'tasks.md'],
+        extractedAt: new Date().toISOString(),
+        keywords,
+      },
+    },
+    requirements,
+  };
+}
+
+/**
+ * CLI entry point
+ */
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const args = process.argv.slice(2);
+  const inputDir = args[0];
+  const outputFile = args[1] || './exports/temp/requirements-from-openspec.json';
+  
+  if (!inputDir) {
+    console.error('Usage: tsx parse-openspec.ts <openspec-change-dir> [output.json]');
+    console.error('');
+    console.error('Example:');
+    console.error('  tsx parse-openspec.ts openspec/changes/001-pricing-system/ output.json');
+    process.exit(1);
+  }
+  
+  const result = parseOpenSpec(inputDir);
+  
+  console.log(`\nFound ${result.requirements.length} requirements`);
+  
+  // Write output
+  const outputDir = path.dirname(outputFile);
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+  
+  fs.writeFileSync(outputFile, JSON.stringify(result, null, 2));
+  console.log('Output:', outputFile);
+}