@paths.design/caws-cli 10.2.0 → 11.0.0

package/dist/commands/parallel.js

@@ -1,242 +0,0 @@
-/**
- * @fileoverview CAWS Parallel CLI Command
- * Orchestrates parallel multi-agent workspaces
- * @author @darianrosebrook
- */
-
-const chalk = require('chalk');
-const path = require('path');
-const {
-  loadPlan,
-  setupParallel,
-  getParallelStatus,
-  mergeParallel,
-  teardownParallel,
-} = require('../parallel/parallel-manager');
-
-/**
- * Handle parallel subcommands
- * @param {string} subcommand - Subcommand name
- * @param {Object} options - Command options
- */
-async function parallelCommand(subcommand, options = {}) {
-  try {
-    switch (subcommand) {
-      case 'setup':
-        return handleSetup(options);
-      case 'status':
-        return handleStatus();
-      case 'merge':
-        return handleMerge(options);
-      case 'teardown':
-        return handleTeardown(options);
-      default:
-        console.error(chalk.red(`Unknown parallel subcommand: ${subcommand}`));
-        console.log(chalk.blue('Available: setup, status, merge, teardown'));
-        process.exit(1);
-    }
-  } catch (error) {
-    console.error(chalk.red(`${error.message}`));
-    process.exit(1);
-  }
-}
-
-function handleSetup(options) {
-  const { planFile, baseBranch } = options;
-
-  if (!planFile) {
-    console.error(chalk.red('Plan file is required'));
-    console.log(chalk.blue('Usage: caws parallel setup <plan-file> [--base-branch <branch>]'));
-    process.exit(1);
-  }
-
-  const planPath = path.resolve(planFile);
-  console.log(chalk.cyan(`Loading plan: ${planFile}`));
-
-  const plan = loadPlan(planPath);
-
-  // Allow CLI --base-branch to override plan file
-  if (baseBranch) {
-    plan.baseBranch = baseBranch;
-  }
-
-  console.log(chalk.cyan(`Setting up ${plan.agents.length} parallel worktree(s)...`));
-  const results = setupParallel(plan);
-
-  console.log(chalk.green(`\nParallel workspace created`));
-  console.log(chalk.gray(`   Base branch: ${results[0] ? results[0].baseBranch : plan.baseBranch || 'main'}`));
-  console.log(chalk.gray(`   Strategy:    ${plan.mergeStrategy}`));
-  console.log('');
-
-  // Print table
-  console.log(
-    chalk.bold(
-      'Agent'.padEnd(20) +
-        'Branch'.padEnd(25) +
-        'Scope'
-    )
-  );
-  console.log(chalk.gray('-'.repeat(70)));
-
-  for (const entry of results) {
-    console.log(
-      entry.name.padEnd(20) +
-        chalk.cyan(entry.branch.padEnd(25)) +
-        chalk.gray(entry.scope || '(all)')
-    );
-  }
-
-  console.log('');
-  console.log(chalk.blue('Direct each agent to its worktree:'));
-  for (const entry of results) {
-    console.log(chalk.gray(`   ${entry.name}: cd ${entry.path}`));
-  }
-  console.log('');
-  console.log(chalk.blue('Monitor progress: caws parallel status'));
-}
-
-function handleStatus() {
-  const status = getParallelStatus();
-
-  if (!status) {
-    console.log(chalk.gray('No active parallel run.'));
-    console.log(chalk.blue('Start one with: caws parallel setup <plan-file>'));
-    return;
-  }
-
-  console.log(chalk.bold.cyan('CAWS Parallel Status'));
-  console.log(chalk.cyan('='.repeat(70)));
-  console.log(chalk.gray(`   Base branch: ${status.baseBranch}`));
-  console.log(chalk.gray(`   Strategy:    ${status.mergeStrategy}`));
-  console.log(chalk.gray(`   Created:     ${status.createdAt}`));
-  console.log('');
-
-  // Agent table
-  console.log(
-    chalk.bold(
-      'Agent'.padEnd(18) +
-        'Status'.padEnd(10) +
-        'Branch'.padEnd(22) +
-        'Commits'.padEnd(9) +
-        'Dirty'.padEnd(7) +
-        'Scope'
-    )
-  );
-  console.log(chalk.gray('-'.repeat(80)));
-
-  for (const agent of status.agents) {
-    const statusColor =
-      agent.status === 'active'
-        ? chalk.green
-        : agent.status === 'fresh'
-        ? chalk.cyan
-        : agent.status === 'merged'
-        ? chalk.blue
-        : agent.status === 'missing'
-        ? chalk.red
-        : chalk.yellow;
-
-    console.log(
-      agent.name.padEnd(18) +
-        statusColor(agent.status.padEnd(10)) +
-        agent.branch.padEnd(22) +
-        String(agent.commitCount).padEnd(9) +
-        (agent.dirty ? chalk.yellow('yes') : chalk.gray('no')).padEnd(7 + 10) + // +10 for chalk color codes
-        chalk.gray(agent.scope || '(all)')
-    );
-  }
-
-  // Show conflicts
-  if (status.conflicts.length > 0) {
-    console.log('');
-    console.log(chalk.yellow(`WARNING: ${status.conflicts.length} file-level conflict(s) detected:`));
-    for (const conflict of status.conflicts) {
-      console.log(chalk.yellow(`   ${conflict.file} -- modified by: ${conflict.agents.join(', ')}`));
-    }
-    console.log(chalk.blue('   These files were modified by multiple agents and may cause merge conflicts.'));
-  }
-
-  console.log('');
-}
-
-function handleMerge(options) {
-  const { strategy, dryRun, force } = options;
-
-  if (dryRun) {
-    console.log(chalk.cyan('Dry run: previewing merge...'));
-  } else {
-    console.log(chalk.cyan('Merging parallel branches back to base...'));
-  }
-
-  const result = mergeParallel({ strategy, dryRun, force });
-
-  // Show conflicts
-  if (result.conflicts.length > 0) {
-    console.log(chalk.yellow(`\n${result.conflicts.length} file-level conflict(s) detected:`));
-    for (const conflict of result.conflicts) {
-      console.log(chalk.yellow(`   ${conflict.file} -- ${conflict.agents.join(', ')}`));
-    }
-
-    if (!force && !dryRun) {
-      console.log('');
-      console.log(chalk.red('Merge aborted due to conflicts.'));
-      console.log(chalk.blue('   Review conflicts, then: caws parallel merge --force'));
-      return;
-    }
-  }
-
-  if (dryRun) {
-    console.log(chalk.green(`\nWould merge ${result.merged.length} branch(es):`));
-    for (const name of result.merged) {
-      console.log(chalk.gray(`   - ${name}`));
-    }
-    return;
-  }
-
-  if (result.merged.length > 0) {
-    console.log(chalk.green(`\nMerged ${result.merged.length} branch(es):`));
-    for (const name of result.merged) {
-      console.log(chalk.gray(`   - ${name}`));
-    }
-  }
-
-  if (result.failed.length > 0) {
-    console.log(chalk.red(`\nFailed to merge ${result.failed.length} branch(es):`));
-    for (const fail of result.failed) {
-      console.log(chalk.red(`   - ${fail.name}: ${fail.error}`));
-    }
-  }
-
-  if (result.merged.length > 0 && result.failed.length === 0) {
-    console.log('');
-    console.log(chalk.blue('Clean up with: caws parallel teardown --delete-branches'));
-  }
-}
-
-function handleTeardown(options) {
-  const { deleteBranches, force } = options;
-
-  console.log(chalk.cyan('Tearing down parallel worktrees...'));
-  const result = teardownParallel({ deleteBranches, force });
-
-  if (result.destroyed.length > 0) {
-    console.log(chalk.green(`Destroyed ${result.destroyed.length} worktree(s):`));
-    for (const name of result.destroyed) {
-      console.log(chalk.gray(`   - ${name}`));
-    }
-  }
-
-  if (result.failed.length > 0) {
-    console.log(chalk.red(`Failed to destroy ${result.failed.length} worktree(s):`));
-    for (const fail of result.failed) {
-      console.log(chalk.red(`   - ${fail.name}: ${fail.error}`));
-    }
-    console.log(chalk.blue('   Use --force to override'));
-  }
-
-  if (deleteBranches) {
-    console.log(chalk.gray('   Branches also deleted'));
-  }
-}
-
-module.exports = { parallelCommand };

package/dist/commands/plan.js

@@ -1,438 +0,0 @@
-/**
- * @fileoverview CAWS Plan Command
- * Automated plan generation from specifications (multi-spec aware)
- * @author @darianrosebrook
- */
-
-const fs = require('fs-extra');
-const path = require('path');
-const chalk = require('chalk');
-const { safeAsync, outputResult } = require('../error-handler');
-
-// Import spec resolution system
-const { resolveSpec, loadSpecsRegistry } = require('../utils/spec-resolver');
-
-/**
- * Plan templates for different spec types
- */
-const PLAN_TEMPLATES = {
-  feature: {
-    sections: [
-      'Overview',
-      'Acceptance Criteria Analysis',
-      'Implementation Strategy',
-      'Testing Strategy',
-      'Risk Assessment',
-      'Dependencies',
-      'Timeline',
-      'Success Metrics',
-    ],
-    defaultTasks: [
-      'Set up development environment',
-      'Implement core functionality',
-      'Add error handling',
-      'Write comprehensive tests',
-      'Update documentation',
-      'Performance optimization',
-      'Security review',
-      'Final validation',
-    ],
-  },
-  fix: {
-    sections: [
-      'Problem Analysis',
-      'Root Cause Investigation',
-      'Solution Design',
-      'Implementation Plan',
-      'Testing Strategy',
-      'Rollback Plan',
-      'Verification',
-    ],
-    defaultTasks: [
-      'Reproduce the issue',
-      'Identify root cause',
-      'Design fix approach',
-      'Implement solution',
-      'Write regression tests',
-      'Update documentation',
-      'Deploy and verify',
-    ],
-  },
-  refactor: {
-    sections: [
-      'Current State Analysis',
-      'Refactoring Goals',
-      'Approach Strategy',
-      'Implementation Plan',
-      'Testing Strategy',
-      'Performance Impact',
-      'Migration Plan',
-    ],
-    defaultTasks: [
-      'Analyze current code',
-      'Design new architecture',
-      'Plan incremental changes',
-      'Implement refactoring',
-      'Update tests',
-      'Performance validation',
-      'Documentation update',
-    ],
-  },
-};
-
-/**
- * Load spec for plan generation
- * @param {string} specId - Spec identifier
- * @returns {Promise<Object|null>} Spec data or null
- */
-async function loadSpecForPlanning(specId) {
-  const resolved = await resolveSpec({
-    specId,
-    warnLegacy: false,
-  });
-  return resolved.spec;
-}
-
-/**
- * Generate and display implementation plan
- * @param {Object} spec - Spec data
- * @param {string} specId - Spec identifier
- * @param {Object} options - Command options
- */
-async function generateAndDisplayPlan(spec, specId, options) {
-  // Generate plan
-  const plan = generateImplementationPlan(spec);
-
-  // Determine output path
-  const outputPath = options.output || `.caws/plans/${specId}-plan.md`;
-
-  // Write plan to file
-  await writePlanToFile(plan, outputPath);
-
-  // Display plan summary
-  displayGeneratedPlan(plan);
-
-  console.log(chalk.green(`Plan generated: ${outputPath}`));
-
-  return outputResult({
-    command: 'plan generate',
-    specId,
-    outputPath,
-    planSections: plan.sections.length,
-    tasks: plan.tasks.length,
-  });
-}
-
-/**
- * Generate implementation tasks from acceptance criteria
- * @param {Array} criteria - Acceptance criteria
- * @returns {Array} Generated tasks
- */
-function generateTasksFromCriteria(criteria) {
-  const tasks = [];
-
-  criteria.forEach((criterion, index) => {
-    const criterionId = criterion.id || `A${index + 1}`;
-    const description = criterion.description || criterion.title || `Implement ${criterionId}`;
-
-    // Break down complex criteria into multiple tasks
-    if (description.includes('and') || description.includes('then') || description.length > 100) {
-      // Split into multiple tasks
-      const parts = description.split(/[.;]/).filter((part) => part.trim().length > 0);
-      parts.forEach((part, partIndex) => {
-        tasks.push({
-          id: `${criterionId}.${partIndex + 1}`,
-          title: part.trim(),
-          criterion: criterionId,
-          type: 'implementation',
-          estimatedHours: 2,
-          dependencies: partIndex > 0 ? [`${criterionId}.${partIndex}`] : [],
-        });
-      });
-    } else {
-      // Single task for simple criteria
-      tasks.push({
-        id: criterionId,
-        title: description,
-        criterion: criterionId,
-        type: 'implementation',
-        estimatedHours: 3,
-        dependencies: [],
-      });
-    }
-  });
-
-  return tasks;
-}
-
-/**
- * Generate testing tasks for acceptance criteria
- * @param {Array} criteria - Acceptance criteria
- * @returns {Array} Generated test tasks
- */
-function generateTestTasks(criteria) {
-  const tasks = [];
-
-  criteria.forEach((criterion, index) => {
-    const criterionId = criterion.id || `A${index + 1}`;
-
-    tasks.push({
-      id: `test-${criterionId}`,
-      title: `Write tests for ${criterionId}`,
-      criterion: criterionId,
-      type: 'testing',
-      estimatedHours: 2,
-      dependencies: [criterionId],
-    });
-
-    tasks.push({
-      id: `integration-${criterionId}`,
-      title: `Integration tests for ${criterionId}`,
-      criterion: criterionId,
-      type: 'testing',
-      estimatedHours: 1,
-      dependencies: [`test-${criterionId}`],
-    });
-  });
-
-  return tasks;
-}
-
-/**
- * Generate implementation plan from spec
- * @param {Object} spec - Spec data
- * @returns {Object} Generated plan
- */
-function generateImplementationPlan(spec) {
-  const template = PLAN_TEMPLATES[spec.type] || PLAN_TEMPLATES.feature;
-
-  // Generate tasks from acceptance criteria
-  const implementationTasks = generateTasksFromCriteria(spec.acceptance_criteria || []);
-  const testTasks = generateTestTasks(spec.acceptance_criteria || []);
-
-  // Combine all tasks
-  const allTasks = [
-    ...template.defaultTasks.map((task, index) => ({
-      id: `setup-${index + 1}`,
-      title: task,
-      type: 'setup',
-      estimatedHours: 1,
-      dependencies: [],
-    })),
-    ...implementationTasks,
-    ...testTasks,
-  ];
-
-  // Calculate timeline
-  const totalHours = allTasks.reduce((sum, task) => sum + task.estimatedHours, 0);
-  const estimatedDays = Math.ceil(totalHours / 8); // Assuming 8-hour work days
-
-  // Generate plan content
-  const planContent = {
-    spec_id: spec.id,
-    title: `Implementation Plan: ${spec.title}`,
-    generated_at: new Date().toISOString(),
-    sections: template.sections,
-    tasks: allTasks,
-    timeline: {
-      total_hours: totalHours,
-      estimated_days: estimatedDays,
-      parallel_execution: true,
-    },
-    risks: [
-      {
-        level: 'low',
-        description: 'Standard implementation risks',
-        mitigation: 'Follow established patterns and conduct thorough testing',
-      },
-    ],
-  };
-
-  return planContent;
-}
-
-/**
- * Write plan to file
- * @param {Object} plan - Plan data
- * @param {string} outputPath - Output file path
- * @returns {Promise<void>}
- */
-async function writePlanToFile(plan, outputPath) {
-  const planDir = path.dirname(outputPath);
-  await fs.ensureDir(planDir);
-
-  const markdownContent = generatePlanMarkdown(plan);
-  await fs.writeFile(outputPath, markdownContent);
-}
-
-/**
- * Generate markdown content from plan
- * @param {Object} plan - Plan data
- * @returns {string} Markdown content
- */
-function generatePlanMarkdown(plan) {
-  let content = `# ${plan.title}\n\n`;
-  content += `**Generated:** ${new Date(plan.generated_at).toLocaleString()}\n`;
-  content += `**Spec ID:** ${plan.spec_id}\n\n`;
-
-  // Overview section
-  content += `## Overview\n\n`;
-  content += `This plan outlines the implementation strategy for the specified requirements.\n`;
-  content += `**Timeline:** ${plan.timeline.estimated_days} days (${plan.timeline.total_hours} hours)\n\n`;
-
-  // Tasks section
-  content += `## Implementation Tasks\n\n`;
-
-  // Group tasks by type
-  const setupTasks = plan.tasks.filter((task) => task.type === 'setup');
-  const implementationTasks = plan.tasks.filter((task) => task.type === 'implementation');
-  const testTasks = plan.tasks.filter((task) => task.type === 'testing');
-
-  if (setupTasks.length > 0) {
-    content += `### Setup (${setupTasks.length} tasks)\n\n`;
-    setupTasks.forEach((task) => {
-      content += `- [ ] **${task.id}** - ${task.title} (${task.estimatedHours}h)\n`;
-    });
-    content += '\n';
-  }
-
-  if (implementationTasks.length > 0) {
-    content += `### Implementation (${implementationTasks.length} tasks)\n\n`;
-    implementationTasks.forEach((task) => {
-      const deps =
-        task.dependencies.length > 0 ? ` (depends on: ${task.dependencies.join(', ')})` : '';
-      content += `- [ ] **${task.id}** - ${task.title} (${task.estimatedHours}h)${deps}\n`;
-    });
-    content += '\n';
-  }
-
-  if (testTasks.length > 0) {
-    content += `### Testing (${testTasks.length} tasks)\n\n`;
-    testTasks.forEach((task) => {
-      const deps =
-        task.dependencies.length > 0 ? ` (depends on: ${task.dependencies.join(', ')})` : '';
-      content += `- [ ] **${task.id}** - ${task.title} (${task.estimatedHours}h)${deps}\n`;
-    });
-    content += '\n';
-  }
-
-  // Risk assessment
-  content += `## Risk Assessment\n\n`;
-  plan.risks.forEach((risk, index) => {
-    content += `### ${risk.level.toUpperCase()} Risk ${index + 1}\n`;
-    content += `${risk.description}\n\n`;
-    content += `**Mitigation:** ${risk.mitigation}\n\n`;
-  });
-
-  // Success metrics
-  content += `## Success Metrics\n\n`;
-  content += `- All acceptance criteria implemented and tested\n`;
-  content += `- Code coverage meets project standards\n`;
-  content += `- Performance requirements satisfied\n`;
-  content += `- No breaking changes to existing functionality\n`;
-  content += `- Documentation updated\n\n`;
-
-  return content;
-}
-
-/**
- * Display generated plan
- * @param {Object} plan - Plan data
- */
-function displayGeneratedPlan(plan) {
-  console.log(chalk.bold.cyan(`\nGenerated Implementation Plan`));
-  console.log(chalk.cyan('===================================================\n'));
-
-  console.log(chalk.bold(`Title: ${plan.title}`));
-  console.log(chalk.gray(`Spec: ${plan.spec_id}`));
-  console.log(chalk.gray(`Generated: ${new Date(plan.generated_at).toLocaleString()}`));
-  console.log('');
-
-  // Task summary
-  const setupTasks = plan.tasks.filter((task) => task.type === 'setup').length;
-  const implementationTasks = plan.tasks.filter((task) => task.type === 'implementation').length;
-  const testTasks = plan.tasks.filter((task) => task.type === 'testing').length;
-
-  console.log(chalk.bold('Task Breakdown:'));
-  if (setupTasks > 0) console.log(chalk.gray(`   Setup: ${setupTasks} tasks`));
-  if (implementationTasks > 0)
-    console.log(chalk.gray(`   Implementation: ${implementationTasks} tasks`));
-  if (testTasks > 0) console.log(chalk.gray(`   Testing: ${testTasks} tasks`));
-
-  console.log(
-    chalk.gray(
-      `   Total: ${plan.tasks.length} tasks, ${plan.timeline.total_hours} hours, ${plan.timeline.estimated_days} days`
-    )
-  );
-  console.log('');
-
-  // Next steps
-  console.log(chalk.bold.yellow('Next Steps:'));
-  console.log(chalk.yellow('   1. Review and customize the generated plan'));
-  console.log(chalk.yellow('   2. Update task priorities and dependencies'));
-  console.log(chalk.yellow('   3. Start implementation following the task order'));
-  console.log(chalk.yellow('   4. Update progress: caws progress update --criterion-id A1'));
-  console.log('');
-}
-
-/**
- * Plan command handler
- * @param {string} action - Action to perform (generate)
- * @param {Object} options - Command options
- */
-async function planCommand(action, options = {}) {
-  return safeAsync(
-    async () => {
-      switch (action) {
-        case 'generate': {
-          const specId = options.specId || options.spec;
-
-          if (!specId) {
-            // Try to auto-detect single spec
-            const { checkMultiSpecStatus } = require('../utils/spec-resolver');
-            const status = await checkMultiSpecStatus();
-
-            if (status.specCount === 1) {
-              // Use the single spec automatically
-              const registry = await loadSpecsRegistry();
-              const singleSpecId = Object.keys(registry.specs)[0];
-              console.log(chalk.blue(`Auto-detected single spec: ${singleSpecId}`));
-
-              const spec = await loadSpecForPlanning(singleSpecId);
-              await generateAndDisplayPlan(spec, singleSpecId, options);
-            } else if (status.specCount > 1) {
-              const registry = await loadSpecsRegistry();
-              throw new Error(
-                'Multiple specs detected. Please specify which one: caws plan generate --spec-id <id>\n' +
-                  'Available specs: ' +
-                  Object.keys(registry.specs || {}).join(', ')
-              );
-            } else {
-              throw new Error('No specs found. Create a spec first: caws specs create <id>');
-            }
-          } else {
-            // Load spec for planning
-            const spec = await loadSpecForPlanning(specId);
-
-            return await generateAndDisplayPlan(spec, specId, options);
-          }
-          break;
-        }
-
-        default:
-          throw new Error(`Unknown plan action: ${action}. Use: generate`);
-      }
-    },
-    `plan ${action}`,
-    true
-  );
-}
-
-module.exports = {
-  planCommand,
-  generateImplementationPlan,
-  writePlanToFile,
-  generatePlanMarkdown,
-  displayGeneratedPlan,
-  PLAN_TEMPLATES,
-};