@hivehub/rulebook 5.5.2 → 5.8.0

package/dist/cli/commands/ralph.js

@@ -1,694 +0,0 @@
-import chalk from 'chalk';
-import { writeFile, ensureDir } from '../../utils/file-system.js';
-import path from 'path';
-/**
- * Build prompt for AI agent from user story context
- */
-export function ralphBuildPrompt(task, prd, contextHistory, plansContext) {
-    const criteria = (task.acceptanceCriteria || []).map((c) => `- ${c}`).join('\n');
-    return [
-        `You are working on project: ${prd?.project || 'unknown'}`,
-        ``,
-        plansContext ? `## Session Context (PLANS.md)\n${plansContext}\n` : '',
-        contextHistory && contextHistory !== 'No iteration history available.'
-            ? `## Iteration History\n${contextHistory}\n`
-            : '',
-        `## Current Task: ${task.title}`,
-        `ID: ${task.id}`,
-        ``,
-        `## Description`,
-        task.description,
-        ``,
-        `## Acceptance Criteria`,
-        criteria,
-        ``,
-        task.notes ? `## Notes\n${task.notes}\n` : '',
-        `## Instructions`,
-        `1. Implement the changes described above`,
-        `2. Ensure all acceptance criteria are met`,
-        `3. Run quality checks: type-check, lint, tests`,
-        `4. Fix any issues found by quality checks`,
-        `5. When done, summarize what was changed`,
-    ]
-        .filter(Boolean)
-        .join('\n');
-}
-/**
- * Execute AI agent and capture output
- */
-export async function ralphExecuteAgent(tool, prompt, cwd, spawn) {
-    const toolCommands = {
-        claude: {
-            cmd: 'claude',
-            args: ['-p', '--dangerously-skip-permissions', '--verbose'],
-            stdinPrompt: true,
-        },
-        amp: { cmd: 'amp', args: ['-p', prompt], stdinPrompt: false },
-        gemini: { cmd: 'gemini', args: ['-p', prompt], stdinPrompt: false },
-    };
-    const config = toolCommands[tool] || toolCommands.claude;
-    return new Promise((resolve, reject) => {
-        let output = '';
-        let errorOutput = '';
-        const proc = spawn(config.cmd, config.args, {
-            cwd,
-            shell: true,
-            stdio: ['pipe', 'pipe', 'pipe'],
-            env: { ...process.env },
-        });
-        if (config.stdinPrompt && proc.stdin) {
-            proc.stdin.write(prompt);
-            proc.stdin.end();
-        }
-        proc.stdout?.on('data', (data) => {
-            const text = data.toString();
-            output += text;
-            process.stdout.write(text);
-        });
-        proc.stderr?.on('data', (data) => {
-            errorOutput += data.toString();
-        });
-        proc.on('close', (code) => {
-            if (code === 0 || output.length > 0) {
-                resolve(output || errorOutput);
-            }
-            else {
-                reject(new Error(`Agent ${tool} exited with code ${code}: ${errorOutput.slice(0, 500)}`));
-            }
-        });
-        proc.on('error', (err) => {
-            reject(new Error(`Failed to start ${tool}: ${err.message}`));
-        });
-        setTimeout(() => {
-            proc.kill('SIGTERM');
-            resolve(output || 'Agent execution timed out after 10 minutes');
-        }, 600000);
-    });
-}
-/**
- * Run quality gates and return results
- */
-export async function ralphRunQualityGates(cwd, spawn) {
-    const runGate = (cmd, args) => {
-        return new Promise((resolve) => {
-            const proc = spawn(cmd, args, {
-                cwd,
-                shell: true,
-                stdio: ['pipe', 'pipe', 'pipe'],
-            });
-            proc.on('close', (code) => {
-                resolve(code === 0);
-            });
-            proc.on('error', () => {
-                resolve(false);
-            });
-            setTimeout(() => {
-                proc.kill('SIGTERM');
-                resolve(false);
-            }, 120000);
-        });
-    };
-    const { detectMonorepo } = await import('../../core/detector.js');
-    const monorepo = await detectMonorepo(cwd).catch(() => ({
-        detected: false,
-        tool: null,
-        packages: [],
-    }));
-    let testCmd = ['npm', ['test']];
-    if (monorepo.detected) {
-        if (monorepo.tool === 'turborepo')
-            testCmd = ['turbo', ['run', 'test']];
-        else if (monorepo.tool === 'nx')
-            testCmd = ['nx', ['run-many', '--target=test']];
-    }
-    const [typeCheck, lint, tests] = await Promise.all([
-        runGate('npm', ['run', 'type-check']),
-        runGate('npm', ['run', 'lint']),
-        runGate(testCmd[0], testCmd[1]),
-    ]);
-    return {
-        type_check: typeCheck,
-        lint: lint,
-        tests: tests,
-        coverage_met: tests,
-    };
-}
-/**
- * Create git branch from PRD branchName
- */
-export async function ralphCreateBranch(cwd, branchName) {
-    const { readFileSync } = await import('fs');
-    const { spawn } = await import('child_process');
-    try {
-        const gitHeadPath = path.join(cwd, '.git', 'HEAD');
-        const head = readFileSync(gitHeadPath, 'utf8').trim();
-        const currentBranch = head.replace('ref: refs/heads/', '');
-        if (currentBranch === branchName) {
-            return;
-        }
-    }
-    catch {
-        return;
-    }
-    await new Promise((resolve) => {
-        const proc = spawn('git', ['checkout', '-B', branchName], {
-            cwd,
-            shell: true,
-            stdio: 'pipe',
-        });
-        proc.on('close', () => resolve());
-        proc.on('error', () => resolve());
-    });
-}
-/**
- * Commit changes after successful iteration
- */
-export async function ralphGitCommit(cwd, task, iteration, spawn) {
-    await new Promise((resolve) => {
-        const proc = spawn('git', ['add', '-A'], { cwd, shell: true, stdio: 'pipe' });
-        proc.on('close', () => resolve());
-        proc.on('error', () => resolve());
-    });
-    const hasChanges = await new Promise((resolve) => {
-        let output = '';
-        const proc = spawn('git', ['diff', '--cached', '--stat'], {
-            cwd,
-            shell: true,
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        proc.stdout?.on('data', (data) => {
-            output += data.toString();
-        });
-        proc.on('close', () => resolve(output.trim().length > 0));
-        proc.on('error', () => resolve(false));
-    });
-    if (!hasChanges) {
-        return undefined;
-    }
-    const commitMsg = `ralph(${task.id}): ${task.title}\n\nIteration ${iteration} - Ralph autonomous loop`;
-    const commitHash = await new Promise((resolve) => {
-        let output = '';
-        const proc = spawn('git', ['commit', '-m', commitMsg], {
-            cwd,
-            shell: true,
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        proc.stdout?.on('data', (data) => {
-            output += data.toString();
-        });
-        proc.on('close', (code) => {
-            if (code === 0) {
-                const hashMatch = output.match(/\[[\w/.-]+ ([a-f0-9]+)\]/);
-                resolve(hashMatch ? hashMatch[1] : undefined);
-            }
-            else {
-                resolve(undefined);
-            }
-        });
-        proc.on('error', () => resolve(undefined));
-    });
-    return commitHash;
-}
-export async function ralphInitCommand() {
-    const oraModule = await import('ora');
-    const ora = oraModule.default;
-    const spinner = ora('Initializing Ralph autonomous loop...').start();
-    try {
-        const cwd = process.cwd();
-        const { Logger } = await import('../../core/logger.js');
-        const { RalphManager } = await import('../../core/ralph-manager.js');
-        const { PRDGenerator } = await import('../../core/prd-generator.js');
-        const { createConfigManager } = await import('../../core/config-manager.js');
-        const logger = new Logger(cwd);
-        const configManager = createConfigManager(cwd);
-        const config = await configManager.loadConfig();
-        const ralphManager = new RalphManager(cwd, logger);
-        const prdGenerator = new PRDGenerator(cwd, logger);
-        const maxIterations = config.ralph?.maxIterations || 10;
-        const tool = (config.ralph?.tool || 'claude');
-        await ralphManager.initialize(maxIterations, tool);
-        const prd = await prdGenerator.generatePRD(path.basename(cwd));
-        const prdPath = path.join(cwd, '.rulebook', 'ralph', 'prd.json');
-        await writeFile(prdPath, JSON.stringify(prd, null, 2));
-        spinner.succeed(`Ralph initialized: ${prd.userStories.length} user stories loaded`);
-        console.log(`\n  📋 PRD: ${prdPath}`);
-        console.log(`  🔄 Max iterations: ${maxIterations}`);
-        console.log(`  🤖 AI Tool: ${tool}`);
-        console.log(`\n  Run: ${chalk.bold('rulebook ralph run')}\n`);
-    }
-    catch (error) {
-        spinner.fail('Ralph initialization failed');
-        console.error(chalk.red(String(error)));
-        process.exit(1);
-    }
-}
-export async function ralphRunCommand(options) {
-    const oraModule = await import('ora');
-    const ora = oraModule.default;
-    const spinner = ora('Starting Ralph autonomous loop...').start();
-    try {
-        const cwd = process.cwd();
-        const { Logger } = await import('../../core/logger.js');
-        const { RalphManager } = await import('../../core/ralph-manager.js');
-        const { RalphParser } = await import('../../agents/ralph-parser.js');
-        const { createConfigManager } = await import('../../core/config-manager.js');
-        const { IterationTracker } = await import('../../core/iteration-tracker.js');
-        const childProcess = await import('child_process');
-        const logger = new Logger(cwd);
-        const configManager = createConfigManager(cwd);
-        const config = await configManager.loadConfig();
-        const ralphManager = new RalphManager(cwd, logger);
-        const maxIterations = options.maxIterations || config.ralph?.maxIterations || 10;
-        const tool = options.tool || config.ralph?.tool || 'claude';
-        const parallelWorkers = options.parallel ??
-            (config.ralph?.parallel?.enabled ? config.ralph.parallel.maxWorkers : undefined);
-        const planCheckpointConfig = {
-            enabled: options.planFirst ?? config.ralph?.planCheckpoint?.enabled ?? false,
-            autoApproveAfterSeconds: config.ralph?.planCheckpoint?.autoApproveAfterSeconds ?? 0,
-            requireApprovalForStories: config.ralph?.planCheckpoint?.requireApprovalForStories ?? 'all',
-        };
-        const compressionConfig = config.ralph?.contextCompression;
-        const compressionEnabled = compressionConfig?.enabled !== false;
-        const compressionRecentCount = compressionConfig?.recentCount ?? 3;
-        const compressionThreshold = compressionConfig?.threshold ?? 5;
-        const iterationTracker = new IterationTracker(cwd, logger);
-        await iterationTracker.initialize();
-        await ralphManager.initialize(maxIterations, tool);
-        const prd = await ralphManager.loadPRD();
-        if (prd?.branchName) {
-            await ralphCreateBranch(cwd, prd.branchName);
-        }
-        let interrupted = false;
-        const handleInterrupt = async () => {
-            interrupted = true;
-            spinner.warn('Pausing after current iteration...');
-            await ralphManager.pause();
-        };
-        process.on('SIGINT', handleInterrupt);
-        await ralphManager.refreshTaskCount();
-        if (parallelWorkers && parallelWorkers > 1) {
-            spinner.text = `Ralph parallel mode (${parallelWorkers} workers)...`;
-            const batches = await ralphManager.getParallelBatches(parallelWorkers);
-            spinner.stop();
-            console.log(chalk.bold.cyan(`\n  Parallel mode: ${batches.length} batch(es), max ${parallelWorkers} workers\n`));
-            let iterationCount = 0;
-            for (const batch of batches) {
-                if (interrupted)
-                    break;
-                console.log(chalk.bold(`  ── Batch: ${batch.map((s) => s.id).join(', ')} (${batch.length} stories) ──`));
-                const batchResults = await Promise.allSettled(batch.map(async (task) => {
-                    iterationCount++;
-                    const localIteration = iterationCount;
-                    const startTime = Date.now();
-                    let contextHistory = '';
-                    if (compressionEnabled) {
-                        contextHistory = await iterationTracker.buildCompressedContext(compressionRecentCount, compressionThreshold);
-                    }
-                    let plansContext = '';
-                    try {
-                        const { readPlans, plansExists } = await import('../../core/plans-manager.js');
-                        if (plansExists(cwd)) {
-                            const plans = await readPlans(cwd);
-                            if (plans?.context && plans.context.trim()) {
-                                plansContext = plans.context.trim();
-                            }
-                        }
-                    }
-                    catch {
-                        // PLANS.md injection is optional
-                    }
-                    const prompt = ralphBuildPrompt(task, prd, contextHistory, plansContext);
-                    let agentOutput = '';
-                    try {
-                        agentOutput = await ralphExecuteAgent(tool, prompt, cwd, childProcess.spawn);
-                    }
-                    catch (agentError) {
-                        agentOutput = `Error executing agent: ${agentError.message || agentError}`;
-                    }
-                    const qualityResults = await ralphRunQualityGates(cwd, childProcess.spawn);
-                    const executionTime = Date.now() - startTime;
-                    const parsed = RalphParser.parseAgentOutput(agentOutput, localIteration, task.id, task.title, tool);
-                    const allGatesPass = qualityResults.type_check &&
-                        qualityResults.lint &&
-                        qualityResults.tests &&
-                        qualityResults.coverage_met;
-                    const passCount = Object.values(qualityResults).filter(Boolean).length;
-                    const status = allGatesPass
-                        ? 'success'
-                        : passCount >= 2
-                            ? 'partial'
-                            : 'failed';
-                    let gitCommit;
-                    if (allGatesPass) {
-                        gitCommit = await ralphGitCommit(cwd, task, localIteration, childProcess.spawn);
-                        await ralphManager.markStoryComplete(task.id);
-                        console.log(chalk.green(`    [parallel] Story ${task.id} completed`));
-                    }
-                    else {
-                        console.log(chalk.yellow(`    [parallel] Story ${task.id} not completed (quality gates failed)`));
-                    }
-                    const result = {
-                        iteration: localIteration,
-                        timestamp: new Date().toISOString(),
-                        task_id: task.id,
-                        task_title: task.title,
-                        status,
-                        ai_tool: tool,
-                        execution_time_ms: executionTime,
-                        quality_checks: qualityResults,
-                        output_summary: parsed.output_summary || `Iteration ${localIteration}: ${task.title}`,
-                        git_commit: gitCommit,
-                        learnings: parsed.learnings,
-                        errors: parsed.errors,
-                        metadata: {
-                            context_loss_count: parsed.metadata.context_loss_count,
-                            parsed_completion: parsed.metadata.parsed_completion,
-                        },
-                    };
-                    await ralphManager.recordIteration(result);
-                    return result;
-                }));
-                for (const [i, result] of batchResults.entries()) {
-                    if (result.status === 'rejected') {
-                        const story = batch[i];
-                        console.log(chalk.red(`    [parallel] Story ${story.id} threw: ${result.reason}`));
-                    }
-                }
-                const currentStatus = await ralphManager.getStatus();
-                if (currentStatus?.paused)
-                    break;
-            }
-            process.removeListener('SIGINT', handleInterrupt);
-            const stats = await ralphManager.getTaskStats();
-            console.log(`\n  Parallel run complete: ${stats.completed}/${stats.total} tasks completed`);
-            console.log(`  Iterations: ${iterationCount}`);
-            if (interrupted) {
-                console.log(chalk.yellow(`  Paused by user. Resume: ${chalk.bold('rulebook ralph resume')}`));
-            }
-            console.log(`\n  View history: ${chalk.bold('rulebook ralph history')}\n`);
-            return;
-        }
-        spinner.text = 'Ralph loop running (Ctrl+C to pause)...';
-        let iterationCount = 0;
-        while (ralphManager.canContinue() && !interrupted) {
-            iterationCount++;
-            const task = await ralphManager.getNextTask();
-            if (!task) {
-                break;
-            }
-            spinner.stop();
-            console.log(chalk.bold.cyan(`\n  ── Iteration ${iterationCount}: ${task.title} ──\n`));
-            const startTime = Date.now();
-            if (planCheckpointConfig.enabled) {
-                const checkpoint = await ralphManager.runCheckpoint(task, tool, planCheckpointConfig);
-                if (!checkpoint.proceed) {
-                    console.log(chalk.yellow(`  Plan rejected for ${task.id}. Skipping implementation.`));
-                    if (checkpoint.feedback) {
-                        console.log(chalk.gray(`  Feedback: ${checkpoint.feedback}`));
-                    }
-                    spinner.start('Preparing next iteration...');
-                    continue;
-                }
-            }
-            let contextHistory = '';
-            if (compressionEnabled) {
-                contextHistory = await iterationTracker.buildCompressedContext(compressionRecentCount, compressionThreshold);
-            }
-            let plansContext = '';
-            try {
-                const { readPlans, plansExists } = await import('../../core/plans-manager.js');
-                if (plansExists(cwd)) {
-                    const plans = await readPlans(cwd);
-                    if (plans?.context && plans.context.trim()) {
-                        plansContext = plans.context.trim();
-                    }
-                }
-            }
-            catch {
-                // PLANS.md injection is optional — skip on error
-            }
-            const prompt = ralphBuildPrompt(task, prd, contextHistory, plansContext);
-            let agentOutput = '';
-            try {
-                agentOutput = await ralphExecuteAgent(tool, prompt, cwd, childProcess.spawn);
-            }
-            catch (agentError) {
-                agentOutput = `Error executing agent: ${agentError.message || agentError}`;
-                console.log(chalk.red(`  Agent error: ${agentError.message || agentError}`));
-            }
-            spinner.start('Running quality gates...');
-            const qualityResults = await ralphRunQualityGates(cwd, childProcess.spawn);
-            spinner.stop();
-            const gateIcon = (pass) => (pass ? chalk.green('✓') : chalk.red('✗'));
-            console.log(`  ${gateIcon(qualityResults.type_check)} type-check`);
-            console.log(`  ${gateIcon(qualityResults.lint)} lint`);
-            console.log(`  ${gateIcon(qualityResults.tests)} tests`);
-            console.log(`  ${gateIcon(qualityResults.coverage_met)} coverage`);
-            const executionTime = Date.now() - startTime;
-            const parsed = RalphParser.parseAgentOutput(agentOutput, iterationCount, task.id, task.title, tool);
-            const allGatesPass = qualityResults.type_check &&
-                qualityResults.lint &&
-                qualityResults.tests &&
-                qualityResults.coverage_met;
-            const passCount = Object.values(qualityResults).filter(Boolean).length;
-            const status = allGatesPass
-                ? 'success'
-                : passCount >= 2
-                    ? 'partial'
-                    : 'failed';
-            let gitCommit;
-            if (allGatesPass) {
-                gitCommit = await ralphGitCommit(cwd, task, iterationCount, childProcess.spawn);
-                await ralphManager.markStoryComplete(task.id);
-                console.log(chalk.green(`\n  ✅ Story ${task.id} completed`));
-            }
-            else {
-                console.log(chalk.yellow(`\n  ⚠ Story ${task.id} not completed (quality gates failed)`));
-            }
-            const result = {
-                iteration: iterationCount,
-                timestamp: new Date().toISOString(),
-                task_id: task.id,
-                task_title: task.title,
-                status,
-                ai_tool: tool,
-                execution_time_ms: executionTime,
-                quality_checks: qualityResults,
-                output_summary: parsed.output_summary || `Iteration ${iterationCount}: ${task.title}`,
-                git_commit: gitCommit,
-                learnings: parsed.learnings,
-                errors: parsed.errors,
-                metadata: {
-                    context_loss_count: parsed.metadata.context_loss_count,
-                    parsed_completion: parsed.metadata.parsed_completion,
-                },
-            };
-            await ralphManager.recordIteration(result);
-            spinner.start('Preparing next iteration...');
-        }
-        process.removeListener('SIGINT', handleInterrupt);
-        const stats = await ralphManager.getTaskStats();
-        spinner.succeed(`Ralph loop complete: ${stats.completed}/${stats.total} tasks completed`);
-        console.log(`\n  ✅ Iterations: ${iterationCount}`);
-        console.log(`  📊 Completed: ${stats.completed}/${stats.total}`);
-        if (interrupted) {
-            console.log(chalk.yellow(`  ⏸  Paused by user. Resume: ${chalk.bold('rulebook ralph resume')}`));
-        }
-        console.log(`\n  View history: ${chalk.bold('rulebook ralph history')}\n`);
-    }
-    catch (error) {
-        spinner.fail('Ralph loop failed');
-        console.error(chalk.red(String(error)));
-        process.exit(1);
-    }
-}
-export async function ralphStatusCommand() {
-    const oraModule = await import('ora');
-    const ora = oraModule.default;
-    const spinner = ora('Loading Ralph status...').start();
-    try {
-        const cwd = process.cwd();
-        const { Logger } = await import('../../core/logger.js');
-        const { RalphManager } = await import('../../core/ralph-manager.js');
-        const logger = new Logger(cwd);
-        const ralphManager = new RalphManager(cwd, logger);
-        const status = await ralphManager.getStatus();
-        if (!status) {
-            spinner.fail('Ralph not initialized');
-            console.log(`\n  Run: ${chalk.bold('rulebook ralph init')}\n`);
-            return;
-        }
-        spinner.stop();
-        const { createConfigManager } = await import('../../core/config-manager.js');
-        const configManager = createConfigManager(cwd);
-        const cfg = await configManager.loadConfig();
-        const agentsMode = cfg.agentsMode ?? 'full';
-        console.log(`\n  ${chalk.bold('Ralph Loop Status')}`);
-        console.log(`  Iteration:    ${status.current_iteration}/${status.max_iterations}`);
-        console.log(`  Tasks:        ${status.completed_tasks}/${status.total_tasks}`);
-        console.log(`  Status:       ${status.paused ? chalk.yellow('PAUSED') : chalk.green('RUNNING')}`);
-        console.log(`  AI Tool:      ${status.tool}`);
-        console.log(`  Started:      ${new Date(status.started_at).toLocaleString()}`);
-        console.log(`  Agents Mode:  ${agentsMode === 'lean' ? chalk.cyan('lean') : chalk.gray('full')} (rulebook mode set lean|full)`);
-        console.log();
-    }
-    catch (error) {
-        spinner.fail('Failed to load status');
-        console.error(chalk.red(String(error)));
-        process.exit(1);
-    }
-}
-export async function ralphHistoryCommand(options) {
-    const oraModule = await import('ora');
-    const ora = oraModule.default;
-    const spinner = ora('Loading iteration history...').start();
-    try {
-        const cwd = process.cwd();
-        const { Logger } = await import('../../core/logger.js');
-        const { IterationTracker } = await import('../../core/iteration-tracker.js');
-        const logger = new Logger(cwd);
-        const tracker = new IterationTracker(cwd, logger);
-        const limit = options.limit || 10;
-        const history = await tracker.getHistory(limit);
-        if (history.length === 0) {
-            spinner.fail('No iteration history found');
-            return;
-        }
-        spinner.stop();
-        console.log(`\n  ${chalk.bold('Recent Iterations')} (${history.length})\n`);
-        for (const iter of history) {
-            const statusIcon = iter.status === 'success'
-                ? chalk.green('✓')
-                : iter.status === 'partial'
-                    ? chalk.yellow('◐')
-                    : chalk.red('✗');
-            console.log(`  ${statusIcon} Iteration ${iter.iteration}: ${iter.task_title}`);
-            console.log(`     Status: ${iter.status} | Duration: ${(iter.duration_ms || 0) / 1000}s`);
-            console.log(`     Checks: type=${iter.quality_checks.type_check ? '✓' : '✗'} lint=${iter.quality_checks.lint ? '✓' : '✗'} tests=${iter.quality_checks.tests ? '✓' : '✗'}`);
-            if (iter.git_commit) {
-                console.log(`     Commit: ${iter.git_commit}`);
-            }
-            console.log();
-        }
-        const stats = await tracker.getStatistics();
-        console.log(`  ${chalk.bold('Statistics')}`);
-        console.log(`  Total: ${stats.total_iterations} | Success: ${stats.successful_iterations} | Failed: ${stats.failed_iterations}`);
-        console.log(`  Success rate: ${(stats.success_rate * 100).toFixed(1)}%`);
-        console.log(`  Avg duration: ${stats.average_duration_ms}ms\n`);
-    }
-    catch (error) {
-        spinner.fail('Failed to load history');
-        console.error(chalk.red(String(error)));
-        process.exit(1);
-    }
-}
-export async function ralphPauseCommand() {
-    const oraModule = await import('ora');
-    const ora = oraModule.default;
-    const spinner = ora('Pausing Ralph loop...').start();
-    try {
-        const cwd = process.cwd();
-        const { Logger } = await import('../../core/logger.js');
-        const { RalphManager } = await import('../../core/ralph-manager.js');
-        const logger = new Logger(cwd);
-        const ralphManager = new RalphManager(cwd, logger);
-        const status = await ralphManager.getStatus();
-        if (!status) {
-            spinner.fail('Ralph not initialized');
-            console.log(`\n  Run: ${chalk.bold('rulebook ralph init')}\n`);
-            return;
-        }
-        await ralphManager.pause();
-        spinner.succeed('Ralph loop paused');
-        console.log(`\n  Resume with: ${chalk.bold('rulebook ralph resume')}\n`);
-    }
-    catch (error) {
-        spinner.fail('Failed to pause');
-        console.error(chalk.red(String(error)));
-        process.exit(1);
-    }
-}
-export async function ralphResumeCommand() {
-    const oraModule = await import('ora');
-    const ora = oraModule.default;
-    const spinner = ora('Resuming Ralph loop...').start();
-    try {
-        const cwd = process.cwd();
-        const { Logger } = await import('../../core/logger.js');
-        const { RalphManager } = await import('../../core/ralph-manager.js');
-        const logger = new Logger(cwd);
-        const ralphManager = new RalphManager(cwd, logger);
-        const status = await ralphManager.getStatus();
-        if (!status) {
-            spinner.fail('Ralph not initialized');
-            console.log(`\n  Run: ${chalk.bold('rulebook ralph init')}\n`);
-            return;
-        }
-        await ralphManager.resume();
-        spinner.succeed('Ralph loop resumed');
-        console.log(`\n  Continue loop: ${chalk.bold('rulebook ralph run')}\n`);
-    }
-    catch (error) {
-        spinner.fail('Failed to resume');
-        console.error(chalk.red(String(error)));
-        process.exit(1);
-    }
-}
-export async function ralphImportIssuesCommand(options) {
-    const oraModule = await import('ora');
-    const ora = oraModule.default;
-    try {
-        const { checkGhCliAvailable, fetchGithubIssues, convertIssueToStory, mergeStoriesIntoExistingPrd, } = await import('../../core/github-issues-importer.js');
-        const ghAvailable = await checkGhCliAvailable();
-        if (!ghAvailable) {
-            console.error(chalk.red('GitHub CLI (gh) is not installed. Install it from: https://cli.github.com'));
-            return;
-        }
-        const spinner = ora('Fetching GitHub issues...').start();
-        const issues = await fetchGithubIssues({
-            label: options.label,
-            milestone: options.milestone,
-            limit: options.limit ?? 20,
-        });
-        if (issues.length === 0) {
-            spinner.info('No open issues found matching the given filters.');
-            return;
-        }
-        spinner.text = `Converting ${issues.length} issues to Ralph stories...`;
-        const cwd = process.cwd();
-        let existingPrd = null;
-        try {
-            const { RalphManager } = await import('../../core/ralph-manager.js');
-            const { Logger } = await import('../../core/logger.js');
-            const logger = new Logger(cwd);
-            const manager = new RalphManager(cwd, logger);
-            existingPrd = await manager.loadPRD();
-        }
-        catch {
-            // PRD not initialized — will create a new one
-        }
-        const newStories = issues.map((issue) => convertIssueToStory(issue));
-        const { prd: mergedPrd, result } = mergeStoriesIntoExistingPrd(existingPrd, newStories);
-        if (options.dryRun) {
-            spinner.stop();
-            console.log(chalk.yellow(`Dry run — would import ${result.imported} stories, update ${result.updated}, skip ${result.skipped}`));
-            console.log('');
-            for (const story of mergedPrd.userStories) {
-                const marker = story.passes ? chalk.green('[PASS]') : chalk.gray('[    ]');
-                console.log(`  ${marker} ${story.id}: ${story.title}`);
-            }
-            return;
-        }
-        const prdPath = path.join(cwd, '.rulebook', 'ralph', 'prd.json');
-        await ensureDir(path.join(cwd, '.rulebook', 'ralph'));
-        await writeFile(prdPath, JSON.stringify(mergedPrd, null, 2));
-        spinner.succeed(`Imported ${result.imported} new stories, updated ${result.updated} existing, ${result.skipped} skipped`);
-        console.log(`\n  PRD saved to: ${prdPath}`);
-        console.log(`  Total stories: ${mergedPrd.userStories.length}\n`);
-    }
-    catch (error) {
-        console.error(chalk.red(`Failed to import GitHub issues: ${String(error)}`));
-        process.exit(1);
-    }
-}
-//# sourceMappingURL=ralph.js.map