@girardmedia/bootspring 1.2.0 → 2.0.3

package/cli/health.js

@@ -0,0 +1,477 @@
+/**
+ * Bootspring Health Command
+ * Quick project health overview and status check
+ *
+ * @package bootspring
+ * @command health
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const config = require('../core/config');
+const utils = require('../core/utils');
+const projectState = require('../core/project-state');
+const checkpointEngine = require('../core/checkpoint-engine');
+
+/**
+ * Get workflow status
+ */
+function getWorkflowStatus(projectRoot) {
+  const workflows = ['analyze', 'audit', 'onboard', 'deploy'];
+  const status = {};
+
+  for (const workflow of workflows) {
+    const stateFile = path.join(projectRoot, '.bootspring', workflow, 'workflow-state.json');
+    if (fs.existsSync(stateFile)) {
+      try {
+        const state = JSON.parse(fs.readFileSync(stateFile, 'utf-8'));
+        const completedPhases = Object.values(state.phases || {})
+          .filter(p => p.status === 'completed').length;
+        const totalPhases = Object.keys(state.phases || {}).length;
+
+        status[workflow] = {
+          exists: true,
+          progress: totalPhases > 0 ? Math.round((completedPhases / totalPhases) * 100) : 0,
+          lastUpdated: state.lastUpdated,
+          isComplete: completedPhases === totalPhases && totalPhases > 0
+        };
+      } catch {
+        status[workflow] = { exists: true, error: true };
+      }
+    } else {
+      status[workflow] = { exists: false };
+    }
+  }
+
+  return status;
+}
+
+/**
+ * Get todo summary
+ */
+function getTodoSummary(projectRoot) {
+  const todoPath = path.join(projectRoot, 'todo.md');
+  if (!fs.existsSync(todoPath)) {
+    return { exists: false };
+  }
+
+  try {
+    const content = fs.readFileSync(todoPath, 'utf-8');
+    const pending = (content.match(/- \[ \]/g) || []).length;
+    const completed = (content.match(/- \[x\]/gi) || []).length;
+
+    return {
+      exists: true,
+      pending,
+      completed,
+      total: pending + completed
+    };
+  } catch {
+    return { exists: true, error: true };
+  }
+}
+
+/**
+ * Get dependency health
+ */
+function getDependencyHealth(projectRoot) {
+  const pkgPath = path.join(projectRoot, 'package.json');
+  if (!fs.existsSync(pkgPath)) {
+    return { exists: false };
+  }
+
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    const deps = Object.keys(pkg.dependencies || {}).length;
+    const devDeps = Object.keys(pkg.devDependencies || {}).length;
+
+    // Try to get outdated count
+    const outdated = 0;
+    let vulnerabilities = { total: 0, critical: 0, high: 0 };
+
+    try {
+      const auditResult = execSync('npm audit --json 2>/dev/null', {
+        cwd: projectRoot,
+        encoding: 'utf-8',
+        timeout: 10000,
+        stdio: ['pipe', 'pipe', 'pipe']
+      });
+      const audit = JSON.parse(auditResult);
+      if (audit.metadata && audit.metadata.vulnerabilities) {
+        vulnerabilities = audit.metadata.vulnerabilities;
+      }
+    } catch {
+      // Audit failed or timed out
+    }
+
+    return {
+      exists: true,
+      dependencies: deps,
+      devDependencies: devDeps,
+      total: deps + devDeps,
+      vulnerabilities
+    };
+  } catch {
+    return { exists: true, error: true };
+  }
+}
+
+/**
+ * Get quality metrics
+ */
+function getQualityMetrics(projectRoot) {
+  const metrics = {
+    hasTypeScript: false,
+    hasEslint: false,
+    hasPrettier: false,
+    hasTests: false,
+    testCoverage: null
+  };
+
+  // Check for TypeScript
+  if (fs.existsSync(path.join(projectRoot, 'tsconfig.json'))) {
+    metrics.hasTypeScript = true;
+  }
+
+  // Check for ESLint
+  const eslintConfigs = ['.eslintrc', '.eslintrc.json', '.eslintrc.js', 'eslint.config.js'];
+  metrics.hasEslint = eslintConfigs.some(f => fs.existsSync(path.join(projectRoot, f)));
+
+  // Check for Prettier
+  const prettierConfigs = ['.prettierrc', '.prettierrc.json', 'prettier.config.js'];
+  metrics.hasPrettier = prettierConfigs.some(f => fs.existsSync(path.join(projectRoot, f)));
+
+  // Check for tests
+  const testDirs = ['__tests__', 'tests', 'test', 'spec'];
+  metrics.hasTests = testDirs.some(d => fs.existsSync(path.join(projectRoot, d)));
+
+  // Check for coverage
+  const coveragePath = path.join(projectRoot, 'coverage', 'coverage-summary.json');
+  if (fs.existsSync(coveragePath)) {
+    try {
+      const coverage = JSON.parse(fs.readFileSync(coveragePath, 'utf-8'));
+      metrics.testCoverage = coverage.total?.lines?.pct || null;
+    } catch {
+      // Coverage file invalid
+    }
+  }
+
+  return metrics;
+}
+
+/**
+ * Get monitor metrics
+ */
+function getMonitorMetrics(projectRoot) {
+  const metricsDir = path.join(projectRoot, '.bootspring', 'monitor', 'metrics');
+  if (!fs.existsSync(metricsDir)) {
+    return { exists: false };
+  }
+
+  try {
+    const files = fs.readdirSync(metricsDir).sort().slice(-1);
+    if (files.length === 0) {
+      return { exists: true, noData: true };
+    }
+
+    const latest = JSON.parse(fs.readFileSync(path.join(metricsDir, files[0]), 'utf-8'));
+    return {
+      exists: true,
+      bundleSize: latest.bundleSize,
+      dependencies: latest.dependencies,
+      timestamp: latest.timestamp
+    };
+  } catch {
+    return { exists: true, error: true };
+  }
+}
+
+/**
+ * Calculate overall health score
+ */
+function calculateHealthScore(data) {
+  let score = 0;
+  let maxScore = 0;
+
+  // Checkpoints (20 points max)
+  if (data.checkpoints && data.checkpoints.total > 0) {
+    maxScore += 20;
+    score += (data.checkpoints.percentage / 100) * 20;
+  }
+
+  // Workflows (15 points max)
+  maxScore += 15;
+  const workflowsDone = Object.values(data.workflows)
+    .filter(w => w.isComplete).length;
+  score += (workflowsDone / 4) * 15;
+
+  // Todos (10 points max)
+  if (data.todos.exists && data.todos.total > 0) {
+    maxScore += 10;
+    const completionRate = data.todos.completed / data.todos.total;
+    score += completionRate * 10;
+  }
+
+  // Quality tooling (25 points max)
+  maxScore += 25;
+  if (data.quality.hasTypeScript) score += 8;
+  if (data.quality.hasEslint) score += 8;
+  if (data.quality.hasPrettier) score += 4;
+  if (data.quality.hasTests) score += 5;
+
+  // Test coverage (15 points max)
+  if (data.quality.testCoverage !== null) {
+    maxScore += 15;
+    score += (data.quality.testCoverage / 100) * 15;
+  }
+
+  // Dependencies (15 points max)
+  maxScore += 15;
+  if (data.deps.exists) {
+    const vulns = data.deps.vulnerabilities || {};
+    if (vulns.critical === 0 && vulns.high === 0) {
+      score += 15;
+    } else if (vulns.critical === 0) {
+      score += 8;
+    }
+  }
+
+  return Math.round((score / maxScore) * 100);
+}
+
+/**
+ * Get health grade
+ */
+function getHealthGrade(score) {
+  if (score >= 90) return { grade: 'A', color: utils.COLORS.green };
+  if (score >= 80) return { grade: 'B', color: utils.COLORS.green };
+  if (score >= 70) return { grade: 'C', color: utils.COLORS.yellow };
+  if (score >= 60) return { grade: 'D', color: utils.COLORS.yellow };
+  return { grade: 'F', color: utils.COLORS.red };
+}
+
+/**
+ * Show health report
+ */
+function showHealth(projectRoot) {
+  const cfg = config.load();
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Project Health Report${utils.COLORS.reset}
+${utils.COLORS.dim}${cfg.project?.name || 'Unknown Project'}${utils.COLORS.reset}
+`);
+
+  // Collect all data
+  const data = {
+    workflows: getWorkflowStatus(projectRoot),
+    todos: getTodoSummary(projectRoot),
+    quality: getQualityMetrics(projectRoot),
+    deps: getDependencyHealth(projectRoot),
+    monitor: getMonitorMetrics(projectRoot),
+    checkpoints: projectState.getCheckpointProgress(projectRoot)
+  };
+
+  // Calculate score
+  const score = calculateHealthScore(data);
+  const { grade, color } = getHealthGrade(score);
+
+  // Health Score
+  console.log(`${utils.COLORS.bold}Overall Health${utils.COLORS.reset}`);
+  console.log(`  ${color}${utils.COLORS.bold}${grade}${utils.COLORS.reset} - ${score}/100`);
+  console.log();
+
+  // Checkpoints
+  if (data.checkpoints && data.checkpoints.total > 0) {
+    console.log(`${utils.COLORS.bold}Checkpoints${utils.COLORS.reset}`);
+    const cpBar = checkpointEngine.getColoredProgressBar(data.checkpoints.percentage, 20);
+    console.log(`  ${cpBar} ${data.checkpoints.completed}/${data.checkpoints.total} (${data.checkpoints.percentage}%)`);
+    console.log();
+  }
+
+  // Workflows
+  console.log(`${utils.COLORS.bold}Workflows${utils.COLORS.reset}`);
+  for (const [name, status] of Object.entries(data.workflows)) {
+    if (status.error) {
+      console.log(`  ${utils.COLORS.yellow}⚠${utils.COLORS.reset} ${name}: Error reading state`);
+    } else if (!status.exists) {
+      console.log(`  ${utils.COLORS.dim}○${utils.COLORS.reset} ${name}: Not started`);
+    } else if (status.isComplete) {
+      console.log(`  ${utils.COLORS.green}✓${utils.COLORS.reset} ${name}: Complete`);
+    } else {
+      console.log(`  ${utils.COLORS.yellow}◐${utils.COLORS.reset} ${name}: ${status.progress}% complete`);
+    }
+  }
+  console.log();
+
+  // Todos
+  console.log(`${utils.COLORS.bold}Tasks${utils.COLORS.reset}`);
+  if (!data.todos.exists) {
+    console.log(`  ${utils.COLORS.dim}No todo.md found${utils.COLORS.reset}`);
+  } else {
+    const pendingIcon = data.todos.pending === 0 ?
+      `${utils.COLORS.green}✓${utils.COLORS.reset}` :
+      `${utils.COLORS.yellow}●${utils.COLORS.reset}`;
+    console.log(`  ${pendingIcon} ${data.todos.pending} pending, ${data.todos.completed} completed`);
+  }
+  console.log();
+
+  // Quality
+  console.log(`${utils.COLORS.bold}Quality Tooling${utils.COLORS.reset}`);
+  const qIcon = (has) => has ?
+    `${utils.COLORS.green}✓${utils.COLORS.reset}` :
+    `${utils.COLORS.dim}○${utils.COLORS.reset}`;
+  console.log(`  ${qIcon(data.quality.hasTypeScript)} TypeScript`);
+  console.log(`  ${qIcon(data.quality.hasEslint)} ESLint`);
+  console.log(`  ${qIcon(data.quality.hasPrettier)} Prettier`);
+  console.log(`  ${qIcon(data.quality.hasTests)} Tests`);
+  if (data.quality.testCoverage !== null) {
+    const covColor = data.quality.testCoverage >= 80 ? utils.COLORS.green :
+      data.quality.testCoverage >= 60 ? utils.COLORS.yellow : utils.COLORS.red;
+    console.log(`  ${covColor}●${utils.COLORS.reset} Coverage: ${data.quality.testCoverage}%`);
+  }
+  console.log();
+
+  // Dependencies
+  console.log(`${utils.COLORS.bold}Dependencies${utils.COLORS.reset}`);
+  if (!data.deps.exists) {
+    console.log(`  ${utils.COLORS.dim}No package.json found${utils.COLORS.reset}`);
+  } else {
+    console.log(`  ${utils.COLORS.dim}●${utils.COLORS.reset} ${data.deps.dependencies} deps, ${data.deps.devDependencies} devDeps`);
+    const vulns = data.deps.vulnerabilities || {};
+    if (vulns.critical > 0) {
+      console.log(`  ${utils.COLORS.red}✗${utils.COLORS.reset} ${vulns.critical} critical vulnerabilities`);
+    } else if (vulns.high > 0) {
+      console.log(`  ${utils.COLORS.yellow}⚠${utils.COLORS.reset} ${vulns.high} high vulnerabilities`);
+    } else if (vulns.total > 0) {
+      console.log(`  ${utils.COLORS.yellow}○${utils.COLORS.reset} ${vulns.total} vulnerabilities (low/moderate)`);
+    } else {
+      console.log(`  ${utils.COLORS.green}✓${utils.COLORS.reset} No vulnerabilities`);
+    }
+  }
+  console.log();
+
+  // Metrics
+  if (data.monitor.exists && !data.monitor.noData && !data.monitor.error) {
+    console.log(`${utils.COLORS.bold}Latest Metrics${utils.COLORS.reset}`);
+    if (data.monitor.bundleSize) {
+      console.log(`  Bundle size: ${data.monitor.bundleSize} KB`);
+    }
+    if (data.monitor.timestamp) {
+      const date = new Date(data.monitor.timestamp).toLocaleDateString();
+      console.log(`  ${utils.COLORS.dim}Collected: ${date}${utils.COLORS.reset}`);
+    }
+    console.log();
+  }
+
+  // Recommendations
+  const recommendations = [];
+
+  // Checkpoint recommendations
+  if (!data.checkpoints || data.checkpoints.total === 0) {
+    recommendations.push('Run `bootspring checkpoint init` to start tracking progress');
+  } else if (data.checkpoints.percentage < 50) {
+    recommendations.push('Complete more checkpoints with `bootspring checkpoint sync`');
+  }
+
+  if (!data.quality.hasTypeScript) {
+    recommendations.push('Add TypeScript for type safety');
+  }
+  if (!data.quality.hasEslint) {
+    recommendations.push('Add ESLint for code quality');
+  }
+  if (!data.quality.hasTests) {
+    recommendations.push('Add tests for reliability');
+  }
+  if (data.todos.pending > 5) {
+    recommendations.push(`Address ${data.todos.pending} pending tasks`);
+  }
+  if (!data.workflows.analyze?.isComplete) {
+    recommendations.push('Run `bootspring analyze` for codebase insights');
+  }
+  if (!data.workflows.audit?.isComplete) {
+    recommendations.push('Run `bootspring audit` for quality assessment');
+  }
+  const vulns = data.deps.vulnerabilities || {};
+  if (vulns.critical > 0 || vulns.high > 0) {
+    recommendations.push('Run `npm audit fix` to address vulnerabilities');
+  }
+
+  if (recommendations.length > 0) {
+    console.log(`${utils.COLORS.bold}Recommendations${utils.COLORS.reset}`);
+    recommendations.slice(0, 5).forEach(rec => {
+      console.log(`  ${utils.COLORS.cyan}→${utils.COLORS.reset} ${rec}`);
+    });
+    console.log();
+  }
+
+  return { score, grade, data };
+}
+
+/**
+ * Show help
+ */
+function showHelp() {
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Health${utils.COLORS.reset}
+${utils.COLORS.dim}Quick project health overview${utils.COLORS.reset}
+
+${utils.COLORS.bold}Usage:${utils.COLORS.reset}
+  bootspring health [options]
+
+${utils.COLORS.bold}Options:${utils.COLORS.reset}
+  --json          Output as JSON
+
+${utils.COLORS.bold}What it checks:${utils.COLORS.reset}
+  - Workflow completion status
+  - Todo/task progress
+  - Quality tooling (TypeScript, ESLint, Prettier)
+  - Test coverage
+  - Dependency vulnerabilities
+  - Recent metrics
+
+${utils.COLORS.bold}Examples:${utils.COLORS.reset}
+  bootspring health
+  bootspring health --json
+`);
+}
+
+/**
+ * Run health command
+ */
+async function run(args) {
+  const parsedArgs = utils.parseArgs(args);
+  const subcommand = parsedArgs._[0];
+
+  if (subcommand === 'help' || subcommand === '-h' || subcommand === '--help') {
+    showHelp();
+    return;
+  }
+
+  const cfg = config.load();
+  const projectRoot = cfg._projectRoot;
+
+  if (parsedArgs.json) {
+    const data = {
+      workflows: getWorkflowStatus(projectRoot),
+      todos: getTodoSummary(projectRoot),
+      quality: getQualityMetrics(projectRoot),
+      deps: getDependencyHealth(projectRoot),
+      monitor: getMonitorMetrics(projectRoot)
+    };
+    data.score = calculateHealthScore(data);
+    data.grade = getHealthGrade(data.score).grade;
+    console.log(JSON.stringify(data, null, 2));
+  } else {
+    showHealth(projectRoot);
+  }
+}
+
+module.exports = {
+  run,
+  getWorkflowStatus,
+  getTodoSummary,
+  getDependencyHealth,
+  getQualityMetrics,
+  calculateHealthScore
+};

package/cli/init.js

@@ -19,6 +19,8 @@ const { runQuestionnaire } = require('../generators/questionnaire');
 const claudeTemplate = require('../generators/templates/claude.template');
 const seedTemplate = require('../generators/templates/seed.template');
 const planningTemplate = require('../generators/templates/planning.template');
+const api = require('../core/api-client');
+const { requireProjectSelection } = require('./auth');
 // Presets available via runQuestionnaire('preset-name')
 
 // Available options (for legacy quick mode)
@@ -314,9 +316,57 @@ async function run(args) {
   const parsedArgs = utils.parseArgs(args);
   const force = parsedArgs.force || parsedArgs.f;
   const quick = parsedArgs.quick || parsedArgs.q;
-  const preset = parsedArgs.preset || (quick ? 'minimal' : null);
+  const listPresetsFlag = parsedArgs['list-presets'] || parsedArgs.presets;
+  const presetArg = parsedArgs.preset || (quick ? 'minimal' : null);
   const projectRoot = config.findProjectRoot();
 
+  // Handle --list-presets flag (no auth required for help)
+  if (listPresetsFlag) {
+    console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}Available Config Presets${utils.COLORS.reset}
+
+${config.listPresets({ verbose: true }).map(p =>
+    `  ${utils.COLORS.bold}${p.key}${utils.COLORS.reset}
+   ${p.description}
+   ${utils.COLORS.dim}Tags: ${p.tags.join(', ')}${p.extends ? ` | Extends: ${p.extends}` : ''}${utils.COLORS.reset}
+`).join('\n')}
+${utils.COLORS.dim}Usage: bootspring init --preset <preset-name>
+       bootspring init --preset saas-starter,ai-app  (combine presets)${utils.COLORS.reset}
+`);
+    return;
+  }
+
+  // Require authentication before proceeding
+  try {
+    api.requireAuth();
+  } catch (error) {
+    utils.print.error(error.message);
+    utils.print.dim('Run: bootspring auth login');
+    return;
+  }
+
+  // Ensure project is selected
+  await requireProjectSelection();
+
+  // Parse and validate preset(s)
+  let configPresets = null;
+  if (presetArg && !['minimal', 'standard', 'full'].includes(presetArg)) {
+    // This is a config preset (saas-starter, api-only, etc.), not a questionnaire preset
+    configPresets = config.parsePresetString(presetArg);
+    const validation = config.validatePresets(configPresets);
+    if (!validation.valid) {
+      utils.print.error('Invalid preset(s):');
+      validation.errors.forEach(err => utils.print.dim(`  - ${err}`));
+      console.log(`\n${utils.COLORS.dim}Run 'bootspring init --list-presets' to see available presets${utils.COLORS.reset}`);
+      return;
+    }
+  }
+
+  // Determine questionnaire preset (for interactive mode)
+  const questionnairePreset = !configPresets && presetArg && ['minimal', 'standard', 'full'].includes(presetArg)
+    ? presetArg
+    : null;
+
   console.log(`
 ${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Init${utils.COLORS.reset}
 ${utils.COLORS.dim}Development scaffolding with intelligence${utils.COLORS.reset}
@@ -337,21 +387,41 @@ ${utils.COLORS.dim}Development scaffolding with intelligence${utils.COLORS.reset
 
   let projectConfig;
 
-  // Questionnaire mode (new default or with --preset)
-  if (preset) {
-    // Use questionnaire with specified preset
-    const presetName = ['minimal', 'standard', 'full'].includes(preset) ? preset : 'standard';
-    utils.print.info(`Using ${presetName} preset questionnaire`);
+  // Config preset mode (saas-starter, api-only, etc.)
+  if (configPresets && configPresets.length > 0) {
+    const presetDisplay = configPresets.join(' + ');
+    utils.print.info(`Using config preset(s): ${presetDisplay}`);
+
+    try {
+      // Apply presets (combining if multiple)
+      projectConfig = config.applyPreset(configPresets, {
+        project: {
+          name: detected.name,
+          description: '',
+          version: '1.0.0'
+        }
+      });
+      projectConfig._configPreset = configPresets.join(',');
+      projectConfig._preset = 'config'; // Mark as config preset for template generation
+    } catch (error) {
+      utils.print.error(`Failed to apply preset: ${error.message}`);
+      return;
+    }
+  }
+  // Questionnaire preset mode (minimal, standard, full)
+  else if (questionnairePreset) {
+    utils.print.info(`Using ${questionnairePreset} preset questionnaire`);
 
     try {
-      projectConfig = await runQuestionnaire(presetName);
-      projectConfig._preset = presetName;
+      projectConfig = await runQuestionnaire(questionnairePreset);
+      projectConfig._preset = questionnairePreset;
     } catch (error) {
       utils.print.error(`Questionnaire failed: ${error.message}`);
       return;
     }
-  } else if (quick) {
-    // Quick mode - use detected values (legacy behavior)
+  }
+  // Quick mode - use detected values (legacy behavior)
+  else if (quick) {
     utils.print.info('Using detected settings (quick mode)');
     projectConfig = {
       project: {
@@ -377,8 +447,9 @@ ${utils.COLORS.dim}Development scaffolding with intelligence${utils.COLORS.reset
       quality: { preCommit: true, prePush: false, strictMode: false },
       paths: { context: 'CLAUDE.md', config: 'bootspring.config.js', todo: 'todo.md' }
     };
-  } else {
-    // Interactive mode - use standard questionnaire by default
+  }
+  // Default: Interactive questionnaire mode
+  else {
     try {
       projectConfig = await runQuestionnaire('standard');
       projectConfig._preset = 'standard';
@@ -483,7 +554,7 @@ ${utils.COLORS.dim}Development scaffolding with intelligence${utils.COLORS.reset
     // Global install detected but no global MCP config - suggest global
     utils.print.info('Global bootspring installation detected');
 
-    if (!quick && !preset) {
+    if (!quick && !presetArg) {
       const rl = createPrompt();
       const useGlobal = await askYesNo(rl, 'Configure MCP server globally (for all projects)?', true);
       rl.close();