@girardmedia/bootspring 1.1.0

package/cli/update.js

@@ -0,0 +1,312 @@
+/**
+ * Bootspring Update Command
+ * Check for updates and manage versions
+ *
+ * @package bootspring
+ * @command update
+ */
+
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const config = require('../core/config');
+const utils = require('../core/utils');
+
+/**
+ * Get current installed version
+ */
+function getCurrentVersion() {
+  const packagePath = path.join(__dirname, '..', 'package.json');
+
+  try {
+    const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf-8'));
+    return pkg.version || '0.0.0';
+  } catch (error) {
+    return '0.0.0';
+  }
+}
+
+/**
+ * Get latest version from npm
+ */
+async function getLatestVersion() {
+  try {
+    const result = execSync('npm view bootspring version 2>/dev/null', {
+      encoding: 'utf-8',
+      timeout: 10000
+    }).trim();
+    return result || null;
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Compare semantic versions
+ * Returns: -1 if a < b, 0 if a === b, 1 if a > b
+ */
+function compareVersions(a, b) {
+  const partsA = a.split('.').map(Number);
+  const partsB = b.split('.').map(Number);
+
+  for (let i = 0; i < 3; i++) {
+    const partA = partsA[i] || 0;
+    const partB = partsB[i] || 0;
+
+    if (partA < partB) return -1;
+    if (partA > partB) return 1;
+  }
+
+  return 0;
+}
+
+/**
+ * Check for updates
+ */
+async function checkForUpdates(options = {}) {
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Update Check${utils.COLORS.reset}
+`);
+
+  const spinner = utils.createSpinner('Checking for updates...').start();
+
+  const currentVersion = getCurrentVersion();
+  const latestVersion = await getLatestVersion();
+
+  if (!latestVersion) {
+    spinner.warn('Could not fetch latest version from npm');
+    console.log(`${utils.COLORS.dim}Current version: ${currentVersion}${utils.COLORS.reset}`);
+    console.log(`${utils.COLORS.dim}Package may not be published yet${utils.COLORS.reset}`);
+    return { current: currentVersion, latest: null, updateAvailable: false };
+  }
+
+  const comparison = compareVersions(currentVersion, latestVersion);
+
+  if (comparison < 0) {
+    spinner.succeed(`Update available: ${currentVersion} → ${latestVersion}`);
+    console.log(`
+${utils.COLORS.bold}To update:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}npm update -g bootspring${utils.COLORS.reset}
+
+${utils.COLORS.bold}Or for local projects:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}npm update bootspring${utils.COLORS.reset}
+`);
+    return { current: currentVersion, latest: latestVersion, updateAvailable: true };
+  } else if (comparison === 0) {
+    spinner.succeed(`You're on the latest version (${currentVersion})`);
+    return { current: currentVersion, latest: latestVersion, updateAvailable: false };
+  } else {
+    spinner.info(`You're ahead of npm (${currentVersion} > ${latestVersion})`);
+    console.log(`${utils.COLORS.dim}You may be running a development version${utils.COLORS.reset}`);
+    return { current: currentVersion, latest: latestVersion, updateAvailable: false };
+  }
+}
+
+/**
+ * Apply update via npm
+ */
+async function applyUpdate(options = {}) {
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Update${utils.COLORS.reset}
+`);
+
+  const checkResult = await checkForUpdates();
+
+  if (!checkResult.updateAvailable) {
+    return;
+  }
+
+  console.log(`${utils.COLORS.bold}Starting update...${utils.COLORS.reset}`);
+
+  const spinner = utils.createSpinner('Updating bootspring...').start();
+
+  try {
+    // Detect if installed globally or locally
+    const isGlobal = options.global || process.argv[1].includes('node_modules/.bin');
+
+    const command = isGlobal
+      ? 'npm update -g bootspring'
+      : 'npm update bootspring';
+
+    execSync(command, {
+      stdio: 'pipe',
+      encoding: 'utf-8',
+      timeout: 120000 // 2 minutes
+    });
+
+    spinner.succeed(`Updated to ${checkResult.latest}`);
+
+    console.log(`
+${utils.COLORS.green}Update complete!${utils.COLORS.reset}
+${utils.COLORS.dim}Run "bootspring --version" to verify${utils.COLORS.reset}
+`);
+  } catch (error) {
+    spinner.fail('Update failed');
+    console.log(`${utils.COLORS.red}${error.message}${utils.COLORS.reset}`);
+    console.log(`
+${utils.COLORS.dim}Try updating manually:${utils.COLORS.reset}
+  npm update -g bootspring
+`);
+  }
+}
+
+/**
+ * Show version information
+ */
+function showVersion() {
+  const currentVersion = getCurrentVersion();
+  const packagePath = path.join(__dirname, '..', 'package.json');
+
+  let packageInfo = {};
+  try {
+    packageInfo = JSON.parse(fs.readFileSync(packagePath, 'utf-8'));
+  } catch (error) {
+    // Ignore
+  }
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring${utils.COLORS.reset}
+${utils.COLORS.dim}Development scaffolding with intelligence${utils.COLORS.reset}
+
+${utils.COLORS.bold}Version Information${utils.COLORS.reset}
+  Version: ${utils.COLORS.cyan}${currentVersion}${utils.COLORS.reset}
+  ${packageInfo.description ? `Description: ${packageInfo.description}` : ''}
+  ${packageInfo.homepage ? `Homepage: ${packageInfo.homepage}` : ''}
+  ${packageInfo.repository?.url ? `Repository: ${packageInfo.repository.url}` : ''}
+
+${utils.COLORS.bold}Environment${utils.COLORS.reset}
+  Node.js: ${process.version}
+  Platform: ${process.platform}
+  Arch: ${process.arch}
+
+${utils.COLORS.dim}Run "bootspring update check" to check for updates${utils.COLORS.reset}
+`);
+}
+
+/**
+ * Show changelog/release notes
+ */
+async function showChangelog() {
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Changelog${utils.COLORS.reset}
+`);
+
+  const spinner = utils.createSpinner('Fetching changelog...').start();
+
+  try {
+    // Try to fetch from npm
+    const result = execSync('npm view bootspring --json 2>/dev/null', {
+      encoding: 'utf-8',
+      timeout: 10000
+    });
+
+    const npmInfo = JSON.parse(result);
+
+    spinner.succeed('Latest release info');
+
+    console.log(`
+${utils.COLORS.bold}Latest Version${utils.COLORS.reset}
+  Version: ${npmInfo.version}
+  Published: ${npmInfo.time?.[npmInfo.version] || 'unknown'}
+
+${utils.COLORS.bold}Recent Versions${utils.COLORS.reset}`);
+
+    const versions = Object.keys(npmInfo.time || {})
+      .filter(v => v !== 'created' && v !== 'modified')
+      .slice(-5)
+      .reverse();
+
+    for (const version of versions) {
+      const date = new Date(npmInfo.time[version]);
+      console.log(`  ${utils.COLORS.cyan}${version}${utils.COLORS.reset} - ${utils.formatDate(date)}`);
+    }
+
+    console.log(`
+${utils.COLORS.dim}For full changelog, visit: ${npmInfo.homepage || 'https://github.com/bootspring/bootspring'}${utils.COLORS.reset}
+`);
+  } catch (error) {
+    spinner.warn('Could not fetch changelog');
+    console.log(`
+${utils.COLORS.dim}Package may not be published yet.
+Check the repository for changelog information.${utils.COLORS.reset}
+`);
+  }
+}
+
+/**
+ * Show help
+ */
+function showHelp() {
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Update${utils.COLORS.reset}
+${utils.COLORS.dim}Check for updates and manage versions${utils.COLORS.reset}
+
+${utils.COLORS.bold}Usage:${utils.COLORS.reset}
+  bootspring update [command]
+
+${utils.COLORS.bold}Commands:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}check${utils.COLORS.reset}             Check for available updates
+  ${utils.COLORS.cyan}apply${utils.COLORS.reset}             Download and apply updates
+  ${utils.COLORS.cyan}version${utils.COLORS.reset}           Show version information
+  ${utils.COLORS.cyan}changelog${utils.COLORS.reset}         Show recent changes
+
+${utils.COLORS.bold}Options:${utils.COLORS.reset}
+  --global            Update global installation
+
+${utils.COLORS.bold}Examples:${utils.COLORS.reset}
+  bootspring update check
+  bootspring update apply
+  bootspring update version
+`);
+}
+
+/**
+ * Run update command
+ */
+async function run(args) {
+  const parsedArgs = utils.parseArgs(args);
+  const subcommand = parsedArgs._[0] || 'check';
+
+  switch (subcommand) {
+    case 'check':
+      await checkForUpdates();
+      break;
+
+    case 'apply':
+    case 'upgrade':
+    case 'install':
+      await applyUpdate({ global: parsedArgs.global });
+      break;
+
+    case 'version':
+    case '-v':
+    case '--version':
+      showVersion();
+      break;
+
+    case 'changelog':
+    case 'changes':
+    case 'releases':
+      await showChangelog();
+      break;
+
+    case 'help':
+    case '-h':
+    case '--help':
+      showHelp();
+      break;
+
+    default:
+      utils.print.error(`Unknown subcommand: ${subcommand}`);
+      showHelp();
+  }
+}
+
+module.exports = {
+  run,
+  checkForUpdates,
+  applyUpdate,
+  getCurrentVersion,
+  getLatestVersion,
+  compareVersions
+};

package/core/config.js

@@ -0,0 +1,245 @@
+/**
+ * Bootspring Configuration
+ * Handles loading and validating bootspring.config.js
+ *
+ * @package bootspring
+ * @module core/config
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Default configuration
+const DEFAULT_CONFIG = {
+  project: {
+    name: 'My Project',
+    description: '',
+    version: '1.0.0'
+  },
+
+  stack: {
+    framework: 'nextjs',
+    language: 'typescript',
+    database: 'postgresql',
+    hosting: 'vercel'
+  },
+
+  plugins: {
+    auth: { enabled: false, provider: 'clerk' },
+    payments: { enabled: false, provider: 'stripe' },
+    database: { enabled: true, provider: 'prisma' },
+    testing: { enabled: true, provider: 'vitest' },
+    security: { enabled: true },
+    ai: { enabled: false, provider: 'anthropic' }
+  },
+
+  dashboard: {
+    port: 3456,
+    autoOpen: false
+  },
+
+  quality: {
+    preCommit: true,
+    prePush: false,
+    strictMode: false
+  },
+
+  paths: {
+    context: 'CLAUDE.md',
+    config: 'bootspring.config.js',
+    todo: 'todo.md'
+  }
+};
+
+// Config file names to search for
+const CONFIG_FILES = [
+  'bootspring.config.js',
+  'bootspring.config.mjs',
+  'bootspring.config.json',
+  '.bootspringrc',
+  '.bootspringrc.js',
+  '.bootspringrc.json'
+];
+
+/**
+ * Find the project root directory
+ * @returns {string|null} Project root path or null
+ */
+function findProjectRoot() {
+  let dir = process.cwd();
+  const root = path.parse(dir).root;
+
+  while (dir !== root) {
+    // Check for common project indicators
+    if (
+      fs.existsSync(path.join(dir, 'package.json')) ||
+      fs.existsSync(path.join(dir, 'bootspring.config.js')) ||
+      fs.existsSync(path.join(dir, '.git'))
+    ) {
+      return dir;
+    }
+    dir = path.dirname(dir);
+  }
+
+  return process.cwd();
+}
+
+/**
+ * Find config file in project
+ * @param {string} projectRoot - Project root directory
+ * @returns {string|null} Config file path or null
+ */
+function findConfigFile(projectRoot) {
+  for (const filename of CONFIG_FILES) {
+    const filepath = path.join(projectRoot, filename);
+    if (fs.existsSync(filepath)) {
+      return filepath;
+    }
+  }
+  return null;
+}
+
+/**
+ * Deep merge two objects
+ * @param {object} target - Target object
+ * @param {object} source - Source object
+ * @returns {object} Merged object
+ */
+function deepMerge(target, source) {
+  const result = { ...target };
+
+  for (const key of Object.keys(source)) {
+    if (source[key] instanceof Object && key in target && target[key] instanceof Object) {
+      result[key] = deepMerge(target[key], source[key]);
+    } else {
+      result[key] = source[key];
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Load configuration from file
+ * @param {string} [projectRoot] - Optional project root path
+ * @returns {object} Configuration object
+ */
+function load(projectRoot = null) {
+  const root = projectRoot || findProjectRoot();
+  const configPath = findConfigFile(root);
+
+  let userConfig = {};
+
+  if (configPath) {
+    try {
+      if (configPath.endsWith('.json') || configPath.endsWith('.bootspringrc')) {
+        const content = fs.readFileSync(configPath, 'utf-8');
+        userConfig = JSON.parse(content);
+      } else {
+        // Clear require cache to get fresh config
+        delete require.cache[require.resolve(configPath)];
+        userConfig = require(configPath);
+      }
+    } catch (error) {
+      console.warn(`Warning: Could not load config from ${configPath}: ${error.message}`);
+    }
+  }
+
+  // Merge with defaults
+  const config = deepMerge(DEFAULT_CONFIG, userConfig);
+
+  // Add computed paths
+  config._projectRoot = root;
+  config._configPath = configPath;
+  config._bootspringDir = path.join(root, '.bootspring');
+
+  return config;
+}
+
+/**
+ * Save configuration to file
+ * @param {object} config - Configuration object
+ * @param {string} [filepath] - Optional file path
+ * @returns {boolean} Success status
+ */
+function save(config, filepath = null) {
+  const root = config._projectRoot || findProjectRoot();
+  const targetPath = filepath || path.join(root, 'bootspring.config.js');
+
+  // Remove internal properties
+  const cleanConfig = { ...config };
+  delete cleanConfig._projectRoot;
+  delete cleanConfig._configPath;
+  delete cleanConfig._bootspringDir;
+
+  const content = `/**
+ * Bootspring Configuration
+ * https://bootspring.com/docs/configuration
+ */
+
+module.exports = ${JSON.stringify(cleanConfig, null, 2)};
+`;
+
+  try {
+    fs.writeFileSync(targetPath, content, 'utf-8');
+    return true;
+  } catch (error) {
+    console.error(`Error saving config: ${error.message}`);
+    return false;
+  }
+}
+
+/**
+ * Validate configuration
+ * @param {object} config - Configuration object
+ * @returns {object} Validation result { valid, errors }
+ */
+function validate(config) {
+  const errors = [];
+
+  // Required fields
+  if (!config.project?.name) {
+    errors.push('project.name is required');
+  }
+
+  // Valid framework
+  const validFrameworks = ['nextjs', 'remix', 'nuxt', 'sveltekit', 'express', 'fastify'];
+  if (config.stack?.framework && !validFrameworks.includes(config.stack.framework)) {
+    errors.push(`Invalid framework: ${config.stack.framework}. Valid: ${validFrameworks.join(', ')}`);
+  }
+
+  // Valid language
+  const validLanguages = ['typescript', 'javascript'];
+  if (config.stack?.language && !validLanguages.includes(config.stack.language)) {
+    errors.push(`Invalid language: ${config.stack.language}. Valid: ${validLanguages.join(', ')}`);
+  }
+
+  // Port range
+  if (config.dashboard?.port && (config.dashboard.port < 1024 || config.dashboard.port > 65535)) {
+    errors.push('dashboard.port must be between 1024 and 65535');
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+/**
+ * Get default configuration
+ * @returns {object} Default configuration
+ */
+function getDefaults() {
+  return { ...DEFAULT_CONFIG };
+}
+
+module.exports = {
+  load,
+  save,
+  validate,
+  getDefaults,
+  findProjectRoot,
+  findConfigFile,
+  DEFAULT_CONFIG,
+  CONFIG_FILES
+};