@girardmedia/bootspring 1.1.0

package/cli/context.js

@@ -0,0 +1,194 @@
+/**
+ * Bootspring Context Command
+ * View and manage project context
+ *
+ * @package bootspring
+ * @command context
+ */
+
+const path = require('path');
+const config = require('../core/config');
+const context = require('../core/context');
+const utils = require('../core/utils');
+
+/**
+ * Show project context summary
+ */
+function showContext() {
+  const cfg = config.load();
+  const ctx = context.get({ config: cfg });
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Context${utils.COLORS.reset}
+${utils.COLORS.dim}Project: ${cfg._projectRoot}${utils.COLORS.reset}
+`);
+
+  // Project Info
+  console.log(`${utils.COLORS.bold}Project${utils.COLORS.reset}`);
+  console.log(`  Name: ${ctx.project.name}`);
+  console.log(`  Version: ${ctx.project.version}`);
+  if (ctx.project.description) {
+    console.log(`  Description: ${ctx.project.description}`);
+  }
+  console.log();
+
+  // Stack
+  console.log(`${utils.COLORS.bold}Stack${utils.COLORS.reset}`);
+  console.log(`  Framework: ${utils.COLORS.cyan}${ctx.stack.framework}${utils.COLORS.reset}`);
+  console.log(`  Language: ${ctx.stack.language}`);
+  console.log(`  Database: ${ctx.stack.database}`);
+  console.log(`  Hosting: ${ctx.stack.hosting}`);
+  console.log();
+
+  // Plugins
+  const plugins = Object.keys(ctx.plugins);
+  if (plugins.length > 0) {
+    console.log(`${utils.COLORS.bold}Enabled Plugins${utils.COLORS.reset}`);
+    for (const [name, plugin] of Object.entries(ctx.plugins)) {
+      console.log(`  ${utils.COLORS.green}●${utils.COLORS.reset} ${name} (${plugin.provider})`);
+    }
+    console.log();
+  }
+
+  // State
+  const healthColor = ctx.state.health === 'good' ? utils.COLORS.green :
+                      ctx.state.health === 'fair' ? utils.COLORS.yellow :
+                      utils.COLORS.red;
+
+  console.log(`${utils.COLORS.bold}State${utils.COLORS.reset}`);
+  console.log(`  Phase: ${ctx.state.phase}`);
+  console.log(`  Health: ${healthColor}${ctx.state.health}${utils.COLORS.reset}`);
+  console.log(`  Open Todos: ${ctx.state.todos}`);
+  if (ctx.state.lastGenerated) {
+    console.log(`  Context Updated: ${utils.formatRelativeTime(ctx.state.lastGenerated)}`);
+  }
+  console.log();
+
+  // Git
+  if (ctx.git.initialized) {
+    console.log(`${utils.COLORS.bold}Git${utils.COLORS.reset}`);
+    console.log(`  Branch: ${ctx.git.branch || 'unknown'}`);
+    console.log(`  Remote: ${ctx.git.hasRemote ? 'configured' : 'not configured'}`);
+    console.log();
+  }
+}
+
+/**
+ * Validate project context
+ */
+function validateContext() {
+  const cfg = config.load();
+  const validation = context.validate({ config: cfg });
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Context Validation${utils.COLORS.reset}
+`);
+
+  for (const check of validation.checks) {
+    const icon = check.status === 'pass' ? utils.COLORS.green + '✓' :
+                 check.status === 'fail' ? utils.COLORS.red + '✗' :
+                 check.status === 'warn' ? utils.COLORS.yellow + '⚠' :
+                 utils.COLORS.dim + 'ℹ';
+    const color = check.status === 'pass' ? '' :
+                  check.status === 'fail' ? utils.COLORS.red :
+                  check.status === 'warn' ? utils.COLORS.yellow :
+                  utils.COLORS.dim;
+    console.log(`  ${icon}${utils.COLORS.reset} ${check.name}`);
+    console.log(`    ${utils.COLORS.dim}${check.message}${utils.COLORS.reset}`);
+  }
+
+  console.log();
+
+  // Score bar
+  const barWidth = 30;
+  const filled = Math.round((validation.percentage / 100) * barWidth);
+  const empty = barWidth - filled;
+  const scoreColor = validation.percentage >= 80 ? utils.COLORS.green :
+                     validation.percentage >= 50 ? utils.COLORS.yellow :
+                     utils.COLORS.red;
+
+  console.log(`${utils.COLORS.bold}Score${utils.COLORS.reset}`);
+  console.log(`  ${scoreColor}${'█'.repeat(filled)}${utils.COLORS.dim}${'░'.repeat(empty)}${utils.COLORS.reset} ${validation.percentage}%`);
+  console.log(`  ${validation.score}/${validation.maxScore} checks passed`);
+  console.log();
+
+  if (validation.valid) {
+    utils.print.success('Context validation passed');
+  } else {
+    utils.print.warning('Context needs attention - fix the issues above');
+    utils.print.dim('Run "bootspring generate" to regenerate context');
+  }
+}
+
+/**
+ * Refresh project context
+ */
+function refreshContext() {
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Context Refresh${utils.COLORS.reset}
+`);
+
+  utils.print.info('Refreshing context...');
+
+  // This triggers a regeneration
+  const generateModule = require('./generate');
+  generateModule.run([]);
+}
+
+/**
+ * Show context help
+ */
+function showHelp() {
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Context${utils.COLORS.reset}
+${utils.COLORS.dim}View and manage project context${utils.COLORS.reset}
+
+${utils.COLORS.bold}Usage:${utils.COLORS.reset}
+  bootspring context <command>
+
+${utils.COLORS.bold}Commands:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}show${utils.COLORS.reset}              Show context summary (default)
+  ${utils.COLORS.cyan}validate${utils.COLORS.reset}          Validate project setup
+  ${utils.COLORS.cyan}refresh${utils.COLORS.reset}           Regenerate context files
+
+${utils.COLORS.bold}Examples:${utils.COLORS.reset}
+  bootspring context
+  bootspring context validate
+  bootspring context refresh
+`);
+}
+
+/**
+ * Run context command
+ */
+async function run(args) {
+  const subcommand = args[0] || 'show';
+
+  switch (subcommand) {
+    case 'show':
+      showContext();
+      break;
+
+    case 'validate':
+    case 'check':
+      validateContext();
+      break;
+
+    case 'refresh':
+    case 'regenerate':
+      refreshContext();
+      break;
+
+    case 'help':
+    case '-h':
+    case '--help':
+      showHelp();
+      break;
+
+    default:
+      utils.print.error(`Unknown subcommand: ${subcommand}`);
+      showHelp();
+  }
+}
+
+module.exports = { run, showContext, validateContext, refreshContext };

package/cli/dashboard.js

@@ -0,0 +1,150 @@
+/**
+ * Bootspring Dashboard Command
+ * Control the real-time dashboard
+ *
+ * @package bootspring
+ * @command dashboard
+ */
+
+const path = require('path');
+const { spawn } = require('child_process');
+const config = require('../core/config');
+const utils = require('../core/utils');
+
+/**
+ * Start the dashboard server
+ */
+function startDashboard(options = {}) {
+  const cfg = config.load();
+  const port = options.port || cfg.dashboard?.port || 3456;
+
+  const dashboardPath = path.resolve(__dirname, '../dashboard/server.js');
+
+  // Check if dashboard server exists
+  if (!utils.fileExists(dashboardPath)) {
+    utils.print.warning('Dashboard server not yet implemented');
+    utils.print.dim('Coming soon in a future release');
+    return;
+  }
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Dashboard${utils.COLORS.reset}
+${utils.COLORS.dim}Real-time project visibility${utils.COLORS.reset}
+`);
+
+  utils.print.info(`Starting dashboard on port ${port}...`);
+
+  // Start the server
+  const server = spawn('node', [dashboardPath], {
+    env: {
+      ...process.env,
+      PORT: port,
+      BOOTSPRING_ROOT: cfg._projectRoot
+    },
+    stdio: 'inherit'
+  });
+
+  server.on('error', (error) => {
+    utils.print.error(`Failed to start dashboard: ${error.message}`);
+  });
+
+  server.on('close', (code) => {
+    if (code !== 0) {
+      utils.print.error(`Dashboard exited with code ${code}`);
+    }
+  });
+
+  // Handle graceful shutdown
+  process.on('SIGINT', () => {
+    utils.print.info('Shutting down dashboard...');
+    server.kill('SIGINT');
+    process.exit(0);
+  });
+
+  process.on('SIGTERM', () => {
+    server.kill('SIGTERM');
+    process.exit(0);
+  });
+}
+
+/**
+ * Show dashboard status
+ */
+function showStatus() {
+  const cfg = config.load();
+  const port = cfg.dashboard?.port || 3456;
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Dashboard Status${utils.COLORS.reset}
+
+${utils.COLORS.bold}Configuration:${utils.COLORS.reset}
+  Port: ${port}
+  Auto-open: ${cfg.dashboard?.autoOpen ? 'yes' : 'no'}
+
+${utils.COLORS.bold}To start:${utils.COLORS.reset}
+  bootspring dashboard
+
+${utils.COLORS.bold}URL:${utils.COLORS.reset}
+  http://localhost:${port}
+`);
+}
+
+/**
+ * Show dashboard help
+ */
+function showHelp() {
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Dashboard${utils.COLORS.reset}
+${utils.COLORS.dim}Real-time project visibility${utils.COLORS.reset}
+
+${utils.COLORS.bold}Usage:${utils.COLORS.reset}
+  bootspring dashboard [command] [options]
+
+${utils.COLORS.bold}Commands:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}start${utils.COLORS.reset}             Start the dashboard (default)
+  ${utils.COLORS.cyan}status${utils.COLORS.reset}            Show dashboard status
+
+${utils.COLORS.bold}Options:${utils.COLORS.reset}
+  --port <port>     Use a specific port (default: 3456)
+
+${utils.COLORS.bold}Examples:${utils.COLORS.reset}
+  bootspring dashboard
+  bootspring dashboard --port 8080
+  bootspring dashboard status
+`);
+}
+
+/**
+ * Run dashboard command
+ */
+async function run(args) {
+  const parsedArgs = utils.parseArgs(args);
+  const subcommand = parsedArgs._[0] || 'start';
+
+  switch (subcommand) {
+    case 'start':
+      startDashboard({ port: parsedArgs.port });
+      break;
+
+    case 'status':
+      showStatus();
+      break;
+
+    case 'help':
+    case '-h':
+    case '--help':
+      showHelp();
+      break;
+
+    default:
+      // Treat unknown as start with possible port
+      if (!isNaN(parseInt(subcommand, 10))) {
+        startDashboard({ port: parseInt(subcommand, 10) });
+      } else {
+        utils.print.error(`Unknown subcommand: ${subcommand}`);
+        showHelp();
+      }
+  }
+}
+
+module.exports = { run, startDashboard, showStatus };

package/cli/generate.js

@@ -0,0 +1,294 @@
+/**
+ * Bootspring Generate Command
+ * Generate and regenerate AI context files
+ *
+ * @package bootspring
+ * @command generate
+ */
+
+const fs = require('fs');
+const path = require('path');
+const config = require('../core/config');
+const context = require('../core/context');
+const utils = require('../core/utils');
+const gitMemory = require('../intelligence/git-memory');
+
+/**
+ * Generate CLAUDE.md content from config and project state
+ */
+function generateClaudeMd(cfg, ctx) {
+  const date = utils.formatDate();
+
+  const sections = [];
+
+  // Header
+  sections.push(`# ${cfg.project.name} - AI Context
+
+**Generated by**: Bootspring v1.0.0
+**Last Updated**: ${date}
+**Status**: ${ctx.state.phase}
+**Health**: ${ctx.state.health}
+
+---`);
+
+  // Project Overview
+  sections.push(`## Project Overview
+
+${cfg.project.description || 'A modern web application built with Bootspring.'}
+
+---`);
+
+  // Tech Stack
+  sections.push(`## Tech Stack
+
+| Component | Technology |
+|-----------|------------|
+| Framework | ${cfg.stack.framework} |
+| Language | ${cfg.stack.language} |
+| Database | ${cfg.stack.database} |
+| Hosting | ${cfg.stack.hosting} |
+
+---`);
+
+  // Enabled Plugins
+  const enabledPlugins = Object.entries(cfg.plugins)
+    .filter(([_, p]) => p.enabled !== false);
+
+  if (enabledPlugins.length > 0) {
+    sections.push(`## Enabled Plugins
+
+${enabledPlugins.map(([name, plugin]) => `### ${name.charAt(0).toUpperCase() + name.slice(1)}
+- **Provider**: ${plugin.provider || 'default'}
+- **Features**: ${(plugin.features || []).join(', ') || 'default'}`).join('\n\n')}
+
+---`);
+  }
+
+  // Bootspring Commands
+  sections.push(`## Bootspring Commands
+
+Quick commands for your AI assistant:
+
+### Todo Management
+\`\`\`bash
+bootspring todo add "task"    # Add a new todo
+bootspring todo list          # List all todos
+bootspring todo done <id>     # Mark as complete
+bootspring todo clear         # Clear completed
+\`\`\`
+
+### Agents & Skills
+\`\`\`bash
+bootspring agent list         # List available agents
+bootspring agent invoke <n>   # Get specialized help
+bootspring skill search <q>   # Find code patterns
+bootspring skill show <name>  # View a skill
+\`\`\`
+
+### Project Tools
+\`\`\`bash
+bootspring dashboard          # Start real-time dashboard
+bootspring generate           # Regenerate this context
+bootspring quality pre-commit # Run quality checks
+bootspring context validate   # Validate project setup
+\`\`\`
+
+---`);
+
+  // Project State
+  sections.push(`## Current State
+
+- **Phase**: ${ctx.state.phase}
+- **Health**: ${ctx.state.health}
+- **Open Todos**: ${ctx.state.todos}
+${ctx.state.issues.length > 0 ? `- **Issues**: ${ctx.state.issues.join(', ')}` : ''}
+
+---`);
+
+  // Git Info
+  if (ctx.git.initialized) {
+    sections.push(`## Git Repository
+
+- **Branch**: ${ctx.git.branch || 'unknown'}
+- **Remote**: ${ctx.git.hasRemote ? 'configured' : 'not configured'}
+
+---`);
+
+    // Extract git learnings
+    try {
+      const { learnings } = gitMemory.extractLearnings({
+        limit: 30,
+        since: '2 months ago',
+        cwd: cfg._projectRoot
+      });
+
+      if (learnings && learnings.length > 0) {
+        const learningsSection = gitMemory.toCompactSummary(learnings, { maxItems: 12 });
+        sections.push(learningsSection + '\n---');
+      }
+    } catch (e) {
+      // Git memory extraction failed silently
+    }
+  }
+
+  // Project Structure
+  sections.push(`## Project Structure
+
+- **Structure Type**: ${ctx.files.structure}
+- **Has TypeScript**: ${ctx.files.hasTsConfig ? 'yes' : 'no'}
+- **Has Package.json**: ${ctx.files.hasPackageJson ? 'yes' : 'no'}
+
+---`);
+
+  // Development Guidelines
+  sections.push(`## Development Guidelines
+
+### Code Style
+- Use ${cfg.stack.language === 'typescript' ? 'TypeScript' : 'JavaScript'} for all new code
+- Follow existing naming conventions in the codebase
+- Keep files focused and under 300 lines when possible
+
+### Best Practices
+- Use Server Components by default (if Next.js)
+- Prefer Server Actions over API routes for mutations
+- Use Zod for all input validation
+- Never expose API keys to client-side code
+- Write tests for new features
+
+### Git Commits
+- Use conventional commit format: \`feat:\`, \`fix:\`, \`docs:\`, \`refactor:\`
+- Keep commits focused and atomic
+- Never commit sensitive data or API keys
+
+---`);
+
+  // Custom Instructions
+  if (cfg.customInstructions) {
+    sections.push(`## Custom Instructions
+
+${cfg.customInstructions}
+
+---`);
+  }
+
+  // Footer
+  sections.push(`---
+
+*Generated by [Bootspring](https://bootspring.com) - Development scaffolding with intelligence*
+`);
+
+  return sections.join('\n\n');
+}
+
+/**
+ * Run generate command
+ */
+async function run(args) {
+  const parsedArgs = utils.parseArgs(args);
+  const full = parsedArgs.full || parsedArgs.f;
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Generate${utils.COLORS.reset}
+${utils.COLORS.dim}Regenerating AI context...${utils.COLORS.reset}
+`);
+
+  // Load config
+  const cfg = config.load();
+
+  if (!cfg._configPath) {
+    utils.print.error('No bootspring.config.js found');
+    utils.print.dim('Run "bootspring init" first to initialize your project');
+    return;
+  }
+
+  // Get context
+  const ctx = context.get({ config: cfg });
+
+  // Generate CLAUDE.md
+  const claudePath = path.join(cfg._projectRoot, cfg.paths?.context || 'CLAUDE.md');
+  const spinner = utils.createSpinner('Generating CLAUDE.md').start();
+
+  try {
+    const content = generateClaudeMd(cfg, ctx);
+    utils.writeFile(claudePath, content);
+    spinner.succeed('Generated CLAUDE.md');
+  } catch (error) {
+    spinner.fail(`Failed to generate CLAUDE.md: ${error.message}`);
+    return;
+  }
+
+  // Validate context
+  const validation = context.validate({ config: cfg });
+
+  console.log(`
+${utils.COLORS.bold}Context Validation${utils.COLORS.reset}
+`);
+
+  for (const check of validation.checks) {
+    const icon = check.status === 'pass' ? utils.COLORS.green + '✓' :
+                 check.status === 'fail' ? utils.COLORS.red + '✗' :
+                 check.status === 'warn' ? utils.COLORS.yellow + '⚠' :
+                 utils.COLORS.dim + 'ℹ';
+    console.log(`  ${icon}${utils.COLORS.reset} ${check.name}: ${utils.COLORS.dim}${check.message}${utils.COLORS.reset}`);
+  }
+
+  console.log(`
+${utils.COLORS.bold}Score:${utils.COLORS.reset} ${validation.score}/${validation.maxScore} (${validation.percentage}%)
+`);
+
+  if (validation.valid) {
+    utils.print.success('Context is valid and ready for AI assistants');
+  } else {
+    utils.print.warning('Context has some issues - review the checks above');
+  }
+
+  // Full generation includes additional files
+  if (full) {
+    console.log(`\n${utils.COLORS.bold}Full Generation${utils.COLORS.reset}\n`);
+
+    // Generate .mcp.json if missing
+    const mcpPath = path.join(cfg._projectRoot, '.mcp.json');
+    if (!utils.fileExists(mcpPath)) {
+      const mcpSpinner = utils.createSpinner('Generating .mcp.json').start();
+      const mcpConfig = {
+        mcpServers: {
+          bootspring: {
+            command: 'npx',
+            args: ['bootspring', 'mcp'],
+            env: {}
+          }
+        }
+      };
+      utils.writeFile(mcpPath, JSON.stringify(mcpConfig, null, 2));
+      mcpSpinner.succeed('Generated .mcp.json');
+    }
+
+    // Generate todo.md if missing
+    const todoPath = path.join(cfg._projectRoot, cfg.paths?.todo || 'todo.md');
+    if (!utils.fileExists(todoPath)) {
+      const todoSpinner = utils.createSpinner('Generating todo.md').start();
+      const todoContent = `# ${cfg.project.name} - Todo List
+
+> Last updated: ${utils.formatDate()}
+
+## In Progress
+
+## Pending
+
+- [ ] Review generated context
+- [ ] Configure environment variables
+
+## Completed
+
+`;
+      utils.writeFile(todoPath, todoContent);
+      todoSpinner.succeed('Generated todo.md');
+    }
+  }
+
+  console.log(`
+${utils.COLORS.dim}Tip: Run 'bootspring generate --full' to regenerate all files${utils.COLORS.reset}
+`);
+}
+
+module.exports = { run, generateClaudeMd };