@waoooo/claude-skills 1.0.0

package/skills/requirement-parse/scripts/infer-builder-config.ts

@@ -0,0 +1,346 @@
+/**
+ * Infer Builder Configuration from MDX Content
+ * 
+ * This script analyzes MDX content and automatically infers:
+ * - Required capabilities (L1/L2/L3)
+ * - Layer hints
+ * 
+ * Uses simple keyword matching (keywords from MDX frontmatter vs capability tree keywords)
+ */
+
+import fs from 'fs';
+import path from 'path';
+import type { UnifiedRequirement } from '../types/unified-requirements';
+
+/**
+ * Load capability definitions from capability tree
+ */
+function loadCapabilityDefinitions(): Array<{
+  id: string;
+  name: string;
+  tags: string[];
+  layer: string;
+}> {
+  const capabilityTreePath = path.join(process.cwd(), 'exports/capability-tree/capability-tree.json');
+  
+  if (!fs.existsSync(capabilityTreePath)) {
+    throw new Error(`
+❌ Capability tree not found: ${capabilityTreePath}
+
+Please run: pnpm capability:build-tree
+
+Or create the capability tree manually.
+`);
+  }
+  
+  try {
+    const treeData = JSON.parse(fs.readFileSync(capabilityTreePath, 'utf-8'));
+    const capabilities: Array<{ id: string; name: string; tags: string[]; layer: string }> = [];
+    
+    // Flatten capability tree
+    function flattenTree(nodes: any[], layer: string = 'L1') {
+      for (const node of nodes) {
+        if (node.id && node.name) {
+          capabilities.push({
+            id: node.id,
+            name: node.name,
+            tags: node.tags || [node.id, node.name.toLowerCase()],
+            layer: node.layer || layer,
+          });
+        }
+        if (node.children && node.children.length > 0) {
+          flattenTree(node.children, node.layer || layer);
+        }
+      }
+    }
+    
+    flattenTree(treeData.capabilities || treeData);
+    
+    if (capabilities.length === 0) {
+      throw new Error('Capability tree is empty');
+    }
+    
+    console.log(`   Loaded ${capabilities.length} capabilities from tree`);
+    
+    return capabilities;
+  } catch (error) {
+    throw new Error(`Failed to load capability tree: ${error}`);
+  }
+}
+
+/**
+ * Extract keywords from text (simple tokenization)
+ */
+function extractTags(text: string): string[] {
+  // Remove special characters and split by whitespace
+  const words = text
+    .toLowerCase()
+    .replace(/[^\w\s-]/g, ' ')
+    .split(/\s+/)
+    .filter(w => w.length > 2); // Filter out short words
+  
+  // Remove duplicates and return
+  return Array.from(new Set(words));
+}
+
+/**
+ * Match keywords with capabilities (simple intersection)
+ */
+function matchCapabilities(
+  docKeywords: string[],
+  capabilities: Array<{ id: string; name: string; tags: string[]; layer: string }>
+): Array<{ id: string; layer: string; score: number }> {
+  const matches: Array<{ id: string; layer: string; score: number }> = [];
+  
+  // Normalize keywords to lowercase
+  const normalizedKeywords = docKeywords.map(k => k.toLowerCase());
+  
+  for (const cap of capabilities) {
+    // Normalize capability tags to lowercase
+    const normalizedTags = cap.tags.map(t => t.toLowerCase());
+    
+    // Calculate intersection (how many keywords match)
+    const matchCount = normalizedKeywords.filter(k => normalizedTags.includes(k)).length;
+    
+    if (matchCount > 0) {
+      // Score = match count / total tags (normalized)
+      const score = matchCount / normalizedTags.length;
+      matches.push({
+        id: cap.id,
+        layer: cap.layer,
+        score,
+      });
+    }
+  }
+  
+  // Sort by score (descending)
+  return matches.sort((a, b) => b.score - a.score);
+}
+
+/**
+ * Infer required capabilities from requirements
+ */
+export function inferCapabilities(requirements: UnifiedRequirement[], docKeywords?: string[]): {
+  L1: string[];
+  L2: string[];
+  L3: string[];
+} {
+  // Load capability definitions
+  const capabilityDefs = loadCapabilityDefinitions();
+  
+  // Use provided keywords or extract from requirements
+  let keywords: string[];
+  if (docKeywords && docKeywords.length > 0) {
+    keywords = docKeywords;
+    console.log('📝 Using provided keywords:', keywords.slice(0, 10).join(', '), '...');
+  } else {
+    // Fallback: extract from requirements
+    const allText = requirements
+      .map(req => `${req.title} ${req.description} ${req.acceptance?.join(' ')} ${req.tasks?.join(' ')}`)
+      .join(' ');
+    keywords = extractTags(allText);
+    console.log('📝 Extracted keywords:', keywords.slice(0, 10).join(', '), '...');
+  }
+  
+  // Match capabilities
+  const matches = matchCapabilities(keywords, capabilityDefs);
+  console.log('🎯 Matched capabilities:', matches.slice(0, 5).map(m => `${m.id}(${m.score.toFixed(2)})`).join(', '));
+  
+  // Group by layer
+  const capabilities = {
+    L1: new Set<string>(),
+    L2: new Set<string>(),
+    L3: new Set<string>(),
+  };
+  
+  // Take top matches (score > 0.1)
+  matches
+    .filter(m => m.score > 0.1)
+    .forEach(match => {
+      const layer = match.layer as 'L1' | 'L2' | 'L3';
+      if (capabilities[layer]) {
+        capabilities[layer].add(match.id);
+      }
+    });
+  
+  // Also check explicit hints from requirements
+  requirements.forEach(req => {
+    if (req.layerHint && req.capabilityHints) {
+      req.capabilityHints.forEach(capId => {
+        const layer = req.layerHint as 'L1' | 'L2' | 'L3';
+        if (capabilities[layer]) {
+          capabilities[layer].add(capId);
+        }
+      });
+    }
+  });
+  
+  return {
+    L1: Array.from(capabilities.L1),
+    L2: Array.from(capabilities.L2),
+    L3: Array.from(capabilities.L3),
+  };
+}
+
+/**
+ * Infer project name from requirements
+ */
+function inferProjectName(requirements: UnifiedRequirement[]): string {
+  // Try to extract from first requirement's source file
+  const firstReq = requirements[0];
+  if (firstReq?.sourceFiles?.[0]) {
+    const filename = firstReq.sourceFiles[0].split('/').pop()?.replace('.mdx', '');
+    if (filename) {
+      return filename
+        .replace(/-/g, ' ')
+        .replace(/\b\w/g, l => l.toUpperCase());
+    }
+  }
+  
+  // Fallback: use common words from titles
+  const words = requirements
+    .map(r => r.title.split(/\s+/))
+    .flat()
+    .filter(w => w.length > 2);
+  
+  const wordCount = new Map<string, number>();
+  words.forEach(w => {
+    wordCount.set(w, (wordCount.get(w) || 0) + 1);
+  });
+  
+  const mostCommon = Array.from(wordCount.entries())
+    .sort((a, b) => b[1] - a[1])[0];
+  
+  return mostCommon ? `${mostCommon[0]} System` : 'Untitled Project';
+}
+
+/**
+ * Generate Builder configuration from requirements
+ * Output format: UnifiedRequirements (for merging)
+ */
+export function generateBuilderConfig(
+  requirements: UnifiedRequirement[],
+  docKeywords?: string[]
+): {
+  version: string;
+  sources: {
+    builder: {
+      method: string;
+      capabilities: string[];
+      extractedAt: string;
+      keywords?: string[];
+    };
+  };
+  requirements: UnifiedRequirement[];
+} {
+  const capabilities = inferCapabilities(requirements, docKeywords);
+  const allCapabilities = [...capabilities.L1, ...capabilities.L2, ...capabilities.L3];
+  
+  // Generate requirements from inferred capabilities
+  const builderRequirements: UnifiedRequirement[] = [];
+  
+  // Add L1 capabilities
+  capabilities.L1.forEach(capId => {
+    builderRequirements.push({
+      reqId: `REQ-BUILDER-${capId.toUpperCase()}`,
+      title: `集成 ${capId} 能力`,
+      description: `使用 ${capId} 能力`,
+      source: 'builder',
+      type: 'feature',
+      status: 'ready',
+      layerHint: 'L1',
+      capabilityHints: [capId],
+      acceptance: [],
+      tasks: [],
+      blockedBy: [],
+      blocks: [],
+    });
+  });
+  
+  // Add L2 capabilities
+  capabilities.L2.forEach(capId => {
+    builderRequirements.push({
+      reqId: `REQ-BUILDER-${capId.toUpperCase()}`,
+      title: `集成 ${capId} 能力`,
+      description: `使用 ${capId} 能力`,
+      source: 'builder',
+      type: 'feature',
+      status: 'ready',
+      layerHint: 'L2',
+      capabilityHints: [capId],
+      acceptance: [],
+      tasks: [],
+      blockedBy: [],
+      blocks: [],
+    });
+  });
+  
+  // Add L3 capabilities
+  capabilities.L3.forEach(capId => {
+    builderRequirements.push({
+      reqId: `REQ-BUILDER-${capId.toUpperCase()}`,
+      title: `集成 ${capId} 能力`,
+      description: `使用 ${capId} 能力`,
+      source: 'builder',
+      type: 'feature',
+      status: 'ready',
+      layerHint: 'L3',
+      capabilityHints: [capId],
+      acceptance: [],
+      tasks: [],
+      blockedBy: [],
+      blocks: [],
+    });
+  });
+  
+  return {
+    version: '1.0.0',
+    sources: {
+      builder: {
+        method: 'inferred',
+        capabilities: allCapabilities,
+        extractedAt: new Date().toISOString(),
+        keywords: docKeywords, // Include keywords in output
+      },
+    },
+    requirements: builderRequirements,
+  };
+}
+
+/**
+ * CLI entry point
+ */
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const args = process.argv.slice(2);
+  const inputFile = args[0] || './exports/requirements.pricing-from-docs.json';
+  const outputFile = args[1] || './exports/requirements.pricing-from-builder-inferred.json';
+  
+  console.log('🔍 Inferring Builder configuration from requirements...');
+  console.log('   Input:', inputFile);
+  
+  // Load requirements
+  const data = JSON.parse(fs.readFileSync(inputFile, 'utf-8'));
+  const requirements = data.requirements as UnifiedRequirement[];
+  const docKeywords = data.sources?.docs?.keywords as string[] | undefined;
+  
+  if (docKeywords && docKeywords.length > 0) {
+    console.log(`   Found ${docKeywords.length} keywords from docs`);
+  }
+  
+  // Generate config
+  const config = generateBuilderConfig(requirements, docKeywords);
+  
+  console.log('\n✅ Inferred capabilities:');
+  const l1Caps = config.requirements.filter(r => r.layerHint === 'L1').map(r => r.capabilityHints?.[0]).filter(Boolean);
+  const l2Caps = config.requirements.filter(r => r.layerHint === 'L2').map(r => r.capabilityHints?.[0]).filter(Boolean);
+  const l3Caps = config.requirements.filter(r => r.layerHint === 'L3').map(r => r.capabilityHints?.[0]).filter(Boolean);
+  
+  console.log('   L1:', l1Caps.join(', ') || 'none');
+  console.log('   L2:', l2Caps.join(', ') || 'none');
+  console.log('   L3:', l3Caps.join(', ') || 'none');
+  console.log(`   Total: ${config.requirements.length} capability requirements`);
+  
+  // Write output
+  fs.writeFileSync(outputFile, JSON.stringify(config, null, 2));
+  console.log('\n📄 Output:', outputFile);
+}

package/skills/requirement-parse/scripts/merge-requirements.ts

@@ -0,0 +1,228 @@
+/**
+ * Merge Requirements from Multiple Sources
+ * 
+ * This script merges requirements from:
+ * - MDX planning documents (narrative, flexible)
+ * - Product Builder (structured, technical)
+ * - Historical data (preserves status)
+ */
+
+import fs from 'fs';
+import path from 'path';
+import type { UnifiedRequirement, UnifiedRequirements } from '../types/unified-requirements';
+
+/**
+ * Merge requirements from multiple sources
+ */
+export function mergeRequirements(
+  fromDocs?: UnifiedRequirements,
+  fromBuilder?: UnifiedRequirements,
+  history?: UnifiedRequirements
+): UnifiedRequirements {
+  const merged = new Map<string, UnifiedRequirement>();
+  
+  // 1. Load history (preserve status)
+  if (history) {
+    history.requirements.forEach(req => {
+      merged.set(req.reqId, { ...req });
+    });
+  }
+  
+  // 2. Merge docs (high priority)
+  if (fromDocs) {
+    fromDocs.requirements.forEach(req => {
+      const existing = merged.get(req.reqId);
+      
+      if (existing) {
+        // Preserve completed status
+        if (existing.status === 'done') {
+          req.status = 'done';
+          req.completedAt = existing.completedAt;
+        }
+        
+        // Merge source files
+        req.sourceFiles = [
+          ...(existing.sourceFiles || []),
+          ...(req.sourceFiles || []),
+        ];
+        req.source = 'merged';
+      }
+      
+      merged.set(req.reqId, req);
+    });
+  }
+  
+  // 3. Supplement with builder info (only add missing fields)
+  if (fromBuilder) {
+    fromBuilder.requirements.forEach(req => {
+      const existing = merged.get(req.reqId);
+      
+      if (!existing) {
+        // New requirement from builder
+        merged.set(req.reqId, req);
+      } else {
+        // Supplement technical fields
+        if (!existing.layerHint) existing.layerHint = req.layerHint;
+        if (!existing.capabilityHints) existing.capabilityHints = req.capabilityHints;
+        if (!existing.module) existing.module = req.module;
+        if (!existing.modules) existing.modules = req.modules;
+        existing.source = 'merged';
+      }
+    });
+  }
+  
+  // 4. Calculate dependencies and execution order
+  const requirements = Array.from(merged.values());
+  calculateBlockedBy(requirements);
+  const executionOrder = calculateExecutionOrder(requirements);
+  
+  return {
+    version: '1.0.0',
+    generatedAt: new Date().toISOString(),
+    sources: {
+      docs: fromDocs?.sources.docs,
+      builder: fromBuilder?.sources.builder,
+    },
+    requirements,
+    executionOrder,
+  };
+}
+
+/**
+ * Calculate blockedBy and blocks fields
+ */
+function calculateBlockedBy(requirements: UnifiedRequirement[]): void {
+  const reqMap = new Map(requirements.map(r => [r.reqId, r]));
+  
+  // Don't clear existing blockedBy/blocks - preserve them from parse-openspec
+  // Only initialize if they don't exist
+  requirements.forEach(req => {
+    if (!req.blockedBy) req.blockedBy = [];
+    if (!req.blocks) req.blocks = [];
+  });
+  
+  // Add additional dependencies from dependsOn field
+  requirements.forEach(req => {
+    if (req.dependsOn) {
+      req.dependsOn.forEach(depId => {
+        const dep = reqMap.get(depId);
+        if (dep) {
+          // This req is blocked by dep
+          if (dep.status !== 'done' && !req.blockedBy!.includes(depId)) {
+            req.blockedBy!.push(depId);
+          }
+          // dep blocks this req
+          if (!dep.blocks) dep.blocks = [];
+          if (!dep.blocks.includes(req.reqId)) {
+            dep.blocks.push(req.reqId);
+          }
+        }
+      });
+    }
+  });
+}
+
+/**
+ * Calculate execution order using topological sort
+ */
+function calculateExecutionOrder(requirements: UnifiedRequirement[]): string[] {
+  const graph = new Map<string, string[]>();
+  const inDegree = new Map<string, number>();
+  
+  // Build graph
+  requirements.forEach(req => {
+    graph.set(req.reqId, req.dependsOn || []);
+    inDegree.set(req.reqId, 0);
+  });
+  
+  // Calculate in-degrees
+  requirements.forEach(req => {
+    (req.dependsOn || []).forEach(depId => {
+      inDegree.set(depId, (inDegree.get(depId) || 0) + 1);
+    });
+  });
+  
+  // Topological sort
+  const queue: string[] = [];
+  const sorted: string[] = [];
+  
+  // Start with nodes that have no dependencies
+  inDegree.forEach((degree, reqId) => {
+    if (degree === 0) {
+      queue.push(reqId);
+    }
+  });
+  
+  while (queue.length > 0) {
+    const reqId = queue.shift()!;
+    sorted.push(reqId);
+    
+    const deps = graph.get(reqId) || [];
+    deps.forEach(depId => {
+      const newDegree = (inDegree.get(depId) || 0) - 1;
+      inDegree.set(depId, newDegree);
+      if (newDegree === 0) {
+        queue.push(depId);
+      }
+    });
+  }
+  
+  // Check for cycles
+  if (sorted.length !== requirements.length) {
+    console.warn('Warning: Circular dependencies detected');
+  }
+  
+  return sorted;
+}
+
+/**
+ * CLI entry point
+ */
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const args = process.argv.slice(2);
+  
+  if (args.length < 3) {
+    console.error('Usage: tsx merge-requirements.ts <docs.json> <form.json> <output.json>');
+    console.error('');
+    console.error('Example:');
+    console.error('  tsx merge-requirements.ts docs.json form.json unified.json');
+    process.exit(1);
+  }
+  
+  const docsFile = args[0];
+  const builderFile = args[1];
+  const outputFile = args[2];
+  
+  console.log('🔄 Merging requirements...');
+  console.log('   Docs:', docsFile);
+  console.log('   Builder:', builderFile);
+  
+  // Load inputs
+  const fromDocs = fs.existsSync(docsFile) 
+    ? JSON.parse(fs.readFileSync(docsFile, 'utf-8')) 
+    : undefined;
+  
+  const fromBuilder = fs.existsSync(builderFile)
+    ? JSON.parse(fs.readFileSync(builderFile, 'utf-8'))
+    : undefined;
+  
+  if (!fromDocs && !fromBuilder) {
+    console.error('❌ Error: At least one input file must exist');
+    process.exit(1);
+  }
+  
+  // Merge (no history for now)
+  const result = mergeRequirements(fromDocs, fromBuilder, undefined);
+  
+  console.log(`\n✅ Merged ${result.requirements.length} requirements`);
+  console.log(`   Execution order: ${result.executionOrder?.length || 0} items`);
+  
+  // 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(`\n📄 Output: ${outputFile}`);
+}