@hyperdrive.bot/bmad-workflow 1.0.2

package/dist/commands/decompose.js

@@ -0,0 +1,327 @@
+/**
+ * Decompose Command
+ *
+ * Decomposes large goals into executable task graphs with dependency management.
+ * Supports per-file task generation, parallel execution, and intelligent dependency resolution.
+ */
+import { Args, Command, Flags } from '@oclif/core';
+import { join } from 'node:path';
+import { createAgentRunner, isProviderSupported } from '../services/agents/agent-runner-factory.js';
+import { FileManager } from '../services/file-system/file-manager.js';
+import { GlobMatcher } from '../services/file-system/glob-matcher.js';
+import { BatchProcessor } from '../services/orchestration/batch-processor.js';
+import { DependencyGraphExecutor } from '../services/orchestration/dependency-graph-executor.js';
+import { TaskDecompositionService } from '../services/orchestration/task-decomposition-service.js';
+import { DecomposeSessionScaffolder } from '../services/scaffolding/decompose-session-scaffolder.js';
+import * as colors from '../utils/colors.js';
+import { formatBox, formatTable } from '../utils/formatters.js';
+import { createLogger } from '../utils/logger.js';
+/**
+ * Decompose Command
+ *
+ * Breaks down large goals into small, executable tasks with dependency management.
+ *
+ * @example
+ * ```bash
+ * # Decompose a goal with per-file mode
+ * bmad-cli decompose "Migrate project to TypeScript" --per-file --file-pattern "src/*.js"
+ *
+ * # Plan only without execution
+ * bmad-cli decompose "Add authentication" --plan-only
+ *
+ * # Execute with custom context
+ * bmad-cli decompose "Refactor API layer" --context package.json --context tsconfig.json --execute
+ * ```
+ */
+export default class Decompose extends Command {
+    static args = {
+        goal: Args.string({
+            description: 'The big goal to decompose into executable tasks',
+            required: true,
+        }),
+    };
+    static description = 'Decompose large goals into executable task graphs with dependency management';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> "Migrate project to TypeScript 100%" --per-file --file-pattern "src/*.js"',
+        '<%= config.bin %> <%= command.id %> "Add user authentication" --plan-only',
+        '<%= config.bin %> <%= command.id %> "Refactor API layer" --execute --context package.json',
+        '<%= config.bin %> <%= command.id %> "Implement dark mode" --max-parallel 5 --context src/theme.ts',
+        '<%= config.bin %> <%= command.id %> "Refactor codebase" --story-format --story-prefix "REFACTOR"',
+        '<%= config.bin %> <%= command.id %> "Design new API endpoints" --agent architect --plan-only',
+    ];
+    static flags = {
+        agent: Flags.string({
+            default: 'architect',
+            description: 'BMAD agent to use for planning/decomposition (the agent will choose best agents for each task)',
+            options: ['analyst', 'architect', 'dev', 'pm', 'quick-flow-solo-dev', 'sm', 'tea', 'tech-writer', 'ux-designer'],
+        }),
+        context: Flags.string({
+            description: 'Context files to provide to the planner (can be used multiple times)',
+            multiple: true,
+        }),
+        cwd: Flags.string({
+            description: 'Working directory path for task execution',
+        }),
+        execute: Flags.boolean({
+            default: false,
+            description: 'Execute tasks immediately after planning (skips confirmation)',
+        }),
+        'file-pattern': Flags.string({
+            description: 'Glob pattern for per-file mode (e.g., "src/**/*.js")',
+        }),
+        'max-parallel': Flags.integer({
+            default: 3,
+            description: 'Maximum number of tasks to run in parallel',
+        }),
+        'output-dir': Flags.string({
+            default: 'docs/decompose-sessions',
+            description: 'Directory for session outputs',
+        }),
+        'per-file': Flags.boolean({
+            default: false,
+            description: 'Create one task per file for file-heavy operations',
+        }),
+        'plan-only': Flags.boolean({
+            default: false,
+            description: 'Generate task graph without executing',
+        }),
+        provider: Flags.string({
+            default: 'claude',
+            description: 'AI provider to use (claude or gemini)',
+            options: ['claude', 'gemini'],
+        }),
+        'story-format': Flags.boolean({
+            default: false,
+            description: 'Format tasks as BMAD stories with acceptance criteria and proper structure',
+        }),
+        'story-prefix': Flags.string({
+            description: 'Project prefix for story IDs (e.g., "MIGRATE", "REFACTOR") - used with --story-format',
+        }),
+        'task-timeout': Flags.integer({
+            default: 1_800_000, // 30 minutes
+            description: 'Timeout per task in milliseconds',
+        }),
+        verbose: Flags.boolean({
+            char: 'v',
+            default: false,
+            description: 'Detailed output mode',
+        }),
+    };
+    cancelled = false;
+    fileManager;
+    logger;
+    scaffolder;
+    /**
+     * Main command execution
+     */
+    async run() {
+        const { args, flags } = await this.parse(Decompose);
+        try {
+            // Validate provider
+            if (!isProviderSupported(flags.provider)) {
+                this.error(`Unsupported provider: ${flags.provider}. Use 'claude' or 'gemini'.`, { exit: 1 });
+            }
+            // Validate per-file mode
+            if (flags['per-file'] && !flags['file-pattern']) {
+                this.error('--file-pattern is required when using --per-file mode', { exit: 1 });
+            }
+            // Validate story format mode
+            if (flags['story-format'] && !flags['story-prefix']) {
+                this.error('--story-prefix is required when using --story-format mode', { exit: 1 });
+            }
+            // Initialize services
+            await this.initializeServices(flags.provider);
+            // Register signal handlers
+            this.registerSignalHandlers();
+            // Show header
+            this.displayHeader(args.goal);
+            // Build options
+            const options = {
+                agent: flags.agent,
+                contextFiles: flags.context || [],
+                cwd: flags.cwd,
+                execute: flags.execute,
+                filePattern: flags['file-pattern'],
+                goal: args.goal,
+                maxParallel: flags['max-parallel'],
+                perFile: flags['per-file'],
+                planOnly: flags['plan-only'],
+                storyFormat: flags['story-format'],
+                storyPrefix: flags['story-prefix'],
+                taskTimeout: flags['task-timeout'],
+            };
+            // Log configuration if verbose
+            if (flags.verbose) {
+                this.logger.info({ options }, 'Decompose configuration');
+            }
+            // Create session directory
+            const timestamp = new Date().toISOString().replaceAll(/[:.]/g, '-').split('.')[0];
+            const sessionDir = join(flags['output-dir'], `session-${timestamp}`);
+            await this.fileManager.createDirectory(sessionDir);
+            this.log(colors.info(`📁 Session directory: ${sessionDir}\n`));
+            // Phase 1: Decompose goal into task graph
+            this.log(colors.bold('⚙️  Phase 1: Decomposing goal into task graph...\n'));
+            const decompositionService = new TaskDecompositionService(createAgentRunner(flags.provider, this.logger), this.fileManager, new GlobMatcher(this.fileManager, this.logger), this.logger);
+            const taskGraph = await decompositionService.decomposeGoal(options, sessionDir);
+            this.log(colors.success('✓ Task graph generated!\n'));
+            this.displayTaskGraphSummary(taskGraph);
+            // Phase 2: Scaffold session structure
+            this.log(colors.bold('\n⚙️  Phase 2: Creating session structure...\n'));
+            await this.scaffolder.createSessionStructure(sessionDir, options.storyFormat);
+            const sessionConfig = {
+                createdAt: new Date(),
+                goal: args.goal,
+                options,
+                outputDir: sessionDir,
+                sessionId: taskGraph.session.id,
+            };
+            await this.scaffolder.writeGoalFile(sessionDir, sessionConfig);
+            await this.scaffolder.writeTaskGraphFile(sessionDir, taskGraph);
+            await this.scaffolder.writeMasterPromptFile(sessionDir, taskGraph);
+            await this.scaffolder.writeTaskPromptFiles(sessionDir, taskGraph);
+            await this.scaffolder.writeSessionReadme(sessionDir, taskGraph, options.storyFormat);
+            this.log(colors.success('✓ Session structure created!\n'));
+            this.log(colors.info(`📄 Task graph saved to: ${sessionDir}/task-graph.yaml`));
+            this.log(colors.info(`📄 Session README: ${sessionDir}/SESSION_README.md\n`));
+            // Phase 3: Execute (if not plan-only)
+            if (flags['plan-only']) {
+                this.log(colors.info('\n💡 Plan-only mode: Task graph generated but not executed.'));
+                this.log(colors.info(`To execute, run: bmad-cli decompose "${args.goal}" --execute\n`));
+            }
+            else {
+                // Ask for confirmation unless --execute flag is set
+                if (!flags.execute) {
+                    const confirmed = await this.confirmExecution(taskGraph);
+                    if (!confirmed) {
+                        this.log(colors.warning('\n⏸️  Execution cancelled. Task graph saved for later use.'));
+                        this.log(colors.info(`To execute later, review: ${sessionDir}/task-graph.yaml\n`));
+                        return;
+                    }
+                }
+                this.log(colors.bold('\n⚙️  Phase 3: Executing task graph...\n'));
+                const executor = new DependencyGraphExecutor(taskGraph, createAgentRunner(flags.provider, this.logger), new BatchProcessor(flags['max-parallel'], 0, this.logger), this.fileManager, this.logger, flags.cwd);
+                const executionResult = await executor.execute((layerIndex, totalLayers, layerSize) => {
+                    this.log(colors.info(`\n🔄 Starting Layer ${layerIndex + 1}/${totalLayers} (${layerSize} task${layerSize > 1 ? 's' : ''} in parallel)`));
+                }, (taskId, _layerIndex, _taskIndex, _totalTasks) => {
+                    this.log(colors.dim(`  → Executing ${taskId}...`));
+                });
+                // Write execution report
+                await this.scaffolder.writeExecutionReport(sessionDir, taskGraph, executionResult);
+                // Display results
+                this.displayExecutionResults(executionResult, sessionDir);
+                // Check for cancellation
+                if (this.cancelled) {
+                    this.log('\n' + colors.warning('⚠️  Execution cancelled by user'));
+                    process.exit(130);
+                }
+                // Exit with appropriate code
+                if (!executionResult.success) {
+                    this.error('Task graph execution completed with failures', { exit: 1 });
+                }
+                this.log('\n' + colors.success('✅ All tasks completed successfully!'));
+            }
+        }
+        catch (error) {
+            this.logger.error({ error: error.message }, 'Decompose command failed');
+            this.log('\n' + colors.error('✗ Decompose failed:'));
+            this.log(colors.error(`  ${error.message}`));
+            this.error('Execution failed', { exit: 1 });
+        }
+    }
+    /**
+     * Confirm execution with user
+     */
+    async confirmExecution(taskGraph) {
+        this.log(colors.warning('\n⚠️  Ready to execute task graph'));
+        this.log(colors.dim(`   This will run ${taskGraph.metadata.totalTasks} tasks across ${taskGraph.metadata.executionLayers.length} layers.`));
+        this.log(colors.dim(`   Estimated duration: ${taskGraph.metadata.estimatedDuration} minutes\n`));
+        // For now, default to yes in yolo mode
+        // In production, you'd use a proper prompt library
+        this.log(colors.info('   Press Ctrl+C to cancel, or Enter to continue...'));
+        // Simple confirmation
+        return true;
+    }
+    /**
+     * Display execution results
+     */
+    displayExecutionResults(result, sessionDir) {
+        this.log('\n' + colors.bold('╔════════════════════════════════════════════════════════╗'));
+        this.log(colors.bold('║                 Execution Summary                      ║'));
+        this.log(colors.bold('╚════════════════════════════════════════════════════════╝') + '\n');
+        const headers = ['Metric', 'Value'];
+        const rows = [
+            ['Total Tasks', String(result.totalTasks)],
+            [colors.success('✓ Completed'), colors.success(String(result.completedTasks))],
+            [colors.error('✗ Failed'), result.failedTasks > 0 ? colors.error(String(result.failedTasks)) : '0'],
+            [colors.warning('⊘ Skipped'), result.skippedTasks > 0 ? colors.warning(String(result.skippedTasks)) : '0'],
+            ['Duration', `${Math.round(result.totalDuration / 1000)}s`],
+            ['Success Rate', `${Math.round((result.completedTasks / result.totalTasks) * 100)}%`],
+        ];
+        this.log(formatTable(headers, rows));
+        this.log(colors.info(`\n📊 Full execution report: ${sessionDir}/execution-report.yaml`));
+        this.log(colors.info(`📁 Task outputs: ${sessionDir}/outputs/\n`));
+        // Show failed tasks if any
+        if (result.failedTasks > 0) {
+            this.log(colors.error('\n❌ Failed Tasks:'));
+            for (const taskResult of result.taskResults) {
+                if (!taskResult.success) {
+                    this.log(colors.error(`  • ${taskResult.taskId}: ${taskResult.errors}`));
+                }
+            }
+        }
+    }
+    /**
+     * Display command header
+     */
+    displayHeader(goal) {
+        const banner = formatBox('DECOMPOSE: Break Big Goals into Executable Tasks', `Goal: ${goal}`);
+        this.log('\n' + colors.bold(banner) + '\n');
+    }
+    /**
+     * Display task graph summary
+     */
+    displayTaskGraphSummary(taskGraph) {
+        this.log(colors.bold('📊 Task Graph Summary:'));
+        this.log(colors.dim('  ├─ Total Tasks: ') + colors.info(String(taskGraph.metadata.totalTasks)));
+        this.log(colors.dim('  ├─ Estimated Duration: ') + colors.info(`${taskGraph.metadata.estimatedDuration} minutes`));
+        this.log(colors.dim('  ├─ Execution Layers: ') + colors.info(String(taskGraph.metadata.executionLayers.length)));
+        this.log(colors.dim('  ├─ Max Parallelism: ') + colors.info(String(taskGraph.metadata.maxParallelism)));
+        // Check if we have any story-formatted tasks (check if task IDs don't start with "task-")
+        const isStoryFormat = taskGraph.tasks.some((t) => !t.id.startsWith('task-'));
+        if (isStoryFormat) {
+            this.log(colors.dim('  ├─ Format Mode: ') + colors.info('BMAD Stories'));
+        }
+        if (taskGraph.metadata.perFileMode) {
+            this.log(colors.dim('  └─ Per-File Mode: ') +
+                colors.info(`Enabled (${taskGraph.metadata.totalFiles ?? 0} files)`));
+        }
+        // Show execution layers
+        this.log(colors.bold('\n📋 Execution Plan:'));
+        for (let i = 0; i < taskGraph.metadata.executionLayers.length; i++) {
+            const layer = taskGraph.metadata.executionLayers[i];
+            const symbol = i === taskGraph.metadata.executionLayers.length - 1 ? '└─' : '├─';
+            const taskWord = isStoryFormat ? 'story/stories' : 'task(s)';
+            this.log(colors.dim(`  ${symbol} Layer ${i + 1}: `) + colors.info(`${layer.length} ${taskWord} in parallel`));
+        }
+    }
+    /**
+     * Initialize services
+     */
+    async initializeServices(provider) {
+        this.logger = createLogger({ namespace: 'commands:decompose' });
+        this.logger.info({ provider }, 'Initializing decompose services');
+        this.fileManager = new FileManager(this.logger);
+        this.scaffolder = new DecomposeSessionScaffolder(this.fileManager, this.logger);
+    }
+    /**
+     * Register signal handlers for graceful cancellation
+     */
+    registerSignalHandlers() {
+        process.on('SIGINT', () => {
+            if (!this.cancelled) {
+                this.cancelled = true;
+                this.log('\n' + colors.warning('⚠️  Cancellation requested. Finishing current tasks...'));
+            }
+        });
+    }
+}

package/dist/commands/demo.d.ts

@@ -0,0 +1,18 @@
+import { Command } from '@oclif/core';
+/**
+ * Demo command that showcases all terminal output utilities
+ *
+ * Demonstrates colors, progress indicators, formatters, and countdown timers.
+ * Useful for verifying that all output utilities work correctly.
+ */
+export default class Demo extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+    /**
+     * Helper method to delay execution
+     *
+     * @param ms - Milliseconds to delay
+     */
+    private delay;
+}

package/dist/commands/demo.js

@@ -0,0 +1,107 @@
+import { Command } from '@oclif/core';
+import * as colors from '../utils/colors.js';
+import { formatBox, formatCountdown, formatList, formatTable } from '../utils/formatters.js';
+import { createLogger, generateCorrelationId } from '../utils/logger.js';
+import { createSpinner, MultiStepProgress } from '../utils/progress.js';
+/**
+ * Demo command that showcases all terminal output utilities
+ *
+ * Demonstrates colors, progress indicators, formatters, and countdown timers.
+ * Useful for verifying that all output utilities work correctly.
+ */
+export default class Demo extends Command {
+    static description = 'Demonstrate terminal output utilities (colors, progress, formatters)';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    async run() {
+        const logger = createLogger({ namespace: 'commands:demo' });
+        const correlationId = generateCorrelationId();
+        logger.info({ command: 'demo', correlationId }, 'Starting demo command');
+        try {
+            // Section 1: Color utilities
+            this.log('\n' + colors.bold('═══ Section 1: Color Utilities ═══\n'));
+            this.log(colors.success('This is a success message'));
+            this.log(colors.error('This is an error message'));
+            this.log(colors.warning('This is a warning message'));
+            this.log(colors.info('This is an info message'));
+            this.log(colors.highlight('This is highlighted text'));
+            this.log(colors.dim('This is dimmed text'));
+            // Section 2: Simple spinner
+            this.log('\n' + colors.bold('═══ Section 2: Simple Spinner ═══\n'));
+            const spinner = createSpinner('Loading data...');
+            spinner.start();
+            await this.delay(2000);
+            spinner.succeed('Data loaded successfully');
+            // Section 3: Multi-step progress
+            this.log('\n' + colors.bold('═══ Section 3: Multi-Step Progress ═══\n'));
+            const steps = ['Parse configuration', 'Validate inputs', 'Execute workflow'];
+            const progress = new MultiStepProgress(steps);
+            // Sequential execution with await is intentional for demo
+            for (let i = 0; i < steps.length; i++) {
+                progress.start(i);
+                // eslint-disable-next-line no-await-in-loop
+                await this.delay(1500);
+            }
+            progress.succeed('All workflow steps completed');
+            // Section 4: Table formatting
+            this.log('\n' + colors.bold('═══ Section 4: Table Formatting ═══\n'));
+            const table = formatTable(['Epic', 'Status', 'Stories'], [
+                ['Epic 1', 'Done', '5'],
+                ['Epic 2', 'In Progress', '3'],
+                ['Epic 3', 'Pending', '0'],
+            ]);
+            this.log(table);
+            // Section 5: List formatting
+            this.log('\n' + colors.bold('═══ Section 5: List Formatting ═══\n'));
+            this.log(colors.info('Unordered list:'));
+            const unorderedList = formatList(['First item', 'Second item', 'Third item'], false);
+            this.log(unorderedList);
+            this.log('\n' + colors.info('Ordered list:'));
+            const orderedList = formatList(['Initialize project', 'Install dependencies', 'Run tests'], true);
+            this.log(orderedList);
+            // Section 6: Box formatting
+            this.log('\n' + colors.bold('═══ Section 6: Box Formatting ═══\n'));
+            const box = formatBox('Summary', `Total Epics: 3
+Success: 2
+Failed: 0
+Pending: 1`);
+            this.log(box);
+            // Section 7: Countdown timer
+            this.log('\n' + colors.bold('═══ Section 7: Countdown Timer ═══\n'));
+            this.log(colors.info('Countdown examples:'));
+            this.log(`  0 seconds:    ${formatCountdown(0)}`);
+            this.log(`  45 seconds:   ${formatCountdown(45)}`);
+            this.log(`  90 seconds:   ${formatCountdown(90)}`);
+            this.log(`  3600 seconds: ${formatCountdown(3600)}`);
+            this.log(`  3665 seconds: ${formatCountdown(3665)}`);
+            // Live countdown demonstration
+            this.log('\n' + colors.info('Live countdown (5 seconds):'));
+            const countdownSpinner = createSpinner('Next operation in...');
+            countdownSpinner.start();
+            // Sequential execution with await is intentional for demo
+            for (let i = 5; i > 0; i--) {
+                countdownSpinner.text = `Next operation in ${formatCountdown(i)}...`;
+                // eslint-disable-next-line no-await-in-loop
+                await this.delay(1000);
+            }
+            countdownSpinner.succeed('Countdown complete!');
+            // Final message
+            this.log('\n' + colors.success('Demo completed successfully!'));
+            logger.info({ correlationId }, 'Demo command completed');
+        }
+        catch (error) {
+            logger.error({ correlationId, error }, 'Demo command failed');
+            this.log('\n' + colors.error('Demo encountered an error'));
+            throw error;
+        }
+    }
+    /**
+     * Helper method to delay execution
+     *
+     * @param ms - Milliseconds to delay
+     */
+    async delay(ms) {
+        return new Promise((resolve) => {
+            setTimeout(resolve, ms);
+        });
+    }
+}

package/dist/commands/epics/create.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Epics Create Command
+ *
+ * Creates epic files from a PRD document using Claude AI agents.
+ * Supports batch processing with progress indicators and idempotent behavior.
+ *
+ * @example
+ * ```bash
+ * bmad-workflow epics create docs/prd.md
+ * bmad-workflow epics create docs/prd.md --start 2 --count 3
+ * bmad-workflow epics create docs/prd.md --reference docs/architecture.md
+ * ```
+ */
+import { Command } from '@oclif/core';
+/**
+ * Epics Create Command
+ *
+ * Creates epic markdown files from a PRD document by:
+ * 1. Parsing epics from PRD
+ * 2. Filtering based on flags (start, count)
+ * 3. Skipping existing epic files (idempotent)
+ * 4. Creating placeholder files
+ * 5. Running Claude AI agents to populate content
+ * 6. Displaying progress and summary
+ */
+export default class EpicsCreate extends Command {
+    static args: {
+        'prd-path': import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        count: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        interval: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        prefix: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        reference: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        start: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        agent: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        cwd: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        provider: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        task: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    /**
+     * AI agent runner service (Claude or Gemini)
+     */
+    private agentRunner;
+    /**
+     * File manager service
+     */
+    private fileManager;
+    /**
+     * File scaffolder service
+     */
+    private fileScaffolder;
+    /**
+     * Logger instance
+     */
+    private logger;
+    /**
+     * Path resolver service
+     */
+    private pathResolver;
+    /**
+     * PRD parser service
+     */
+    private prdParser;
+    /**
+     * Execute the command
+     */
+    run(): Promise<void>;
+    /**
+     * Build Claude CLI prompt for epic population
+     */
+    private buildClaudePrompt;
+    /**
+     * Check for existing epic files to support idempotent behavior
+     */
+    private checkExistingEpics;
+    /**
+     * Create epic files using Claude AI agents
+     */
+    private createEpics;
+    /**
+     * Create a single epic file
+     */
+    private createSingleEpic;
+    /**
+     * Display initial status before creating epics
+     */
+    private displayInitialStatus;
+    /**
+     * Display summary report after creating epics
+     */
+    private displaySummary;
+    /**
+     * Filter epics based on start and count flags
+     */
+    private filterEpics;
+    /**
+     * Generate epic filename from epic data
+     */
+    private generateEpicFileName;
+    /**
+     * Generate scaffolded content for epic file
+     */
+    private generateScaffoldedContent;
+    /**
+     * Initialize service dependencies
+     */
+    private initializeServices;
+    /**
+     * Parse PRD file and extract epics
+     */
+    private parsePrd;
+    /**
+     * Validate PRD path exists
+     */
+    private validatePrdPath;
+    /**
+     * Wait for specified interval with countdown
+     */
+    private waitInterval;
+}