claude-autopm 2.8.2 → 2.8.3

package/packages/plugin-pm/scripts/pm/epic-split.js

@@ -0,0 +1,522 @@
+#!/usr/bin/env node
+
+const fs = require('fs').promises;
+const path = require('path');
+const yaml = require('js-yaml');
+
+/**
+ * Epic Split - Automatically split a PRD into multiple epics
+ * Usage: node epic-split.js <feature_name>
+ */
+
+// ANSI colors
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+  gray: '\x1b[90m'
+};
+
+// Epic templates for different components
+const EPIC_TEMPLATES = {
+  infrastructure: {
+    name: 'Infrastructure Foundation',
+    priority: 'P0',
+    type: 'infrastructure',
+    weeks: 1,
+    description: 'Core infrastructure setup including Docker, database, and development environment',
+    components: ['docker', 'database', 'redis', 'monitoring', 'logging'],
+    keywords: ['docker', 'postgres', 'redis', 'infrastructure', 'compose', 'health', 'monitoring']
+  },
+  auth_backend: {
+    name: 'Authentication Backend',
+    priority: 'P0',
+    type: 'backend',
+    weeks: 2,
+    description: 'Backend authentication system with JWT, user management, and RBAC',
+    components: ['jwt', 'users', 'roles', 'permissions', 'tokens'],
+    keywords: ['auth', 'jwt', 'login', 'register', 'token', 'rbac', 'user model']
+  },
+  auth_frontend: {
+    name: 'Authentication UI',
+    priority: 'P0',
+    type: 'frontend',
+    weeks: 2,
+    description: 'Frontend authentication flows including login, registration, and password management',
+    components: ['login_ui', 'register_ui', 'password_reset_ui', 'auth_state'],
+    keywords: ['sign in', 'sign up', 'login form', 'register form', 'auth ui']
+  },
+  api_core: {
+    name: 'API Core Services',
+    priority: 'P0',
+    type: 'backend',
+    weeks: 2,
+    description: 'Core REST API endpoints and business logic',
+    components: ['endpoints', 'services', 'middleware', 'validation'],
+    keywords: ['api', 'endpoint', 'rest', 'fastapi', 'route', 'service']
+  },
+  frontend_foundation: {
+    name: 'Frontend Foundation',
+    priority: 'P0',
+    type: 'frontend',
+    weeks: 1,
+    description: 'Frontend setup with React, TypeScript, and core libraries',
+    components: ['react', 'typescript', 'routing', 'state', 'styling'],
+    keywords: ['react', 'typescript', 'vite', 'mui', 'material', 'router', 'zustand']
+  },
+  dashboard: {
+    name: 'Dashboard & User Experience',
+    priority: 'P1',
+    type: 'frontend',
+    weeks: 2,
+    description: 'Main application dashboard and user interface',
+    components: ['dashboard', 'navigation', 'profile', 'layouts'],
+    keywords: ['dashboard', 'profile', 'navigation', 'layout', 'appbar', 'drawer']
+  },
+  testing: {
+    name: 'Testing & Quality',
+    priority: 'P1',
+    type: 'testing',
+    weeks: 1,
+    description: 'Comprehensive testing suite including unit, integration, and E2E tests',
+    components: ['unit_tests', 'integration_tests', 'e2e_tests', 'coverage'],
+    keywords: ['test', 'pytest', 'vitest', 'playwright', 'tdd', 'coverage']
+  },
+  deployment: {
+    name: 'Deployment & DevOps',
+    priority: 'P1',
+    type: 'devops',
+    weeks: 1,
+    description: 'CI/CD pipelines, deployment configurations, and production setup',
+    components: ['ci_cd', 'deployment', 'monitoring', 'security'],
+    keywords: ['deploy', 'ci/cd', 'github actions', 'production', 'release']
+  },
+  data_layer: {
+    name: 'Data Layer & Persistence',
+    priority: 'P0',
+    type: 'backend',
+    weeks: 1,
+    description: 'Database models, migrations, and data access layer',
+    components: ['models', 'migrations', 'orm', 'queries'],
+    keywords: ['database', 'model', 'migration', 'alembic', 'sqlalchemy', 'schema']
+  },
+  security: {
+    name: 'Security & Compliance',
+    priority: 'P0',
+    type: 'security',
+    weeks: 1,
+    description: 'Security hardening, OWASP compliance, and vulnerability management',
+    components: ['security_headers', 'rate_limiting', 'csrf', 'validation'],
+    keywords: ['security', 'owasp', 'csrf', 'cors', 'rate limit', 'vulnerability']
+  }
+};
+
+// Analyze PRD content to identify needed epics
+function analyzePRD(content) {
+  const contentLower = content.toLowerCase();
+  const identifiedEpics = [];
+
+  // Check for each epic template
+  for (const [key, template] of Object.entries(EPIC_TEMPLATES)) {
+    let score = 0;
+    let matchedKeywords = [];
+
+    // Check keywords
+    for (const keyword of template.keywords) {
+      if (contentLower.includes(keyword.toLowerCase())) {
+        score += 1;
+        matchedKeywords.push(keyword);
+      }
+    }
+
+    // If enough keywords match, include this epic
+    if (score >= 2) {
+      identifiedEpics.push({
+        key,
+        template,
+        score,
+        matchedKeywords
+      });
+    }
+  }
+
+  // Sort by score and priority
+  identifiedEpics.sort((a, b) => {
+    if (a.template.priority !== b.template.priority) {
+      return a.template.priority === 'P0' ? -1 : 1;
+    }
+    return b.score - a.score;
+  });
+
+  return identifiedEpics;
+}
+
+// Determine epic dependencies
+function determineDependencies(epics) {
+  const dependencies = {};
+
+  for (const epic of epics) {
+    dependencies[epic.key] = [];
+
+    // Infrastructure is always first
+    if (epic.key !== 'infrastructure' && epics.some(e => e.key === 'infrastructure')) {
+      if (['auth_backend', 'api_core', 'frontend_foundation', 'data_layer'].includes(epic.key)) {
+        dependencies[epic.key].push('infrastructure');
+      }
+    }
+
+    // Frontend auth depends on backend auth
+    if (epic.key === 'auth_frontend') {
+      if (epics.some(e => e.key === 'auth_backend')) {
+        dependencies[epic.key].push('auth_backend');
+      }
+      if (epics.some(e => e.key === 'frontend_foundation')) {
+        dependencies[epic.key].push('frontend_foundation');
+      }
+    }
+
+    // Dashboard depends on auth UI
+    if (epic.key === 'dashboard') {
+      if (epics.some(e => e.key === 'auth_frontend')) {
+        dependencies[epic.key].push('auth_frontend');
+      }
+    }
+
+    // API depends on data layer
+    if (epic.key === 'api_core' && epics.some(e => e.key === 'data_layer')) {
+      dependencies[epic.key].push('data_layer');
+    }
+
+    // Testing depends on implementation epics
+    if (epic.key === 'testing') {
+      const implEpics = ['api_core', 'auth_backend', 'auth_frontend', 'dashboard'];
+      for (const impl of implEpics) {
+        if (epics.some(e => e.key === impl)) {
+          dependencies[epic.key].push(impl);
+        }
+      }
+    }
+
+    // Deployment depends on testing
+    if (epic.key === 'deployment' && epics.some(e => e.key === 'testing')) {
+      dependencies[epic.key].push('testing');
+    }
+  }
+
+  return dependencies;
+}
+
+// Generate epic content
+function generateEpicContent(epic, dependencies, prdPath, index) {
+  const now = new Date().toISOString();
+  const template = epic.template;
+
+  const frontmatter = {
+    name: template.name.toLowerCase().replace(/\s+/g, '-'),
+    status: 'backlog',
+    created: now,
+    progress: 0,
+    prd: prdPath,
+    github: '[Will be updated when synced to GitHub]',
+    priority: template.priority,
+    type: template.type,
+    dependencies: dependencies[epic.key] || [],
+    epic_number: index + 1
+  };
+
+  const content = `---
+${yaml.dump(frontmatter).trim()}
+---
+
+# Epic ${index + 1}: ${template.name}
+
+## Overview
+${template.description}
+
+## Scope
+This epic covers the following components:
+${template.components.map(c => `- ${c.replace(/_/g, ' ').charAt(0).toUpperCase() + c.replace(/_/g, ' ').slice(1)}`).join('\n')}
+
+## Dependencies
+${dependencies[epic.key]?.length > 0 ? dependencies[epic.key].map(d => {
+  const depEpic = EPIC_TEMPLATES[d];
+  return `- ${depEpic ? depEpic.name : d}`;
+}).join('\n') : '- None (can start immediately)'}
+
+## Success Criteria
+- All ${template.components.length} components implemented and tested
+- Integration with dependent epics verified
+- Documentation complete
+- Code review passed
+- ${template.type === 'frontend' ? 'UI/UX review approved' : ''}
+- ${template.type === 'backend' ? 'API documentation generated' : ''}
+- ${template.type === 'testing' ? 'Coverage targets met (>80%)' : ''}
+
+## Estimated Effort
+**${template.weeks} week${template.weeks > 1 ? 's' : ''}**
+
+## Technical Approach
+${template.type === 'infrastructure' ? `
+- Set up containerized development environment
+- Configure database and caching layers
+- Implement logging and monitoring
+- Create development scripts and tooling` : ''}
+${template.type === 'backend' ? `
+- Design data models and API contracts
+- Implement service layer with business logic
+- Create RESTful endpoints
+- Add validation and error handling` : ''}
+${template.type === 'frontend' ? `
+- Set up component architecture
+- Implement UI components with accessibility
+- Create responsive layouts
+- Integrate with backend APIs` : ''}
+${template.type === 'testing' ? `
+- Write comprehensive unit tests
+- Create integration test suites
+- Implement E2E test scenarios
+- Set up continuous testing pipeline` : ''}
+${template.type === 'devops' ? `
+- Configure CI/CD pipelines
+- Set up deployment automation
+- Implement monitoring and alerting
+- Create rollback procedures` : ''}
+
+## Risk Factors
+- Dependency on ${dependencies[epic.key]?.length || 0} other epic${dependencies[epic.key]?.length !== 1 ? 's' : ''}
+- Estimated complexity: ${template.weeks > 1 ? 'High' : 'Medium'}
+- Technical challenges in ${template.components[0].replace(/_/g, ' ')}
+
+## Notes
+- Epic identified based on PRD analysis
+- Matched keywords: ${epic.matchedKeywords.join(', ')}
+- Can be further decomposed into ${3 + template.components.length} to ${5 + template.components.length * 2} tasks
+
+---
+*Generated on ${now} by Epic Split System*`;
+
+  return content;
+}
+
+// Create meta file for multi-epic structure
+function generateMetaFile(epics, featureName) {
+  const now = new Date().toISOString();
+
+  const meta = {
+    feature: featureName,
+    created: now,
+    total_epics: epics.length,
+    epics: epics.map((e, i) => ({
+      number: i + 1,
+      key: e.key,
+      name: e.template.name,
+      priority: e.template.priority,
+      weeks: e.template.weeks,
+      type: e.template.type
+    })),
+    total_weeks: epics.reduce((sum, e) => sum + e.template.weeks, 0),
+    execution_strategy: 'parallel_where_possible'
+  };
+
+  return `---
+${yaml.dump(meta).trim()}
+---
+
+# Multi-Epic Structure: ${featureName}
+
+## Overview
+This feature has been automatically split into ${epics.length} epics based on PRD analysis.
+
+## Epic Breakdown
+
+${epics.map((e, i) => `### Epic ${i + 1}: ${e.template.name}
+- **Priority:** ${e.template.priority}
+- **Duration:** ${e.template.weeks} week${e.template.weeks > 1 ? 's' : ''}
+- **Type:** ${e.template.type}
+- **Confidence:** ${Math.round((e.score / e.template.keywords.length) * 100)}%
+`).join('\n')}
+
+## Execution Timeline
+
+\`\`\`
+Week 1-${epics[0]?.template.weeks || 1}: ${epics[0]?.template.name || 'TBD'}
+${epics.slice(1).map((e, i) => {
+  const startWeek = epics.slice(0, i + 1).reduce((sum, ep) => sum + ep.template.weeks, 1);
+  const endWeek = startWeek + e.template.weeks - 1;
+  return `Week ${startWeek}-${endWeek}: ${e.template.name}`;
+}).join('\n')}
+\`\`\`
+
+## Total Estimated Effort
+**${epics.reduce((sum, e) => sum + e.template.weeks, 0)} weeks**
+
+## Next Steps
+1. Review and adjust epic breakdown
+2. Decompose each epic into tasks: \`/pm:epic-decompose <feature>/<epic_number>\`
+3. Sync to GitHub: \`/pm:epic-sync <feature>\`
+
+---
+*Generated on ${now} by Epic Split System*`;
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0) {
+    console.error(`${colors.red}❌ Missing feature name${colors.reset}`);
+    console.log('Usage: node epic-split.js <feature_name>');
+    process.exit(1);
+  }
+
+  const featureName = args[0];
+  const prdPath = path.join('.claude', 'prds', `${featureName}.md`);
+  const epicDir = path.join('.claude', 'epics', featureName);
+
+  console.log(`${colors.cyan}🔄 Analyzing PRD: ${featureName}${colors.reset}`);
+  console.log('══════════════════════════════════════════════════\n');
+
+  try {
+    // Check if PRD exists
+    try {
+      await fs.access(prdPath);
+    } catch {
+      console.error(`${colors.red}❌ PRD not found: ${prdPath}${colors.reset}`);
+      console.log(`First create a PRD with: /pm:prd-new ${featureName}`);
+      process.exit(1);
+    }
+
+    // Check if epics already exist
+    try {
+      await fs.access(epicDir);
+      const files = await fs.readdir(epicDir);
+      const epicFolders = files.filter(f => !f.includes('.'));
+
+      if (epicFolders.length > 0) {
+        console.log(`${colors.yellow}⚠️  Found existing epic structure:${colors.reset}`);
+        console.log(`   ${epicFolders.join(', ')}`);
+        console.log('\nThis will replace the existing structure.');
+        console.log('Continue? (Press Ctrl+C to cancel)\n');
+
+        // In real implementation, would wait for user input
+        // For now, we'll proceed
+      }
+    } catch {
+      // Directory doesn't exist, that's fine
+    }
+
+    // Read PRD content
+    console.log(`${colors.blue}📖 Reading PRD...${colors.reset}`);
+    const prdContent = await fs.readFile(prdPath, 'utf8');
+
+    // Analyze PRD to identify epics
+    console.log(`${colors.blue}🔍 Analyzing requirements...${colors.reset}`);
+    const identifiedEpics = analyzePRD(prdContent);
+
+    if (identifiedEpics.length === 0) {
+      console.error(`${colors.red}❌ Could not identify any epics from PRD${colors.reset}`);
+      console.log('The PRD may be too simple or lack typical keywords.');
+      process.exit(1);
+    }
+
+    console.log(`${colors.green}✓ Identified ${identifiedEpics.length} epics${colors.reset}\n`);
+
+    // Determine dependencies
+    console.log(`${colors.blue}🔗 Determining dependencies...${colors.reset}`);
+    const dependencies = determineDependencies(identifiedEpics);
+
+    // Create epic directory structure
+    console.log(`${colors.blue}📁 Creating epic structure...${colors.reset}\n`);
+    await fs.mkdir(epicDir, { recursive: true });
+
+    // Create meta file
+    const metaContent = generateMetaFile(identifiedEpics, featureName);
+    await fs.writeFile(path.join(epicDir, 'meta.yaml'), metaContent);
+
+    // Create each epic
+    for (let i = 0; i < identifiedEpics.length; i++) {
+      const epic = identifiedEpics[i];
+      const epicNumber = String(i + 1).padStart(2, '0');
+      const epicFolder = `${epicNumber}-${epic.key}`;
+      const epicPath = path.join(epicDir, epicFolder);
+
+      // Create epic folder
+      await fs.mkdir(epicPath, { recursive: true });
+
+      // Generate epic content
+      const epicContent = generateEpicContent(
+        epic,
+        dependencies,
+        prdPath,
+        i
+      );
+
+      // Write epic file
+      await fs.writeFile(path.join(epicPath, 'epic.md'), epicContent);
+
+      console.log(`${colors.green}✓${colors.reset} Epic ${i + 1}: ${epic.template.name}`);
+      console.log(`  ${colors.gray}Priority: ${epic.template.priority}, Duration: ${epic.template.weeks}w${colors.reset}`);
+      console.log(`  ${colors.gray}Location: ${epicPath}${colors.reset}`);
+    }
+
+    // Success summary
+    console.log(`\n${colors.green}✅ Successfully split PRD into ${identifiedEpics.length} epics!${colors.reset}\n`);
+
+    console.log(`${colors.bright}📋 Epic Summary:${colors.reset}`);
+    console.log('──────────────────────────────────────────────────');
+
+    const p0Epics = identifiedEpics.filter(e => e.template.priority === 'P0');
+    const p1Epics = identifiedEpics.filter(e => e.template.priority === 'P1');
+
+    console.log(`${colors.cyan}P0 (Must Have):${colors.reset} ${p0Epics.length} epics`);
+    p0Epics.forEach((e, i) => {
+      console.log(`  • ${e.template.name} (${e.template.weeks}w)`);
+    });
+
+    if (p1Epics.length > 0) {
+      console.log(`\n${colors.yellow}P1 (Should Have):${colors.reset} ${p1Epics.length} epics`);
+      p1Epics.forEach((e, i) => {
+        console.log(`  • ${e.template.name} (${e.template.weeks}w)`);
+      });
+    }
+
+    const totalWeeks = identifiedEpics.reduce((sum, e) => sum + e.template.weeks, 0);
+    console.log(`\n${colors.bright}⏱️  Total Estimated Effort: ${totalWeeks} weeks${colors.reset}`);
+
+    // Show dependency graph
+    console.log(`\n${colors.bright}🔗 Dependency Graph:${colors.reset}`);
+    console.log('──────────────────────────────────────────────────');
+
+    for (const epic of identifiedEpics) {
+      const deps = dependencies[epic.key];
+      if (deps && deps.length > 0) {
+        console.log(`${epic.template.name} ${colors.gray}depends on${colors.reset} → ${deps.map(d => {
+          const depEpic = identifiedEpics.find(e => e.key === d);
+          return depEpic ? depEpic.template.name : d;
+        }).join(', ')}`);
+      } else {
+        console.log(`${epic.template.name} ${colors.green}(can start immediately)${colors.reset}`);
+      }
+    }
+
+    console.log(`\n${colors.bright}💡 Next Steps:${colors.reset}`);
+    console.log(`  1. Review epics: ${colors.cyan}/pm:epic-show ${featureName}${colors.reset}`);
+    console.log(`  2. Decompose first epic: ${colors.cyan}/pm:epic-decompose ${featureName}/01-${identifiedEpics[0].key}${colors.reset}`);
+    console.log(`  3. Sync all to GitHub: ${colors.cyan}/pm:epic-sync ${featureName}${colors.reset}`);
+
+  } catch (error) {
+    console.error(`${colors.red}❌ Error: ${error.message}${colors.reset}`);
+    if (error.stack && process.env.DEBUG) {
+      console.error(colors.gray + error.stack + colors.reset);
+    }
+    process.exit(1);
+  }
+}
+
+main().catch(error => {
+  console.error(`${colors.red}Fatal error: ${error.message}${colors.reset}`);
+  process.exit(1);
+});

package/packages/plugin-pm/scripts/pm/epic-start/epic-start.js

@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+/**
+ * Epic Start - Launch parallel agent execution for an epic
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync, spawn } = require('child_process');
+
+class EpicStarter {
+  constructor(epicName) {
+    this.epicName = epicName;
+    this.epicFile = null;
+  }
+
+  findEpicFile() {
+    // Check in epics directory
+    let epicPath = path.join('.claude', 'epics', `${this.epicName}.md`);
+    if (fs.existsSync(epicPath)) {
+      this.epicFile = epicPath;
+      return true;
+    }
+
+    // Check in PRDs directory
+    epicPath = path.join('.claude', 'prds', `${this.epicName}.md`);
+    if (fs.existsSync(epicPath)) {
+      this.epicFile = epicPath;
+      return true;
+    }
+
+    return false;
+  }
+
+  listAvailableEpics() {
+    const epics = [];
+
+    // List from epics directory
+    const epicsDir = path.join('.claude', 'epics');
+    if (fs.existsSync(epicsDir)) {
+      fs.readdirSync(epicsDir)
+        .filter(file => file.endsWith('.md'))
+        .forEach(file => epics.push(file.replace('.md', '')));
+    }
+
+    // List from PRDs directory
+    const prdsDir = path.join('.claude', 'prds');
+    if (fs.existsSync(prdsDir)) {
+      fs.readdirSync(prdsDir)
+        .filter(file => file.endsWith('.md'))
+        .forEach(file => epics.push(file.replace('.md', '')));
+    }
+
+    return [...new Set(epics)]; // Remove duplicates
+  }
+
+  extractTasks() {
+    const content = fs.readFileSync(this.epicFile, 'utf8');
+    const lines = content.split('\n');
+
+    const tasks = {
+      complete: [],
+      incomplete: [],
+      total: 0
+    };
+
+    lines.forEach(line => {
+      if (line.match(/^- \[x\]/)) {
+        tasks.complete.push(line.replace(/^- \[x\] /, ''));
+      } else if (line.match(/^- \[ \]/)) {
+        tasks.incomplete.push(line.replace(/^- \[ \] /, ''));
+      }
+    });
+
+    tasks.total = tasks.complete.length + tasks.incomplete.length;
+    return tasks;
+  }
+
+  async startParallelExecution(tasks) {
+    console.log('\n🔄 Starting parallel execution for', tasks.incomplete.length, 'tasks...\n');
+
+    // Check if parallel streams script exists
+    const parallelScript = path.join(__dirname, '..', 'start-parallel-streams.js');
+
+    if (fs.existsSync(parallelScript)) {
+      console.log('Using Node.js parallel executor...');
+
+      // Spawn the parallel execution script
+      const child = spawn('node', [parallelScript, '--epic', this.epicName], {
+        stdio: 'inherit'
+      });
+
+      return new Promise((resolve) => {
+        child.on('close', (code) => {
+          if (code === 0) {
+            console.log('\n✅ Parallel execution completed successfully');
+          } else {
+            console.log('\n⚠️  Parallel execution finished with code:', code);
+          }
+          resolve(code);
+        });
+      });
+    } else {
+      // Fallback to basic parallel execution
+      console.log('Starting tasks in parallel...\n');
+
+      tasks.incomplete.forEach((task, index) => {
+        console.log(`  ▶ [${index + 1}/${tasks.incomplete.length}] Starting: ${task}`);
+
+        // Here you can add actual task execution logic
+        // For example, launching specific agents or scripts
+      });
+
+      console.log('\n✅ Parallel execution initiated');
+    }
+  }
+
+  async run() {
+    // Check if epic name provided
+    if (!this.epicName) {
+      console.error('❌ Error: Epic name required');
+      console.error('Usage: /pm:epic-start epic-name');
+      process.exit(1);
+    }
+
+    // Find epic file
+    if (!this.findEpicFile()) {
+      console.error(`❌ Error: Epic not found: ${this.epicName}`);
+      console.error('\nAvailable epics:');
+
+      const availableEpics = this.listAvailableEpics();
+      if (availableEpics.length > 0) {
+        availableEpics.forEach(epic => console.log(`  - ${epic}`));
+      } else {
+        console.log('  No epics found');
+      }
+      process.exit(1);
+    }
+
+    console.log(`🚀 Starting parallel execution for epic: ${this.epicName}`);
+    console.log(`📄 Epic file: ${this.epicFile}\n`);
+
+    // Extract tasks
+    console.log('📋 Extracting tasks from epic...');
+    const tasks = this.extractTasks();
+
+    if (tasks.total === 0) {
+      console.log('⚠️  No tasks found in epic file');
+      console.log('Tip: Add tasks in format: - [ ] Task description');
+      process.exit(1);
+    }
+
+    // Display task status
+    console.log('\n📊 Task Status:');
+    console.log(`  • Total: ${tasks.total}`);
+    console.log(`  • Complete: ${tasks.complete.length}`);
+    console.log(`  • Remaining: ${tasks.incomplete.length}`);
+
+    if (tasks.incomplete.length === 0) {
+      console.log('\n✅ All tasks are already complete!');
+      process.exit(0);
+    }
+
+    // Start parallel execution
+    await this.startParallelExecution(tasks);
+
+    // Show next steps
+    console.log(`\n💡 Monitor progress with: /pm:epic-status ${this.epicName}`);
+    console.log(`📝 View details with: /pm:epic-show ${this.epicName}`);
+  }
+}
+
+// Main execution
+if (require.main === module) {
+  const epicName = process.argv[2];
+  const starter = new EpicStarter(epicName);
+
+  starter.run().catch(error => {
+    console.error('❌ Error:', error.message);
+    process.exit(1);
+  });
+}
+
+module.exports = EpicStarter;