gameforge-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,830 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const picocolors_1 = __importDefault(require("picocolors"));
+const dotenv_1 = __importDefault(require("dotenv"));
+const ora_1 = __importDefault(require("ora"));
+const enquirer_1 = __importDefault(require("enquirer"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const StateMachine_1 = require("./core/StateMachine");
+const SessionManager_1 = require("./core/SessionManager");
+const costTracker_1 = require("./utils/costTracker");
+const modelSelector_1 = require("./utils/modelSelector");
+const fileManager_1 = require("./utils/fileManager");
+const budget_1 = require("./config/budget");
+const templates_1 = require("./config/templates");
+const Inquisitor_1 = require("./agents/core/Inquisitor");
+const Architect_1 = require("./agents/core/Architect");
+const Consistency_1 = require("./agents/core/Consistency");
+const Chaos_1 = require("./agents/core/Chaos");
+const Remediation_1 = require("./agents/core/Remediation");
+const FeatureSpecialist_1 = require("./agents/specialists/FeatureSpecialist");
+const EntitySpecialist_1 = require("./agents/specialists/EntitySpecialist");
+const TechSpecialist_1 = require("./agents/specialists/TechSpecialist");
+const CreativeSpecialist_1 = require("./agents/specialists/CreativeSpecialist");
+const Orchestrator_1 = require("./core/Orchestrator");
+const debugLogger_1 = require("./utils/debugLogger");
+dotenv_1.default.config();
+const program = new commander_1.Command();
+program
+    .name('gameforge')
+    .description('AI-powered Game Design Document generator')
+    .version('0.1.0');
+program
+    .command('create')
+    .description('Create a new game design document')
+    .option('-b, --budget <tier>', 'Budget tier: quick | standard | deep', 'standard')
+    .option('-t, --template <id>', 'Start from template')
+    .option('-d, --debug', 'Enable debug logging to file')
+    .action(async (options) => {
+    await runCreationFlow(options);
+});
+program
+    .command('resume <checkpointId>')
+    .description('Resume from a saved checkpoint')
+    .option('-d, --debug', 'Enable debug logging to file')
+    .action(async (checkpointId, options) => {
+    await resumeFlow(checkpointId, options);
+});
+program
+    .command('sessions')
+    .description('List all saved sessions')
+    .action(async () => {
+    await listSessions();
+});
+program
+    .command('session <sessionId>')
+    .description('Show details and checkpoints for a session')
+    .action(async (sessionId) => {
+    await showSession(sessionId);
+});
+program
+    .command('templates')
+    .description('List available genre templates')
+    .action(() => {
+    console.log(picocolors_1.default.cyan('\n📚 Available Templates\n'));
+    templates_1.GENRE_TEMPLATES.forEach(template => {
+        console.log(picocolors_1.default.green(`${template.id}`));
+        console.log(picocolors_1.default.bold(`  ${template.name}`));
+        console.log(picocolors_1.default.dim(`  ${template.description}`));
+        console.log(picocolors_1.default.dim(`  Tags: ${template.tags.join(', ')}`));
+        console.log(picocolors_1.default.dim(`  Features: ${template.partialBible.features?.length || 0}\n`));
+    });
+    console.log(picocolors_1.default.dim('Usage: gameforge create --template <id>\n'));
+});
+program.parse();
+async function runCreationFlow(options) {
+    console.clear();
+    console.log(picocolors_1.default.cyan('\n╔══════════════════════════════╗'));
+    console.log(picocolors_1.default.cyan('║       GameForge CLI          ║'));
+    console.log(picocolors_1.default.cyan('╚══════════════════════════════╝\n'));
+    console.log(picocolors_1.default.dim('AI-Powered Game Design Documents\n'));
+    // Enable debug logging if requested
+    if (options.debug) {
+        const projectId = `gameforge-${Date.now()}`;
+        debugLogger_1.debugLogger.enable(projectId);
+        console.log(picocolors_1.default.yellow(`🐛 Debug mode enabled`));
+        console.log(picocolors_1.default.dim(`   Log file: ${debugLogger_1.debugLogger.getLogFilePath()}\n`));
+    }
+    // Setup
+    const budgetTier = budget_1.BUDGET_TIERS[options.budget];
+    if (!budgetTier) {
+        console.error(picocolors_1.default.red(`Unknown budget tier: ${options.budget}`));
+        console.log(picocolors_1.default.dim('Available tiers: quick, standard, deep'));
+        process.exit(1);
+    }
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+        console.error(picocolors_1.default.red('Error: ANTHROPIC_API_KEY not set in .env'));
+        console.log(picocolors_1.default.yellow('\nPlease create a .env file with your Anthropic API key:'));
+        console.log(picocolors_1.default.dim('ANTHROPIC_API_KEY=your_api_key_here\n'));
+        process.exit(1);
+    }
+    // Prompt for session title
+    const { title } = await enquirer_1.default.prompt({
+        type: 'input',
+        name: 'title',
+        message: 'Session name (e.g., "My Card Game", "RPG Project"):',
+        initial: 'New Game Design'
+    });
+    const costTracker = new costTracker_1.CostTracker(budgetTier.maxBudget);
+    const modelSelector = new modelSelector_1.ModelSelector();
+    const stateMachine = new StateMachine_1.StateMachine(budgetTier.maxBudget);
+    const sessionManager = new SessionManager_1.SessionManager();
+    const fileManager = new fileManager_1.FileManager();
+    // Create a new session
+    const sessionId = await sessionManager.createSession(title);
+    const projectId = sessionId; // Use session ID as project ID for consistency
+    console.log(picocolors_1.default.green(`\n✓ Session created: ${sessionId}`));
+    console.log(picocolors_1.default.green(`Budget: ${budgetTier.name} ($${budgetTier.maxBudget})`));
+    console.log(picocolors_1.default.dim(`Model: ${budgetTier.preferredModel}\n`));
+    try {
+        // Check if template was requested
+        let selectedTemplate = null;
+        if (options.template) {
+            selectedTemplate = templates_1.GENRE_TEMPLATES.find(t => t.id === options.template);
+            if (!selectedTemplate) {
+                console.error(picocolors_1.default.red(`Template not found: ${options.template}`));
+                console.log(picocolors_1.default.yellow('\nAvailable templates:'));
+                templates_1.GENRE_TEMPLATES.forEach(t => {
+                    console.log(picocolors_1.default.dim(`  - ${t.id}: ${t.name}`));
+                });
+                process.exit(1);
+            }
+            console.log(picocolors_1.default.green(`Using template: ${selectedTemplate.name}`));
+            console.log(picocolors_1.default.dim(`${selectedTemplate.description}\n`));
+        }
+        // Phase 1: Discovery
+        console.log(picocolors_1.default.cyan('\n📋 Phase 1: Discovery\n'));
+        stateMachine.transition(StateMachine_1.GameForgePhase.DISCOVERY);
+        const inquisitor = new Inquisitor_1.Inquisitor(apiKey, costTracker, modelSelector);
+        const questions = getInquisitorQuestions(options.template);
+        const transcript = await inquisitor.execute(questions);
+        transcript.forEach(entry => {
+            stateMachine.addTranscriptEntry(entry.question, entry.answer, entry.autoGenerated);
+        });
+        // Gate 1: Review Concept
+        console.log(picocolors_1.default.cyan('\n📊 Concept Review\n'));
+        stateMachine.transition(StateMachine_1.GameForgePhase.REVIEW_CONCEPT);
+        showConceptBrief(transcript);
+        const proceed1 = await confirmGate('Proceed to architecture phase?');
+        if (!proceed1) {
+            console.log(picocolors_1.default.yellow('Exiting...'));
+            return;
+        }
+        await sessionManager.saveCheckpoint(sessionId, stateMachine.getState(), 'after_discovery');
+        // Phase 2: Architecture
+        console.log(picocolors_1.default.cyan('\n🏗️  Phase 2: Architecture\n'));
+        stateMachine.transition(StateMachine_1.GameForgePhase.ARCHITECTURE);
+        const spinner = (0, ora_1.default)('Generating Game Bible...').start();
+        const architect = new Architect_1.Architect(apiKey, costTracker, modelSelector);
+        let bible = await architect.execute(transcript, (message) => {
+            spinner.text = `Generating Game Bible: ${message}`;
+        });
+        // Merge template features if a template was selected
+        if (selectedTemplate && selectedTemplate.partialBible.features) {
+            console.log(picocolors_1.default.dim(`  Merging ${selectedTemplate.partialBible.features.length} template features...`));
+            bible.features = [...selectedTemplate.partialBible.features, ...bible.features];
+        }
+        stateMachine.updateBible(bible);
+        spinner.succeed('Game Bible generated');
+        // Save checkpoint
+        await sessionManager.saveCheckpoint(sessionId, stateMachine.getState(), 'after_architecture');
+        // Gate 2: Review Data
+        console.log(picocolors_1.default.cyan('\n📊 Data Review\n'));
+        stateMachine.transition(StateMachine_1.GameForgePhase.REVIEW_DATA);
+        console.log(picocolors_1.default.green(`✓ Generated ${bible.features.length} features`));
+        console.log(picocolors_1.default.green(`✓ Generated ${bible.gameObjects.length} game objects`));
+        const proceed2 = await confirmGate('Proceed to production phase?');
+        if (!proceed2) {
+            console.log(picocolors_1.default.yellow('Exiting...'));
+            return;
+        }
+        // Phase 3: Production (Specialists)
+        console.log(picocolors_1.default.cyan('\n🎨 Phase 3: Production\n'));
+        stateMachine.transition(StateMachine_1.GameForgePhase.PRODUCTION);
+        const orchestrator = new Orchestrator_1.SpecialistOrchestrator(2); // Concurrency of 2
+        const specialists = [
+            { name: 'Creative Direction', agent: new CreativeSpecialist_1.CreativeSpecialist(apiKey, costTracker, modelSelector) },
+            { name: 'Feature Specifications', agent: new FeatureSpecialist_1.FeatureSpecialist(apiKey, costTracker, modelSelector) },
+            { name: 'Entity Specifications', agent: new EntitySpecialist_1.EntitySpecialist(apiKey, costTracker, modelSelector) },
+            { name: 'Technical Specifications', agent: new TechSpecialist_1.TechSpecialist(apiKey, costTracker, modelSelector) }
+        ];
+        let markdownSections = await orchestrator.runAllSpecialists(bible, specialists);
+        // Phase 4: Validation
+        console.log(picocolors_1.default.cyan('\n✅ Phase 4: Validation\n'));
+        stateMachine.transition(StateMachine_1.GameForgePhase.VALIDATION);
+        // Run consistency check
+        const consistencyAgent = new Consistency_1.ConsistencyAgent();
+        let currentConsistencyIssues = consistencyAgent.validate(bible);
+        console.log(picocolors_1.default.yellow(`Found ${currentConsistencyIssues.length} consistency issues`));
+        // Run chaos analysis
+        let chaosSpinner = (0, ora_1.default)('Running Chaos Agent...').start();
+        const chaosAgent = new Chaos_1.Chaos(apiKey, costTracker, modelSelector);
+        let currentChaosIssues = await chaosAgent.execute(bible, (message) => {
+            chaosSpinner.text = `Chaos Agent: ${message}`;
+        });
+        chaosSpinner.succeed(`Found ${currentChaosIssues.length} design issues`);
+        // Gate 3: Review Issues with Fix Option
+        const MAX_FIX_ATTEMPTS = 3;
+        let fixAttempts = 0;
+        let fixesApplied = false;
+        while (true) {
+            stateMachine.transition(StateMachine_1.GameForgePhase.REVIEW_ISSUES);
+            const totalIssues = currentConsistencyIssues.length + currentChaosIssues.length;
+            if (totalIssues > 0) {
+                console.log(picocolors_1.default.yellow(`\n⚠️  ${totalIssues} issues found:`));
+                currentConsistencyIssues.slice(0, 3).forEach((issue) => {
+                    console.log(picocolors_1.default.dim(`  - [${issue.severity}] ${issue.message}`));
+                });
+                currentChaosIssues.slice(0, 3).forEach((issue) => {
+                    console.log(picocolors_1.default.dim(`  - [${issue.severity}] ${issue.description}`));
+                });
+                if (totalIssues > 6) {
+                    console.log(picocolors_1.default.dim(`  ... and ${totalIssues - 6} more issues`));
+                }
+                if (fixAttempts > 0) {
+                    console.log(picocolors_1.default.cyan(`\n(Fix attempt ${fixAttempts}/${MAX_FIX_ATTEMPTS} complete)`));
+                }
+            }
+            else {
+                console.log(picocolors_1.default.green('\n✓ All issues resolved!'));
+            }
+            // Determine action based on state
+            let action;
+            if (totalIssues === 0) {
+                const proceed = await confirmGate('Save and export GDD?');
+                action = proceed ? 'save' : 'exit';
+            }
+            else if (fixAttempts >= MAX_FIX_ATTEMPTS) {
+                console.log(picocolors_1.default.yellow(`\nMaximum fix attempts (${MAX_FIX_ATTEMPTS}) reached.`));
+                const proceed = await confirmGate('Save and export GDD with remaining issues?');
+                action = proceed ? 'save' : 'exit';
+            }
+            else {
+                action = await selectReviewAction();
+            }
+            if (action === 'exit') {
+                console.log(picocolors_1.default.yellow('Exiting...'));
+                return;
+            }
+            if (action === 'save') {
+                break;
+            }
+            // action === 'fix': Run remediation
+            fixAttempts++;
+            fixesApplied = true;
+            console.log(picocolors_1.default.cyan(`\n🔧 Fixing issues (attempt ${fixAttempts}/${MAX_FIX_ATTEMPTS})...\n`));
+            const remediationSpinner = (0, ora_1.default)('Running Remediation Agent...').start();
+            const remediationAgent = new Remediation_1.Remediation(apiKey, costTracker, modelSelector);
+            try {
+                const result = await remediationAgent.execute(bible, currentConsistencyIssues, currentChaosIssues, (message) => { remediationSpinner.text = `Remediation: ${message}`; });
+                remediationSpinner.succeed(`Fixed ${result.fixedIssues.length} issues`);
+                if (result.fixedIssues.length > 0) {
+                    console.log(picocolors_1.default.green('\nFixes applied:'));
+                    result.fixedIssues.forEach(fix => {
+                        console.log(picocolors_1.default.dim(`  ✓ ${fix}`));
+                    });
+                }
+                if (result.unfixableIssues.length > 0) {
+                    console.log(picocolors_1.default.yellow('\nCould not fix:'));
+                    result.unfixableIssues.forEach(issue => {
+                        console.log(picocolors_1.default.dim(`  ✗ ${issue}`));
+                    });
+                }
+                // Update bible
+                bible = result.updatedBible;
+                stateMachine.updateBible(bible);
+                // Transition back to production for re-validation
+                stateMachine.transition(StateMachine_1.GameForgePhase.PRODUCTION);
+                // Re-run validation
+                console.log(picocolors_1.default.cyan('\n🔄 Re-validating...\n'));
+                stateMachine.transition(StateMachine_1.GameForgePhase.VALIDATION);
+                const newConsistencyAgent = new Consistency_1.ConsistencyAgent();
+                currentConsistencyIssues = newConsistencyAgent.validate(bible);
+                console.log(picocolors_1.default.yellow(`Found ${currentConsistencyIssues.length} consistency issues`));
+                chaosSpinner = (0, ora_1.default)('Re-running Chaos Agent...').start();
+                const newChaosAgent = new Chaos_1.Chaos(apiKey, costTracker, modelSelector);
+                currentChaosIssues = await newChaosAgent.execute(bible, (message) => {
+                    chaosSpinner.text = `Chaos Agent: ${message}`;
+                });
+                chaosSpinner.succeed(`Found ${currentChaosIssues.length} design issues`);
+            }
+            catch (error) {
+                remediationSpinner.fail('Remediation failed');
+                console.error(picocolors_1.default.red('Error during remediation:'), error);
+                const continueAnyway = await confirmGate('Continue to save despite remediation failure?');
+                if (!continueAnyway) {
+                    console.log(picocolors_1.default.yellow('Exiting...'));
+                    return;
+                }
+                break;
+            }
+        }
+        // If fixes were applied, re-run specialists to regenerate markdown
+        if (fixesApplied) {
+            console.log(picocolors_1.default.cyan('\n🔄 Regenerating documentation with fixed Bible...\n'));
+            markdownSections = await orchestrator.runAllSpecialists(bible, specialists);
+        }
+        // Save all outputs
+        console.log(picocolors_1.default.cyan('\n💾 Saving outputs...\n'));
+        const projectDir = await fileManager.initialize(projectId);
+        await fileManager.saveGameBible(projectDir, bible);
+        await fileManager.saveCoverPage(projectDir, bible);
+        for (const [name, content] of markdownSections) {
+            const filename = name.replace(/\s+/g, '_') + '.md';
+            await fileManager.saveMarkdown(projectDir, filename, content);
+        }
+        await fileManager.saveGapAnalysis(projectDir, currentChaosIssues, currentConsistencyIssues);
+        // Save combined GDD
+        await fileManager.saveCombinedGDD(projectDir, bible, markdownSections, currentChaosIssues, currentConsistencyIssues);
+        console.log(picocolors_1.default.green('✓ Saved combined Game Design Document'));
+        // Complete
+        stateMachine.transition(StateMachine_1.GameForgePhase.COMPLETE);
+        // Save final checkpoint
+        await sessionManager.saveCheckpoint(sessionId, stateMachine.getState(), 'complete');
+        // Show final report
+        const report = costTracker.getReport();
+        console.log(picocolors_1.default.green('\n✅ Complete!\n'));
+        console.log(picocolors_1.default.dim(`Session ID: ${sessionId}`));
+        console.log(picocolors_1.default.dim(`Output directory: ${projectDir}`));
+        console.log(picocolors_1.default.dim(`Total cost: $${report.total.toFixed(2)} (${report.operations} operations)`));
+        console.log(picocolors_1.default.dim(`Budget remaining: $${report.remaining.toFixed(2)}\n`));
+        if (debugLogger_1.debugLogger.isEnabled()) {
+            console.log(picocolors_1.default.yellow(`🐛 Debug log saved to: ${debugLogger_1.debugLogger.getLogFilePath()}\n`));
+            debugLogger_1.debugLogger.disable();
+        }
+        console.log(picocolors_1.default.dim('View this session anytime with:'));
+        console.log(picocolors_1.default.dim(`  gameforge session ${sessionId}\n`));
+    }
+    catch (error) {
+        if (debugLogger_1.debugLogger.isEnabled()) {
+            debugLogger_1.debugLogger.logError('RunCreationFlow', error);
+            console.log(picocolors_1.default.yellow(`\n🐛 Debug log with error details: ${debugLogger_1.debugLogger.getLogFilePath()}\n`));
+            debugLogger_1.debugLogger.disable();
+        }
+        console.error(picocolors_1.default.red('\n❌ Error:'), error);
+        process.exit(1);
+    }
+}
+function getInquisitorQuestions(templateId) {
+    return [
+        {
+            question: 'What is your game\'s core concept? (Elevator pitch)',
+            category: 'meta',
+            allowCustom: true,
+            allowAIDecide: false
+        },
+        {
+            question: 'Select primary genre:',
+            category: 'meta',
+            suggestedAnswers: ['Roguelike', 'FPS', 'RPG', 'Platformer', 'Puzzle', 'Strategy', 'Simulation'],
+            allowCustom: true,
+            allowAIDecide: false
+        },
+        {
+            question: 'What platforms are you targeting?',
+            category: 'technical',
+            suggestedAnswers: ['PC Only', 'PC + Consoles', 'Mobile', 'Multi-platform'],
+            allowCustom: true,
+            allowAIDecide: true
+        },
+        {
+            question: 'What is the estimated scope?',
+            category: 'meta',
+            suggestedAnswers: ['Prototype', 'Vertical Slice', 'MVP', 'Full Game'],
+            allowCustom: false,
+            allowAIDecide: true
+        },
+        {
+            question: 'Which game engine?',
+            category: 'technical',
+            suggestedAnswers: ['Unreal Engine 5', 'Unity', 'Godot', 'Custom'],
+            allowCustom: true,
+            allowAIDecide: true
+        },
+        {
+            question: 'Describe your art style:',
+            category: 'creative',
+            suggestedAnswers: ['2D Pixel Art', '3D Low-poly', '3D Realistic', 'Hand-drawn 2D', 'Voxel'],
+            allowCustom: true,
+            allowAIDecide: true
+        },
+        {
+            question: 'What is the core gameplay loop?',
+            category: 'gameplay',
+            allowCustom: true,
+            allowAIDecide: false
+        },
+        {
+            question: 'Who is the target audience?',
+            category: 'meta',
+            suggestedAnswers: ['Casual players', 'Hardcore gamers', 'Families', 'Competitive players'],
+            allowCustom: true,
+            allowAIDecide: true
+        },
+        {
+            question: 'Monetization strategy?',
+            category: 'meta',
+            suggestedAnswers: ['Premium (one-time purchase)', 'Free-to-play + IAP', 'Free with Ads', 'Subscription'],
+            allowCustom: true,
+            allowAIDecide: true
+        },
+        {
+            question: 'Any key features you want to include?',
+            category: 'gameplay',
+            allowCustom: true,
+            allowAIDecide: false
+        }
+    ];
+}
+function showConceptBrief(transcript) {
+    console.log(picocolors_1.default.bold('Concept Brief:'));
+    transcript.forEach(entry => {
+        const marker = entry.autoGenerated ? picocolors_1.default.yellow(' [AI]') : '';
+        console.log(picocolors_1.default.dim(`  ${entry.question}`));
+        console.log(picocolors_1.default.green(`  → ${entry.answer}${marker}`));
+    });
+    console.log('');
+}
+async function confirmGate(message) {
+    const response = await enquirer_1.default.prompt({
+        type: 'confirm',
+        name: 'confirm',
+        message,
+        initial: true
+    });
+    return response.confirm;
+}
+async function selectReviewAction() {
+    const response = await enquirer_1.default.prompt({
+        type: 'select',
+        name: 'action',
+        message: 'What would you like to do?',
+        choices: [
+            { name: 'save', message: 'Save and export GDD' },
+            { name: 'fix', message: 'Fix issues and re-validate' },
+            { name: 'exit', message: 'Exit without saving' }
+        ]
+    });
+    return response.action;
+}
+async function listSessions() {
+    console.log(picocolors_1.default.cyan('\n📋 Saved Sessions\n'));
+    const sessionManager = new SessionManager_1.SessionManager();
+    try {
+        const sessions = await sessionManager.listSessions();
+        if (sessions.length === 0) {
+            console.log(picocolors_1.default.dim('No sessions found.'));
+            console.log(picocolors_1.default.dim('\nCreate a new session with: gameforge create\n'));
+            return;
+        }
+        sessions.forEach((session) => {
+            console.log(picocolors_1.default.green(session.sessionId));
+            console.log(picocolors_1.default.bold(`  ${session.title}`));
+            console.log(picocolors_1.default.dim(`  Phase: ${session.currentPhase}`));
+            console.log(picocolors_1.default.dim(`  Checkpoints: ${session.checkpointCount}`));
+            console.log(picocolors_1.default.dim(`  Created: ${new Date(session.createdAt).toLocaleString()}`));
+            console.log(picocolors_1.default.dim(`  Modified: ${new Date(session.lastModified).toLocaleString()}\n`));
+        });
+        console.log(picocolors_1.default.dim('Usage:'));
+        console.log(picocolors_1.default.dim('  gameforge resume <session-id>     Resume from latest checkpoint'));
+        console.log(picocolors_1.default.dim('  gameforge session <session-id>    View session details\n'));
+    }
+    catch (error) {
+        console.error(picocolors_1.default.red('Error listing sessions:'), error);
+    }
+}
+async function showSession(sessionId) {
+    console.log(picocolors_1.default.cyan(`\n📋 Session Details: ${sessionId}\n`));
+    const sessionManager = new SessionManager_1.SessionManager();
+    try {
+        const session = await sessionManager.getSession(sessionId);
+        if (!session) {
+            console.error(picocolors_1.default.red(`Session not found: ${sessionId}`));
+            console.log(picocolors_1.default.dim('\nList all sessions with: gameforge sessions\n'));
+            return;
+        }
+        console.log(picocolors_1.default.bold(session.title));
+        console.log(picocolors_1.default.dim(`Session ID: ${session.sessionId}`));
+        console.log(picocolors_1.default.dim(`Current Phase: ${session.currentPhase}`));
+        console.log(picocolors_1.default.dim(`Created: ${new Date(session.createdAt).toLocaleString()}`));
+        console.log(picocolors_1.default.dim(`Last Modified: ${new Date(session.lastModified).toLocaleString()}`));
+        console.log(picocolors_1.default.dim(`Total Checkpoints: ${session.checkpointCount}\n`));
+        // List checkpoints for this session
+        const checkpoints = await sessionManager.listCheckpoints(sessionId);
+        if (checkpoints.length === 0) {
+            console.log(picocolors_1.default.dim('No checkpoints found for this session.'));
+        }
+        else {
+            console.log(picocolors_1.default.cyan('Checkpoints:\n'));
+            checkpoints.forEach((cp, idx) => {
+                const isLatest = cp.checkpointId === session.latestCheckpointId;
+                const prefix = isLatest ? picocolors_1.default.green('→ ') : '  ';
+                console.log(`${prefix}${picocolors_1.default.bold(cp.label)} ${isLatest ? picocolors_1.default.green('(latest)') : ''}`);
+                console.log(`  ${picocolors_1.default.dim('ID:')} ${cp.checkpointId}`);
+                console.log(`  ${picocolors_1.default.dim('Phase:')} ${cp.phase}`);
+                console.log(`  ${picocolors_1.default.dim('Budget:')} $${cp.budgetUsed.toFixed(2)} / $${cp.budgetLimit.toFixed(2)}`);
+                console.log(`  ${picocolors_1.default.dim('Saved:')} ${new Date(cp.timestamp).toLocaleString()}\n`);
+            });
+        }
+        console.log(picocolors_1.default.dim('Usage:'));
+        console.log(picocolors_1.default.dim(`  gameforge resume ${sessionId}                Resume from latest checkpoint`));
+        console.log(picocolors_1.default.dim(`  gameforge resume <checkpoint-id>             Resume from specific checkpoint\n`));
+    }
+    catch (error) {
+        console.error(picocolors_1.default.red('Error showing session:'), error);
+    }
+}
+async function resumeFlow(idOrCheckpoint, options = {}) {
+    console.clear();
+    console.log(picocolors_1.default.cyan('\n╔══════════════════════════════╗'));
+    console.log(picocolors_1.default.cyan('║   GameForge CLI - Resume     ║'));
+    console.log(picocolors_1.default.cyan('╚══════════════════════════════╝\n'));
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+        console.error(picocolors_1.default.red('Error: ANTHROPIC_API_KEY not set in .env'));
+        process.exit(1);
+    }
+    const sessionManager = new SessionManager_1.SessionManager();
+    try {
+        // Determine if this is a session ID or checkpoint ID
+        let sessionId;
+        let checkpointId;
+        let savedState;
+        if (idOrCheckpoint.startsWith('session-')) {
+            // It's a session ID - load latest checkpoint
+            sessionId = idOrCheckpoint;
+            console.log(picocolors_1.default.yellow(`Loading latest checkpoint for session: ${sessionId}...`));
+            const latest = await sessionManager.getLatestCheckpoint(sessionId);
+            if (!latest) {
+                console.error(picocolors_1.default.red(`No checkpoints found for session: ${sessionId}`));
+                console.log(picocolors_1.default.dim('\nList all sessions with: gameforge sessions\n'));
+                process.exit(1);
+            }
+            checkpointId = latest.id;
+            savedState = latest.state;
+            console.log(picocolors_1.default.green(`✓ Using checkpoint: ${checkpointId}`));
+        }
+        else {
+            // It's a checkpoint ID - load it directly
+            checkpointId = idOrCheckpoint;
+            console.log(picocolors_1.default.yellow(`Loading checkpoint: ${checkpointId}...`));
+            savedState = await sessionManager.loadCheckpoint(checkpointId);
+            // Extract session ID from checkpoint ID
+            sessionId = checkpointId.split('_')[0];
+            // Check if this is an old-format checkpoint (starts with "gameforge-" instead of "session-")
+            if (sessionId.startsWith('gameforge-')) {
+                // Old checkpoint format - create a session for it if it doesn't exist
+                const existingSession = await sessionManager.getSession(sessionId);
+                if (!existingSession) {
+                    console.log(picocolors_1.default.dim('Migrating old checkpoint to session-based format...'));
+                    // Extract the checkpoint label to create a meaningful session title
+                    const checkpointData = await fs_extra_1.default.readJson(path_1.default.join('.gameforge', 'checkpoints', `${checkpointId}.json`));
+                    const sessionTitle = `Migrated Session (${checkpointData.label})`;
+                    // Create a new session with the old project ID as the session ID for backward compatibility
+                    const sessionPath = path_1.default.join('.gameforge', 'sessions', `${sessionId}.json`);
+                    const sessionMetadata = {
+                        sessionId: sessionId,
+                        title: sessionTitle,
+                        createdAt: checkpointData.timestamp,
+                        lastModified: checkpointData.timestamp,
+                        currentPhase: savedState.phase,
+                        checkpointCount: 1,
+                        latestCheckpointId: checkpointId
+                    };
+                    await fs_extra_1.default.writeJson(sessionPath, sessionMetadata, { spaces: 2 });
+                    console.log(picocolors_1.default.green(`✓ Created session: ${sessionId}`));
+                }
+            }
+        }
+        // Enable debug logging if requested
+        if (options.debug) {
+            debugLogger_1.debugLogger.enable(sessionId);
+            console.log(picocolors_1.default.yellow(`🐛 Debug mode enabled`));
+            console.log(picocolors_1.default.dim(`   Log file: ${debugLogger_1.debugLogger.getLogFilePath()}\n`));
+        }
+        console.log(picocolors_1.default.green(`✓ Loaded checkpoint from phase: ${savedState.phase}`));
+        console.log(picocolors_1.default.dim(`  Budget used: $${savedState.costAccumulated.toFixed(2)}/$${savedState.budgetLimit.toFixed(2)}\n`));
+        // Recreate the state machine and restore state
+        const stateMachine = new StateMachine_1.StateMachine(savedState.budgetLimit);
+        stateMachine.restoreState(savedState);
+        const costTracker = new costTracker_1.CostTracker(savedState.budgetLimit);
+        const modelSelector = new modelSelector_1.ModelSelector();
+        const fileManager = new fileManager_1.FileManager();
+        const projectId = sessionId;
+        // Determine what phase we're resuming from
+        const currentPhase = savedState.phase;
+        // If we have a transcript from discovery/review phase, we can use or regenerate the Game Bible
+        if (currentPhase === StateMachine_1.GameForgePhase.REVIEW_CONCEPT || currentPhase === StateMachine_1.GameForgePhase.DISCOVERY ||
+            currentPhase === StateMachine_1.GameForgePhase.ARCHITECTURE || currentPhase === StateMachine_1.GameForgePhase.REVIEW_DATA) {
+            if (!savedState.transcript || savedState.transcript.length === 0) {
+                console.log(picocolors_1.default.yellow('Checkpoint has no transcript data. Please restart with a new session.'));
+                return;
+            }
+            let bible;
+            // Check if we already have a generated bible in the checkpoint
+            if (savedState.bible && savedState.bible.features && savedState.bible.features.length > 0) {
+                // Use existing bible from checkpoint
+                console.log(picocolors_1.default.cyan('\n🏗️  Loading Game Bible from checkpoint\n'));
+                console.log(picocolors_1.default.green(`✓ Found existing Game Bible with ${savedState.bible.features.length} features`));
+                console.log(picocolors_1.default.green(`✓ Found ${savedState.bible.gameObjects.length} game objects\n`));
+                bible = savedState.bible;
+            }
+            else {
+                // No bible in checkpoint, need to regenerate (backward compatibility)
+                console.log(picocolors_1.default.cyan('\n🏗️  Generating Game Bible\n'));
+                console.log(picocolors_1.default.dim(`Found ${savedState.transcript.length} interview questions/answers\n`));
+                // Transition to architecture phase if we're coming from review_concept or discovery
+                if (currentPhase === StateMachine_1.GameForgePhase.REVIEW_CONCEPT || currentPhase === StateMachine_1.GameForgePhase.DISCOVERY) {
+                    stateMachine.transition(StateMachine_1.GameForgePhase.ARCHITECTURE);
+                }
+                const architect = new Architect_1.Architect(apiKey, costTracker, modelSelector);
+                const spinner = (0, ora_1.default)('Generating Game Bible...').start();
+                bible = await architect.execute(savedState.transcript);
+                spinner.succeed('Game Bible generated');
+            }
+            stateMachine.updateBible(bible);
+            // Transition to review_data phase
+            stateMachine.transition(StateMachine_1.GameForgePhase.REVIEW_DATA);
+            // Save checkpoint after successful generation (only if we regenerated)
+            if (!savedState.bible || !savedState.bible.features) {
+                await sessionManager.saveCheckpoint(sessionId, stateMachine.getState(), 'after_architecture');
+            }
+            // Transition to production and continue
+            stateMachine.transition(StateMachine_1.GameForgePhase.PRODUCTION);
+            await continueToProduction(stateMachine, bible, apiKey, costTracker, modelSelector, fileManager, sessionId, sessionManager);
+            return;
+        }
+        if (currentPhase === StateMachine_1.GameForgePhase.PRODUCTION || currentPhase === StateMachine_1.GameForgePhase.VALIDATION || currentPhase === StateMachine_1.GameForgePhase.REVIEW_ISSUES) {
+            console.log(picocolors_1.default.cyan('\n🎨 Resuming from Production/Validation\n'));
+            const bible = savedState.bible; // GameBible
+            if (!bible || !bible.features) {
+                console.error(picocolors_1.default.red('Error: No GameBible found in checkpoint'));
+                return;
+            }
+            // Handle phase transitions based on current phase
+            if (currentPhase === StateMachine_1.GameForgePhase.REVIEW_ISSUES) {
+                // REVIEW_ISSUES can transition back to PRODUCTION for retry
+                console.log(picocolors_1.default.yellow('Regenerating all outputs from production phase...'));
+                stateMachine.transition(StateMachine_1.GameForgePhase.PRODUCTION);
+            }
+            else if (currentPhase === StateMachine_1.GameForgePhase.VALIDATION) {
+                // VALIDATION cannot go back, but we're already past production
+                console.log(picocolors_1.default.yellow('Checkpoint is at validation phase. Continuing from there...'));
+                // We'll skip the production phase and go straight to validation in continueToProduction
+            }
+            // If currentPhase is already PRODUCTION, no transition needed
+            await continueToProduction(stateMachine, bible, apiKey, costTracker, modelSelector, fileManager, sessionId, sessionManager);
+            return;
+        }
+        console.log(picocolors_1.default.green('Checkpoint already complete!'));
+    }
+    catch (error) {
+        if (debugLogger_1.debugLogger.isEnabled()) {
+            debugLogger_1.debugLogger.logError('ResumeFlow', error);
+            console.log(picocolors_1.default.yellow(`\n🐛 Debug log with error details: ${debugLogger_1.debugLogger.getLogFilePath()}\n`));
+            debugLogger_1.debugLogger.disable();
+        }
+        console.error(picocolors_1.default.red('\n❌ Error resuming:'), error);
+        process.exit(1);
+    }
+}
+async function continueToProduction(stateMachine, bible, apiKey, costTracker, modelSelector, fileManager, sessionId, sessionManager) {
+    // Phase 3: Production (Specialists)
+    console.log(picocolors_1.default.cyan('\n🎨 Phase 3: Production\n'));
+    // Note: Caller should have already transitioned to PRODUCTION phase
+    const projectId = sessionId;
+    const orchestrator = new Orchestrator_1.SpecialistOrchestrator(2);
+    const specialists = [
+        { name: 'Creative Direction', agent: new CreativeSpecialist_1.CreativeSpecialist(apiKey, costTracker, modelSelector) },
+        { name: 'Feature Specifications', agent: new FeatureSpecialist_1.FeatureSpecialist(apiKey, costTracker, modelSelector) },
+        { name: 'Entity Specifications', agent: new EntitySpecialist_1.EntitySpecialist(apiKey, costTracker, modelSelector) },
+        { name: 'Technical Specifications', agent: new TechSpecialist_1.TechSpecialist(apiKey, costTracker, modelSelector) }
+    ];
+    let markdownSections = await orchestrator.runAllSpecialists(bible, specialists);
+    // Phase 4: Validation
+    console.log(picocolors_1.default.cyan('\n✅ Phase 4: Validation\n'));
+    stateMachine.transition(StateMachine_1.GameForgePhase.VALIDATION);
+    const consistencyAgent = new Consistency_1.ConsistencyAgent();
+    let currentConsistencyIssues = consistencyAgent.validate(bible);
+    console.log(picocolors_1.default.yellow(`Found ${currentConsistencyIssues.length} consistency issues`));
+    let chaosSpinner = (0, ora_1.default)('Running Chaos Agent...').start();
+    const chaosAgent = new Chaos_1.Chaos(apiKey, costTracker, modelSelector);
+    let currentChaosIssues = await chaosAgent.execute(bible);
+    chaosSpinner.succeed(`Found ${currentChaosIssues.length} design issues`);
+    // Gate 3: Review Issues with Fix Option
+    const MAX_FIX_ATTEMPTS = 3;
+    let fixAttempts = 0;
+    let fixesApplied = false;
+    while (true) {
+        stateMachine.transition(StateMachine_1.GameForgePhase.REVIEW_ISSUES);
+        const totalIssues = currentConsistencyIssues.length + currentChaosIssues.length;
+        if (totalIssues > 0) {
+            console.log(picocolors_1.default.yellow(`\n⚠️  ${totalIssues} issues found:`));
+            currentConsistencyIssues.slice(0, 3).forEach((issue) => {
+                console.log(picocolors_1.default.dim(`  - [${issue.severity}] ${issue.message}`));
+            });
+            currentChaosIssues.slice(0, 3).forEach((issue) => {
+                console.log(picocolors_1.default.dim(`  - [${issue.severity}] ${issue.description}`));
+            });
+            if (totalIssues > 6) {
+                console.log(picocolors_1.default.dim(`  ... and ${totalIssues - 6} more issues`));
+            }
+            if (fixAttempts > 0) {
+                console.log(picocolors_1.default.cyan(`\n(Fix attempt ${fixAttempts}/${MAX_FIX_ATTEMPTS} complete)`));
+            }
+        }
+        else {
+            console.log(picocolors_1.default.green('\n✓ All issues resolved!'));
+        }
+        // Determine action based on state
+        let action;
+        if (totalIssues === 0) {
+            const proceed = await confirmGate('Save and export GDD?');
+            action = proceed ? 'save' : 'exit';
+        }
+        else if (fixAttempts >= MAX_FIX_ATTEMPTS) {
+            console.log(picocolors_1.default.yellow(`\nMaximum fix attempts (${MAX_FIX_ATTEMPTS}) reached.`));
+            const proceed = await confirmGate('Save and export GDD with remaining issues?');
+            action = proceed ? 'save' : 'exit';
+        }
+        else {
+            action = await selectReviewAction();
+        }
+        if (action === 'exit') {
+            console.log(picocolors_1.default.yellow('Exiting...'));
+            return;
+        }
+        if (action === 'save') {
+            break;
+        }
+        // action === 'fix': Run remediation
+        fixAttempts++;
+        fixesApplied = true;
+        console.log(picocolors_1.default.cyan(`\n🔧 Fixing issues (attempt ${fixAttempts}/${MAX_FIX_ATTEMPTS})...\n`));
+        const remediationSpinner = (0, ora_1.default)('Running Remediation Agent...').start();
+        const remediationAgent = new Remediation_1.Remediation(apiKey, costTracker, modelSelector);
+        try {
+            const result = await remediationAgent.execute(bible, currentConsistencyIssues, currentChaosIssues, (message) => { remediationSpinner.text = `Remediation: ${message}`; });
+            remediationSpinner.succeed(`Fixed ${result.fixedIssues.length} issues`);
+            if (result.fixedIssues.length > 0) {
+                console.log(picocolors_1.default.green('\nFixes applied:'));
+                result.fixedIssues.forEach(fix => {
+                    console.log(picocolors_1.default.dim(`  ✓ ${fix}`));
+                });
+            }
+            if (result.unfixableIssues.length > 0) {
+                console.log(picocolors_1.default.yellow('\nCould not fix:'));
+                result.unfixableIssues.forEach(issue => {
+                    console.log(picocolors_1.default.dim(`  ✗ ${issue}`));
+                });
+            }
+            // Update bible
+            bible = result.updatedBible;
+            stateMachine.updateBible(bible);
+            // Transition back to production for re-validation
+            stateMachine.transition(StateMachine_1.GameForgePhase.PRODUCTION);
+            // Re-run validation
+            console.log(picocolors_1.default.cyan('\n🔄 Re-validating...\n'));
+            stateMachine.transition(StateMachine_1.GameForgePhase.VALIDATION);
+            const newConsistencyAgent = new Consistency_1.ConsistencyAgent();
+            currentConsistencyIssues = newConsistencyAgent.validate(bible);
+            console.log(picocolors_1.default.yellow(`Found ${currentConsistencyIssues.length} consistency issues`));
+            chaosSpinner = (0, ora_1.default)('Re-running Chaos Agent...').start();
+            const newChaosAgent = new Chaos_1.Chaos(apiKey, costTracker, modelSelector);
+            currentChaosIssues = await newChaosAgent.execute(bible, (message) => {
+                chaosSpinner.text = `Chaos Agent: ${message}`;
+            });
+            chaosSpinner.succeed(`Found ${currentChaosIssues.length} design issues`);
+        }
+        catch (error) {
+            remediationSpinner.fail('Remediation failed');
+            console.error(picocolors_1.default.red('Error during remediation:'), error);
+            const continueAnyway = await confirmGate('Continue to save despite remediation failure?');
+            if (!continueAnyway) {
+                console.log(picocolors_1.default.yellow('Exiting...'));
+                return;
+            }
+            break;
+        }
+    }
+    // If fixes were applied, re-run specialists to regenerate markdown
+    if (fixesApplied) {
+        console.log(picocolors_1.default.cyan('\n🔄 Regenerating documentation with fixed Bible...\n'));
+        markdownSections = await orchestrator.runAllSpecialists(bible, specialists);
+    }
+    // Save all outputs
+    console.log(picocolors_1.default.cyan('\n💾 Saving outputs...\n'));
+    const projectDir = await fileManager.initialize(projectId);
+    await fileManager.saveGameBible(projectDir, bible);
+    await fileManager.saveCoverPage(projectDir, bible);
+    for (const [name, content] of markdownSections) {
+        const filename = name.replace(/\s+/g, '_') + '.md';
+        await fileManager.saveMarkdown(projectDir, filename, content);
+    }
+    await fileManager.saveGapAnalysis(projectDir, currentChaosIssues, currentConsistencyIssues);
+    // Save combined GDD
+    await fileManager.saveCombinedGDD(projectDir, bible, markdownSections, currentChaosIssues, currentConsistencyIssues);
+    stateMachine.transition(StateMachine_1.GameForgePhase.COMPLETE);
+    // Save final checkpoint
+    await sessionManager.saveCheckpoint(sessionId, stateMachine.getState(), 'complete');
+    const report = costTracker.getReport();
+    console.log(picocolors_1.default.green('\n✅ Complete!\n'));
+    console.log(picocolors_1.default.dim(`Session ID: ${sessionId}`));
+    console.log(picocolors_1.default.dim(`Output directory: ${projectDir}`));
+    console.log(picocolors_1.default.dim(`Total cost: $${report.total.toFixed(2)} (${report.operations} operations)`));
+    console.log(picocolors_1.default.dim(`Budget remaining: $${report.remaining.toFixed(2)}\n`));
+    if (debugLogger_1.debugLogger.isEnabled()) {
+        console.log(picocolors_1.default.yellow(`🐛 Debug log saved to: ${debugLogger_1.debugLogger.getLogFilePath()}\n`));
+        debugLogger_1.debugLogger.disable();
+    }
+    console.log(picocolors_1.default.dim('View this session anytime with:'));
+    console.log(picocolors_1.default.dim(`  gameforge session ${sessionId}\n`));
+}
+//# sourceMappingURL=index.js.map