spec-agent 1.0.3

package/src/commands/merge.ts

@@ -0,0 +1,377 @@
+import * as path from 'path';
+import { Command } from 'commander';
+import { Logger } from '../utils/logger';
+import { 
+  ensureDir, 
+  fileExists, 
+  readJson, 
+  writeJson,
+  findFiles 
+} from '../utils/file';
+import { ChunkSummary, SpecSummary, Feature, DataModel, Page, Api, DependencyGraph } from '../types';
+
+interface MergeOptions {
+  summaries: string;
+  output: string;
+  strategy: string;
+  dryRun?: boolean;
+  yes?: boolean;
+}
+
+export async function mergeCommand(options: MergeOptions, command: Command): Promise<void> {
+  const logger = new Logger();
+  
+  try {
+    const summariesDir = path.resolve(options.summaries);
+    
+    if (!(await fileExists(summariesDir))) {
+      logger.error(`Error: Summaries directory not found: ${options.summaries}`);
+      logger.info('Run spec-agent analyze first to create summaries.');
+      process.exit(1);
+    }
+
+    // Find all chunk summaries
+    const summaryFiles = await findFiles('chunk_*_summary.json', summariesDir);
+    
+    if (summaryFiles.length === 0) {
+      logger.error(`Error: No chunk summaries found in ${options.summaries}`);
+      process.exit(1);
+    }
+
+    logger.info(`Found ${summaryFiles.length} chunk summaries`);
+
+    // Load all summaries
+    const summaries: ChunkSummary[] = await Promise.all(
+      summaryFiles.map(async (file) => {
+        const summary = await readJson<ChunkSummary>(file);
+        return summary;
+      })
+    );
+
+    // Sort by chunk id
+    summaries.sort((a, b) => a.chunkId - b.chunkId);
+
+    logger.info(`Loading summaries from ${summaries.length} chunks...`);
+
+    // Preview mode
+    if (options.dryRun) {
+      logger.info('Dry run mode - merge plan:');
+      const totalFeatures = summaries.reduce((sum, s) => sum + s.features.length, 0);
+      logger.info(`  Total features to merge: ${totalFeatures}`);
+      logger.info(`  Strategy: ${options.strategy}`);
+      return;
+    }
+
+    // Merge logic
+    const startTime = Date.now();
+    
+    // Collect all items
+    const allFeatures: Feature[] = [];
+    const allDataModels: DataModel[] = [];
+    const allPages: Page[] = [];
+    const allApis: Api[] = [];
+    const allBusinessRules: string[] = [];
+
+    for (const summary of summaries) {
+      allFeatures.push(...summary.features);
+      allDataModels.push(...summary.dataModels);
+      allPages.push(...summary.pages);
+      allApis.push(...summary.apis);
+      allBusinessRules.push(...summary.businessRules);
+    }
+
+    logger.info(`Collected ${allFeatures.length} features, ${allDataModels.length} models, ${allPages.length} pages, ${allApis.length} APIs`);
+
+    // Deduplication
+    const { features: dedupedFeatures, duplicates } = deduplicateFeatures(
+      allFeatures, 
+      options.strategy as 'conservative' | 'aggressive'
+    );
+
+    logger.info(`Deduplication: ${allFeatures.length} → ${dedupedFeatures.length} features (${duplicates.length} removed)`);
+
+    // Build dependency graph
+    const dependencyGraph = buildDependencyGraph(dedupedFeatures);
+
+    // Detect conflicts
+    const conflicts = detectConflicts(dedupedFeatures, allDataModels);
+
+    if (conflicts.length > 0) {
+      logger.warn(`Detected ${conflicts.length} potential conflicts`);
+      for (const conflict of conflicts.slice(0, 5)) {
+        logger.warn(`  - ${conflict}`);
+      }
+    }
+
+    // Create spec summary
+    const specSummary: SpecSummary = {
+      version: '1.0.0',
+      createdAt: new Date().toISOString(),
+      sourceChunks: summaries.length,
+      deduplicatedFeatures: dedupedFeatures.length,
+      features: dedupedFeatures,
+      dataModels: deduplicateDataModels(allDataModels),
+      pages: deduplicatePages(allPages),
+      apis: deduplicateApis(allApis),
+      businessRules: [...new Set(allBusinessRules)],
+      dependencyGraph,
+      conflicts: conflicts.length > 0 ? conflicts : undefined,
+    };
+
+    // Write output
+    const outputPath = path.resolve(options.output);
+    await ensureDir(path.dirname(outputPath));
+    await writeJson(outputPath, specSummary);
+
+    const duration = ((Date.now() - startTime) / 1000).toFixed(1);
+
+    logger.success(`Merge complete in ${duration}s`);
+    logger.json({
+      status: 'success',
+      sourceChunks: summaries.length,
+      totalFeatures: dedupedFeatures.length,
+      duplicatesRemoved: duplicates.length,
+      dataModels: specSummary.dataModels.length,
+      pages: specSummary.pages.length,
+      apis: specSummary.apis.length,
+      conflicts: conflicts.length,
+      outputPath,
+    });
+
+  } catch (error) {
+    logger.error(`Merge failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+}
+
+function deduplicateFeatures(
+  features: Feature[], 
+  strategy: 'conservative' | 'aggressive'
+): { features: Feature[]; duplicates: string[] } {
+  interface FeatureGroup {
+    key: string;
+    items: Feature[];
+  }
+
+  const groups: FeatureGroup[] = [];
+  const duplicates: string[] = [];
+
+  for (const feature of features) {
+    const key = strategy === 'aggressive'
+      ? generateAggressiveKey(feature)
+      : generateConservativeKey(feature);
+    const normalizedName = normalizeText(feature.name);
+
+    let targetGroup = groups.find(group => {
+      if (group.key === key) return true;
+      if (strategy !== 'aggressive') return false;
+      const rep = group.items[0];
+      const repName = normalizeText(rep.name);
+      const nameSimilarity = jaccardSimilarity(tokenize(repName), tokenize(normalizedName));
+      return nameSimilarity >= 0.72;
+    });
+
+    if (!targetGroup) {
+      targetGroup = { key, items: [] };
+      groups.push(targetGroup);
+    } else {
+      duplicates.push(feature.id);
+    }
+
+    targetGroup.items.push(feature);
+  }
+
+  const oldIdAlias = new Map<string, string>();
+  const dedupedFeatures: Feature[] = groups.map((group, idx) => {
+    const representative = chooseRepresentativeFeature(group.items);
+    const newId = `F${String(idx + 1).padStart(3, '0')}`;
+
+    // Build alias from old IDs to new canonical ID for dependency remapping.
+    const uniqueOldIds = Array.from(new Set(group.items.map(item => item.id)));
+    for (const oldId of uniqueOldIds) {
+      oldIdAlias.set(oldId, newId);
+    }
+
+    return {
+      ...representative,
+      id: newId,
+      dependencies: [] as string[],
+    };
+  });
+
+  // Rebuild dependencies from grouped items and remap to canonical IDs.
+  groups.forEach((group, idx) => {
+    const currentId = dedupedFeatures[idx].id;
+    const mappedDeps = new Set<string>();
+    for (const item of group.items) {
+      for (const dep of item.dependencies || []) {
+        const mapped = oldIdAlias.get(dep);
+        if (mapped && mapped !== currentId) {
+          mappedDeps.add(mapped);
+        }
+      }
+    }
+    dedupedFeatures[idx].dependencies = Array.from(mappedDeps);
+  });
+
+  return { features: dedupedFeatures, duplicates };
+}
+
+function generateConservativeKey(feature: Feature): string {
+  // Only exact name match is considered duplicate
+  return normalizeText(feature.name);
+}
+
+function generateAggressiveKey(feature: Feature): string {
+  // Similar names might be duplicates
+  return normalizeText(feature.name)
+    .replace(/\b(功能|流程|管理|申请|支持|模块|客户)\b/g, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function normalizeText(input: string): string {
+  return (input || '')
+    .toLowerCase()
+    .replace(/[^\u4e00-\u9fa5a-z0-9\s]/gi, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function tokenize(input: string): string[] {
+  return normalizeText(input)
+    .split(' ')
+    .filter(token => token.length > 0);
+}
+
+function jaccardSimilarity(aTokens: string[], bTokens: string[]): number {
+  const a = new Set(aTokens);
+  const b = new Set(bTokens);
+  if (a.size === 0 || b.size === 0) return 0;
+  let intersection = 0;
+  for (const token of a) {
+    if (b.has(token)) intersection++;
+  }
+  const union = new Set([...a, ...b]).size;
+  return union === 0 ? 0 : intersection / union;
+}
+
+function chooseRepresentativeFeature(features: Feature[]): Feature {
+  const sorted = features.slice().sort((a, b) => {
+    // Prefer higher priority first.
+    const priorityRank: Record<Feature['priority'], number> = {
+      P0: 0,
+      P1: 1,
+      P2: 2,
+      P3: 3,
+    };
+    const pa = priorityRank[a.priority] ?? 3;
+    const pb = priorityRank[b.priority] ?? 3;
+    if (pa !== pb) return pa - pb;
+    // Prefer richer description.
+    if (a.description.length !== b.description.length) {
+      return b.description.length - a.description.length;
+    }
+    return a.sourceChunk - b.sourceChunk;
+  });
+
+  const representative = sorted[0];
+  const mergedDescription = mergeFeatureDescriptions(features);
+  return {
+    ...representative,
+    description: mergedDescription,
+  };
+}
+
+function mergeFeatureDescriptions(features: Feature[]): string {
+  const descriptions = Array.from(
+    new Set(
+      features
+        .map(item => item.description?.trim())
+        .filter((item): item is string => Boolean(item))
+    )
+  );
+
+  if (descriptions.length === 0) {
+    return '';
+  }
+
+  descriptions.sort((a, b) => b.length - a.length);
+  return descriptions[0];
+}
+
+function buildDependencyGraph(features: Feature[]): DependencyGraph {
+  const graph: DependencyGraph = {};
+  
+  for (const feature of features) {
+    graph[feature.id] = feature.dependencies || [];
+  }
+
+  return graph;
+}
+
+function detectConflicts(features: Feature[], dataModels: unknown[]): string[] {
+  const conflicts: string[] = [];
+  
+  // Check for circular dependencies
+  const visited = new Set<string>();
+  const recursionStack = new Set<string>();
+
+  function hasCircularDependency(featureId: string, graph: DependencyGraph): boolean {
+    visited.add(featureId);
+    recursionStack.add(featureId);
+
+    const dependencies = graph[featureId] || [];
+    for (const depId of dependencies) {
+      if (!visited.has(depId)) {
+        if (hasCircularDependency(depId, graph)) {
+          return true;
+        }
+      } else if (recursionStack.has(depId)) {
+        return true;
+      }
+    }
+
+    recursionStack.delete(featureId);
+    return false;
+  }
+
+  const graph = buildDependencyGraph(features);
+  for (const feature of features) {
+    if (hasCircularDependency(feature.id, graph)) {
+      conflicts.push(`Circular dependency detected for feature ${feature.id}`);
+    }
+  }
+
+  return conflicts;
+}
+
+function deduplicateDataModels(models: DataModel[]): DataModel[] {
+  const seen = new Set<string>();
+  return models.filter((model) => {
+    const key = `${model.name}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function deduplicatePages(pages: Page[]): Page[] {
+  const seen = new Set<string>();
+  return pages.filter((page) => {
+    const key = `${page.route}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function deduplicateApis(apis: Api[]): Api[] {
+  const seen = new Set<string>();
+  return apis.filter((api) => {
+    const key = `${api.method}:${api.path}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}

package/src/commands/pipeline.ts

@@ -0,0 +1,306 @@
+import * as path from 'path';
+import { Command } from 'commander';
+import { Logger } from '../utils/logger';
+import { 
+  ensureDir, 
+  fileExists, 
+  readJson,
+  writeJson 
+} from '../utils/file';
+import { scanCommand } from './scan';
+import { analyzeCommand } from './analyze';
+import { mergeCommand } from './merge';
+import { planCommand } from './plan';
+import { dispatchCommand } from './dispatch';
+
+interface PipelineOptions {
+  input?: string;
+  output: string;
+  agents: string;
+  chunkSize: string;
+  minChunkSize: string;
+  analyzeRetries: string;
+  analyzeBudgetTokens: string;
+  framework: string;
+  strictLlm?: boolean;
+  stopAt?: string;
+  from?: string;
+  dryRun?: boolean;
+  yes?: boolean;
+}
+
+const PHASES = ['scan', 'analyze', 'merge', 'plan', 'dispatch'] as const;
+type Phase = typeof PHASES[number];
+
+export async function pipelineCommand(options: PipelineOptions, command: Command): Promise<void> {
+  const logger = new Logger();
+  const startedAt = new Date().toISOString();
+  
+  try {
+    if (!options.input && !options.from) {
+      logger.error('Error: --input is required (unless using --from to resume)');
+      process.exit(1);
+    }
+
+    const workspacePath = path.resolve(options.output);
+    await ensureDir(workspacePath);
+
+    // Determine start and end phases
+    const startPhase: Phase = (options.from as Phase) || 'scan';
+    const endPhase: Phase = (options.stopAt as Phase) || 'dispatch';
+
+    const startIndex = PHASES.indexOf(startPhase);
+    const endIndex = PHASES.indexOf(endPhase);
+
+    if (startIndex === -1 || endIndex === -1) {
+      logger.error(`Error: Invalid phase. Valid phases: ${PHASES.join(', ')}`);
+      process.exit(1);
+    }
+
+    if (startIndex > endIndex) {
+      logger.error('Error: Start phase cannot be after end phase');
+      process.exit(1);
+    }
+
+    logger.info(`Pipeline: ${startPhase} → ${endPhase}`);
+    logger.info(`Workspace: ${workspacePath}`);
+
+    // Preview mode
+    if (options.dryRun) {
+      logger.info('Dry run mode - pipeline preview:');
+      for (let i = startIndex; i <= endIndex; i++) {
+        const phase = PHASES[i];
+        const phaseDone = await checkPhaseDone(workspacePath, phase);
+        logger.info(`  ${phaseDone ? '✔' : '○'} ${phase}`);
+      }
+      return;
+    }
+
+    const startTime = Date.now();
+    const results: Array<{ phase: string; status: string; duration: string }> = [];
+    let failedPhase: string | null = null;
+    let failedReason = '';
+
+    // Execute phases
+    for (let i = startIndex; i <= endIndex; i++) {
+      const phase = PHASES[i];
+      const phaseStart = Date.now();
+
+      logger.info(`\n[${i - startIndex + 1}/${endIndex - startIndex + 1}] Running ${phase}...`);
+
+      // Check if phase already done
+      if (await checkPhaseDone(workspacePath, phase)) {
+        logger.info(`  Phase ${phase} already completed, skipping`);
+        results.push({ phase, status: 'skipped', duration: '0s' });
+        continue;
+      }
+
+      try {
+        await executePhase(phase, options, workspacePath, logger);
+        
+        // Mark phase as done
+        await markPhaseDone(workspacePath, phase);
+        
+        const phaseDuration = ((Date.now() - phaseStart) / 1000).toFixed(1);
+        results.push({ phase, status: 'success', duration: `${phaseDuration}s` });
+        logger.success(`  ${phase} complete (${phaseDuration}s)`);
+
+      } catch (error) {
+        const phaseDuration = ((Date.now() - phaseStart) / 1000).toFixed(1);
+        results.push({ phase, status: 'failed', duration: `${phaseDuration}s` });
+        failedPhase = phase;
+        failedReason = error instanceof Error ? error.message : String(error);
+        logger.error(`  ${phase} failed: ${failedReason}`);
+        
+        logger.info('\nPipeline stopped. To resume:');
+        logger.info(`  spec-agent pipeline --from ${phase} --output ${options.output}`);
+        
+        break;
+      }
+    }
+
+    const totalDuration = ((Date.now() - startTime) / 1000).toFixed(1);
+
+    logger.info('\n' + '='.repeat(50));
+    logger.success('Pipeline complete');
+    logger.info('='.repeat(50));
+    
+    for (const result of results) {
+      const icon = result.status === 'success' ? '✔' : result.status === 'failed' ? '✖' : '○';
+      logger.info(`  ${icon} ${result.phase.padEnd(10)} ${result.status.padEnd(10)} ${result.duration}`);
+    }
+    
+    logger.info(`  Total: ${totalDuration}s`);
+    logger.info(`  Output: ${workspacePath}`);
+
+    const summaryPath = path.join(workspacePath, 'pipeline_summary.json');
+    await writeJson(summaryPath, {
+      startedAt,
+      endedAt: new Date().toISOString(),
+      status: failedPhase ? 'failed' : 'success',
+      startPhase,
+      endPhase,
+      totalDurationSeconds: Number(totalDuration),
+      failedPhase,
+      failedReason: failedPhase ? failedReason : undefined,
+      phases: results,
+    });
+    logger.info(`  Summary: ${summaryPath}`);
+
+    const runReportPath = path.join(workspacePath, 'run_report.json');
+    const runReport = await buildRunReport(workspacePath, {
+      startedAt,
+      totalDurationSeconds: Number(totalDuration),
+      status: failedPhase ? 'failed' : 'success',
+    });
+    await writeJson(runReportPath, runReport);
+    logger.info(`  Run report: ${runReportPath}`);
+
+    if (failedPhase) {
+      process.exit(2);
+    }
+
+  } catch (error) {
+    logger.error(`Pipeline failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+}
+
+async function executePhase(
+  phase: Phase, 
+  options: PipelineOptions, 
+  workspacePath: string,
+  logger: Logger
+): Promise<void> {
+  const manifestPath = path.join(workspacePath, 'manifest.json');
+  const summariesDir = path.join(workspacePath, 'summaries');
+  const specPath = path.join(workspacePath, 'spec_summary.json');
+  const planPath = path.join(workspacePath, 'task_plan.json');
+  const dispatchPath = path.join(workspacePath, 'dispatch_plan.json');
+
+  switch (phase) {
+    case 'scan':
+      if (!options.input) {
+        throw new Error('Input required for scan phase');
+      }
+      await scanCommand({
+        input: options.input,
+        output: manifestPath,
+        chunkSize: options.chunkSize,
+        minChunkSize: options.minChunkSize,
+        format: 'auto',
+        strictLlm: options.strictLlm,
+        dryRun: false,
+        yes: options.yes,
+      }, {} as Command);
+      break;
+
+    case 'analyze':
+      await analyzeCommand({
+        manifest: manifestPath,
+        output: summariesDir,
+        agents: options.agents,
+        focus: 'full',
+        retries: options.analyzeRetries || '1',
+        budgetTokens: options.analyzeBudgetTokens || '0',
+        dryRun: false,
+        yes: options.yes,
+      }, {} as Command);
+      break;
+
+    case 'merge':
+      await mergeCommand({
+        summaries: summariesDir,
+        output: specPath,
+        strategy: 'conservative',
+        dryRun: false,
+        yes: options.yes,
+      }, {} as Command);
+      break;
+
+    case 'plan':
+      await planCommand({
+        spec: specPath,
+        output: planPath,
+        type: 'prototype',
+        framework: options.framework,
+        parallel: '3',
+        dryRun: false,
+        yes: options.yes,
+      }, {} as Command);
+      break;
+
+    case 'dispatch':
+      await dispatchCommand({
+        plan: planPath,
+        output: dispatchPath,
+        strategy: 'balanced',
+        dryRun: false,
+        yes: options.yes,
+      }, {} as Command);
+      break;
+  }
+}
+
+async function checkPhaseDone(workspacePath: string, phase: string): Promise<boolean> {
+  const doneFile = path.join(workspacePath, `.${phase}_done`);
+  return await fileExists(doneFile);
+}
+
+async function markPhaseDone(workspacePath: string, phase: string): Promise<void> {
+  const doneFile = path.join(workspacePath, `.${phase}_done`);
+  await writeJson(doneFile, { completedAt: new Date().toISOString() });
+}
+
+async function buildRunReport(
+  workspacePath: string,
+  context: { startedAt: string; totalDurationSeconds: number; status: 'success' | 'failed' }
+): Promise<{
+  startedAt: string;
+  endedAt: string;
+  status: 'success' | 'failed';
+  totalDurationSeconds: number;
+  metrics: Record<string, number>;
+}> {
+  const metrics: Record<string, number> = {};
+  const manifestPath = path.join(workspacePath, 'manifest.json');
+  const specPath = path.join(workspacePath, 'spec_summary.json');
+  const taskPlanPath = path.join(workspacePath, 'task_plan.json');
+  const summariesDir = path.join(workspacePath, 'summaries');
+
+  if (await fileExists(manifestPath)) {
+    const manifest = await readJson<{ chunks?: unknown[] }>(manifestPath);
+    metrics.chunks = manifest.chunks?.length || 0;
+  }
+
+  if (await fileExists(specPath)) {
+    const spec = await readJson<{ features?: unknown[]; apis?: unknown[]; pages?: unknown[] }>(specPath);
+    metrics.features = spec.features?.length || 0;
+    metrics.apis = spec.apis?.length || 0;
+    metrics.pages = spec.pages?.length || 0;
+  }
+
+  if (await fileExists(taskPlanPath)) {
+    const plan = await readJson<{ totalTasks?: number }>(taskPlanPath);
+    metrics.totalTasks = plan.totalTasks || 0;
+  }
+
+  if (await fileExists(summariesDir)) {
+    const files = await import('../utils/file').then(m => m.findFiles('chunk_*_summary.json', summariesDir));
+    metrics.chunkSummaries = files.length;
+    let totalTokens = 0;
+    for (const file of files) {
+      const summary = await readJson<{ llmUsage?: { totalTokens?: number } }>(file);
+      totalTokens += summary.llmUsage?.totalTokens || 0;
+    }
+    metrics.totalTokens = totalTokens;
+  }
+
+  return {
+    startedAt: context.startedAt,
+    endedAt: new Date().toISOString(),
+    status: context.status,
+    totalDurationSeconds: context.totalDurationSeconds,
+    metrics,
+  };
+}