@girardmedia/bootspring 1.2.0 → 2.0.3

package/cli/onboard.js

@@ -0,0 +1,521 @@
+/**
+ * Bootspring Onboard CLI
+ *
+ * Layer Bootspring onto existing projects with stack detection,
+ * pattern scanning, and configuration generation.
+ *
+ * @package bootspring
+ * @module cli/onboard
+ */
+
+const path = require('path');
+const utils = require('../core/utils');
+const { OnboardWorkflowEngine, ONBOARD_PHASES } = require('../core/onboard-workflow');
+
+// Get project root
+const projectRoot = process.cwd();
+
+/**
+ * Show onboard help
+ */
+function showHelp() {
+  console.log(`
+${utils.COLORS.bold}Bootspring Onboard${utils.COLORS.reset}
+Layer Bootspring onto existing projects
+
+${utils.COLORS.bold}Usage:${utils.COLORS.reset}
+  bootspring onboard              Start interactive onboarding
+  bootspring onboard status       Show progress
+  bootspring onboard resume       Continue from checkpoint
+  bootspring onboard detect       Run detection only
+  bootspring onboard generate     Generate config only
+  bootspring onboard reset        Reset workflow
+
+${utils.COLORS.bold}Options:${utils.COLORS.reset}
+  --dry-run                       Preview without changes
+  --skip-optional                 Skip optional phases
+  --quick                         Force fast mode (auto for 500+ files)
+  --apply                         Apply generated files
+
+${utils.COLORS.bold}Notes:${utils.COLORS.reset}
+  Large codebases (500+ files) automatically use fast mode to skip
+  heavy dependency analysis. Use --quick to force it on smaller projects.
+
+${utils.COLORS.bold}Examples:${utils.COLORS.reset}
+  bootspring onboard              Auto-detects and adjusts for codebase size
+  bootspring onboard status
+  bootspring onboard --dry-run
+`);
+}
+
+/**
+ * Start onboarding workflow
+ */
+async function onboardStart(args) {
+  const workflow = new OnboardWorkflowEngine(projectRoot);
+
+  // Check for existing workflow
+  if (workflow.hasWorkflow()) {
+    workflow.loadState();
+    const progress = workflow.getProgress();
+
+    if (!progress.isComplete) {
+      utils.print.info('Existing onboarding workflow found.');
+      console.log(`  Progress: ${progress.overall.percentage}% complete`);
+      console.log(`  Current phase: ${progress.currentPhase || 'none'}`);
+      console.log('');
+      utils.print.info('Use "bootspring onboard resume" to continue');
+      utils.print.info('Use "bootspring onboard reset" to start fresh');
+      return;
+    }
+  }
+
+  // Initialize new workflow
+  utils.print.header('Bootspring Onboarding');
+  console.log('Analyzing your existing codebase...\n');
+
+  workflow.initializeWorkflow();
+
+  // Run workflow
+  await runWorkflowLoop(workflow, args);
+}
+
+/**
+ * Resume onboarding workflow
+ */
+async function onboardResume(args) {
+  const workflow = new OnboardWorkflowEngine(projectRoot);
+
+  if (!workflow.hasWorkflow()) {
+    utils.print.error('No existing workflow found.');
+    utils.print.info('Run "bootspring onboard" to start.');
+    return;
+  }
+
+  workflow.loadState();
+  const resumePoint = workflow.getResumePoint();
+
+  if (!resumePoint) {
+    utils.print.success('Onboarding workflow already complete!');
+    return;
+  }
+
+  utils.print.header('Resuming Onboarding');
+  console.log(`Continuing from: ${resumePoint.phaseName}`);
+  console.log('');
+
+  await runWorkflowLoop(workflow, args);
+}
+
+/**
+ * Run the workflow loop
+ */
+async function runWorkflowLoop(workflow, args) {
+  const dryRun = args['dry-run'] || false;
+  const skipOptional = args['skip-optional'] || false;
+  const quickMode = args.quick || false;
+
+  while (true) {
+    const nextPhaseId = workflow.getNextPhase();
+
+    if (!nextPhaseId) {
+      // Workflow complete
+      break;
+    }
+
+    const phase = ONBOARD_PHASES[nextPhaseId];
+
+    // Skip optional phases if requested
+    if (skipOptional && !phase.required) {
+      workflow.skipPhase(nextPhaseId);
+      utils.print.dim(`Skipping optional phase: ${phase.name}`);
+      continue;
+    }
+
+    // Run the phase
+    workflow.startPhase(nextPhaseId);
+    const spinner = utils.createSpinner(`Running: ${phase.name}`).start();
+
+    try {
+      let result;
+
+      switch (nextPhaseId) {
+        case 'detection':
+          result = await workflow.runDetection();
+          spinner.succeed(`Detection complete: Found ${result.stack.detected.length} technologies`);
+          displayDetectionResults(result);
+          break;
+
+        case 'patterns':
+          if (quickMode) {
+            // Quick mode: skip heavy dependency analysis, just detect features
+            result = await workflow.runQuickPatternScan();
+            spinner.succeed('Quick pattern scan complete');
+          } else {
+            result = await workflow.runPatternScan();
+            if (result.quickMode) {
+              // Auto-detected large codebase
+              spinner.succeed('Pattern scan complete (large codebase - quick mode)');
+            } else {
+              spinner.succeed(`Pattern scan complete: ${result.architecture.patterns.length} patterns found`);
+            }
+          }
+          displayPatternResults(result);
+          break;
+
+        case 'docs':
+          result = await workflow.runDocDiscovery();
+          spinner.succeed(`Doc discovery complete: ${result.found.length} docs found, ${result.missing.length} missing`);
+          displayDocResults(result);
+          break;
+
+        case 'config':
+          result = await workflow.runConfigGeneration();
+          spinner.succeed('Configuration generated');
+          displayConfigResults(result, dryRun);
+          break;
+
+        case 'baseline':
+          result = await workflow.runBaselineCapture();
+          spinner.succeed('Baseline captured');
+          break;
+
+        case 'reverse':
+          // Skip for now - optional
+          spinner.info('Skipping reverse engineering (optional)');
+          workflow.skipPhase(nextPhaseId);
+          continue;
+
+        default:
+          spinner.warn(`Unknown phase: ${nextPhaseId}`);
+          workflow.skipPhase(nextPhaseId);
+          continue;
+      }
+
+      workflow.completePhase(nextPhaseId, result);
+
+    } catch (error) {
+      spinner.fail(`Failed: ${error.message}`);
+      workflow.failPhase(nextPhaseId, error.message);
+
+      if (phase.required) {
+        utils.print.error('Required phase failed. Cannot continue.');
+        return;
+      }
+    }
+
+    console.log('');
+  }
+
+  // Workflow complete
+  utils.print.success('Onboarding complete!');
+  console.log('');
+
+  const progress = workflow.getProgress();
+
+  // Apply files if requested
+  const shouldApply = args.apply || false;
+  if (shouldApply && !dryRun) {
+    utils.print.info('Applying generated files...');
+    workflow.applyGeneratedFiles();
+    utils.print.success('bootspring.config.js and CLAUDE.md created');
+  } else if (!dryRun) {
+    utils.print.info('Generated files are in .bootspring/onboard/generated/');
+    utils.print.info('Run with --apply to copy them to project root');
+  }
+
+  // Show summary
+  console.log('');
+  utils.print.header('Summary');
+  console.log(`  Stack: ${formatStack(progress.detection?.stack)}`);
+  console.log(`  Phases completed: ${progress.overall.completed}/${progress.overall.total}`);
+  console.log('');
+  utils.print.info('Next steps:');
+  console.log('  1. Review generated configuration');
+  console.log('  2. Run "bootspring analyze" for deeper insights');
+  console.log('  3. Run "bootspring audit" for quality checks');
+}
+
+/**
+ * Display detection results
+ */
+function displayDetectionResults(result) {
+  console.log('');
+
+  if (result.stack.framework) {
+    console.log(`  ${utils.COLORS.cyan}Framework:${utils.COLORS.reset} ${result.stack.framework.name}`);
+  }
+  if (result.stack.language) {
+    console.log(`  ${utils.COLORS.cyan}Language:${utils.COLORS.reset} ${result.stack.language.name}`);
+  }
+  if (result.stack.database) {
+    console.log(`  ${utils.COLORS.cyan}Database:${utils.COLORS.reset} ${result.stack.database.name}`);
+  }
+  if (result.stack.hosting) {
+    console.log(`  ${utils.COLORS.cyan}Hosting:${utils.COLORS.reset} ${result.stack.hosting.name}`);
+  }
+  if (result.stack.auth) {
+    console.log(`  ${utils.COLORS.cyan}Auth:${utils.COLORS.reset} ${result.stack.auth.name}`);
+  }
+  if (result.stack.payments) {
+    console.log(`  ${utils.COLORS.cyan}Payments:${utils.COLORS.reset} ${result.stack.payments.name}`);
+  }
+
+  console.log('');
+  console.log(`  ${utils.COLORS.dim}Files: ${result.structure.stats.totalFiles} | Dirs: ${result.structure.stats.totalDirs}${utils.COLORS.reset}`);
+}
+
+/**
+ * Display pattern results
+ */
+function displayPatternResults(result) {
+  if (result.architecture.patterns.length > 0) {
+    console.log('');
+    console.log('  Detected patterns:');
+    for (const pattern of result.architecture.patterns.slice(0, 3)) {
+      console.log(`    - ${pattern.name} (${pattern.confidence}%)`);
+    }
+  }
+
+  if (result.features) {
+    const activeFeatures = Object.entries(result.features)
+      .filter(([, v]) => v)
+      .map(([k]) => k);
+
+    if (activeFeatures.length > 0) {
+      console.log('');
+      console.log('  Detected features:');
+      console.log(`    ${activeFeatures.join(', ')}`);
+    }
+  }
+}
+
+/**
+ * Display documentation results
+ */
+function displayDocResults(result) {
+  if (result.found.length > 0) {
+    console.log('');
+    console.log('  Found documentation:');
+    for (const doc of result.found.slice(0, 5)) {
+      console.log(`    ${utils.COLORS.green}✓${utils.COLORS.reset} ${doc.file}`);
+    }
+  }
+
+  if (result.missing.length > 0) {
+    console.log('');
+    console.log('  Missing (recommended):');
+    for (const doc of result.missing) {
+      console.log(`    ${utils.COLORS.yellow}○${utils.COLORS.reset} ${doc.file}`);
+    }
+  }
+}
+
+/**
+ * Display config generation results
+ */
+function displayConfigResults(result, dryRun) {
+  console.log('');
+
+  if (dryRun) {
+    console.log(`  ${utils.COLORS.dim}[DRY RUN] Would generate:${utils.COLORS.reset}`);
+  } else {
+    console.log('  Generated:');
+  }
+
+  console.log('    - bootspring.config.js');
+  console.log('    - CLAUDE.md');
+}
+
+/**
+ * Format stack for display
+ */
+function formatStack(stack) {
+  if (!stack) return 'Unknown';
+
+  const parts = [];
+  if (stack.framework) parts.push(stack.framework.name);
+  if (stack.language) parts.push(stack.language.name);
+  if (stack.database) parts.push(stack.database.name);
+
+  return parts.join(' + ') || 'Unknown';
+}
+
+/**
+ * Show onboard status
+ */
+async function onboardStatus() {
+  const workflow = new OnboardWorkflowEngine(projectRoot);
+
+  if (!workflow.hasWorkflow()) {
+    utils.print.info('No onboarding workflow started.');
+    utils.print.info('Run "bootspring onboard" to begin.');
+    return;
+  }
+
+  workflow.loadState();
+  const progress = workflow.getProgress();
+
+  utils.print.header('Onboarding Status');
+
+  // Overall progress
+  console.log(`Progress: ${progress.overall.percentage}% complete`);
+  console.log(`Started: ${progress.startedAt ? new Date(progress.startedAt).toLocaleString() : 'N/A'}`);
+  console.log(`Last updated: ${progress.lastUpdated ? utils.formatRelativeTime(new Date(progress.lastUpdated)) : 'N/A'}`);
+  console.log('');
+
+  // Phase status
+  console.log('Phases:');
+  for (const phase of progress.phases) {
+    const statusIcon = getStatusIcon(phase.status);
+    const required = phase.required ? '' : ' (optional)';
+    console.log(`  ${statusIcon} ${phase.name}${required}`);
+  }
+
+  console.log('');
+
+  // Detection summary if available
+  if (progress.detection?.stack) {
+    console.log('Detected stack:');
+    console.log(`  ${formatStack(progress.detection.stack)}`);
+  }
+
+  if (!progress.isComplete) {
+    console.log('');
+    utils.print.info('Run "bootspring onboard resume" to continue');
+  }
+}
+
+/**
+ * Run detection only
+ */
+async function onboardDetect() {
+  const workflow = new OnboardWorkflowEngine(projectRoot);
+  workflow.initializeWorkflow();
+
+  const spinner = utils.createSpinner('Detecting stack...').start();
+
+  try {
+    const result = await workflow.runDetection();
+    spinner.succeed('Detection complete');
+
+    displayDetectionResults(result);
+  } catch (error) {
+    spinner.fail(`Detection failed: ${error.message}`);
+  }
+}
+
+/**
+ * Generate config only
+ */
+async function onboardGenerate(args) {
+  const workflow = new OnboardWorkflowEngine(projectRoot);
+
+  // Need detection first
+  if (!workflow.hasWorkflow()) {
+    workflow.initializeWorkflow();
+
+    const spinner = utils.createSpinner('Running detection first...').start();
+    await workflow.runDetection();
+    workflow.completePhase('detection');
+
+    await workflow.runPatternScan();
+    workflow.completePhase('patterns');
+
+    spinner.succeed('Detection complete');
+  } else {
+    workflow.loadState();
+  }
+
+  const spinner = utils.createSpinner('Generating configuration...').start();
+
+  try {
+    const result = await workflow.runConfigGeneration();
+    spinner.succeed('Configuration generated');
+
+    displayConfigResults(result, args['dry-run']);
+
+    if (args.apply) {
+      workflow.applyGeneratedFiles();
+      utils.print.success('Files applied to project root');
+    } else {
+      console.log('');
+      utils.print.info('Files saved to .bootspring/onboard/generated/');
+      utils.print.info('Run with --apply to copy to project root');
+    }
+  } catch (error) {
+    spinner.fail(`Generation failed: ${error.message}`);
+  }
+}
+
+/**
+ * Reset onboard workflow
+ */
+async function onboardReset() {
+  const workflow = new OnboardWorkflowEngine(projectRoot);
+
+  if (!workflow.hasWorkflow()) {
+    utils.print.info('No workflow to reset.');
+    return;
+  }
+
+  workflow.resetWorkflow();
+  utils.print.success('Onboarding workflow reset.');
+}
+
+/**
+ * Get status icon
+ */
+function getStatusIcon(status) {
+  switch (status) {
+    case 'completed':
+      return `${utils.COLORS.green}✓${utils.COLORS.reset}`;
+    case 'in_progress':
+      return `${utils.COLORS.cyan}●${utils.COLORS.reset}`;
+    case 'failed':
+      return `${utils.COLORS.red}✗${utils.COLORS.reset}`;
+    case 'skipped':
+      return `${utils.COLORS.dim}○${utils.COLORS.reset}`;
+    default:
+      return `${utils.COLORS.dim}○${utils.COLORS.reset}`;
+  }
+}
+
+/**
+ * Main entry point
+ */
+async function run(args) {
+  const parsedArgs = utils.parseArgs(args);
+  const subcommand = parsedArgs._[0] || 'start';
+
+  switch (subcommand) {
+    case 'start':
+      return onboardStart(parsedArgs);
+
+    case 'status':
+      return onboardStatus();
+
+    case 'resume':
+      return onboardResume(parsedArgs);
+
+    case 'detect':
+      return onboardDetect();
+
+    case 'generate':
+      return onboardGenerate(parsedArgs);
+
+    case 'reset':
+      return onboardReset();
+
+    case 'help':
+    case '--help':
+    case '-h':
+      return showHelp();
+
+    default:
+      // If no subcommand, start workflow
+      return onboardStart(parsedArgs);
+  }
+}
+
+module.exports = { run };

package/cli/orchestrator.js

@@ -83,15 +83,16 @@ async function run(args) {
  * Analyze context and suggest agents
  */
 function runAnalyze(context) {
-  // Require MCP for intelligence features
-  if (!utils.requireMCP('Intelligence analysis')) {
-    return;
-  }
+  const isMCP = utils.isMCPContext();
 
   console.log(`
 ${utils.COLORS.cyan}${utils.COLORS.bold}Intelligence Analysis${utils.COLORS.reset}
 `);
 
+  if (!isMCP) {
+    utils.print.dim('Note: Running in CLI mode. Use with Claude MCP for enhanced analysis.\n');
+  }
+
   const analysis = intelligence.analyzeContext(context);
 
   console.log(`${utils.COLORS.bold}Current Phase:${utils.COLORS.reset} ${analysis.phase} - ${analysis.phaseConfig?.name || 'Unknown'}`);
@@ -149,11 +150,6 @@ function runWorkflow(name, accessOptions = {}) {
     return;
   }
 
-  // Require MCP for workflow details
-  if (!utils.requireMCP('Workflow details')) {
-    return;
-  }
-
   const workflow = intelligence.getWorkflow(name);
 
   if (!workflow) {
@@ -233,11 +229,6 @@ ${utils.COLORS.cyan}${utils.COLORS.bold}Available Workflows${utils.COLORS.reset}
  * Start a workflow
  */
 function runStartWorkflow(name, accessOptions = {}) {
-  // Require MCP for workflow execution
-  if (!utils.requireMCP('Workflow execution')) {
-    return;
-  }
-
   if (!name) {
     utils.print.error('Usage: bootspring orchestrator start <workflow-name>');
     return;
@@ -270,11 +261,6 @@ function runStartWorkflow(name, accessOptions = {}) {
  * Advance to next workflow step
  */
 function runNextStep() {
-  // Require MCP for workflow execution
-  if (!utils.requireMCP('Workflow execution')) {
-    return;
-  }
-
   const result = intelligence.advanceWorkflow();
 
   if (result.success) {
@@ -298,10 +284,12 @@ function runStatus() {
   const currentPhase = intelligence.getCurrentPhase();
   const phaseConfig = intelligence.PHASE_AGENTS[currentPhase];
   const agents = intelligence.getAvailableAgents();
+  const isMCP = utils.isMCPContext();
 
   console.log(`
 ${utils.COLORS.cyan}${utils.COLORS.bold}Orchestrator Status${utils.COLORS.reset}
 
+${utils.COLORS.bold}Mode:${utils.COLORS.reset} ${isMCP ? `${utils.COLORS.green}MCP (full)${utils.COLORS.reset}` : `${utils.COLORS.yellow}CLI (limited)${utils.COLORS.reset}`}
 ${utils.COLORS.bold}Current Phase:${utils.COLORS.reset} ${currentPhase} - ${phaseConfig?.name || 'Unknown'}
 ${utils.COLORS.bold}Last Analysis:${utils.COLORS.reset} ${state.lastAnalysis || 'Never'}
 ${utils.COLORS.bold}Active Workflow:${utils.COLORS.reset} ${state.activeWorkflow || 'None'}
@@ -324,14 +312,14 @@ ${utils.COLORS.bold}Active Workflow:${utils.COLORS.reset} ${state.activeWorkflow
   }
 
   console.log(`\n${utils.COLORS.bold}Available Agents:${utils.COLORS.reset} ${agents.length}`);
-}
 
-function runCheckpoint(workflowName, signalRef, accessOptions = {}) {
-  // Require MCP for workflow execution
-  if (!utils.requireMCP('Workflow checkpoints')) {
-    return;
+  if (!isMCP) {
+    console.log(`
+${utils.COLORS.dim}Enable MCP for enhanced orchestration: bootspring mcp start${utils.COLORS.reset}`);
   }
+}
 
+function runCheckpoint(workflowName, signalRef, accessOptions = {}) {
   const targetWorkflowName = workflowName || intelligence.loadState().activeWorkflow;
   if (targetWorkflowName) {
     const workflow = intelligence.getWorkflow(targetWorkflowName);