spec-agent 1.0.3

package/src/commands/plan.ts

@@ -0,0 +1,331 @@
+import * as path from 'path';
+import { Command } from 'commander';
+import { Logger } from '../utils/logger';
+import { 
+  ensureDir, 
+  fileExists, 
+  readJson, 
+  writeJson 
+} from '../utils/file';
+import { SpecSummary, TaskPlan, Task, ParallelGroup, Feature } from '../types';
+
+interface PlanOptions {
+  spec: string;
+  output: string;
+  type: string;
+  framework: string;
+  parallel: string;
+  dryRun?: boolean;
+  yes?: boolean;
+}
+
+export async function planCommand(options: PlanOptions, command: Command): Promise<void> {
+  const logger = new Logger();
+  
+  try {
+    const specPath = path.resolve(options.spec);
+    
+    if (!(await fileExists(specPath))) {
+      logger.error(`Error: Spec summary not found: ${options.spec}`);
+      logger.info('Run spec-agent merge first to create spec_summary.json.');
+      process.exit(1);
+    }
+
+    const spec: SpecSummary = await readJson(specPath);
+    logger.info(`Loaded spec with ${spec.features.length} features, ${spec.pages.length} pages, ${spec.apis.length} APIs`);
+
+    // Preview mode
+    if (options.dryRun) {
+      logger.info('Dry run mode - task plan preview:');
+      logger.info(`  Features to plan: ${spec.features.length}`);
+      logger.info(`  Framework: ${options.framework}`);
+      logger.info(`  Output type: ${options.type}`);
+      return;
+    }
+
+    const startTime = Date.now();
+
+    // Generate tasks from spec
+    const tasks: Task[] = [];
+    const featureTaskIdMap = new Map<string, string>();
+
+    // 1. Setup task (always first)
+    tasks.push({
+      id: 'T001',
+      name: '项目基础架构初始化',
+      type: 'setup',
+      description: `Initialize ${options.framework} project structure`,
+      dependencies: [],
+      priority: 'P0',
+      estimatedHours: 2,
+      status: 'pending',
+    });
+
+    // 2. Tasks from features
+    let taskId = 2;
+    const dedupedFeatures = deduplicateFeaturesForPlanning(spec.features);
+    for (const feature of dedupedFeatures) {
+      const featureTask: Task = {
+        id: `T${String(taskId).padStart(3, '0')}`,
+        name: feature.name,
+        type: mapFeatureToTaskType(feature),
+        description: feature.description,
+        dependencies: ['T001'],
+        priority: feature.priority,
+        estimatedHours: estimateHours(feature),
+        status: 'pending',
+      };
+      tasks.push(featureTask);
+      featureTaskIdMap.set(feature.id, featureTask.id);
+      taskId++;
+    }
+
+    // Patch feature dependencies after all feature tasks are created.
+    for (const task of tasks.filter(item => item.type === 'feature' || item.type === 'api' || item.type === 'page' || item.type === 'component')) {
+      const feature = dedupedFeatures.find(item => item.name === task.name && item.description === task.description);
+      if (!feature) continue;
+      const mappedDependencies = (feature.dependencies || [])
+        .map(depId => featureTaskIdMap.get(depId))
+        .filter((depId): depId is string => Boolean(depId));
+      task.dependencies = mappedDependencies.length > 0
+        ? Array.from(new Set(['T001', ...mappedDependencies]))
+        : ['T001'];
+    }
+
+    // 3. Tasks from pages
+    for (const page of deduplicatePagesForPlanning(spec.pages)) {
+      const pageTask: Task = {
+        id: `T${String(taskId).padStart(3, '0')}`,
+        name: page.name,
+        type: 'page',
+        description: `Page at ${page.route}`,
+        dependencies: ['T001'],
+        priority: 'P1',
+        estimatedHours: 4,
+        status: 'pending',
+      };
+      tasks.push(pageTask);
+      taskId++;
+    }
+
+    // 4. Tasks from APIs
+    for (const api of deduplicateApisForPlanning(spec.apis)) {
+      const apiTask: Task = {
+        id: `T${String(taskId).padStart(3, '0')}`,
+        name: `${api.method} ${api.path}`,
+        type: 'api',
+        description: api.description,
+        dependencies: ['T001'],
+        priority: 'P1',
+        estimatedHours: 2,
+        status: 'pending',
+      };
+      tasks.push(apiTask);
+      taskId++;
+    }
+
+    // 5. Test tasks
+    tasks.push({
+      id: `T${String(taskId).padStart(3, '0')}`,
+      name: '单元测试',
+      type: 'test',
+      description: 'Unit tests for all components',
+      dependencies: tasks.filter(t => t.type !== 'test' && t.type !== 'setup').map(t => t.id),
+      priority: 'P2',
+      estimatedHours: 8,
+      status: 'pending',
+    });
+    taskId++;
+
+    const compactedTasks = deduplicateTasks(tasks);
+    logger.info(`Generated ${tasks.length} tasks, compacted to ${compactedTasks.length} tasks`);
+
+    // Group tasks by dependencies (parallel groups)
+    const parallelGroups = groupTasksByDependencies(compactedTasks, parseInt(options.parallel, 10));
+    
+    logger.info(`Organized into ${parallelGroups.length} parallel groups`);
+
+    // Create task plan
+    const taskPlan: TaskPlan = {
+      version: '1.0.0',
+      createdAt: new Date().toISOString(),
+      totalTasks: compactedTasks.length,
+      parallelGroups,
+      outputDir: './build/',
+      framework: options.framework,
+      type: options.type,
+    };
+
+    // Write output
+    const outputPath = path.resolve(options.output);
+    await ensureDir(path.dirname(outputPath));
+    await writeJson(outputPath, taskPlan);
+
+    const duration = ((Date.now() - startTime) / 1000).toFixed(1);
+
+    logger.success(`Task plan created in ${duration}s`);
+    logger.json({
+      status: 'success',
+      totalTasks: compactedTasks.length,
+      parallelGroups: parallelGroups.length,
+      framework: options.framework,
+      type: options.type,
+      outputPath,
+    });
+
+    // Print group summary
+    for (const group of parallelGroups) {
+      logger.info(`  Group ${group.group}: ${group.tasks.length} tasks (${group.tasks.map(t => t.id).join(', ')})`);
+    }
+
+  } catch (error) {
+    logger.error(`Plan failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+}
+
+function mapFeatureToTaskType(feature: Feature): Task['type'] {
+  const name = feature.name.toLowerCase();
+  if (name.includes('page') || name.includes('页面')) return 'page';
+  if (name.includes('component') || name.includes('组件')) return 'component';
+  if (name.includes('api') || name.includes('接口')) return 'api';
+  return 'feature';
+}
+
+function estimateHours(feature: Feature): number {
+  // Simple estimation based on priority and description length
+  const baseHours = feature.priority === 'P0' ? 4 : feature.priority === 'P1' ? 6 : 8;
+  const complexityFactor = Math.min(feature.description.length / 100, 3);
+  return Math.round(baseHours + complexityFactor);
+}
+
+function normalizeTaskText(input: string): string {
+  return (input || '')
+    .toLowerCase()
+    .replace(/[^\u4e00-\u9fa5a-z0-9\s/]/gi, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function deduplicateFeaturesForPlanning(features: Feature[]): Feature[] {
+  const seen = new Map<string, Feature>();
+  for (const feature of features) {
+    const key = normalizeTaskText(feature.name);
+    const existing = seen.get(key);
+    if (!existing) {
+      seen.set(key, feature);
+      continue;
+    }
+    // Keep higher-priority / richer representative.
+    const rank = { P0: 0, P1: 1, P2: 2, P3: 3 } as const;
+    const existingRank = rank[existing.priority] ?? 3;
+    const currentRank = rank[feature.priority] ?? 3;
+    if (currentRank < existingRank || feature.description.length > existing.description.length) {
+      seen.set(key, feature);
+    }
+  }
+  return Array.from(seen.values());
+}
+
+function deduplicatePagesForPlanning(pages: SpecSummary['pages']): SpecSummary['pages'] {
+  const seen = new Set<string>();
+  return pages.filter(page => {
+    const key = normalizeTaskText(page.route || page.name);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function deduplicateApisForPlanning(apis: SpecSummary['apis']): SpecSummary['apis'] {
+  const seen = new Set<string>();
+  return apis.filter(api => {
+    const key = normalizeTaskText(`${api.method}:${api.path}`);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function deduplicateTasks(tasks: Task[]): Task[] {
+  const seen = new Map<string, Task>();
+  for (const task of tasks) {
+    const key = `${task.type}:${normalizeTaskText(task.name)}`;
+    const existing = seen.get(key);
+    if (!existing) {
+      seen.set(key, { ...task, dependencies: Array.from(new Set(task.dependencies)) });
+      continue;
+    }
+
+    existing.dependencies = Array.from(new Set([...existing.dependencies, ...task.dependencies]));
+    existing.estimatedHours = Math.max(existing.estimatedHours || 0, task.estimatedHours || 0);
+    const priorityRank = { P0: 0, P1: 1, P2: 2, P3: 3 } as const;
+    if ((priorityRank[task.priority] ?? 3) < (priorityRank[existing.priority] ?? 3)) {
+      existing.priority = task.priority;
+    }
+    if ((task.description || '').length > (existing.description || '').length) {
+      existing.description = task.description;
+    }
+  }
+
+  // Re-number IDs to keep compact sequence and remap dependencies.
+  const uniqueTasks = Array.from(seen.values());
+  const idMap = new Map<string, string>();
+  uniqueTasks.forEach((task, idx) => {
+    idMap.set(task.id, `T${String(idx + 1).padStart(3, '0')}`);
+  });
+
+  return uniqueTasks.map((task, idx) => {
+    const newId = `T${String(idx + 1).padStart(3, '0')}`;
+    const remappedDependencies = Array.from(
+      new Set(
+        task.dependencies
+          .map(dep => idMap.get(dep) || dep)
+          .filter(dep => dep !== newId)
+      )
+    );
+    return {
+      ...task,
+      id: newId,
+      dependencies: remappedDependencies,
+    };
+  });
+}
+
+function groupTasksByDependencies(tasks: Task[], maxParallel: number): ParallelGroup[] {
+  const groups: ParallelGroup[] = [];
+  const remaining = new Set(tasks.map(t => t.id));
+  const completed = new Set<string>();
+
+  let groupNum = 1;
+  while (remaining.size > 0) {
+    // Find tasks whose dependencies are all completed
+    const ready = Array.from(remaining).filter(taskId => {
+      const task = tasks.find(t => t.id === taskId)!;
+      return task.dependencies.every(dep => completed.has(dep));
+    });
+
+    if (ready.length === 0) {
+      // Circular dependency or error
+      break;
+    }
+
+    // Take up to maxParallel tasks
+    const batch = ready.slice(0, maxParallel);
+    
+    groups.push({
+      group: groupNum,
+      tasks: batch.map(id => tasks.find(t => t.id === id)!),
+    });
+
+    // Mark as completed
+    for (const taskId of batch) {
+      remaining.delete(taskId);
+      completed.add(taskId);
+    }
+
+    groupNum++;
+  }
+
+  return groups;
+}