@girardmedia/bootspring 1.2.0 → 2.0.3

package/cli/build.js

@@ -0,0 +1,695 @@
+/**
+ * Bootspring Build Command
+ *
+ * Dedicated build management commands:
+ * - status: Check build progress
+ * - pause: Pause the build loop
+ * - resume: Resume the build loop
+ * - task: Show current task
+ * - skip: Skip current task
+ * - plan: View full plan
+ * - reset: Reset build state
+ *
+ * @package bootspring
+ * @command build
+ */
+
+const path = require('path');
+const fs = require('fs');
+const config = require('../core/config');
+const utils = require('../core/utils');
+const buildState = require('../core/build-state');
+const { BuildOrchestrator } = require('../core/build-orchestrator');
+
+// Colors
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  green: '\x1b[32m',
+  blue: '\x1b[34m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  red: '\x1b[31m',
+  magenta: '\x1b[35m'
+};
+
+/**
+ * Main run function - Interactive by default
+ * @param {array} args - Command arguments
+ */
+async function run(args) {
+  const parsedArgs = utils.parseArgs(args);
+  const subcommand = parsedArgs._[0];
+
+  const cfg = config.load();
+  const projectRoot = cfg._projectRoot;
+
+  // If no subcommand, run interactive mode
+  if (!subcommand) {
+    return interactiveBuild(projectRoot, parsedArgs);
+  }
+
+  // Advanced users can use subcommands directly
+  switch (subcommand) {
+    case 'status':
+      return showBuildStatus(projectRoot, parsedArgs);
+
+    case 'pause':
+    case 'stop':
+      return pauseBuildLoop(projectRoot);
+
+    case 'resume':
+    case 'continue':
+      return resumeBuildLoop(projectRoot);
+
+    case 'task':
+      return showCurrentTask(projectRoot, parsedArgs);
+
+    case 'skip':
+      return skipCurrentTask(projectRoot, parsedArgs);
+
+    case 'plan':
+      return showPlan(projectRoot);
+
+    case 'reset':
+      return resetBuild(projectRoot, parsedArgs);
+
+    case 'next':
+      return buildNextTask(projectRoot, parsedArgs);
+
+    case 'all':
+      return buildAll(projectRoot, parsedArgs);
+
+    case 'help':
+    case '-h':
+    case '--help':
+      return showHelp();
+
+    default:
+      console.log(`${c.red}Unknown subcommand: ${subcommand}${c.reset}`);
+      showHelp();
+  }
+}
+
+/**
+ * Interactive build mode - guides user through options
+ */
+async function interactiveBuild(projectRoot, args = {}) {
+  const readline = require('readline');
+  const state = buildState.load(projectRoot);
+
+  console.log(`
+${c.cyan}${c.bold}Bootspring Build${c.reset}
+`);
+
+  // No build state - offer to initialize
+  if (!state) {
+    console.log(`${c.yellow}No build found.${c.reset}
+
+This will:
+  1. Extract tasks from your seed documents
+  2. Create a build plan in /planning
+  3. Guide you through building your MVP
+
+`);
+
+    const answer = await askQuestion('Initialize build from seed docs? [Y/n] ');
+
+    if (answer.toLowerCase() === 'n') {
+      console.log(`\n${c.dim}Run 'bootspring preseed start' first if you haven't set up seed docs.${c.reset}\n`);
+      return;
+    }
+
+    // Initialize build
+    const { BuildOrchestrator } = require('../core/build-orchestrator');
+    const orchestrator = new BuildOrchestrator(projectRoot);
+    const spinner = utils.createSpinner('Analyzing seed documents...').start();
+
+    const result = await orchestrator.initialize();
+
+    if (!result.success) {
+      spinner.fail(result.error);
+      return;
+    }
+
+    spinner.succeed(`Found ${result.taskCount} tasks to build`);
+    console.log('');
+
+    // Continue to show options
+    return interactiveBuild(projectRoot, args);
+  }
+
+  // Show current progress
+  const stats = buildState.getStats(projectRoot);
+  const nextTask = buildState.getNextTask(projectRoot);
+
+  // Progress bar
+  const barWidth = 30;
+  const filled = Math.round((stats.progress / 100) * barWidth);
+  const bar = '█'.repeat(filled) + '░'.repeat(barWidth - filled);
+  const progressColor = stats.progress === 100 ? c.green : stats.progress > 50 ? c.cyan : c.yellow;
+
+  console.log(`${c.bold}${state.projectName}${c.reset}
+
+  Progress: [${progressColor}${bar}${c.reset}] ${stats.progress}%
+  Tasks: ${c.green}${stats.completed}${c.reset} done, ${stats.pending} remaining
+  Phase: ${formatPhaseName(state.currentPhase)}
+`);
+
+  // All done!
+  if (!nextTask) {
+    if (stats.completed === stats.total) {
+      console.log(`${c.green}${c.bold}All tasks complete! Your MVP is ready.${c.reset}
+
+Next steps:
+  ${c.cyan}npm run dev${c.reset}     Start development server
+  ${c.cyan}npm run build${c.reset}   Build for production
+  ${c.cyan}bootspring deploy${c.reset}  Deploy to production
+`);
+    } else {
+      console.log(`${c.yellow}No pending tasks available.${c.reset}
+Some tasks may be blocked. Run ${c.cyan}bootspring build status${c.reset} for details.
+`);
+    }
+    return;
+  }
+
+  // Show next task
+  console.log(`${c.bold}Next Task:${c.reset}
+  ${nextTask.title}
+  ${c.dim}${nextTask.source || ''}${c.reset}
+`);
+
+  // Show options
+  console.log(`${c.bold}What would you like to do?${c.reset}
+
+  ${c.cyan}1${c.reset}  Build this task
+  ${c.cyan}2${c.reset}  Build all remaining tasks (autonomous)
+  ${c.cyan}3${c.reset}  View task details
+  ${c.cyan}4${c.reset}  Skip this task
+  ${c.cyan}5${c.reset}  View full plan
+  ${c.cyan}q${c.reset}  Quit
+`);
+
+  const choice = await askQuestion('Choose [1-5, q]: ');
+
+  switch (choice.trim()) {
+    case '1':
+    case '':
+      return buildNextTask(projectRoot, args);
+
+    case '2':
+      return buildAll(projectRoot, args);
+
+    case '3':
+      showCurrentTask(projectRoot, { prompt: true });
+      console.log('');
+      return interactiveBuild(projectRoot, args);
+
+    case '4': {
+      const reason = await askQuestion('Skip reason (optional): ');
+      skipCurrentTask(projectRoot, { reason: reason || 'Skipped by user' });
+      return interactiveBuild(projectRoot, args);
+    }
+
+    case '5':
+      showPlan(projectRoot);
+      return interactiveBuild(projectRoot, args);
+
+    case 'q':
+    case 'Q':
+      console.log(`\n${c.dim}Run 'bootspring build' anytime to continue.${c.reset}\n`);
+      return;
+
+    default:
+      console.log(`${c.yellow}Invalid choice. Please try again.${c.reset}\n`);
+      return interactiveBuild(projectRoot, args);
+  }
+}
+
+/**
+ * Build the next task
+ */
+async function buildNextTask(projectRoot, args = {}) {
+  const state = buildState.load(projectRoot);
+
+  if (!state) {
+    console.log(`${c.yellow}No build state found. Run 'bootspring build' to start.${c.reset}`);
+    return;
+  }
+
+  const nextTask = buildState.getNextTask(projectRoot);
+
+  if (!nextTask) {
+    console.log(`${c.green}No more tasks to build!${c.reset}`);
+    return;
+  }
+
+  console.log(`
+${c.cyan}${c.bold}Building: ${nextTask.title}${c.reset}
+`);
+
+  // Start the loop for just one task - force to clear any stale session
+  const loop = require('./loop');
+  await loop.runLoop(projectRoot, {
+    source: 'build',
+    iterations: 1,
+    live: args.live,
+    verbose: args.verbose || args.v,
+    force: true  // Always force to avoid "session already running" issues
+  });
+
+  // Show what's next
+  const readline = require('readline');
+  const updatedTask = buildState.getNextTask(projectRoot);
+
+  if (updatedTask) {
+    console.log(`
+${c.bold}Next task:${c.reset} ${updatedTask.title}
+`);
+    const answer = await askQuestion('Continue to next task? [Y/n] ');
+
+    if (answer.toLowerCase() !== 'n') {
+      return buildNextTask(projectRoot, args);
+    }
+  }
+
+  console.log(`\n${c.dim}Run 'bootspring build' to continue later.${c.reset}\n`);
+}
+
+/**
+ * Build all remaining tasks
+ */
+async function buildAll(projectRoot, args = {}) {
+  const state = buildState.load(projectRoot);
+
+  if (!state) {
+    console.log(`${c.yellow}No build state found. Run 'bootspring build' to start.${c.reset}`);
+    return;
+  }
+
+  const stats = buildState.getStats(projectRoot);
+
+  console.log(`
+${c.cyan}${c.bold}Building all ${stats.pending} remaining tasks...${c.reset}
+${c.dim}Press Ctrl+C to stop at any time${c.reset}
+`);
+
+  // Start the full loop - force to clear any stale session
+  const loop = require('./loop');
+  await loop.runLoop(projectRoot, {
+    source: 'build',
+    iterations: args.iterations || 50,
+    live: args.live,
+    verbose: args.verbose || args.v,
+    force: true  // Always force to avoid "session already running" issues
+  });
+}
+
+/**
+ * Ask a question and get user input
+ */
+function askQuestion(question) {
+  const readline = require('readline');
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise(resolve => {
+    rl.question(question, answer => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
+
+/**
+ * Show build status
+ */
+function showBuildStatus(projectRoot, args = {}) {
+  const state = buildState.load(projectRoot);
+
+  if (!state) {
+    console.log(`
+${c.cyan}${c.bold}Build Status${c.reset}
+
+${c.yellow}No build state found.${c.reset}
+Run ${c.cyan}bootspring seed build${c.reset} to initialize the build system.
+`);
+    return;
+  }
+
+  const stats = buildState.getStats(projectRoot);
+
+  // Status icon
+  const statusIcon = {
+    pending: `${c.dim}○${c.reset}`,
+    in_progress: `${c.green}●${c.reset}`,
+    paused: `${c.yellow}◐${c.reset}`,
+    completed: `${c.green}✓${c.reset}`,
+    failed: `${c.red}✗${c.reset}`
+  }[state.status] || '?';
+
+  // Progress bar
+  const barWidth = 40;
+  const filled = Math.round((stats.progress / 100) * barWidth);
+  const bar = '█'.repeat(filled) + '░'.repeat(barWidth - filled);
+  const progressColor = stats.progress === 100 ? c.green :
+    stats.progress > 50 ? c.cyan : c.yellow;
+
+  console.log(`
+${c.cyan}${c.bold}Build Status${c.reset}
+
+${c.bold}Project:${c.reset} ${state.projectName}
+${c.bold}Status:${c.reset} ${statusIcon} ${state.status}
+${c.bold}Phase:${c.reset} ${formatPhaseName(state.currentPhase)}
+
+${c.bold}Progress${c.reset}
+  [${progressColor}${bar}${c.reset}] ${stats.progress}%
+
+${c.bold}Tasks${c.reset}
+  Total:       ${stats.total}
+  Completed:   ${c.green}${stats.completed}${c.reset}
+  In Progress: ${c.cyan}${stats.inProgress}${c.reset}
+  Pending:     ${stats.pending}
+  Blocked:     ${c.red}${stats.blocked}${c.reset}
+  Skipped:     ${c.dim}${stats.skipped}${c.reset}
+
+${c.bold}MVP Progress${c.reset}
+  ${stats.mvpProgress}% complete ${stats.mvpComplete ? `${c.green}✓ MVP Complete${c.reset}` : ''}
+
+${c.bold}Loop Session${c.reset}
+  Iteration: ${stats.iteration}/${stats.maxIterations}
+  Session ID: ${c.dim}${state.loopSession?.sessionId || 'N/A'}${c.reset}
+`);
+
+  // Show next actions
+  showNextActions(state, stats);
+}
+
+/**
+ * Show suggested next actions
+ */
+function showNextActions(state, stats) {
+  console.log(`${c.bold}Next Actions:${c.reset}`);
+
+  if (state.status === 'paused') {
+    console.log(`  ${c.cyan}1.${c.reset} Resume building     → ${c.dim}bootspring build resume${c.reset}`);
+    console.log(`  ${c.cyan}2.${c.reset} View current task   → ${c.dim}bootspring build task${c.reset}`);
+    console.log(`  ${c.cyan}3.${c.reset} View full plan      → ${c.dim}bootspring build plan${c.reset}`);
+  } else if (state.status === 'completed') {
+    console.log(`  ${c.green}Build complete!${c.reset} All tasks have been finished.`);
+    console.log(`  ${c.cyan}1.${c.reset} View summary        → ${c.dim}bootspring build plan${c.reset}`);
+    console.log(`  ${c.cyan}2.${c.reset} Deploy              → ${c.dim}bootspring deploy${c.reset}`);
+  } else if (state.status === 'failed') {
+    console.log(`  ${c.red}Build failed.${c.reset} Review errors and resume.`);
+    console.log(`  ${c.cyan}1.${c.reset} View current task   → ${c.dim}bootspring build task${c.reset}`);
+    console.log(`  ${c.cyan}2.${c.reset} Skip blocked task   → ${c.dim}bootspring build skip${c.reset}`);
+    console.log(`  ${c.cyan}3.${c.reset} Reset build         → ${c.dim}bootspring build reset${c.reset}`);
+  } else if (state.status === 'in_progress') {
+    console.log(`  ${c.cyan}Build in progress...${c.reset}`);
+    console.log(`  ${c.cyan}1.${c.reset} Pause building      → ${c.dim}bootspring build pause${c.reset}`);
+    console.log(`  ${c.cyan}2.${c.reset} View current task   → ${c.dim}bootspring build task${c.reset}`);
+  } else {
+    console.log(`  ${c.cyan}1.${c.reset} Start building      → ${c.dim}bootspring seed build --loop${c.reset}`);
+    console.log(`  ${c.cyan}2.${c.reset} View current task   → ${c.dim}bootspring build task${c.reset}`);
+    console.log(`  ${c.cyan}3.${c.reset} View full plan      → ${c.dim}bootspring build plan${c.reset}`);
+  }
+
+  console.log('');
+}
+
+/**
+ * Pause the build loop
+ */
+function pauseBuildLoop(projectRoot) {
+  const state = buildState.load(projectRoot);
+
+  if (!state) {
+    console.log(`${c.yellow}No build state found.${c.reset}`);
+    return;
+  }
+
+  if (state.status !== 'in_progress') {
+    console.log(`${c.yellow}Build is not running (status: ${state.status})${c.reset}`);
+    return;
+  }
+
+  buildState.pause(projectRoot);
+
+  console.log(`
+${c.green}Build paused.${c.reset}
+
+Resume with: ${c.cyan}bootspring build resume${c.reset}
+`);
+}
+
+/**
+ * Resume the build loop
+ */
+function resumeBuildLoop(projectRoot) {
+  const state = buildState.load(projectRoot);
+
+  if (!state) {
+    console.log(`${c.yellow}No build state found.${c.reset}`);
+    console.log(`Initialize with: ${c.cyan}bootspring seed build${c.reset}`);
+    return;
+  }
+
+  if (state.status === 'completed') {
+    console.log(`${c.green}Build is already complete!${c.reset}`);
+    return;
+  }
+
+  if (state.status !== 'paused' && state.status !== 'pending') {
+    console.log(`${c.yellow}Build status: ${state.status}${c.reset}`);
+    console.log('Cannot resume from this state.');
+    return;
+  }
+
+  buildState.resume(projectRoot);
+
+  console.log(`
+${c.green}Build resumed.${c.reset}
+
+To continue the build loop:
+  ${c.cyan}bootspring loop start --source=build${c.reset}
+
+Or start fresh:
+  ${c.cyan}bootspring seed build --loop${c.reset}
+`);
+}
+
+/**
+ * Show current task
+ */
+function showCurrentTask(projectRoot, args = {}) {
+  const state = buildState.load(projectRoot);
+
+  if (!state) {
+    console.log(`${c.yellow}No build state found.${c.reset}`);
+    return;
+  }
+
+  const nextTask = buildState.getNextTask(projectRoot);
+
+  if (!nextTask) {
+    const stats = buildState.getStats(projectRoot);
+
+    if (stats.completed === stats.total) {
+      console.log(`
+${c.green}${c.bold}All tasks complete!${c.reset}
+
+${stats.completed} tasks have been completed.
+`);
+    } else {
+      console.log(`
+${c.yellow}No pending tasks available.${c.reset}
+
+${c.bold}Summary:${c.reset}
+  Completed: ${stats.completed}
+  Blocked: ${stats.blocked}
+  Skipped: ${stats.skipped}
+`);
+    }
+    return;
+  }
+
+  console.log(`
+${c.cyan}${c.bold}Current Task${c.reset}
+
+${c.bold}ID:${c.reset} ${nextTask.id}
+${c.bold}Title:${c.reset} ${nextTask.title}
+${c.bold}Phase:${c.reset} ${formatPhaseName(nextTask.phase)}
+${c.bold}Complexity:${c.reset} ${nextTask.estimatedComplexity || 'medium'}
+${c.bold}Source:${c.reset} ${nextTask.source || 'Manual'} ${nextTask.sourceSection ? `(${nextTask.sourceSection})` : ''}
+${c.bold}Status:${c.reset} ${nextTask.status}
+`);
+
+  if (nextTask.description) {
+    console.log(`${c.bold}Description:${c.reset}
+${nextTask.description}
+`);
+  }
+
+  if (nextTask.acceptanceCriteria && nextTask.acceptanceCriteria.length > 0) {
+    console.log(`${c.bold}Acceptance Criteria:${c.reset}`);
+    nextTask.acceptanceCriteria.forEach((criteria, i) => {
+      console.log(`  ${c.dim}${i + 1}.${c.reset} ${criteria}`);
+    });
+    console.log('');
+  }
+
+  if (nextTask.dependencies && nextTask.dependencies.length > 0) {
+    console.log(`${c.bold}Dependencies:${c.reset} ${nextTask.dependencies.join(', ')}`);
+    console.log('');
+  }
+
+  // Show prompt generation option
+  if (args.prompt) {
+    const orchestrator = new BuildOrchestrator(projectRoot);
+    const prompt = orchestrator.generateTaskPrompt(nextTask);
+    console.log(`${c.bold}Generated Prompt:${c.reset}`);
+    console.log(c.dim + '─'.repeat(60) + c.reset);
+    console.log(prompt);
+    console.log(c.dim + '─'.repeat(60) + c.reset);
+  } else {
+    console.log(`${c.dim}Use --prompt to generate AI prompt for this task${c.reset}`);
+  }
+}
+
+/**
+ * Skip current task
+ */
+function skipCurrentTask(projectRoot, args = {}) {
+  const state = buildState.load(projectRoot);
+
+  if (!state) {
+    console.log(`${c.yellow}No build state found.${c.reset}`);
+    return;
+  }
+
+  const nextTask = buildState.getNextTask(projectRoot);
+
+  if (!nextTask) {
+    console.log(`${c.yellow}No pending tasks to skip.${c.reset}`);
+    return;
+  }
+
+  const reason = args.reason || args._[1] || 'Manually skipped';
+
+  buildState.updateProgress(projectRoot, nextTask.id, 'skipped', {
+    error: reason
+  });
+
+  console.log(`
+${c.yellow}Skipped task: ${nextTask.title}${c.reset}
+Reason: ${reason}
+
+Next task: ${buildState.getNextTask(projectRoot)?.title || 'None remaining'}
+`);
+}
+
+/**
+ * Show full plan
+ */
+function showPlan(projectRoot) {
+  const planPath = path.join(projectRoot, 'planning', 'MASTER_PLAN.md');
+
+  if (!fs.existsSync(planPath)) {
+    console.log(`${c.yellow}No plan found.${c.reset}`);
+    console.log(`Initialize with: ${c.cyan}bootspring seed build${c.reset}`);
+    return;
+  }
+
+  const content = fs.readFileSync(planPath, 'utf-8');
+
+  // Print with formatting
+  console.log(`
+${c.cyan}${c.bold}Master Plan${c.reset}
+${c.dim}${planPath}${c.reset}
+
+${content}
+`);
+}
+
+/**
+ * Reset build state
+ */
+function resetBuild(projectRoot, args = {}) {
+  const force = args.force || args.f;
+
+  const state = buildState.load(projectRoot);
+
+  if (!state) {
+    console.log(`${c.yellow}No build state found.${c.reset}`);
+    return;
+  }
+
+  if (!force && state.status === 'in_progress') {
+    console.log(`${c.yellow}Build is in progress. Use --force to reset.${c.reset}`);
+    return;
+  }
+
+  buildState.reset(projectRoot);
+
+  console.log(`
+${c.green}Build state reset.${c.reset}
+
+Re-initialize with: ${c.cyan}bootspring seed build${c.reset}
+`);
+}
+
+/**
+ * Format phase name for display
+ */
+function formatPhaseName(phase) {
+  if (!phase) return 'Unknown';
+
+  const names = {
+    foundation: 'Foundation',
+    mvp: 'MVP',
+    launch: 'Launch',
+    other: 'Other'
+  };
+
+  return names[phase] || phase.charAt(0).toUpperCase() + phase.slice(1);
+}
+
+/**
+ * Show help
+ */
+function showHelp() {
+  console.log(`
+${c.cyan}${c.bold}Bootspring Build${c.reset}
+${c.dim}Interactive build system for your MVP${c.reset}
+
+${c.bold}Quick Start:${c.reset}
+  ${c.cyan}bootspring build${c.reset}       Interactive mode (recommended)
+
+${c.bold}Advanced Commands:${c.reset}
+  ${c.cyan}bootspring build next${c.reset}      Build next task
+  ${c.cyan}bootspring build all${c.reset}       Build all tasks autonomously
+  ${c.cyan}bootspring build status${c.reset}    View detailed progress
+  ${c.cyan}bootspring build task${c.reset}      View current task details
+  ${c.cyan}bootspring build skip${c.reset}      Skip current task
+  ${c.cyan}bootspring build plan${c.reset}      View the full master plan
+  ${c.cyan}bootspring build pause${c.reset}     Pause building
+  ${c.cyan}bootspring build reset${c.reset}     Start over
+
+${c.bold}Options:${c.reset}
+  --prompt          Show AI prompt for current task
+  --force           Force reset even if in progress
+
+${c.bold}Workflow:${c.reset}
+  1. Run ${c.cyan}bootspring build${c.reset}
+  2. Choose to build one task or all tasks
+  3. Review progress and continue
+
+That's it! The system guides you through the rest.
+`);
+}
+
+module.exports = { run };