@girardmedia/bootspring 1.1.0

package/bin/bootspring.js

@@ -0,0 +1,310 @@
+#!/usr/bin/env node
+
+/**
+ * Bootspring CLI
+ * Development scaffolding with intelligence
+ *
+ * @package bootspring
+ * @version 1.0.0
+ * @license MIT
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+// Version and branding
+const VERSION = '1.1.0';
+const BRAND = {
+  name: 'Bootspring',
+  tagline: 'Development scaffolding with intelligence',
+  color: '\x1b[36m', // Cyan
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m'
+};
+
+// ASCII art logo
+const LOGO = `
+${BRAND.color}╔══════════════════════════════════════════╗
+║                                          ║
+║   ██████╗  ██████╗  ██████╗ ████████╗   ║
+║   ██╔══██╗██╔═══██╗██╔═══██╗╚══██╔══╝   ║
+║   ██████╔╝██║   ██║██║   ██║   ██║      ║
+║   ██╔══██╗██║   ██║██║   ██║   ██║      ║
+║   ██████╔╝╚██████╔╝╚██████╔╝   ██║      ║
+║   ╚═════╝  ╚═════╝  ╚═════╝    ╚═╝      ║
+║                                          ║
+║   ███████╗██████╗ ██████╗ ██╗███╗   ██╗ ║
+║   ██╔════╝██╔══██╗██╔══██╗██║████╗  ██║ ║
+║   ███████╗██████╔╝██████╔╝██║██╔██╗ ██║ ║
+║   ╚════██║██╔═══╝ ██╔══██╗██║██║╚██╗██║ ║
+║   ███████║██║     ██║  ██║██║██║ ╚████║ ║
+║   ╚══════╝╚═╝     ╚═╝  ╚═╝╚═╝╚═╝  ╚═══╝ ║
+║                                          ║
+╚══════════════════════════════════════════╝${BRAND.reset}
+`;
+
+// Compact logo for non-help commands
+const LOGO_COMPACT = `${BRAND.color}${BRAND.bold}⚡ Bootspring${BRAND.reset} ${BRAND.dim}v${VERSION}${BRAND.reset}`;
+
+// Command registry
+const COMMANDS = {
+  // Core commands
+  init: {
+    script: '../cli/init.js',
+    description: 'Initialize Bootspring in current project',
+    usage: 'bootspring init [--force]'
+  },
+  generate: {
+    script: '../cli/generate.js',
+    description: 'Generate/regenerate CLAUDE.md context',
+    usage: 'bootspring generate [--full]'
+  },
+  dashboard: {
+    script: '../cli/dashboard.js',
+    description: 'Start the real-time dashboard',
+    usage: 'bootspring dashboard [--port <port>]'
+  },
+
+  // Todo commands
+  todo: {
+    script: '../cli/todo.js',
+    description: 'Manage project todos',
+    usage: 'bootspring todo <add|list|done|clear> [args]'
+  },
+
+  // Agent commands
+  agent: {
+    script: '../cli/agent.js',
+    description: 'Work with specialized agents',
+    usage: 'bootspring agent <list|show|invoke> [name]'
+  },
+
+  // Skill commands
+  skill: {
+    script: '../cli/skill.js',
+    description: 'Browse and use code patterns',
+    usage: 'bootspring skill <list|show|search|export> [args]'
+  },
+
+  // Plugin commands
+  plugin: {
+    script: '../cli/plugin.js',
+    description: 'Manage plugins',
+    usage: 'bootspring plugin <list|enable|disable|show> [name]'
+  },
+
+  // Task commands
+  task: {
+    script: '../cli/task.js',
+    description: 'Manage complex tasks',
+    usage: 'bootspring task <create|list|show|update> [args]'
+  },
+
+  // Quality commands
+  quality: {
+    script: '../cli/quality.js',
+    description: 'Run quality gates',
+    usage: 'bootspring quality <pre-commit|pre-push|pre-deploy>'
+  },
+
+  // MCP commands
+  mcp: {
+    script: '../cli/mcp.js',
+    description: 'MCP server control',
+    usage: 'bootspring mcp <start|status>'
+  },
+
+  // Context commands
+  context: {
+    script: '../cli/context.js',
+    description: 'View and manage project context',
+    usage: 'bootspring context <show|validate|refresh>'
+  },
+
+  // Update commands
+  update: {
+    script: '../cli/update.js',
+    description: 'Check for and apply updates',
+    usage: 'bootspring update <check|apply>'
+  },
+
+  // Orchestrator commands
+  orchestrator: {
+    script: '../cli/orchestrator.js',
+    description: 'Intelligent agent coordination',
+    usage: 'bootspring orchestrator <analyze|workflow|status> [args]'
+  },
+
+  // Loop commands
+  loop: {
+    script: '../cli/loop.js',
+    description: 'Autonomous task execution loop',
+    usage: 'bootspring loop <start|status|prd> [args]'
+  },
+
+  // Memory commands
+  memory: {
+    script: '../cli/memory.js',
+    description: 'View git-based project memory',
+    usage: 'bootspring memory <summary|search|files|stats> [args]'
+  },
+
+  // Telemetry commands
+  telemetry: {
+    script: '../cli/telemetry.js',
+    description: 'Inspect and upload telemetry events',
+    usage: 'bootspring telemetry <status|list|upload|clear> [options]'
+  },
+
+  // Help
+  help: {
+    script: null,
+    description: 'Show this help message',
+    usage: 'bootspring help [command]'
+  }
+};
+
+// Command categories for help display
+const CATEGORIES = {
+  'Getting Started': ['init', 'generate', 'dashboard', 'help'],
+  'Daily Workflow': ['todo', 'task', 'context'],
+  'Intelligence': ['agent', 'skill', 'orchestrator', 'loop', 'memory'],
+  'Quality & Plugins': ['quality', 'plugin'],
+  'System': ['mcp', 'telemetry', 'update']
+};
+
+/**
+ * Display help message
+ */
+function showHelp(specificCommand = null) {
+  if (specificCommand && COMMANDS[specificCommand]) {
+    const cmd = COMMANDS[specificCommand];
+    console.log(LOGO_COMPACT);
+    console.log(`\n${BRAND.bold}Command: ${specificCommand}${BRAND.reset}`);
+    console.log(`${BRAND.dim}${cmd.description}${BRAND.reset}\n`);
+    console.log(`${BRAND.bold}Usage:${BRAND.reset} ${cmd.usage}\n`);
+    return;
+  }
+
+  console.log(LOGO);
+  console.log(`${BRAND.dim}${BRAND.tagline}${BRAND.reset}\n`);
+  console.log(`${BRAND.bold}Usage:${BRAND.reset} bootspring <command> [options]\n`);
+
+  for (const [category, commands] of Object.entries(CATEGORIES)) {
+    console.log(`${BRAND.bold}${category}:${BRAND.reset}`);
+    for (const cmdName of commands) {
+      const cmd = COMMANDS[cmdName];
+      const padding = ' '.repeat(14 - cmdName.length);
+      console.log(`  ${BRAND.color}${cmdName}${BRAND.reset}${padding}${BRAND.dim}${cmd.description}${BRAND.reset}`);
+    }
+    console.log();
+  }
+
+  console.log(`${BRAND.bold}Examples:${BRAND.reset}`);
+  console.log(`  ${BRAND.dim}$${BRAND.reset} bootspring init                  ${BRAND.dim}# Initialize new project${BRAND.reset}`);
+  console.log(`  ${BRAND.dim}$${BRAND.reset} bootspring todo add "Build auth" ${BRAND.dim}# Add a todo${BRAND.reset}`);
+  console.log(`  ${BRAND.dim}$${BRAND.reset} bootspring agent invoke security ${BRAND.dim}# Get security review${BRAND.reset}`);
+  console.log(`  ${BRAND.dim}$${BRAND.reset} bootspring dashboard             ${BRAND.dim}# Start dashboard${BRAND.reset}`);
+  console.log();
+  console.log(`${BRAND.dim}Documentation: https://bootspring.com/docs${BRAND.reset}`);
+  console.log(`${BRAND.dim}Report issues: https://github.com/bootspring/bootspring/issues${BRAND.reset}\n`);
+}
+
+/**
+ * Display version
+ */
+function showVersion() {
+  console.log(`${BRAND.name} v${VERSION}`);
+}
+
+/**
+ * Main entry point
+ */
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+
+  // Handle no command
+  if (!command) {
+    showHelp();
+    process.exit(0);
+  }
+
+  // Handle version flag
+  if (command === '--version' || command === '-v') {
+    showVersion();
+    process.exit(0);
+  }
+
+  // Handle help flag
+  if (command === '--help' || command === '-h') {
+    showHelp();
+    process.exit(0);
+  }
+
+  // Handle help command
+  if (command === 'help') {
+    showHelp(args[1]);
+    process.exit(0);
+  }
+
+  // Check if command exists
+  if (!COMMANDS[command]) {
+    console.log(LOGO_COMPACT);
+    console.log(`\n${BRAND.red}Error: Unknown command '${command}'${BRAND.reset}`);
+    console.log(`${BRAND.dim}Run 'bootspring help' to see available commands${BRAND.reset}\n`);
+    process.exit(1);
+  }
+
+  // Get command config
+  const cmdConfig = COMMANDS[command];
+
+  // Resolve command script path
+  const scriptPath = path.resolve(__dirname, cmdConfig.script);
+
+  // Check if script exists
+  if (!fs.existsSync(scriptPath)) {
+    console.log(LOGO_COMPACT);
+    console.log(`\n${BRAND.yellow}Command '${command}' is not yet implemented${BRAND.reset}`);
+    console.log(`${BRAND.dim}Coming soon in a future release${BRAND.reset}\n`);
+    process.exit(0);
+  }
+
+  // Load and execute command
+  try {
+    const commandModule = require(scriptPath);
+
+    // Pass remaining args to command
+    const commandArgs = args.slice(1);
+
+    // Execute command
+    if (typeof commandModule.run === 'function') {
+      await commandModule.run(commandArgs);
+    } else if (typeof commandModule === 'function') {
+      await commandModule(commandArgs);
+    } else {
+      console.log(`${BRAND.red}Error: Command '${command}' has invalid module format${BRAND.reset}`);
+      process.exit(1);
+    }
+  } catch (error) {
+    console.log(LOGO_COMPACT);
+    console.log(`\n${BRAND.red}Error executing '${command}':${BRAND.reset}`);
+    console.log(`${BRAND.dim}${error.message}${BRAND.reset}\n`);
+
+    if (process.env.DEBUG) {
+      console.log(error.stack);
+    }
+
+    process.exit(1);
+  }
+}
+
+// Run main
+main().catch(error => {
+  console.error(`${BRAND.red}Fatal error:${BRAND.reset}`, error.message);
+  process.exit(1);
+});

package/cli/agent.js

@@ -0,0 +1,337 @@
+/**
+ * Bootspring Agent Command
+ * Work with specialized AI agents
+ *
+ * @package bootspring
+ * @command agent
+ */
+
+const fs = require('fs');
+const path = require('path');
+const utils = require('../core/utils');
+
+// Agent definitions - these will be loaded from agents/profiles/ in production
+const AGENTS = {
+  'database-expert': {
+    name: 'Database Expert',
+    category: 'Backend',
+    description: 'Specializes in database design, queries, migrations, and optimization',
+    expertise: ['SQL', 'NoSQL', 'Prisma', 'Drizzle', 'PostgreSQL', 'MongoDB'],
+    triggers: ['database', 'schema', 'migration', 'query', 'prisma', 'sql']
+  },
+  'security-expert': {
+    name: 'Security Expert',
+    category: 'Security',
+    description: 'Focuses on application security, OWASP, authentication, and authorization',
+    expertise: ['OWASP', 'Authentication', 'Authorization', 'Input Validation', 'XSS', 'CSRF'],
+    triggers: ['security', 'auth', 'owasp', 'vulnerability', 'xss', 'csrf', 'injection']
+  },
+  'frontend-expert': {
+    name: 'Frontend Expert',
+    category: 'Frontend',
+    description: 'Expert in React, Next.js, UI components, and modern frontend patterns',
+    expertise: ['React', 'Next.js', 'TypeScript', 'Tailwind', 'Components', 'State Management'],
+    triggers: ['component', 'react', 'frontend', 'ui', 'tailwind', 'css', 'styling']
+  },
+  'backend-expert': {
+    name: 'Backend Expert',
+    category: 'Backend',
+    description: 'Specializes in server-side development, APIs, and business logic',
+    expertise: ['Node.js', 'APIs', 'Server Actions', 'Middleware', 'Business Logic'],
+    triggers: ['api', 'backend', 'server', 'endpoint', 'route', 'middleware']
+  },
+  'api-expert': {
+    name: 'API Expert',
+    category: 'Backend',
+    description: 'Focuses on API design, REST, GraphQL, and integration patterns',
+    expertise: ['REST', 'GraphQL', 'tRPC', 'OpenAPI', 'Webhooks', 'Integration'],
+    triggers: ['api', 'rest', 'graphql', 'trpc', 'webhook', 'endpoint']
+  },
+  'testing-expert': {
+    name: 'Testing Expert',
+    category: 'Quality',
+    description: 'Expert in testing strategies, test frameworks, and quality assurance',
+    expertise: ['Unit Testing', 'Integration Testing', 'E2E', 'Vitest', 'Jest', 'Playwright'],
+    triggers: ['test', 'testing', 'jest', 'vitest', 'playwright', 'coverage']
+  },
+  'performance-expert': {
+    name: 'Performance Expert',
+    category: 'DevOps',
+    description: 'Specializes in performance optimization, caching, and monitoring',
+    expertise: ['Optimization', 'Caching', 'Profiling', 'Core Web Vitals', 'Load Testing'],
+    triggers: ['performance', 'optimize', 'cache', 'slow', 'speed', 'profiling']
+  },
+  'devops-expert': {
+    name: 'DevOps Expert',
+    category: 'DevOps',
+    description: 'Focuses on deployment, CI/CD, infrastructure, and monitoring',
+    expertise: ['CI/CD', 'Docker', 'Kubernetes', 'Monitoring', 'Infrastructure'],
+    triggers: ['deploy', 'ci', 'cd', 'docker', 'kubernetes', 'infrastructure']
+  },
+  'ui-ux-expert': {
+    name: 'UI/UX Expert',
+    category: 'Frontend',
+    description: 'Expert in user interface design, user experience, and accessibility',
+    expertise: ['Design Systems', 'Accessibility', 'Responsive Design', 'Animation'],
+    triggers: ['ui', 'ux', 'design', 'accessibility', 'a11y', 'responsive']
+  },
+  'architecture-expert': {
+    name: 'Architecture Expert',
+    category: 'Backend',
+    description: 'Specializes in system architecture, design patterns, and scalability',
+    expertise: ['System Design', 'Design Patterns', 'Microservices', 'Scalability'],
+    triggers: ['architecture', 'design', 'pattern', 'scalability', 'structure']
+  },
+  'code-review-expert': {
+    name: 'Code Review Expert',
+    category: 'Quality',
+    description: 'Focuses on code quality, best practices, and constructive feedback',
+    expertise: ['Code Quality', 'Best Practices', 'Refactoring', 'Clean Code'],
+    triggers: ['review', 'refactor', 'quality', 'clean', 'improve']
+  },
+  'vercel-expert': {
+    name: 'Vercel Expert',
+    category: 'DevOps',
+    description: 'Expert in Vercel deployment, serverless, and edge functions',
+    expertise: ['Vercel', 'Serverless', 'Edge Functions', 'ISR', 'Deployment'],
+    triggers: ['vercel', 'serverless', 'edge', 'deployment', 'hosting']
+  }
+};
+
+/**
+ * List all available agents
+ */
+function listAgents(options = {}) {
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Agents${utils.COLORS.reset}
+${utils.COLORS.dim}Specialized AI expertise on demand${utils.COLORS.reset}
+`);
+
+  // Group by category
+  const categories = {};
+  for (const [id, agent] of Object.entries(AGENTS)) {
+    if (!categories[agent.category]) {
+      categories[agent.category] = [];
+    }
+    categories[agent.category].push({ id, ...agent });
+  }
+
+  for (const [category, agents] of Object.entries(categories)) {
+    console.log(`${utils.COLORS.bold}${category}${utils.COLORS.reset}`);
+    for (const agent of agents) {
+      console.log(`  ${utils.COLORS.cyan}${agent.id}${utils.COLORS.reset}`);
+      console.log(`    ${utils.COLORS.dim}${agent.description}${utils.COLORS.reset}`);
+    }
+    console.log();
+  }
+
+  utils.print.dim(`${Object.keys(AGENTS).length} agents available`);
+  utils.print.dim('Use "bootspring agent show <name>" for details');
+}
+
+/**
+ * Show agent details
+ */
+function showAgent(agentId) {
+  const agent = AGENTS[agentId];
+
+  if (!agent) {
+    utils.print.error(`Agent not found: ${agentId}`);
+    utils.print.dim('Use "bootspring agent list" to see available agents');
+    return;
+  }
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ ${agent.name}${utils.COLORS.reset}
+${utils.COLORS.dim}Category: ${agent.category}${utils.COLORS.reset}
+
+${utils.COLORS.bold}Description${utils.COLORS.reset}
+${agent.description}
+
+${utils.COLORS.bold}Expertise${utils.COLORS.reset}
+${agent.expertise.map(e => `  ${utils.COLORS.green}●${utils.COLORS.reset} ${e}`).join('\n')}
+
+${utils.COLORS.bold}Trigger Keywords${utils.COLORS.reset}
+${agent.triggers.map(t => `  ${utils.COLORS.dim}${t}${utils.COLORS.reset}`).join(', ')}
+
+${utils.COLORS.bold}Usage${utils.COLORS.reset}
+  bootspring agent invoke ${agentId} --topic "your question"
+`);
+}
+
+/**
+ * Invoke an agent
+ */
+function invokeAgent(agentId, args) {
+  const parsedArgs = utils.parseArgs(args);
+  const topic = parsedArgs.topic || parsedArgs.t || args.filter(a => !a.startsWith('-')).join(' ');
+
+  const agent = AGENTS[agentId];
+
+  if (!agent) {
+    utils.print.error(`Agent not found: ${agentId}`);
+    utils.print.dim('Use "bootspring agent list" to see available agents');
+    return;
+  }
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Invoking ${agent.name}${utils.COLORS.reset}
+`);
+
+  // Generate agent context for AI
+  const context = `
+## Agent: ${agent.name}
+
+You are now acting as the **${agent.name}**, a specialized expert in:
+${agent.expertise.map(e => `- ${e}`).join('\n')}
+
+### Your Role
+${agent.description}
+
+### Guidelines
+1. Focus on your areas of expertise listed above
+2. Provide specific, actionable advice
+3. Include code examples when relevant
+4. Consider security and best practices
+5. Reference official documentation when helpful
+
+### Topic
+${topic || 'The user will provide context for your assistance.'}
+
+---
+
+Please provide your expert analysis and recommendations.
+`;
+
+  console.log(`${utils.COLORS.dim}─────────────────────────────────────────${utils.COLORS.reset}`);
+  console.log(context);
+  console.log(`${utils.COLORS.dim}─────────────────────────────────────────${utils.COLORS.reset}`);
+
+  console.log(`
+${utils.COLORS.bold}Instructions${utils.COLORS.reset}
+Copy the context above and provide it to your AI assistant, or use the
+MCP integration for automatic agent invocation.
+
+${utils.COLORS.dim}Tip: With MCP enabled, agents are invoked automatically based on your prompts${utils.COLORS.reset}
+`);
+}
+
+/**
+ * Search for agents by keyword
+ */
+function searchAgents(query) {
+  const queryLower = query.toLowerCase();
+
+  const matches = Object.entries(AGENTS).filter(([id, agent]) => {
+    return id.includes(queryLower) ||
+           agent.name.toLowerCase().includes(queryLower) ||
+           agent.description.toLowerCase().includes(queryLower) ||
+           agent.expertise.some(e => e.toLowerCase().includes(queryLower)) ||
+           agent.triggers.some(t => t.includes(queryLower));
+  });
+
+  if (matches.length === 0) {
+    utils.print.warning(`No agents found matching "${query}"`);
+    utils.print.dim('Use "bootspring agent list" to see all agents');
+    return;
+  }
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Agent Search: "${query}"${utils.COLORS.reset}
+`);
+
+  for (const [id, agent] of matches) {
+    console.log(`  ${utils.COLORS.cyan}${id}${utils.COLORS.reset} - ${agent.description}`);
+  }
+
+  console.log();
+  utils.print.dim(`${matches.length} agents found`);
+}
+
+/**
+ * Show agent help
+ */
+function showHelp() {
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Agent${utils.COLORS.reset}
+${utils.COLORS.dim}Work with specialized AI agents${utils.COLORS.reset}
+
+${utils.COLORS.bold}Usage:${utils.COLORS.reset}
+  bootspring agent <command> [args]
+
+${utils.COLORS.bold}Commands:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}list${utils.COLORS.reset}              List all available agents
+  ${utils.COLORS.cyan}show${utils.COLORS.reset} <name>       Show agent details
+  ${utils.COLORS.cyan}invoke${utils.COLORS.reset} <name>     Invoke an agent
+  ${utils.COLORS.cyan}search${utils.COLORS.reset} <query>    Search for agents
+
+${utils.COLORS.bold}Examples:${utils.COLORS.reset}
+  bootspring agent list
+  bootspring agent show security-expert
+  bootspring agent invoke database-expert --topic "optimize queries"
+  bootspring agent search performance
+`);
+}
+
+/**
+ * Run agent command
+ */
+async function run(args) {
+  const subcommand = args[0] || 'list';
+  const subargs = args.slice(1);
+
+  switch (subcommand) {
+    case 'list':
+    case 'ls':
+      listAgents();
+      break;
+
+    case 'show':
+    case 'info':
+      if (!subargs[0]) {
+        utils.print.error('Please specify an agent name');
+        utils.print.dim('Usage: bootspring agent show <name>');
+        return;
+      }
+      showAgent(subargs[0]);
+      break;
+
+    case 'invoke':
+    case 'use':
+    case 'call':
+      if (!subargs[0]) {
+        utils.print.error('Please specify an agent name');
+        utils.print.dim('Usage: bootspring agent invoke <name> --topic "your question"');
+        return;
+      }
+      invokeAgent(subargs[0], subargs.slice(1));
+      break;
+
+    case 'search':
+    case 'find':
+      if (!subargs[0]) {
+        utils.print.error('Please specify a search query');
+        utils.print.dim('Usage: bootspring agent search <query>');
+        return;
+      }
+      searchAgents(subargs.join(' '));
+      break;
+
+    case 'help':
+    case '-h':
+    case '--help':
+      showHelp();
+      break;
+
+    default:
+      // Check if it's an agent name (shortcut for show)
+      if (AGENTS[subcommand]) {
+        showAgent(subcommand);
+      } else {
+        utils.print.error(`Unknown subcommand: ${subcommand}`);
+        showHelp();
+      }
+  }
+}
+
+module.exports = { run, AGENTS, listAgents, showAgent, invokeAgent, searchAgents };