@girardmedia/bootspring 1.2.0 → 2.0.3

package/core/onboard-workflow.js

@@ -0,0 +1,1007 @@
+/**
+ * Bootspring Onboard Workflow Engine
+ *
+ * Layers Bootspring onto existing codebases through detection,
+ * pattern scanning, and configuration generation.
+ *
+ * @package bootspring
+ * @module core/onboard-workflow
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { StructureAnalyzer } = require('../analyzers/structure-analyzer');
+const { ArchitectureAnalyzer } = require('../analyzers/architecture-analyzer');
+const { DependencyAnalyzer } = require('../analyzers/dependency-analyzer');
+
+/**
+ * Workflow phase status
+ */
+const PHASE_STATUS = {
+  PENDING: 'pending',
+  IN_PROGRESS: 'in_progress',
+  COMPLETED: 'completed',
+  SKIPPED: 'skipped',
+  FAILED: 'failed'
+};
+
+/**
+ * Onboarding phases
+ */
+const ONBOARD_PHASES = {
+  detection: {
+    name: 'Stack Detection',
+    description: 'Detect framework, language, database, and hosting',
+    order: 1,
+    required: true
+  },
+  patterns: {
+    name: 'Pattern Scan',
+    description: 'Find auth, payments, components, and code patterns',
+    order: 2,
+    required: true,
+    dependencies: ['detection']
+  },
+  docs: {
+    name: 'Documentation Discovery',
+    description: 'Inventory existing docs and find gaps',
+    order: 3,
+    required: false,
+    dependencies: ['detection']
+  },
+  config: {
+    name: 'Config Generation',
+    description: 'Generate bootspring.config.js and CLAUDE.md',
+    order: 4,
+    required: true,
+    dependencies: ['detection', 'patterns']
+  },
+  baseline: {
+    name: 'Baseline Capture',
+    description: 'Record metrics for future comparison',
+    order: 5,
+    required: false,
+    dependencies: ['detection', 'patterns']
+  },
+  reverse: {
+    name: 'Reverse Engineer',
+    description: 'Generate PRD from code structure (optional)',
+    order: 6,
+    required: false,
+    dependencies: ['detection', 'patterns', 'docs']
+  }
+};
+
+/**
+ * Stack detection patterns
+ */
+const STACK_DETECTION = {
+  frameworks: [
+    { id: 'nextjs', name: 'Next.js', files: ['next.config.js', 'next.config.mjs', 'next.config.ts'], packages: ['next'] },
+    { id: 'remix', name: 'Remix', files: ['remix.config.js'], packages: ['@remix-run/react'] },
+    { id: 'nuxt', name: 'Nuxt', files: ['nuxt.config.js', 'nuxt.config.ts'], packages: ['nuxt'] },
+    { id: 'svelte', name: 'SvelteKit', files: ['svelte.config.js'], packages: ['@sveltejs/kit'] },
+    { id: 'astro', name: 'Astro', files: ['astro.config.mjs'], packages: ['astro'] },
+    { id: 'vite', name: 'Vite', files: ['vite.config.js', 'vite.config.ts'], packages: ['vite'] },
+    { id: 'express', name: 'Express', packages: ['express'] },
+    { id: 'fastify', name: 'Fastify', packages: ['fastify'] },
+    { id: 'nestjs', name: 'NestJS', packages: ['@nestjs/core'] },
+    { id: 'react', name: 'React', packages: ['react'] },
+    { id: 'vue', name: 'Vue', packages: ['vue'] },
+    { id: 'angular', name: 'Angular', files: ['angular.json'], packages: ['@angular/core'] }
+  ],
+  languages: [
+    { id: 'typescript', name: 'TypeScript', files: ['tsconfig.json'], packages: ['typescript'] },
+    { id: 'javascript', name: 'JavaScript', files: ['package.json'] }
+  ],
+  databases: [
+    { id: 'prisma', name: 'Prisma', files: ['prisma/schema.prisma'], packages: ['prisma', '@prisma/client'] },
+    { id: 'drizzle', name: 'Drizzle', packages: ['drizzle-orm'] },
+    { id: 'mongoose', name: 'MongoDB (Mongoose)', packages: ['mongoose'] },
+    { id: 'typeorm', name: 'TypeORM', packages: ['typeorm'] },
+    { id: 'sequelize', name: 'Sequelize', packages: ['sequelize'] },
+    { id: 'knex', name: 'Knex', packages: ['knex'] },
+    { id: 'supabase', name: 'Supabase', packages: ['@supabase/supabase-js'] },
+    { id: 'firebase', name: 'Firebase', packages: ['firebase', 'firebase-admin'] }
+  ],
+  hosting: [
+    { id: 'vercel', name: 'Vercel', files: ['vercel.json', '.vercel'] },
+    { id: 'netlify', name: 'Netlify', files: ['netlify.toml', '.netlify'] },
+    { id: 'railway', name: 'Railway', files: ['railway.json'] },
+    { id: 'docker', name: 'Docker', files: ['Dockerfile', 'docker-compose.yml'] },
+    { id: 'fly', name: 'Fly.io', files: ['fly.toml'] },
+    { id: 'render', name: 'Render', files: ['render.yaml'] },
+    { id: 'aws', name: 'AWS', files: ['serverless.yml', 'amplify.yml', 'samconfig.toml'] },
+    { id: 'gcp', name: 'Google Cloud', files: ['app.yaml', 'cloudbuild.yaml'] }
+  ],
+  testing: [
+    { id: 'vitest', name: 'Vitest', files: ['vitest.config.ts', 'vitest.config.js'], packages: ['vitest'] },
+    { id: 'jest', name: 'Jest', files: ['jest.config.js', 'jest.config.ts'], packages: ['jest'] },
+    { id: 'playwright', name: 'Playwright', files: ['playwright.config.ts'], packages: ['@playwright/test'] },
+    { id: 'cypress', name: 'Cypress', files: ['cypress.config.js', 'cypress.config.ts'], packages: ['cypress'] },
+    { id: 'mocha', name: 'Mocha', packages: ['mocha'] }
+  ],
+  auth: [
+    { id: 'nextauth', name: 'NextAuth.js', packages: ['next-auth'] },
+    { id: 'authjs', name: 'Auth.js', packages: ['@auth/core'] },
+    { id: 'clerk', name: 'Clerk', packages: ['@clerk/nextjs', '@clerk/clerk-react'] },
+    { id: 'auth0', name: 'Auth0', packages: ['@auth0/nextjs-auth0', 'auth0'] },
+    { id: 'supabase-auth', name: 'Supabase Auth', packages: ['@supabase/auth-helpers-nextjs'] },
+    { id: 'firebase-auth', name: 'Firebase Auth', packages: ['firebase/auth'] },
+    { id: 'passport', name: 'Passport.js', packages: ['passport'] }
+  ],
+  payments: [
+    { id: 'stripe', name: 'Stripe', packages: ['stripe', '@stripe/stripe-js'] },
+    { id: 'lemon-squeezy', name: 'Lemon Squeezy', packages: ['@lemonsqueezy/lemonsqueezy.js'] },
+    { id: 'paddle', name: 'Paddle', packages: ['@paddle/paddle-js'] },
+    { id: 'paypal', name: 'PayPal', packages: ['@paypal/react-paypal-js', 'paypal-rest-sdk'] }
+  ]
+};
+
+/**
+ * Default workflow state
+ */
+const DEFAULT_STATE = {
+  version: '1.0.0',
+  startedAt: null,
+  lastUpdated: null,
+  currentPhase: null,
+  phases: {},
+  detection: {
+    stack: null,
+    patterns: null,
+    docs: null
+  },
+  generated: {
+    config: null,
+    claudeMd: null
+  },
+  baseline: null
+};
+
+/**
+ * OnboardWorkflowEngine - Manages onboarding workflow
+ */
+class OnboardWorkflowEngine {
+  constructor(projectRoot, options = {}) {
+    this.projectRoot = projectRoot;
+    this.workflowDir = path.join(projectRoot, '.bootspring', 'onboard');
+    this.stateFile = path.join(this.workflowDir, 'workflow-state.json');
+    this.detectionDir = path.join(this.workflowDir, 'detection');
+    this.generatedDir = path.join(this.workflowDir, 'generated');
+    this.baselineDir = path.join(this.workflowDir, 'baseline');
+    this.options = options;
+    this.state = null;
+  }
+
+  /**
+   * Setup directories
+   */
+  setupDirectories() {
+    const dirs = [
+      this.workflowDir,
+      this.detectionDir,
+      this.generatedDir,
+      this.baselineDir
+    ];
+
+    for (const dir of dirs) {
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+    }
+  }
+
+  /**
+   * Load workflow state
+   */
+  loadState() {
+    if (fs.existsSync(this.stateFile)) {
+      try {
+        this.state = JSON.parse(fs.readFileSync(this.stateFile, 'utf-8'));
+        return true;
+      } catch (_e) {
+        this.state = { ...DEFAULT_STATE };
+        return false;
+      }
+    }
+    this.state = { ...DEFAULT_STATE };
+    return false;
+  }
+
+  /**
+   * Save workflow state
+   */
+  saveState() {
+    this.setupDirectories();
+    this.state.lastUpdated = new Date().toISOString();
+    fs.writeFileSync(this.stateFile, JSON.stringify(this.state, null, 2));
+  }
+
+  /**
+   * Initialize workflow
+   */
+  initializeWorkflow() {
+    this.setupDirectories();
+    this.state = {
+      ...DEFAULT_STATE,
+      startedAt: new Date().toISOString(),
+      lastUpdated: new Date().toISOString()
+    };
+
+    // Initialize phase states
+    for (const phaseId of Object.keys(ONBOARD_PHASES)) {
+      this.state.phases[phaseId] = {
+        status: PHASE_STATUS.PENDING,
+        startedAt: null,
+        completedAt: null,
+        result: null,
+        error: null
+      };
+    }
+
+    this.state.currentPhase = 'detection';
+    this.saveState();
+    return this.state;
+  }
+
+  /**
+   * Check if workflow exists
+   */
+  hasWorkflow() {
+    return fs.existsSync(this.stateFile);
+  }
+
+  /**
+   * Reset workflow
+   */
+  resetWorkflow() {
+    if (fs.existsSync(this.stateFile)) {
+      fs.unlinkSync(this.stateFile);
+    }
+    this.state = null;
+    return true;
+  }
+
+  /**
+   * Check if phase dependencies are met
+   */
+  arePhaseDependenciesMet(phaseId) {
+    const phase = ONBOARD_PHASES[phaseId];
+    if (!phase || !phase.dependencies || phase.dependencies.length === 0) {
+      return true;
+    }
+
+    for (const depPhaseId of phase.dependencies) {
+      const depPhase = this.state.phases[depPhaseId];
+      if (!depPhase || depPhase.status !== PHASE_STATUS.COMPLETED) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  /**
+   * Get next phase
+   */
+  getNextPhase() {
+    const phaseOrder = Object.keys(ONBOARD_PHASES).sort(
+      (a, b) => ONBOARD_PHASES[a].order - ONBOARD_PHASES[b].order
+    );
+
+    for (const phaseId of phaseOrder) {
+      const phase = this.state.phases[phaseId];
+      if (phase.status === PHASE_STATUS.PENDING && this.arePhaseDependenciesMet(phaseId)) {
+        return phaseId;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Start a phase
+   */
+  startPhase(phaseId) {
+    if (!this.state.phases[phaseId]) {
+      throw new Error(`Unknown phase: ${phaseId}`);
+    }
+
+    this.state.phases[phaseId].status = PHASE_STATUS.IN_PROGRESS;
+    this.state.phases[phaseId].startedAt = new Date().toISOString();
+    this.state.currentPhase = phaseId;
+    this.saveState();
+  }
+
+  /**
+   * Complete a phase
+   */
+  completePhase(phaseId, result = null) {
+    if (!this.state.phases[phaseId]) {
+      throw new Error(`Unknown phase: ${phaseId}`);
+    }
+
+    this.state.phases[phaseId].status = PHASE_STATUS.COMPLETED;
+    this.state.phases[phaseId].completedAt = new Date().toISOString();
+    this.state.phases[phaseId].result = result;
+    this.saveState();
+  }
+
+  /**
+   * Fail a phase
+   */
+  failPhase(phaseId, error) {
+    if (!this.state.phases[phaseId]) {
+      throw new Error(`Unknown phase: ${phaseId}`);
+    }
+
+    this.state.phases[phaseId].status = PHASE_STATUS.FAILED;
+    this.state.phases[phaseId].completedAt = new Date().toISOString();
+    this.state.phases[phaseId].error = error;
+    this.saveState();
+  }
+
+  /**
+   * Skip a phase
+   */
+  skipPhase(phaseId) {
+    if (!this.state.phases[phaseId]) {
+      throw new Error(`Unknown phase: ${phaseId}`);
+    }
+
+    this.state.phases[phaseId].status = PHASE_STATUS.SKIPPED;
+    this.state.phases[phaseId].completedAt = new Date().toISOString();
+    this.saveState();
+  }
+
+  /**
+   * Run detection phase
+   */
+  async runDetection() {
+    const stack = {
+      framework: null,
+      language: null,
+      database: null,
+      hosting: null,
+      testing: null,
+      auth: null,
+      payments: null,
+      detected: []
+    };
+
+    // Read package.json if exists
+    const pkgPath = path.join(this.projectRoot, 'package.json');
+    let pkg = null;
+    if (fs.existsSync(pkgPath)) {
+      try {
+        pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+      } catch (_e) {
+        // Skip
+      }
+    }
+
+    const allDeps = pkg ? {
+      ...pkg.dependencies,
+      ...pkg.devDependencies
+    } : {};
+
+    // Check for files and packages
+    const checkDetection = (category, detections) => {
+      for (const detection of detections) {
+        // Check files
+        if (detection.files) {
+          for (const file of detection.files) {
+            const filePath = path.join(this.projectRoot, file);
+            if (fs.existsSync(filePath)) {
+              return detection;
+            }
+          }
+        }
+
+        // Check packages
+        if (detection.packages) {
+          for (const pkgName of detection.packages) {
+            if (allDeps[pkgName]) {
+              return detection;
+            }
+          }
+        }
+      }
+      return null;
+    };
+
+    // Map plural category names to singular for stack object
+    const categoryToStackKey = {
+      frameworks: 'framework',
+      languages: 'language',
+      databases: 'database',
+      hosting: 'hosting',
+      testing: 'testing',
+      auth: 'auth',
+      payments: 'payments'
+    };
+
+    // Detect each category
+    for (const [category, detections] of Object.entries(STACK_DETECTION)) {
+      const detected = checkDetection(category, detections);
+      if (detected) {
+        const stackKey = categoryToStackKey[category] || category;
+        stack[stackKey] = {
+          id: detected.id,
+          name: detected.name
+        };
+        stack.detected.push({
+          category,
+          ...detected
+        });
+      }
+    }
+
+    // Run structure analysis
+    const structureAnalyzer = new StructureAnalyzer(this.projectRoot);
+    const structure = structureAnalyzer.analyze();
+
+    // Save detection results
+    const detectionResult = {
+      stack,
+      structure,
+      packageJson: pkg ? {
+        name: pkg.name,
+        version: pkg.version,
+        description: pkg.description
+      } : null,
+      timestamp: new Date().toISOString()
+    };
+
+    // Write to detection directory
+    fs.writeFileSync(
+      path.join(this.detectionDir, 'stack.json'),
+      JSON.stringify(stack, null, 2)
+    );
+    fs.writeFileSync(
+      path.join(this.detectionDir, 'structure.json'),
+      JSON.stringify(structure, null, 2)
+    );
+
+    this.state.detection.stack = stack;
+    return detectionResult;
+  }
+
+  /**
+   * Run pattern scan phase
+   */
+  async runPatternScan() {
+    // Auto-detect large codebase and use quick mode
+    const structurePath = path.join(this.detectionDir, 'structure.json');
+    let fileCount = 0;
+    if (fs.existsSync(structurePath)) {
+      try {
+        const structure = JSON.parse(fs.readFileSync(structurePath, 'utf-8'));
+        fileCount = structure.stats?.totalFiles || 0;
+      } catch (_e) {
+        // Ignore
+      }
+    }
+
+    // For large codebases (500+ files), use quick mode automatically
+    const LARGE_CODEBASE_THRESHOLD = 500;
+    if (fileCount >= LARGE_CODEBASE_THRESHOLD) {
+      return this.runQuickPatternScan();
+    }
+
+    // Run architecture analysis
+    const architectureAnalyzer = new ArchitectureAnalyzer(this.projectRoot);
+    const architecture = architectureAnalyzer.analyze();
+
+    // Run dependency analysis
+    const dependencyAnalyzer = new DependencyAnalyzer(this.projectRoot);
+    const dependencies = dependencyAnalyzer.analyze();
+
+    const patterns = {
+      architecture,
+      dependencies,
+      features: this.detectFeatures(),
+      timestamp: new Date().toISOString()
+    };
+
+    // Save pattern results
+    fs.writeFileSync(
+      path.join(this.detectionDir, 'patterns.json'),
+      JSON.stringify(patterns, null, 2)
+    );
+
+    this.state.detection.patterns = {
+      architecturePatterns: architecture.patterns.slice(0, 3),
+      moduleCount: architecture.modules.length,
+      circularDeps: dependencies.circularDependencies.length
+    };
+
+    return patterns;
+  }
+
+  /**
+   * Run quick pattern scan (skips heavy dependency analysis)
+   */
+  async runQuickPatternScan() {
+    // Run architecture analysis only (fast)
+    const architectureAnalyzer = new ArchitectureAnalyzer(this.projectRoot);
+    const architecture = architectureAnalyzer.analyze();
+
+    // Skip dependency analysis - it's too slow for large codebases
+    const patterns = {
+      architecture,
+      dependencies: {
+        fileCount: 0,
+        circularDependencies: [],
+        unusedDependencies: [],
+        summary: { totalFiles: 0, circularCount: 0, unusedCount: 0, skipped: true }
+      },
+      features: this.detectFeatures(),
+      timestamp: new Date().toISOString(),
+      quickMode: true
+    };
+
+    // Save pattern results
+    fs.writeFileSync(
+      path.join(this.detectionDir, 'patterns.json'),
+      JSON.stringify(patterns, null, 2)
+    );
+
+    this.state.detection.patterns = {
+      architecturePatterns: architecture.patterns.slice(0, 3),
+      moduleCount: architecture.modules.length,
+      circularDeps: 0,
+      quickMode: true
+    };
+
+    return patterns;
+  }
+
+  /**
+   * Detect features in the codebase
+   */
+  detectFeatures() {
+    const features = {
+      auth: false,
+      payments: false,
+      api: false,
+      database: false,
+      email: false,
+      uploads: false,
+      search: false,
+      realtime: false,
+      analytics: false,
+      i18n: false
+    };
+
+    // Check for feature directories
+    const featureDirs = {
+      auth: ['auth', 'authentication', 'login'],
+      payments: ['payments', 'billing', 'subscriptions', 'checkout'],
+      api: ['api', 'routes', 'endpoints'],
+      database: ['db', 'database', 'prisma', 'models'],
+      email: ['email', 'mail', 'notifications'],
+      uploads: ['uploads', 'files', 'storage'],
+      search: ['search'],
+      realtime: ['websocket', 'realtime', 'socket'],
+      analytics: ['analytics', 'tracking'],
+      i18n: ['i18n', 'locales', 'translations']
+    };
+
+    const searchPaths = [
+      this.projectRoot,
+      path.join(this.projectRoot, 'src'),
+      path.join(this.projectRoot, 'app'),
+      path.join(this.projectRoot, 'lib')
+    ];
+
+    for (const searchPath of searchPaths) {
+      if (!fs.existsSync(searchPath)) continue;
+
+      try {
+        const items = fs.readdirSync(searchPath);
+        for (const item of items) {
+          const lowerItem = item.toLowerCase();
+          for (const [feature, dirs] of Object.entries(featureDirs)) {
+            if (dirs.includes(lowerItem)) {
+              features[feature] = true;
+            }
+          }
+        }
+      } catch (_e) {
+        // Skip
+      }
+    }
+
+    return features;
+  }
+
+  /**
+   * Run documentation discovery phase
+   */
+  async runDocDiscovery() {
+    const docs = {
+      found: [],
+      missing: [],
+      recommended: []
+    };
+
+    // Check for common documentation files
+    const commonDocs = [
+      { file: 'README.md', type: 'readme', required: true },
+      { file: 'CONTRIBUTING.md', type: 'contributing', required: false },
+      { file: 'CHANGELOG.md', type: 'changelog', required: false },
+      { file: 'LICENSE', type: 'license', required: true },
+      { file: 'CODE_OF_CONDUCT.md', type: 'code-of-conduct', required: false },
+      { file: 'SECURITY.md', type: 'security', required: false },
+      { file: 'docs/README.md', type: 'docs-readme', required: false },
+      { file: 'API.md', type: 'api-docs', required: false },
+      { file: '.env.example', type: 'env-example', required: true }
+    ];
+
+    for (const doc of commonDocs) {
+      const docPath = path.join(this.projectRoot, doc.file);
+      if (fs.existsSync(docPath)) {
+        docs.found.push({
+          ...doc,
+          path: doc.file,
+          size: fs.statSync(docPath).size
+        });
+      } else if (doc.required) {
+        docs.missing.push(doc);
+      } else {
+        docs.recommended.push(doc);
+      }
+    }
+
+    // Check for docs directory
+    const docsDir = path.join(this.projectRoot, 'docs');
+    if (fs.existsSync(docsDir)) {
+      docs.hasDocsDir = true;
+      try {
+        const docFiles = fs.readdirSync(docsDir);
+        docs.docsCount = docFiles.length;
+      } catch (_e) {
+        docs.docsCount = 0;
+      }
+    }
+
+    this.state.detection.docs = docs;
+    return docs;
+  }
+
+  /**
+   * Run config generation phase
+   */
+  async runConfigGeneration() {
+    const stack = this.state.detection.stack || {};
+    const patterns = this.state.detection.patterns || {};
+
+    // Generate bootspring.config.js
+    const configContent = this.generateConfigFile(stack, patterns);
+    const configPath = path.join(this.projectRoot, 'bootspring.config.js');
+
+    // Generate CLAUDE.md
+    const claudeMdContent = this.generateClaudeMd(stack, patterns);
+    const claudeMdPath = path.join(this.projectRoot, 'CLAUDE.md');
+
+    // Save to generated directory first
+    fs.writeFileSync(
+      path.join(this.generatedDir, 'bootspring.config.js'),
+      configContent
+    );
+    fs.writeFileSync(
+      path.join(this.generatedDir, 'CLAUDE.md'),
+      claudeMdContent
+    );
+
+    this.state.generated = {
+      config: configPath,
+      claudeMd: claudeMdPath,
+      timestamp: new Date().toISOString()
+    };
+
+    return {
+      configContent,
+      claudeMdContent,
+      configPath,
+      claudeMdPath
+    };
+  }
+
+  /**
+   * Apply generated config files
+   */
+  applyGeneratedFiles() {
+    const generatedConfig = path.join(this.generatedDir, 'bootspring.config.js');
+    const generatedClaudeMd = path.join(this.generatedDir, 'CLAUDE.md');
+
+    if (fs.existsSync(generatedConfig)) {
+      fs.copyFileSync(generatedConfig, path.join(this.projectRoot, 'bootspring.config.js'));
+    }
+
+    if (fs.existsSync(generatedClaudeMd)) {
+      fs.copyFileSync(generatedClaudeMd, path.join(this.projectRoot, 'CLAUDE.md'));
+    }
+
+    return true;
+  }
+
+  /**
+   * Generate bootspring.config.js content
+   */
+  generateConfigFile(stack, patterns) {
+    const framework = stack.framework?.id || 'unknown';
+    const language = stack.language?.id || 'javascript';
+    const database = stack.database?.id || null;
+    const hosting = stack.hosting?.id || null;
+
+    const plugins = [];
+    if (database) {
+      plugins.push(`    database: {\n      provider: '${database}',\n      features: ['default']\n    }`);
+    }
+    if (stack.testing) {
+      plugins.push(`    testing: {\n      provider: '${stack.testing.id}',\n      features: ['default']\n    }`);
+    }
+    plugins.push('    security: {\n      provider: \'default\',\n      features: [\'default\']\n    }');
+
+    return `/**
+ * Bootspring Configuration
+ * Generated by: bootspring onboard
+ * Generated at: ${new Date().toISOString()}
+ */
+
+module.exports = {
+  // Project information
+  project: {
+    name: '${stack.packageJson?.name || 'my-project'}',
+    version: '${stack.packageJson?.version || '1.0.0'}',
+    description: '${stack.packageJson?.description || 'A modern web application'}'
+  },
+
+  // Technology stack
+  stack: {
+    framework: '${framework}',
+    language: '${language}',
+    database: ${database ? `'${database}'` : 'null'},
+    hosting: ${hosting ? `'${hosting}'` : 'null'}
+  },
+
+  // Enabled plugins
+  plugins: {
+${plugins.join(',\n')}
+  },
+
+  // AI context settings
+  context: {
+    // Files to include in AI context
+    include: [
+      'src/**/*.{ts,tsx,js,jsx}',
+      'app/**/*.{ts,tsx,js,jsx}',
+      'lib/**/*.{ts,tsx,js,jsx}',
+      'components/**/*.{ts,tsx,js,jsx}'
+    ],
+    // Files to exclude from AI context
+    exclude: [
+      'node_modules/**',
+      'dist/**',
+      'build/**',
+      '.next/**',
+      'coverage/**'
+    ]
+  },
+
+  // Development settings
+  dev: {
+    // Quality gates
+    quality: {
+      preCommit: ['typecheck', 'lint'],
+      prePush: ['typecheck', 'lint', 'test'],
+      preDeploy: ['typecheck', 'lint', 'test', 'build']
+    }
+  }
+};
+`;
+  }
+
+  /**
+   * Generate CLAUDE.md content
+   */
+  generateClaudeMd(stack, patterns) {
+    const framework = stack.framework?.name || 'Unknown Framework';
+    const language = stack.language?.name || 'JavaScript';
+    const database = stack.database?.name || 'None';
+    const hosting = stack.hosting?.name || 'Unknown';
+
+    const features = patterns.features || {};
+    const enabledFeatures = Object.entries(features)
+      .filter(([, v]) => v)
+      .map(([k]) => k);
+
+    return `# Project - AI Context
+
+**Generated by**: Bootspring Onboard
+**Last Updated**: ${new Date().toISOString().split('T')[0]}
+**Status**: initialized
+**Health**: good
+
+---
+
+## Project Overview
+
+A modern web application built with ${framework}.
+
+---
+
+## Tech Stack
+
+| Component | Technology |
+|-----------|------------|
+| Framework | ${framework} |
+| Language | ${language} |
+| Database | ${database} |
+| Hosting | ${hosting} |
+
+---
+
+## Detected Features
+
+${enabledFeatures.length > 0 ? enabledFeatures.map(f => `- **${f}**: Detected`).join('\n') : '- No specific features detected'}
+
+---
+
+## Architecture
+
+${patterns.architecturePatterns?.length > 0
+    ? patterns.architecturePatterns.map(p => `- **${p.name}**: ${p.description || 'Detected pattern'}`).join('\n')
+    : '- Standard project structure'}
+
+---
+
+## Development Guidelines
+
+### Code Style
+- Use ${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
+${framework.includes('Next') ? '- Use Server Components by default\n- Prefer Server Actions over API routes for mutations' : '- Follow framework best practices'}
+- 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
+
+---
+
+## Current State
+
+- **Phase**: initialized
+- **Health**: good
+- **Open Todos**: 0
+- **Issues**: none
+
+---
+
+*Generated by [Bootspring](https://bootspring.com) - Development scaffolding with intelligence*
+`;
+  }
+
+  /**
+   * Run baseline capture phase
+   */
+  async runBaselineCapture() {
+    const baseline = {
+      timestamp: new Date().toISOString(),
+      metrics: {
+        files: 0,
+        lines: 0,
+        dependencies: 0
+      }
+    };
+
+    // Count files
+    const structurePath = path.join(this.detectionDir, 'structure.json');
+    if (fs.existsSync(structurePath)) {
+      const structure = JSON.parse(fs.readFileSync(structurePath, 'utf-8'));
+      baseline.metrics.files = structure.stats?.totalFiles || 0;
+    }
+
+    // Count dependencies
+    const pkgPath = path.join(this.projectRoot, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        baseline.metrics.dependencies =
+          Object.keys(pkg.dependencies || {}).length +
+          Object.keys(pkg.devDependencies || {}).length;
+      } catch (_e) {
+        // Skip
+      }
+    }
+
+    // Save baseline
+    fs.writeFileSync(
+      path.join(this.baselineDir, 'metrics.json'),
+      JSON.stringify(baseline, null, 2)
+    );
+
+    this.state.baseline = baseline;
+    return baseline;
+  }
+
+  /**
+   * Get workflow progress
+   */
+  getProgress() {
+    if (!this.state) return null;
+
+    const phases = Object.entries(ONBOARD_PHASES).map(([phaseId, phase]) => {
+      const phaseState = this.state.phases[phaseId] || { status: PHASE_STATUS.PENDING };
+
+      return {
+        id: phaseId,
+        name: phase.name,
+        description: phase.description,
+        order: phase.order,
+        required: phase.required,
+        status: phaseState.status,
+        dependenciesMet: this.arePhaseDependenciesMet(phaseId)
+      };
+    });
+
+    const completedCount = phases.filter(p => p.status === PHASE_STATUS.COMPLETED).length;
+    const requiredCount = phases.filter(p => p.required).length;
+    const requiredCompleted = phases.filter(p => p.required && p.status === PHASE_STATUS.COMPLETED).length;
+
+    return {
+      currentPhase: this.state.currentPhase,
+      startedAt: this.state.startedAt,
+      lastUpdated: this.state.lastUpdated,
+      phases,
+      overall: {
+        completed: completedCount,
+        total: phases.length,
+        percentage: Math.round((completedCount / phases.length) * 100)
+      },
+      required: {
+        completed: requiredCompleted,
+        total: requiredCount,
+        percentage: Math.round((requiredCompleted / requiredCount) * 100)
+      },
+      isComplete: requiredCompleted === requiredCount,
+      detection: this.state.detection
+    };
+  }
+
+  /**
+   * Get resume point
+   */
+  getResumePoint() {
+    if (!this.state || !this.state.currentPhase) {
+      return null;
+    }
+
+    const phase = ONBOARD_PHASES[this.state.currentPhase];
+    const phaseState = this.state.phases[this.state.currentPhase];
+
+    return {
+      phase: this.state.currentPhase,
+      phaseName: phase?.name,
+      phaseStatus: phaseState?.status,
+      lastUpdated: this.state.lastUpdated
+    };
+  }
+}
+
+module.exports = {
+  OnboardWorkflowEngine,
+  ONBOARD_PHASES,
+  PHASE_STATUS,
+  STACK_DETECTION
+};