@girardmedia/bootspring 1.2.0 → 2.0.3

package/cli/business.js

@@ -9,11 +9,10 @@
 const fs = require('fs');
 const path = require('path');
 const utils = require('../core/utils');
-
-/**
- * Template directory
- */
-const TEMPLATES_DIR = path.join(__dirname, '..', 'templates', 'business');
+const projectState = require('../core/project-state');
+const checkpointEngine = require('../core/checkpoint-engine');
+const api = require('../core/api-client');
+const auth = require('../core/auth');
 
 /**
  * Output directory for business docs
@@ -72,15 +71,44 @@ function processTemplate(content, config) {
     .replace(/\{\{DOMAIN\}\}/g, config.domain || 'example.com');
 }
 
+/**
+ * Fetch template content from API
+ */
+async function fetchTemplate(templateFile) {
+  if (!auth.isAuthenticated()) {
+    return { error: 'auth_required' };
+  }
+
+  try {
+    const response = await api.getTemplate('business', templateFile);
+    return response;
+  } catch (error) {
+    if (error.status === 401) {
+      return { error: 'auth_required' };
+    }
+    if (error.status === 403) {
+      return { error: 'upgrade_required' };
+    }
+    return { error: 'network_error', message: error.message };
+  }
+}
+
 /**
  * Initialize business planning docs
  */
-function businessInit() {
+async function businessInit() {
   console.log(`
 ${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Business Planning${utils.COLORS.reset}
 ${utils.COLORS.dim}Initialize business planning documents${utils.COLORS.reset}
 `);
 
+  // Check authentication
+  if (!auth.isAuthenticated()) {
+    utils.print.error('Authentication required');
+    console.log(`${utils.COLORS.dim}Run: bootspring auth login${utils.COLORS.reset}`);
+    return;
+  }
+
   const config = getProjectConfig();
   const outputDir = path.join(process.cwd(), OUTPUT_DIR);
 
@@ -91,6 +119,10 @@ ${utils.COLORS.dim}Initialize business planning documents${utils.COLORS.reset}
 
   const created = [];
   const skipped = [];
+  const failed = [];
+
+  const spinner = utils.createSpinner('Loading templates...');
+  spinner.start();
 
   // Create all business templates
   for (const [key, template] of Object.entries(TEMPLATES)) {
@@ -101,15 +133,20 @@ ${utils.COLORS.dim}Initialize business planning documents${utils.COLORS.reset}
       continue;
     }
 
-    const templatePath = path.join(TEMPLATES_DIR, template.file);
-    if (fs.existsSync(templatePath)) {
-      const content = fs.readFileSync(templatePath, 'utf-8');
-      const processed = processTemplate(content, config);
-      fs.writeFileSync(outputPath, processed);
-      created.push(template.name);
+    const result = await fetchTemplate(template.file);
+
+    if (result.error) {
+      failed.push({ name: template.name, error: result.error });
+      continue;
     }
+
+    const processed = processTemplate(result.content, config);
+    fs.writeFileSync(outputPath, processed);
+    created.push(template.name);
   }
 
+  spinner.stop();
+
   if (created.length > 0) {
     console.log(`${utils.COLORS.bold}Created:${utils.COLORS.reset}`);
     for (const name of created) {
@@ -126,6 +163,26 @@ ${utils.COLORS.dim}Initialize business planning documents${utils.COLORS.reset}
     console.log();
   }
 
+  if (failed.length > 0) {
+    console.log(`${utils.COLORS.bold}Failed:${utils.COLORS.reset}`);
+    for (const { name, error } of failed) {
+      console.log(`  ${utils.COLORS.red}✗${utils.COLORS.reset} ${name} (${error})`);
+    }
+    console.log();
+  }
+
+  // Auto-tag project as business type
+  try {
+    projectState.setProjectType(process.cwd(), projectState.PROJECT_TYPES.BUSINESS, {
+      autoTagged: true,
+      taggedBy: 'business-init'
+    });
+    checkpointEngine.syncCheckpoints(process.cwd(), { verbose: false });
+    utils.print.success('Project tagged as business type');
+  } catch (err) {
+    utils.print.debug(`Auto-tagging failed: ${err.message}`);
+  }
+
   console.log(`${utils.COLORS.bold}Next Steps:${utils.COLORS.reset}`);
   console.log(`  1. Edit ${utils.COLORS.cyan}${OUTPUT_DIR}/BUSINESS_PLAN.md${utils.COLORS.reset}`);
   console.log(`  2. Run ${utils.COLORS.cyan}bootspring agent invoke business-strategy-expert${utils.COLORS.reset}`);
@@ -135,7 +192,7 @@ ${utils.COLORS.dim}Initialize business planning documents${utils.COLORS.reset}
 /**
  * Create or edit a specific business document
  */
-function businessCreate(templateKey) {
+async function businessCreate(templateKey) {
   const template = TEMPLATES[templateKey];
 
   if (!template) {
@@ -149,6 +206,13 @@ ${utils.COLORS.cyan}${utils.COLORS.bold}⚡ ${template.name}${utils.COLORS.reset
 ${utils.COLORS.dim}${template.description}${utils.COLORS.reset}
 `);
 
+  // Check authentication
+  if (!auth.isAuthenticated()) {
+    utils.print.error('Authentication required');
+    console.log(`${utils.COLORS.dim}Run: bootspring auth login${utils.COLORS.reset}`);
+    return;
+  }
+
   const config = getProjectConfig();
   const outputDir = path.join(process.cwd(), OUTPUT_DIR);
   const outputPath = path.join(outputDir, template.output);
@@ -164,21 +228,40 @@ ${utils.COLORS.dim}${template.description}${utils.COLORS.reset}
     return;
   }
 
-  const templatePath = path.join(TEMPLATES_DIR, template.file);
-  if (!fs.existsSync(templatePath)) {
-    utils.print.error(`Template not found: ${template.file}`);
+  const spinner = utils.createSpinner('Loading template...');
+  spinner.start();
+
+  const result = await fetchTemplate(template.file);
+
+  if (result.error === 'auth_required') {
+    spinner.fail('Authentication required');
+    console.log(`${utils.COLORS.dim}Run: bootspring auth login${utils.COLORS.reset}`);
+    return;
+  }
+
+  if (result.error === 'upgrade_required') {
+    spinner.fail('Upgrade required');
+    console.log(`${utils.COLORS.dim}This template requires a Pro subscription.${utils.COLORS.reset}`);
+    console.log(`${utils.COLORS.dim}Run: bootspring billing upgrade${utils.COLORS.reset}`);
     return;
   }
 
-  const content = fs.readFileSync(templatePath, 'utf-8');
-  const processed = processTemplate(content, config);
+  if (result.error) {
+    spinner.fail('Failed to load template');
+    console.log(`${utils.COLORS.dim}${result.message || 'Check your internet connection.'}${utils.COLORS.reset}`);
+    return;
+  }
+
+  spinner.succeed('Template loaded');
+
+  const processed = processTemplate(result.content, config);
   fs.writeFileSync(outputPath, processed);
 
   utils.print.success(`Created ${template.name}`);
   console.log(`\nFile: ${utils.COLORS.cyan}${OUTPUT_DIR}/${template.output}${utils.COLORS.reset}`);
   console.log(`\n${utils.COLORS.bold}Next Steps:${utils.COLORS.reset}`);
-  console.log(`  1. Open and edit the document`);
-  console.log(`  2. Use AI agents for assistance:`);
+  console.log('  1. Open and edit the document');
+  console.log('  2. Use AI agents for assistance:');
   console.log(`     ${utils.COLORS.cyan}bootspring agent invoke business-strategy-expert${utils.COLORS.reset}`);
 }
 
@@ -192,7 +275,7 @@ ${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Business Planning Status${utils.COLO
 
   const outputDir = path.join(process.cwd(), OUTPUT_DIR);
   let found = 0;
-  let total = Object.keys(TEMPLATES).length;
+  const total = Object.keys(TEMPLATES).length;
 
   for (const [key, template] of Object.entries(TEMPLATES)) {
     const outputPath = path.join(outputDir, template.output);
@@ -300,20 +383,20 @@ async function run(args) {
 
   switch (subcommand) {
     case 'init':
-      businessInit();
+      await businessInit();
       break;
 
     case 'plan':
-      businessCreate('plan');
+      await businessCreate('plan');
       break;
 
     case 'model':
-      businessCreate('model');
+      await businessCreate('model');
       break;
 
     case 'competitors':
     case 'competitive':
-      businessCreate('competitors');
+      await businessCreate('competitors');
       break;
 
     case 'status':
@@ -338,7 +421,7 @@ async function run(args) {
     default:
       // Check if it's a template name
       if (TEMPLATES[subcommand]) {
-        businessCreate(subcommand);
+        await businessCreate(subcommand);
       } else {
         utils.print.error(`Unknown subcommand: ${subcommand}`);
         showHelp();

package/cli/checkpoint-utils.js

@@ -0,0 +1,168 @@
+/**
+ * Bootspring Checkpoint Utilities
+ * Shared utilities for checkpoint scanning and syncing
+ *
+ * @package bootspring
+ * @module cli/checkpoint-utils
+ */
+
+const fs = require('fs');
+const path = require('path');
+const config = require('../core/config');
+const auth = require('../core/auth');
+const session = require('../core/session');
+const projectState = require('../core/project-state');
+
+/**
+ * Scan files for checkpoint evaluation
+ * Returns raw file data - server determines what checkpoints are complete
+ * @param {string} projectRoot - Project root directory
+ * @returns {object} File scan data
+ */
+function scanFilesForCheckpoints(projectRoot) {
+  const fileScan = {};
+
+  // List of files to scan (paths are relative to project root)
+  const filesToScan = [
+    'planning/PROJECT_STATE.json',
+    'planning/PRD.md',
+    'planning/TECHNICAL_SPEC.md',
+    'planning/ARCHITECTURE.md',
+    'planning/DATABASE_SCHEMA.md',
+    'planning/API_CONTRACTS.md',
+    'planning/TEST_PLAN.md',
+    'planning/DEPLOYMENT.md',
+    'planning/CONTENT_STRATEGY.md',
+    'planning/EDITORIAL_CALENDAR.md',
+    'planning/STYLE_GUIDE.md',
+    'planning/SEO_PLAN.md',
+    'planning/BUSINESS_PLAN.md',
+    'planning/MARKET_ANALYSIS.md',
+    'planning/COMPETITOR_ANALYSIS.md',
+    'planning/FINANCIAL_MODEL.md',
+    'planning/PITCH_DECK.md',
+    'planning/INVESTOR_LIST.md'
+  ];
+
+  for (const relativePath of filesToScan) {
+    const fullPath = path.join(projectRoot, relativePath);
+    try {
+      if (fs.existsSync(fullPath)) {
+        const stats = fs.statSync(fullPath);
+        const content = fs.readFileSync(fullPath, 'utf-8');
+        fileScan[relativePath] = {
+          exists: true,
+          size: stats.size,
+          // Only include content for files that need pattern matching
+          ...(relativePath === 'planning/DEPLOYMENT.md' && { content })
+        };
+      } else {
+        fileScan[relativePath] = { exists: false, size: 0 };
+      }
+    } catch {
+      fileScan[relativePath] = { exists: false, size: 0 };
+    }
+  }
+
+  return fileScan;
+}
+
+/**
+ * Push checkpoints to dashboard
+ * Sends raw file scan data - server evaluates checkpoints and calculates scores
+ * @param {string} projectRoot - Project root directory
+ * @param {object} options - Options
+ * @param {boolean} options.quiet - Don't log output
+ * @param {boolean} options.autoSync - Mark as automatic sync
+ * @returns {Promise<object>} Push result
+ */
+async function pushCheckpointsToServer(projectRoot, options = {}) {
+  const apiKey = auth.getApiKey();
+
+  if (!apiKey) {
+    if (!options.quiet) {
+      throw new Error('Not authenticated. Run: bootspring auth login');
+    }
+    return { success: false, reason: 'not_authenticated' };
+  }
+
+  // Get project ID from session
+  const currentProject = session.getCurrentProject();
+  const projectId = currentProject?.id;
+
+  if (!projectId) {
+    if (!options.quiet) {
+      throw new Error('No project selected. Run: bootspring switch <project>');
+    }
+    return { success: false, reason: 'no_project' };
+  }
+
+  // Scan files - raw data only, no evaluation
+  const fileScan = scanFilesForCheckpoints(projectRoot);
+
+  // Load local state for config values
+  const state = projectState.loadState(projectRoot) || {};
+  const configValues = {
+    content: state.content || {},
+    business: state.business || {}
+  };
+
+  // Check github connection
+  const githubSync = require('../core/github-sync');
+  const githubMeta = githubSync.loadGitHubSyncMetadata(projectRoot);
+  const githubConnected = githubMeta?.connected || false;
+
+  // Get raw scores from local collectors (server will weight them)
+  let documentationScore, securityScore, testCoverage, githubActivity;
+
+  if (!options.skipMetrics) {
+    try {
+      const metricsEngine = require('../core/metrics-engine');
+      const rawMetrics = await metricsEngine.collectMetrics(projectRoot, { quiet: true });
+      documentationScore = rawMetrics.categories?.docs?.average;
+      securityScore = rawMetrics.categories?.security?.average;
+      testCoverage = rawMetrics.metrics?.test_coverage?.score;
+      githubActivity = rawMetrics.metrics?.commit_frequency?.score;
+    } catch {
+      // Metrics collection is optional
+    }
+  }
+
+  // Send raw data to server for evaluation
+  const cfg = config.load();
+  const apiBase = cfg.apiBase || 'https://bootspring.com';
+  const response = await fetch(`${apiBase}/api/projects/${projectId}/checkpoints/evaluate`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'x-api-key': apiKey
+    },
+    body: JSON.stringify({
+      fileScan,
+      configValues,
+      githubConnected,
+      githubActivity,
+      documentationScore,
+      securityScore,
+      testCoverage,
+      autoSync: options.autoSync || false
+    }),
+    redirect: 'follow'
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({}));
+    throw new Error(error.error || `HTTP ${response.status}`);
+  }
+
+  const result = await response.json();
+  return {
+    success: true,
+    ...result
+  };
+}
+
+module.exports = {
+  scanFilesForCheckpoints,
+  pushCheckpointsToServer
+};