@waoooo/claude-skills 1.0.0

package/skills/spec-generate/scripts/generate-specs.ts

@@ -0,0 +1,538 @@
+/**
+ * Generate Specs
+ * 
+ * Generate specs/ directory with README.md, tasks.json, verification.json, progress.json
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+interface CapabilityAnalysis {
+  version: string;
+  jobId: string;
+  analyzedAt: string;
+  summary: {
+    totalRequirements: number;
+    requiredCapabilities: number;
+    availableCapabilities: number;
+    missingCapabilities: number;
+    implementedInProject: number;
+  };
+  capabilities: {
+    available: Array<{
+      capId: string;
+      name: string;
+      layer: string;
+      status: string;
+      source: string;
+      usedBy?: string[];
+      suggestedAction?: string;
+    }>;
+    missing: Array<{
+      capId: string;
+      name: string;
+      layer: string;
+      status: string;
+      requiredBy?: string[];
+      suggestedAction?: string;
+    }>;
+    implemented: Array<{
+      capId: string;
+      name: string;
+      layer: string;
+      detectedIn?: string[];
+      notInTree?: boolean;
+      suggestedAction?: string;
+    }>;
+  };
+  dependencies: {
+    graph: Record<string, { requires: string[]; blocks: string[] }>;
+    layers: Record<string, string[]>;
+  };
+  recommendations: Array<{
+    type: string;
+    capability: string;
+    reason: string;
+    priority: string;
+  }>;
+}
+
+interface UnifiedRequirements {
+  version: string;
+  sources: any;
+  requirements: Array<{
+    reqId: string;
+    title: string;
+    description?: string;
+    type?: string;
+    status?: string;
+    layerHint?: string;
+    capabilityHints?: string[];
+    acceptance?: string[];
+    tasks?: string[];
+    blockedBy?: string[];
+    blocks?: string[];
+  }>;
+  executionOrder?: string[];
+}
+
+interface Task {
+  taskId: string;
+  title: string;
+  type: 'capability-development' | 'documentation' | 'integration' | 'testing';
+  priority: 'high' | 'medium' | 'low';
+  layer?: string;
+  capability?: string;
+  requirements?: string[];
+  dependencies?: string[];
+  estimatedHours: number;
+  status: 'pending' | 'in-progress' | 'completed';
+  subtasks: Array<{
+    id: string;
+    title: string;
+    status: 'pending' | 'in-progress' | 'completed';
+  }>;
+  verification: string[];
+}
+
+/**
+ * Generate README.md
+ */
+function generateReadme(
+  analysis: CapabilityAnalysis,
+  unified: UnifiedRequirements,
+  outputPath: string
+): void {
+  const { jobId, summary, capabilities, dependencies } = analysis;
+  
+  // Extract job name from jobId
+  const jobName = jobId.split('-').slice(3).join(' ').replace(/\b\w/g, l => l.toUpperCase());
+  
+  let content = `# Development Specification: ${jobName}\n\n`;
+  content += `**Job ID**: ${jobId}  \n`;
+  content += `**Generated**: ${new Date().toISOString()}  \n`;
+  content += `**Status**: Ready for Development\n\n`;
+  
+  content += `## Overview\n\n`;
+  content += `This specification outlines the development plan for the ${jobName} feature.\n\n`;
+  
+  content += `## Summary\n\n`;
+  content += `- **Total Requirements**: ${summary.totalRequirements}\n`;
+  content += `- **Required Capabilities**: ${summary.requiredCapabilities}\n`;
+  content += `- **Available Capabilities**: ${summary.availableCapabilities}\n`;
+  content += `- **Missing Capabilities**: ${summary.missingCapabilities}\n`;
+  content += `- **Implemented (not in tree)**: ${summary.implementedInProject}\n\n`;
+  
+  // Available capabilities
+  if (capabilities.available.length > 0) {
+    content += `## ✅ Available Capabilities (${capabilities.available.length})\n\n`;
+    content += `| Capability | Layer | Status | Action |\n`;
+    content += `|------------|-------|--------|--------|\n`;
+    for (const cap of capabilities.available) {
+      content += `| ${cap.name || cap.capId} | ${cap.layer} | ${cap.status} | ${cap.suggestedAction || 'use'} |\n`;
+    }
+    content += `\n`;
+  }
+  
+  // Missing capabilities
+  if (capabilities.missing.length > 0) {
+    content += `## ❌ Missing Capabilities (${capabilities.missing.length})\n\n`;
+    content += `| Capability | Layer | Priority | Action |\n`;
+    content += `|------------|-------|----------|--------|\n`;
+    for (const cap of capabilities.missing) {
+      const priority = cap.layer === 'L1' ? 'High' : cap.layer === 'L2' ? 'Medium' : 'Low';
+      content += `| ${cap.name || cap.capId} | ${cap.layer} | ${priority} | ${cap.suggestedAction || 'develop'} |\n`;
+    }
+    content += `\n`;
+  }
+  
+  // Implemented but not in tree
+  if (capabilities.implemented.length > 0) {
+    content += `## 🔍 Implemented but Not in Tree (${capabilities.implemented.length})\n\n`;
+    content += `| Capability | Detected In | Action |\n`;
+    content += `|------------|-------------|--------|\n`;
+    for (const cap of capabilities.implemented) {
+      const detectedIn = cap.detectedIn?.join(', ') || 'unknown';
+      content += `| ${cap.name || cap.capId} | ${detectedIn} | ${cap.suggestedAction || 'update-tree'} |\n`;
+    }
+    content += `\n`;
+  }
+  
+  // Dependencies
+  content += `## Dependencies\n\n`;
+  content += `\`\`\`mermaid\n`;
+  content += `graph TD\n`;
+  
+  // Build dependency graph
+  const layers = dependencies.layers;
+  const layerOrder = ['L1', 'L2', 'L3', 'L4'];
+  
+  for (const layer of layerOrder) {
+    if (layers[layer] && layers[layer].length > 0) {
+      for (const cap of layers[layer]) {
+        const deps = dependencies.graph[cap]?.requires || [];
+        if (deps.length > 0) {
+          for (const dep of deps) {
+            content += `  ${dep} --> ${cap}\n`;
+          }
+        } else {
+          content += `  ${cap}\n`;
+        }
+      }
+    }
+  }
+  
+  content += `\`\`\`\n\n`;
+  
+  // Execution plan
+  content += `## Execution Plan\n\n`;
+  for (const layer of layerOrder) {
+    if (layers[layer] && layers[layer].length > 0) {
+      const layerName = layer === 'L1' ? 'Foundation' : layer === 'L2' ? 'Core Features' : layer === 'L3' ? 'Business Logic' : 'Advanced Features';
+      content += `### Phase ${layer.slice(1)}: ${layerName} (${layer})\n`;
+      for (const cap of layers[layer]) {
+        const capInfo = capabilities.available.find(c => c.capId === cap) ||
+                       capabilities.missing.find(c => c.capId === cap) ||
+                       capabilities.implemented.find(c => c.capId === cap);
+        const action = capInfo?.suggestedAction || 'develop';
+        content += `- ${action === 'use' ? 'Use existing' : action === 'develop' ? 'Develop' : 'Update'} \`${cap}\` capability\n`;
+      }
+      content += `\n`;
+    }
+  }
+  
+  content += `## Tasks\n\n`;
+  content += `See [tasks.json](./tasks.json) for detailed task list.\n\n`;
+  
+  content += `## Verification\n\n`;
+  content += `See [verification.json](./verification.json) for test commands.\n\n`;
+  
+  content += `## Progress Tracking\n\n`;
+  content += `See [progress.json](./progress.json) for current status.\n`;
+  
+  fs.writeFileSync(outputPath, content);
+  console.log(`  ✅ Generated: README.md`);
+}
+
+/**
+ * Generate tasks.json
+ */
+function generateTasks(
+  analysis: CapabilityAnalysis,
+  unified: UnifiedRequirements,
+  outputPath: string
+): void {
+  const tasks: Task[] = [];
+  let taskCounter = 1;
+  
+  // Generate tasks for missing capabilities
+  for (const cap of analysis.capabilities.missing) {
+    const taskId = `TASK-${String(taskCounter).padStart(3, '0')}`;
+    taskCounter++;
+    
+    const priority = cap.layer === 'L1' ? 'high' : cap.layer === 'L2' ? 'medium' : 'low';
+    const estimatedHours = cap.layer === 'L1' ? 4 : cap.layer === 'L2' ? 8 : 6;
+    
+    tasks.push({
+      taskId,
+      title: `Develop ${cap.name || cap.capId} capability`,
+      type: 'capability-development',
+      priority,
+      layer: cap.layer,
+      capability: cap.capId,
+      requirements: cap.requiredBy || [],
+      dependencies: analysis.dependencies.graph[cap.capId]?.requires || [],
+      estimatedHours,
+      status: 'pending',
+      subtasks: [
+        {
+          id: `${taskId}-1`,
+          title: `Design ${cap.name || cap.capId} interface`,
+          status: 'pending',
+        },
+        {
+          id: `${taskId}-2`,
+          title: `Implement ${cap.name || cap.capId} logic`,
+          status: 'pending',
+        },
+        {
+          id: `${taskId}-3`,
+          title: `Add tests for ${cap.name || cap.capId}`,
+          status: 'pending',
+        },
+      ],
+      verification: [
+        `pnpm test:${cap.capId}`,
+        'pnpm build',
+      ],
+    });
+  }
+  
+  // Generate tasks for implemented but not in tree
+  for (const cap of analysis.capabilities.implemented) {
+    if (cap.notInTree) {
+      const taskId = `TASK-${String(taskCounter).padStart(3, '0')}`;
+      taskCounter++;
+      
+      tasks.push({
+        taskId,
+        title: `Update capability tree with ${cap.name || cap.capId}`,
+        type: 'documentation',
+        priority: 'medium',
+        capability: cap.capId,
+        estimatedHours: 1,
+        status: 'pending',
+        subtasks: [
+          {
+            id: `${taskId}-1`,
+            title: `Document ${cap.name || cap.capId} capability`,
+            status: 'pending',
+          },
+          {
+            id: `${taskId}-2`,
+            title: 'Add to capability-tree.json',
+            status: 'pending',
+          },
+        ],
+        verification: [
+          'pnpm capability:build-tree',
+        ],
+      });
+    }
+  }
+  
+  // Generate integration tasks from requirements
+  for (const req of unified.requirements || []) {
+    // Skip capability requirements (source === 'builder')
+    if (req.source === 'builder') {
+      continue;
+    }
+    
+    const taskId = `TASK-${String(taskCounter).padStart(3, '0')}`;
+    taskCounter++;
+    
+    // Determine task type based on requirement type
+    let taskType: 'capability-development' | 'documentation' | 'integration' | 'testing' = 'integration';
+    if (req.type === 'documentation' || req.title.includes('文档') || req.title.includes('Documentation')) {
+      taskType = 'documentation';
+    } else if (req.type === 'testing' || req.title.includes('测试') || req.title.includes('Test')) {
+      taskType = 'testing';
+    }
+    
+    // Determine priority based on task number (earlier tasks are higher priority)
+    let priority: 'high' | 'medium' | 'low' = 'medium';
+    const taskNumber = req.title.match(/^(\d+)\.(\d+)/);
+    if (taskNumber) {
+      const phase = parseInt(taskNumber[1]);
+      if (phase <= 3) {
+        priority = 'high';
+      } else if (phase >= 8) {
+        priority = 'low';
+      }
+    }
+    
+    tasks.push({
+      taskId,
+      title: req.title,
+      type: taskType,
+      priority,
+      requirements: [req.reqId],
+      dependencies: req.blockedBy || [],
+      estimatedHours: 2,
+      status: req.status === 'done' ? 'completed' : 'pending',
+      subtasks: req.acceptance?.map((acc, idx) => ({
+        id: `${taskId}-${idx + 1}`,
+        title: acc,
+        status: 'pending' as const,
+      })) || [],
+      verification: [
+        'pnpm test',
+        'pnpm build',
+      ],
+    });
+  }
+  
+  // Sort tasks by priority and dependencies
+  const sortedTasks = tasks.sort((a, b) => {
+    const priorityOrder = { high: 0, medium: 1, low: 2 };
+    return priorityOrder[a.priority] - priorityOrder[b.priority];
+  });
+  
+  const tasksJson = {
+    version: '1.0.0',
+    jobId: analysis.jobId,
+    generatedAt: new Date().toISOString(),
+    tasks: sortedTasks,
+    executionOrder: sortedTasks.map(t => t.taskId),
+    summary: {
+      totalTasks: tasks.length,
+      pending: tasks.length,
+      inProgress: 0,
+      completed: 0,
+      estimatedHours: tasks.reduce((sum, t) => sum + t.estimatedHours, 0),
+    },
+  };
+  
+  fs.writeFileSync(outputPath, JSON.stringify(tasksJson, null, 2));
+  console.log(`  ✅ Generated: tasks.json (${tasks.length} tasks)`);
+}
+
+/**
+ * Generate verification.json
+ */
+function generateVerification(
+  analysis: CapabilityAnalysis,
+  outputPath: string
+): void {
+  const verifications = [
+    {
+      id: 'VERIFY-001',
+      name: 'Type Check',
+      command: 'pnpm type-check',
+      required: true,
+      runBefore: 'commit',
+    },
+    {
+      id: 'VERIFY-002',
+      name: 'Unit Tests',
+      command: 'pnpm test',
+      required: true,
+      runBefore: 'commit',
+    },
+    {
+      id: 'VERIFY-003',
+      name: 'Build',
+      command: 'pnpm build',
+      required: true,
+      runBefore: 'push',
+    },
+  ];
+  
+  // Add capability-specific tests
+  let verifyCounter = 4;
+  for (const cap of analysis.capabilities.missing) {
+    verifications.push({
+      id: `VERIFY-${String(verifyCounter).padStart(3, '0')}`,
+      name: `${cap.name || cap.capId} Tests`,
+      command: `pnpm test:${cap.capId}`,
+      required: true,
+      runBefore: 'merge',
+    });
+    verifyCounter++;
+  }
+  
+  const verificationJson = {
+    version: '1.0.0',
+    jobId: analysis.jobId,
+    generatedAt: new Date().toISOString(),
+    verifications,
+    preCommitChecks: ['VERIFY-001', 'VERIFY-002'],
+    prePushChecks: ['VERIFY-003'],
+    preMergeChecks: verifications.filter(v => v.runBefore === 'merge').map(v => v.id),
+  };
+  
+  fs.writeFileSync(outputPath, JSON.stringify(verificationJson, null, 2));
+  console.log(`  ✅ Generated: verification.json (${verifications.length} checks)`);
+}
+
+/**
+ * Generate progress.json
+ */
+function generateProgress(
+  analysis: CapabilityAnalysis,
+  tasksCount: number,
+  outputPath: string
+): void {
+  const progressJson = {
+    version: '1.0.0',
+    jobId: analysis.jobId,
+    updatedAt: new Date().toISOString(),
+    status: 'pending',
+    progress: {
+      totalTasks: tasksCount,
+      completed: 0,
+      inProgress: 0,
+      pending: tasksCount,
+      percentage: 0,
+    },
+    timeline: [
+      {
+        timestamp: new Date().toISOString(),
+        event: 'specs-generated',
+        description: 'Development specifications generated',
+      },
+    ],
+    currentTask: null,
+    nextTask: tasksCount > 0 ? 'TASK-001' : null,
+    blockers: [],
+  };
+  
+  fs.writeFileSync(outputPath, JSON.stringify(progressJson, null, 2));
+  console.log(`  ✅ Generated: progress.json`);
+}
+
+/**
+ * Main function
+ */
+function generateSpecs(
+  analysisPath: string,
+  unifiedPath: string,
+  outputDir: string
+): void {
+  console.log('📋 Generating specs...');
+  
+  // Read analysis
+  if (!fs.existsSync(analysisPath)) {
+    throw new Error(`Analysis file not found: ${analysisPath}`);
+  }
+  const analysis: CapabilityAnalysis = JSON.parse(fs.readFileSync(analysisPath, 'utf-8'));
+  
+  // Read unified
+  if (!fs.existsSync(unifiedPath)) {
+    throw new Error(`Unified file not found: ${unifiedPath}`);
+  }
+  const unified: UnifiedRequirements = JSON.parse(fs.readFileSync(unifiedPath, 'utf-8'));
+  
+  // Create output directory
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+  
+  // Generate files
+  generateReadme(analysis, unified, path.join(outputDir, 'README.md'));
+  generateTasks(analysis, unified, path.join(outputDir, 'tasks.json'));
+  
+  // Read tasks count for progress
+  const tasksJson = JSON.parse(fs.readFileSync(path.join(outputDir, 'tasks.json'), 'utf-8'));
+  const tasksCount = tasksJson.tasks.length;
+  
+  generateVerification(analysis, path.join(outputDir, 'verification.json'));
+  generateProgress(analysis, tasksCount, path.join(outputDir, 'progress.json'));
+  
+  console.log(`\n✅ Specs generated in: ${outputDir}`);
+  console.log(`   README.md - Development specification`);
+  console.log(`   tasks.json - ${tasksCount} tasks`);
+  console.log(`   verification.json - Verification commands`);
+  console.log(`   progress.json - Progress tracking`);
+}
+
+// CLI
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const args = process.argv.slice(2);
+  
+  if (args.length < 3) {
+    console.error('Usage: tsx generate-specs.ts <capability-analysis.json> <unified.json> <output-dir>');
+    process.exit(1);
+  }
+  
+  const [analysisPath, unifiedPath, outputDir] = args;
+  
+  try {
+    generateSpecs(analysisPath, unifiedPath, outputDir);
+  } catch (error) {
+    console.error('❌ Error:', error);
+    process.exit(1);
+  }
+}
+
+export { generateSpecs };

package/skills/spec-generate/scripts/generate-tasks.ts

@@ -0,0 +1,174 @@
+/**
+ * Generate Tasks
+ * 
+ * Generate task list from capability analysis
+ * Output: tasks.json with execution order
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+interface CapabilityAnalysis {
+  available: Array<{
+    id: string;
+    name: string;
+    layer: string;
+    status: string;
+  }>;
+  missing: Array<{
+    id: string;
+    name: string;
+    reason: string;
+  }>;
+  dependencies: Record<string, string[]>;
+  executionOrder: string[];
+}
+
+interface Task {
+  id: string;
+  order: number;
+  type: 'develop-capability' | 'integrate' | 'test';
+  target: string;
+  description: string;
+  blockedBy: string[];
+  status: 'pending' | 'in-progress' | 'completed' | 'failed';
+  estimatedHours?: number;
+}
+
+interface TaskList {
+  version: string;
+  generatedAt: string;
+  tasks: Task[];
+  summary: {
+    total: number;
+    pending: number;
+    inProgress: number;
+    completed: number;
+  };
+}
+
+/**
+ * Generate tasks from capability analysis
+ */
+function generateTasks(analysisPath: string, outputPath: string) {
+  console.log('📋 Generating tasks...');
+  
+  // Read capability analysis
+  if (!fs.existsSync(analysisPath)) {
+    throw new Error(`Capability analysis not found: ${analysisPath}`);
+  }
+  
+  const analysis: CapabilityAnalysis = JSON.parse(fs.readFileSync(analysisPath, 'utf-8'));
+  
+  const tasks: Task[] = [];
+  let taskOrder = 1;
+  
+  // Generate tasks for missing capabilities (按执行顺序)
+  const taskIdMap = new Map<string, string>();
+  
+  for (const capId of analysis.executionOrder) {
+    const missing = analysis.missing.find(m => m.id === capId);
+    if (!missing) continue;
+    
+    const taskId = `task-${taskOrder}`;
+    taskIdMap.set(capId, taskId);
+    
+    // Find dependencies
+    const deps = analysis.dependencies[capId] || [];
+    const blockedBy = deps.map(dep => taskIdMap.get(dep)).filter(Boolean) as string[];
+    
+    tasks.push({
+      id: taskId,
+      order: taskOrder,
+      type: 'develop-capability',
+      target: capId,
+      description: `开发能力: ${missing.name}`,
+      blockedBy,
+      status: 'pending',
+      estimatedHours: 8, // Default estimate
+    });
+    
+    console.log(`  ${taskOrder}. ${missing.name}${blockedBy.length > 0 ? ` (依赖: ${blockedBy.join(', ')})` : ''}`);
+    taskOrder++;
+  }
+  
+  // Add integration task (after all capabilities are developed)
+  if (tasks.length > 0) {
+    const integrationTaskId = `task-${taskOrder}`;
+    const allCapabilityTasks = tasks.map(t => t.id);
+    
+    tasks.push({
+      id: integrationTaskId,
+      order: taskOrder,
+      type: 'integrate',
+      target: 'job-main',
+      description: '对接所有能力到主功能',
+      blockedBy: allCapabilityTasks,
+      status: 'pending',
+      estimatedHours: 4,
+    });
+    
+    console.log(`  ${taskOrder}. 对接所有能力 (依赖: ${allCapabilityTasks.join(', ')})`);
+    taskOrder++;
+    
+    // Add test task
+    const testTaskId = `task-${taskOrder}`;
+    tasks.push({
+      id: testTaskId,
+      order: taskOrder,
+      type: 'test',
+      target: 'job-main',
+      description: '测试完整功能',
+      blockedBy: [integrationTaskId],
+      status: 'pending',
+      estimatedHours: 2,
+    });
+    
+    console.log(`  ${taskOrder}. 测试完整功能 (依赖: ${integrationTaskId})`);
+  }
+  
+  // Create task list
+  const taskList: TaskList = {
+    version: '1.0.0',
+    generatedAt: new Date().toISOString(),
+    tasks,
+    summary: {
+      total: tasks.length,
+      pending: tasks.filter(t => t.status === 'pending').length,
+      inProgress: tasks.filter(t => t.status === 'in-progress').length,
+      completed: tasks.filter(t => t.status === 'completed').length,
+    },
+  };
+  
+  // Write output
+  const outputDir = path.dirname(outputPath);
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+  
+  fs.writeFileSync(outputPath, JSON.stringify(taskList, null, 2));
+  console.log(`\n✅ Tasks saved to: ${outputPath}`);
+  console.log(`   Total tasks: ${taskList.summary.total}`);
+  console.log(`   Estimated hours: ${tasks.reduce((sum, t) => sum + (t.estimatedHours || 0), 0)}h`);
+}
+
+// CLI
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const args = process.argv.slice(2);
+  
+  if (args.length < 2) {
+    console.error('Usage: tsx generate-tasks.ts <capability-analysis.json> <output.json>');
+    process.exit(1);
+  }
+  
+  const [analysisPath, outputPath] = args;
+  
+  try {
+    generateTasks(analysisPath, outputPath);
+  } catch (error) {
+    console.error('❌ Error:', error);
+    process.exit(1);
+  }
+}
+
+export { generateTasks };