@girardmedia/bootspring 1.1.0

package/generators/generate.js

@@ -0,0 +1,598 @@
+#!/usr/bin/env node
+
+/**
+ * Bootspring Context Generator
+ *
+ * Generates all context files from project configuration.
+ * Includes MVP source code analysis for enhanced context.
+ *
+ * @package bootspring
+ * @module generators/generate
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Try to load yaml package, fall back to simple parser
+let yaml;
+try {
+  yaml = require('yaml');
+} catch (e) {
+  yaml = null;
+}
+
+// Colors
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  green: '\x1b[32m',
+  blue: '\x1b[34m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  red: '\x1b[31m'
+};
+
+/**
+ * Simple YAML parser fallback
+ * Handles basic key: value pairs and arrays
+ */
+function parseYamlSimple(content) {
+  const result = {};
+  const lines = content.split('\n');
+  let currentKey = null;
+  let currentIndent = 0;
+
+  for (let line of lines) {
+    // Skip comments and empty lines
+    if (line.trim().startsWith('#') || !line.trim()) continue;
+
+    const indent = line.search(/\S/);
+    const trimmed = line.trim();
+
+    // Array item
+    if (trimmed.startsWith('- ')) {
+      const value = trimmed.substring(2).trim();
+      if (currentKey && Array.isArray(result[currentKey])) {
+        result[currentKey].push(value);
+      }
+      continue;
+    }
+
+    // Key: value pair
+    const colonIndex = trimmed.indexOf(':');
+    if (colonIndex > 0) {
+      const key = trimmed.substring(0, colonIndex).trim();
+      const value = trimmed.substring(colonIndex + 1).trim();
+
+      if (value === '' || value === '|' || value === '>') {
+        // Start of object or multiline
+        result[key] = [];
+        currentKey = key;
+        currentIndent = indent;
+      } else {
+        // Simple value
+        let parsedValue = value;
+        if (value === 'true') parsedValue = true;
+        else if (value === 'false') parsedValue = false;
+        else if (!isNaN(value) && value !== '') parsedValue = Number(value);
+        else if (value.startsWith('"') && value.endsWith('"')) {
+          parsedValue = value.slice(1, -1);
+        }
+        result[key] = parsedValue;
+        currentKey = null;
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Analyze MVP source files
+ * @param {string} mvpPath - Path to MVP source directory
+ * @returns {object} MVP analysis results
+ */
+function analyzeMvpSource(mvpPath) {
+  if (!fs.existsSync(mvpPath)) {
+    return null;
+  }
+
+  const mvpInfo = {
+    exists: true,
+    files: [],
+    components: [],
+    services: [],
+    utilities: [],
+    hooks: [],
+    pages: [],
+    patterns: [],
+    stats: {
+      totalFiles: 0,
+      totalLines: 0,
+      fileTypes: {}
+    }
+  };
+
+  /**
+   * Recursively scan directory
+   */
+  function scanDir(dir, files = []) {
+    if (!fs.existsSync(dir)) return files;
+
+    const items = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (const item of items) {
+      const fullPath = path.join(dir, item.name);
+      const relativePath = path.relative(mvpPath, fullPath);
+
+      // Skip common ignore patterns
+      if (['node_modules', '.next', 'dist', '.git', 'coverage', '.turbo'].some(p =>
+        relativePath.includes(p)
+      )) continue;
+
+      if (item.isDirectory()) {
+        scanDir(fullPath, files);
+      } else {
+        const ext = path.extname(item.name);
+        if (['.ts', '.tsx', '.js', '.jsx', '.mjs'].includes(ext)) {
+          files.push({
+            name: item.name,
+            path: relativePath,
+            fullPath,
+            ext
+          });
+        }
+      }
+    }
+    return files;
+  }
+
+  mvpInfo.files = scanDir(mvpPath);
+  mvpInfo.stats.totalFiles = mvpInfo.files.length;
+
+  // Analyze each file
+  for (const file of mvpInfo.files) {
+    try {
+      const content = fs.readFileSync(file.fullPath, 'utf8');
+      const lines = content.split('\n').length;
+      mvpInfo.stats.totalLines += lines;
+
+      // Track file types
+      mvpInfo.stats.fileTypes[file.ext] = (mvpInfo.stats.fileTypes[file.ext] || 0) + 1;
+
+      // Categorize by path and content
+      const pathLower = file.path.toLowerCase();
+      const contentLower = content.toLowerCase();
+
+      // Components
+      if (pathLower.includes('component') ||
+          (file.ext === '.tsx' && content.match(/^(export\s+)?(default\s+)?function\s+[A-Z]/m))) {
+        mvpInfo.components.push(file.path);
+      }
+
+      // Services / API
+      if (pathLower.includes('service') || pathLower.includes('api/')) {
+        mvpInfo.services.push(file.path);
+      }
+
+      // Utilities / Lib
+      if (pathLower.includes('util') || pathLower.includes('lib/') || pathLower.includes('helper')) {
+        mvpInfo.utilities.push(file.path);
+      }
+
+      // Hooks
+      if (pathLower.includes('hook') || content.match(/^export\s+(const|function)\s+use[A-Z]/m)) {
+        mvpInfo.hooks.push(file.path);
+      }
+
+      // Pages / App routes
+      if (pathLower.includes('/app/') || pathLower.includes('/pages/')) {
+        mvpInfo.pages.push(file.path);
+      }
+
+      // Detect patterns used
+      if (content.includes('async ') && content.includes('try') && content.includes('catch')) {
+        if (!mvpInfo.patterns.includes('error-handling')) {
+          mvpInfo.patterns.push('error-handling');
+        }
+      }
+      if (content.includes('useState') || content.includes('useEffect')) {
+        if (!mvpInfo.patterns.includes('react-hooks')) {
+          mvpInfo.patterns.push('react-hooks');
+        }
+      }
+      if (content.includes('fetch(') || content.includes('axios')) {
+        if (!mvpInfo.patterns.includes('api-calls')) {
+          mvpInfo.patterns.push('api-calls');
+        }
+      }
+      if (contentLower.includes('prisma')) {
+        if (!mvpInfo.patterns.includes('prisma-orm')) {
+          mvpInfo.patterns.push('prisma-orm');
+        }
+      }
+      if (content.includes('zod') || content.includes('.parse(')) {
+        if (!mvpInfo.patterns.includes('validation')) {
+          mvpInfo.patterns.push('validation');
+        }
+      }
+      if (contentLower.includes('clerk') || contentLower.includes('auth(')) {
+        if (!mvpInfo.patterns.includes('authentication')) {
+          mvpInfo.patterns.push('authentication');
+        }
+      }
+      if (content.includes('stripe')) {
+        if (!mvpInfo.patterns.includes('payments')) {
+          mvpInfo.patterns.push('payments');
+        }
+      }
+      if (content.includes('Server') && (content.includes("'use server'") || content.includes('"use server"'))) {
+        if (!mvpInfo.patterns.includes('server-actions')) {
+          mvpInfo.patterns.push('server-actions');
+        }
+      }
+
+    } catch (e) {
+      // Skip files that can't be read
+    }
+  }
+
+  return mvpInfo;
+}
+
+/**
+ * Parse bootspring.config.js or SEED.md
+ * @param {string} projectRoot - Project root directory
+ * @returns {object} Parsed configuration
+ */
+function parseConfig(projectRoot) {
+  // Try bootspring.config.js first
+  const configPath = path.join(projectRoot, 'bootspring.config.js');
+  if (fs.existsSync(configPath)) {
+    try {
+      delete require.cache[require.resolve(configPath)];
+      return require(configPath);
+    } catch (e) {
+      console.warn(`${c.yellow}Warning: Could not load bootspring.config.js${c.reset}`);
+    }
+  }
+
+  // Try SEED.md (for backward compatibility)
+  const seedPath = path.join(projectRoot, '.bootspring', 'SEED.md');
+  if (fs.existsSync(seedPath)) {
+    return parseSeedMd(seedPath);
+  }
+
+  // Try .girardai/SEED.md
+  const girardaiSeedPath = path.join(projectRoot, '.girardai', 'SEED.md');
+  if (fs.existsSync(girardaiSeedPath)) {
+    return parseSeedMd(girardaiSeedPath);
+  }
+
+  // Return default config
+  return {
+    project: { name: 'My Project', description: '' },
+    stack: { framework: 'nextjs', language: 'typescript' },
+    plugins: {}
+  };
+}
+
+/**
+ * Parse SEED.md and extract YAML blocks
+ * @param {string} seedPath - Path to SEED.md
+ * @returns {object} Parsed configuration
+ */
+function parseSeedMd(seedPath) {
+  const content = fs.readFileSync(seedPath, 'utf8');
+  const config = {};
+
+  // Extract all YAML code blocks
+  const yamlBlockRegex = /```yaml\n([\s\S]*?)```/g;
+  let match;
+
+  while ((match = yamlBlockRegex.exec(content)) !== null) {
+    try {
+      const parsed = yaml ? yaml.parse(match[1]) : parseYamlSimple(match[1]);
+      Object.assign(config, parsed);
+    } catch (e) {
+      // Skip invalid YAML blocks
+    }
+  }
+
+  return config;
+}
+
+/**
+ * Generate MVP section for CLAUDE.md
+ * @param {object} mvpInfo - MVP analysis results
+ * @returns {string} Markdown section
+ */
+function generateMvpSection(mvpInfo) {
+  if (!mvpInfo || mvpInfo.files.length === 0) {
+    return '';
+  }
+
+  return `
+---
+
+## MVP Reference Code
+
+**IMPORTANT**: This project has MVP prototype code. Before implementing features, check the MVP for existing patterns.
+
+### MVP Statistics
+
+| Metric | Count |
+|--------|-------|
+| Total Files | ${mvpInfo.stats.totalFiles} |
+| Total Lines | ${mvpInfo.stats.totalLines.toLocaleString()} |
+| Components | ${mvpInfo.components.length} |
+| Services/API | ${mvpInfo.services.length} |
+| Utilities | ${mvpInfo.utilities.length} |
+| Hooks | ${mvpInfo.hooks.length} |
+| Pages | ${mvpInfo.pages.length} |
+
+### Detected Patterns
+
+${mvpInfo.patterns.length > 0 ? mvpInfo.patterns.map(p => `- ${p}`).join('\n') : '- No specific patterns detected'}
+
+### Key Files
+
+**Components** (${Math.min(mvpInfo.components.length, 10)} of ${mvpInfo.components.length}):
+${mvpInfo.components.slice(0, 10).map(c => `- \`${c}\``).join('\n') || '- None detected'}
+${mvpInfo.components.length > 10 ? `- ... and ${mvpInfo.components.length - 10} more` : ''}
+
+**Services** (${Math.min(mvpInfo.services.length, 5)} of ${mvpInfo.services.length}):
+${mvpInfo.services.slice(0, 5).map(s => `- \`${s}\``).join('\n') || '- None detected'}
+${mvpInfo.services.length > 5 ? `- ... and ${mvpInfo.services.length - 5} more` : ''}
+
+### Before Implementing Features
+
+1. **Check MVP first**: Look for existing implementations
+2. **Reuse patterns**: Follow the detected patterns above
+3. **Ask about MVP**: "Show me the MVP implementation of X"
+`;
+}
+
+/**
+ * Generate full CLAUDE.md content
+ * @param {object} config - Project configuration
+ * @param {object} options - Generation options
+ * @returns {string} Generated content
+ */
+function generateClaudeMd(config, options = {}) {
+  const date = new Date().toISOString().split('T')[0];
+
+  const project = config.project || {};
+  const stack = config.stack || {};
+  const plugins = config.plugins || {};
+
+  // Analyze MVP if exists
+  let mvpInfo = null;
+  if (options.withMvp || options.mvpPath) {
+    const mvpPath = options.mvpPath || path.join(options.projectRoot, 'mvp', 'source');
+    mvpInfo = analyzeMvpSource(mvpPath);
+  }
+
+  // Build enabled plugins section
+  const enabledPlugins = Object.entries(plugins)
+    .filter(([_, p]) => p && p.enabled !== false);
+
+  const pluginsSection = enabledPlugins.length > 0
+    ? enabledPlugins.map(([name, plugin]) => `### ${name.charAt(0).toUpperCase() + name.slice(1)}
+- **Provider**: ${plugin.provider || 'default'}
+- **Features**: ${(plugin.features || []).join(', ') || 'default'}`).join('\n\n')
+    : 'No plugins configured.';
+
+  // Generate content
+  const content = `# ${project.name || 'Project'} - AI Context
+
+**Generated by**: Bootspring v1.0.0
+**Last Updated**: ${date}
+**Framework**: ${stack.framework || 'unknown'}
+
+---
+
+## Project Overview
+
+${project.description || 'A modern application built with Bootspring.'}
+
+---
+
+## Tech Stack
+
+| Component | Technology |
+|-----------|------------|
+| Framework | ${stack.framework || 'N/A'} |
+| Language | ${stack.language || 'typescript'} |
+| Database | ${stack.database || 'N/A'} |
+| Hosting | ${stack.hosting || 'N/A'} |
+
+---
+
+## Enabled Plugins
+
+${pluginsSection}
+
+---
+
+## Bootspring Commands
+
+### Quick Commands (use in AI assistant)
+
+| Command | Description |
+|---------|-------------|
+| \`bootspring todo add "task"\` | Add a todo item |
+| \`bootspring todo list\` | List all todos |
+| \`bootspring todo done <id>\` | Mark todo complete |
+| \`bootspring agent list\` | List available agents |
+| \`bootspring agent invoke <name>\` | Get specialized help |
+| \`bootspring skill search <query>\` | Find code patterns |
+| \`bootspring dashboard\` | Start real-time dashboard |
+| \`bootspring generate\` | Regenerate this context |
+| \`bootspring quality pre-commit\` | Run quality checks |
+
+### Specialized Agents
+
+| Agent | Expertise |
+|-------|-----------|
+| database-expert | Schema design, queries, migrations |
+| security-expert | Security review, OWASP, auth |
+| frontend-expert | UI components, React, CSS |
+| backend-expert | API design, server logic |
+| api-expert | REST/GraphQL, route handlers |
+| testing-expert | Test strategy, coverage, TDD |
+| performance-expert | Optimization, profiling |
+| devops-expert | CI/CD, deployment |
+| ui-ux-expert | Design patterns, accessibility |
+| architecture-expert | System design, patterns |
+| code-review-expert | Code quality, best practices |
+| vercel-expert | Vercel deployment, edge functions |
+
+**Invoke**: \`bootspring agent invoke <name>\`
+
+---
+
+## Development Guidelines
+
+### Code Style
+
+- Use ${stack.language === 'typescript' ? 'TypeScript' : 'JavaScript'} for all new code
+- Follow existing naming conventions
+- Keep files 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 input validation
+- Never expose API keys to client
+- Write tests for new features
+
+### Git Commits
+
+- Use conventional commit format: \`feat:\`, \`fix:\`, \`docs:\`, \`refactor:\`
+- Keep commits focused and atomic
+- Never commit sensitive data
+- No AI/Claude references in commits
+
+---
+
+## Quality Gates
+
+Run before commits:
+
+\`\`\`bash
+bootspring quality pre-commit
+\`\`\`
+${generateMvpSection(mvpInfo)}
+---
+
+*Generated by [Bootspring](https://bootspring.com)*
+`;
+
+  return content;
+}
+
+/**
+ * Main generation function
+ * @param {object} options - Generation options
+ * @returns {object} Generation result
+ */
+async function generate(options = {}) {
+  const projectRoot = options.projectRoot || process.cwd();
+  const outputPath = options.outputPath || path.join(projectRoot, 'CLAUDE.md');
+  const dryRun = options.dryRun || false;
+  const withMvp = options.withMvp || false;
+
+  // Parse config
+  const config = parseConfig(projectRoot);
+
+  // Generate content
+  const content = generateClaudeMd(config, {
+    projectRoot,
+    withMvp,
+    mvpPath: options.mvpPath
+  });
+
+  // Write or return
+  if (dryRun) {
+    return {
+      success: true,
+      dryRun: true,
+      content,
+      bytes: content.length
+    };
+  }
+
+  try {
+    fs.writeFileSync(outputPath, content, 'utf8');
+    return {
+      success: true,
+      outputPath,
+      bytes: content.length
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}
+
+// CLI execution
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const options = {
+    dryRun: args.includes('--dry-run'),
+    withMvp: args.includes('--with-mvp'),
+    help: args.includes('--help') || args.includes('-h')
+  };
+
+  if (options.help) {
+    console.log(`
+${c.bold}Bootspring Context Generator${c.reset}
+
+${c.cyan}Usage:${c.reset}
+  node generate.js [options]
+
+${c.cyan}Options:${c.reset}
+  --with-mvp    Include MVP source analysis
+  --dry-run     Preview without writing files
+  --help, -h    Show this help
+
+${c.cyan}Examples:${c.reset}
+  node generate.js
+  node generate.js --with-mvp
+  node generate.js --dry-run
+`);
+    process.exit(0);
+  }
+
+  console.log(`
+${c.cyan}${c.bold}Bootspring Context Generator${c.reset}
+${c.dim}Generating AI context files...${c.reset}
+`);
+
+  generate(options).then(result => {
+    if (result.success) {
+      if (result.dryRun) {
+        console.log(`${c.yellow}[DRY RUN]${c.reset} Would write ${result.bytes.toLocaleString()} bytes`);
+      } else {
+        console.log(`${c.green}*${c.reset} Generated ${result.outputPath}`);
+        console.log(`${c.dim}  ${result.bytes.toLocaleString()} bytes${c.reset}`);
+      }
+    } else {
+      console.log(`${c.red}Error:${c.reset} ${result.error}`);
+      process.exit(1);
+    }
+  });
+}
+
+module.exports = {
+  generate,
+  generateClaudeMd,
+  analyzeMvpSource,
+  parseConfig,
+  parseSeedMd
+};

package/generators/index.js

@@ -0,0 +1,18 @@
+/**
+ * Bootspring Generators Module
+ *
+ * Provides context generation, scaffolding, and project setup.
+ *
+ * @package bootspring
+ * @module generators
+ */
+
+const generator = require('./generate');
+
+module.exports = {
+  generate: generator.generate,
+  generateClaudeMd: generator.generateClaudeMd,
+  analyzeMvpSource: generator.analyzeMvpSource,
+  parseConfig: generator.parseConfig,
+  parseSeedMd: generator.parseSeedMd
+};