@girardmedia/bootspring 1.2.0 → 2.0.3

package/core/ingest.js

@@ -0,0 +1,1111 @@
+/**
+ * Bootspring File Ingestion System
+ *
+ * Processes user-provided files from .bootspring/inputs/ and extracts
+ * structured information for document generation.
+ *
+ * @package bootspring
+ * @module core/ingest
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Simple YAML parser for basic key-value pairs
+ * @param {string} content - YAML content
+ * @returns {object} Parsed object
+ */
+function parseYamlSimple(content) {
+  const result = {};
+  const lines = content.split('\n');
+  const currentKey = null;
+  const currentIndent = 0;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+
+    const match = line.match(/^(\s*)(\w+):\s*(.*)/);
+    if (match) {
+      const indent = match[1].length;
+      const key = match[2];
+      const value = match[3].trim();
+
+      if (value) {
+        result[key] = value.replace(/^["']|["']$/g, '');
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Ingest all files from .bootspring/inputs
+ * @param {string} projectRoot - Project root directory
+ * @returns {object} Ingested data
+ */
+async function ingestAll(projectRoot) {
+  const inputsDir = path.join(projectRoot, '.bootspring', 'inputs');
+
+  const results = {
+    mvp: await ingestMVP(projectRoot),
+    business: await ingestBusiness(projectRoot),
+    prd: await ingestPRD(projectRoot),
+    designs: await ingestDesigns(projectRoot),
+    api: await ingestAPI(projectRoot),
+    data: await ingestData(projectRoot),
+    timestamp: new Date().toISOString()
+  };
+
+  return results;
+}
+
+/**
+ * Ingest MVP source code
+ * @param {string} projectRoot - Project root directory
+ * @returns {object} MVP analysis
+ */
+async function ingestMVP(projectRoot) {
+  const mvpPath = path.join(projectRoot, '.bootspring', 'inputs', 'mvp', 'source');
+
+  if (!fs.existsSync(mvpPath)) {
+    return { files: [], stats: { totalFiles: 0, totalLines: 0 }, patterns: [], components: [], services: [] };
+  }
+
+  const files = [];
+  const stats = { totalFiles: 0, totalLines: 0 };
+  const patterns = [];
+  const components = [];
+  const services = [];
+  const hooks = [];
+  const utilities = [];
+
+  // Walk the directory
+  function walkDir(dir, relativePath = '') {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      const relPath = path.join(relativePath, entry.name);
+
+      if (entry.isDirectory()) {
+        if (!['node_modules', '.git', '.next', 'dist', 'build'].includes(entry.name)) {
+          walkDir(fullPath, relPath);
+        }
+      } else if (entry.isFile()) {
+        const ext = path.extname(entry.name);
+        if (['.ts', '.tsx', '.js', '.jsx', '.css', '.scss'].includes(ext)) {
+          files.push(relPath);
+          stats.totalFiles++;
+
+          try {
+            const content = fs.readFileSync(fullPath, 'utf-8');
+            const lines = content.split('\n').length;
+            stats.totalLines += lines;
+
+            // Detect patterns
+            if (content.includes("'use client'") || content.includes('"use client"')) {
+              if (!patterns.includes('client-components')) patterns.push('client-components');
+            }
+            if (content.includes("'use server'") || content.includes('"use server"')) {
+              if (!patterns.includes('server-actions')) patterns.push('server-actions');
+            }
+            if (content.includes('useState') || content.includes('useEffect')) {
+              if (!patterns.includes('react-hooks')) patterns.push('react-hooks');
+            }
+            if (content.includes('prisma') || content.includes('PrismaClient')) {
+              if (!patterns.includes('prisma-orm')) patterns.push('prisma-orm');
+            }
+            if (content.includes('zod') || content.includes('.parse(')) {
+              if (!patterns.includes('zod-validation')) patterns.push('zod-validation');
+            }
+            if (content.includes('clerk') || content.includes('Clerk')) {
+              if (!patterns.includes('clerk-auth')) patterns.push('clerk-auth');
+            }
+            if (content.includes('stripe') || content.includes('Stripe')) {
+              if (!patterns.includes('stripe-payments')) patterns.push('stripe-payments');
+            }
+
+            // Categorize files
+            const lowerPath = relPath.toLowerCase();
+            if (lowerPath.includes('component') || entry.name.match(/^[A-Z].*\.(tsx|jsx)$/)) {
+              components.push(relPath);
+            }
+            if (lowerPath.includes('service') || lowerPath.includes('api') || lowerPath.includes('lib')) {
+              services.push(relPath);
+            }
+            if (lowerPath.includes('hook') || entry.name.startsWith('use')) {
+              hooks.push(relPath);
+            }
+            if (lowerPath.includes('util') || lowerPath.includes('helper')) {
+              utilities.push(relPath);
+            }
+          } catch {
+            // Skip files that can't be read
+          }
+        }
+      }
+    }
+  }
+
+  walkDir(mvpPath);
+
+  return {
+    files,
+    stats,
+    patterns,
+    components,
+    services,
+    hooks,
+    utilities
+  };
+}
+
+/**
+ * Ingest business documents
+ * @param {string} projectRoot - Project root directory
+ * @returns {Array} Business documents
+ */
+async function ingestBusiness(projectRoot) {
+  const businessPath = path.join(projectRoot, '.bootspring', 'inputs', 'business');
+
+  if (!fs.existsSync(businessPath)) {
+    return [];
+  }
+
+  const documents = [];
+
+  function walkDir(dir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        walkDir(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith('.md')) {
+        try {
+          const content = fs.readFileSync(fullPath, 'utf-8');
+          const relativePath = path.relative(businessPath, fullPath);
+
+          documents.push({
+            file: relativePath,
+            type: detectBusinessDocType(entry.name, content),
+            sections: parseMarkdownSections(content),
+            summary: extractSummary(content),
+            wordCount: content.split(/\s+/).length
+          });
+        } catch {
+          // Skip files that can't be read
+        }
+      }
+    }
+  }
+
+  walkDir(businessPath);
+  return documents;
+}
+
+/**
+ * Detect business document type from filename and content
+ * @param {string} filename - File name
+ * @param {string} content - File content
+ * @returns {string} Document type
+ */
+function detectBusinessDocType(filename, content) {
+  const lower = filename.toLowerCase();
+  const contentLower = content.toLowerCase();
+
+  if (lower.includes('business-plan') || lower.includes('businessplan')) return 'business-plan';
+  if (lower.includes('pitch') || lower.includes('deck')) return 'pitch-deck';
+  if (lower.includes('competitive') || lower.includes('competitor')) return 'competitive-analysis';
+  if (lower.includes('market') && lower.includes('research')) return 'market-research';
+  if (lower.includes('financial') || lower.includes('model')) return 'financial-model';
+  if (contentLower.includes('executive summary')) return 'business-plan';
+  if (contentLower.includes('tam') && contentLower.includes('sam')) return 'market-research';
+  if (contentLower.includes('competitor') || contentLower.includes('competitive advantage')) return 'competitive-analysis';
+
+  return 'general';
+}
+
+/**
+ * Parse markdown sections
+ * @param {string} content - Markdown content
+ * @returns {Array} Section headers
+ */
+function parseMarkdownSections(content) {
+  const sections = [];
+  const lines = content.split('\n');
+
+  for (const line of lines) {
+    const match = line.match(/^(#{1,3})\s+(.+)/);
+    if (match) {
+      sections.push({
+        level: match[1].length,
+        title: match[2].trim()
+      });
+    }
+  }
+
+  return sections;
+}
+
+/**
+ * Extract summary from document
+ * @param {string} content - Document content
+ * @returns {string} Summary (first 200 chars of first paragraph)
+ */
+function extractSummary(content) {
+  // Skip frontmatter
+  let text = content;
+  if (text.startsWith('---')) {
+    const endFrontmatter = text.indexOf('---', 3);
+    if (endFrontmatter !== -1) {
+      text = text.substring(endFrontmatter + 3);
+    }
+  }
+
+  // Find first paragraph
+  const lines = text.split('\n').filter(l => l.trim() && !l.startsWith('#'));
+  const firstPara = lines.slice(0, 3).join(' ').trim();
+
+  return firstPara.substring(0, 200) + (firstPara.length > 200 ? '...' : '');
+}
+
+/**
+ * Ingest PRD documents
+ * @param {string} projectRoot - Project root directory
+ * @returns {Array} PRD documents
+ */
+async function ingestPRD(projectRoot) {
+  const prdPath = path.join(projectRoot, '.bootspring', 'inputs', 'prd');
+
+  if (!fs.existsSync(prdPath)) {
+    return [];
+  }
+
+  const prds = [];
+
+  function walkDir(dir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        walkDir(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith('.md')) {
+        try {
+          const content = fs.readFileSync(fullPath, 'utf-8');
+          const relativePath = path.relative(prdPath, fullPath);
+
+          prds.push({
+            file: relativePath,
+            userStories: extractUserStories(content),
+            requirements: extractRequirements(content),
+            features: extractFeatures(content),
+            openQuestions: extractOpenQuestions(content),
+            sections: parseMarkdownSections(content)
+          });
+        } catch {
+          // Skip files that can't be read
+        }
+      }
+    }
+  }
+
+  walkDir(prdPath);
+  return prds;
+}
+
+/**
+ * Extract user stories from PRD
+ * @param {string} content - PRD content
+ * @returns {Array} User stories
+ */
+function extractUserStories(content) {
+  const stories = [];
+
+  // Match "As a [user], I want [action] so that [benefit]" pattern
+  const storyPattern = /As\s+(?:a|an)\s+(.+?),\s+I\s+want\s+(.+?)\s+so\s+that\s+(.+?)(?:\.|$)/gi;
+  let match;
+
+  while ((match = storyPattern.exec(content)) !== null) {
+    stories.push({
+      role: match[1].trim(),
+      want: match[2].trim(),
+      benefit: match[3].trim()
+    });
+  }
+
+  // Also look for bullet points starting with "As a"
+  const lines = content.split('\n');
+  for (const line of lines) {
+    if (line.match(/^[-*]\s+As\s+(?:a|an)/i) && !stories.some(s => line.includes(s.want))) {
+      const bulletMatch = line.match(/As\s+(?:a|an)\s+(.+?),\s+I\s+want\s+(.+?)(?:\s+so\s+that\s+(.+?))?(?:\.|$)/i);
+      if (bulletMatch) {
+        stories.push({
+          role: bulletMatch[1].trim(),
+          want: bulletMatch[2].trim(),
+          benefit: bulletMatch[3]?.trim() || ''
+        });
+      }
+    }
+  }
+
+  return stories;
+}
+
+/**
+ * Extract requirements from PRD
+ * @param {string} content - PRD content
+ * @returns {object} Requirements by priority
+ */
+function extractRequirements(content) {
+  const requirements = {
+    mustHave: [],
+    shouldHave: [],
+    niceToHave: []
+  };
+
+  const lines = content.split('\n');
+  let currentPriority = null;
+
+  for (const line of lines) {
+    const lowerLine = line.toLowerCase();
+
+    // Detect priority sections
+    if (lowerLine.includes('must have') || lowerLine.includes('p0') || lowerLine.includes('critical')) {
+      currentPriority = 'mustHave';
+      continue;
+    }
+    if (lowerLine.includes('should have') || lowerLine.includes('p1') || lowerLine.includes('high')) {
+      currentPriority = 'shouldHave';
+      continue;
+    }
+    if (lowerLine.includes('nice to have') || lowerLine.includes('p2') || lowerLine.includes('low')) {
+      currentPriority = 'niceToHave';
+      continue;
+    }
+
+    // Extract bullet points
+    if (currentPriority && line.match(/^[-*]\s+/)) {
+      const req = line.replace(/^[-*]\s+/, '').trim();
+      if (req && !req.match(/^(must|should|nice|p[012])/i)) {
+        requirements[currentPriority].push(req);
+      }
+    }
+  }
+
+  return requirements;
+}
+
+/**
+ * Extract features from PRD
+ * @param {string} content - PRD content
+ * @returns {Array} Features
+ */
+function extractFeatures(content) {
+  const features = [];
+  const lines = content.split('\n');
+  let inFeatureSection = false;
+
+  for (const line of lines) {
+    const lowerLine = line.toLowerCase();
+
+    // Detect feature sections
+    if (lowerLine.includes('## feature') || lowerLine.includes('### feature') || lowerLine.includes('## core feature')) {
+      inFeatureSection = true;
+      continue;
+    }
+
+    // New section ends feature section
+    if (inFeatureSection && line.match(/^#{1,3}\s/) && !lowerLine.includes('feature')) {
+      inFeatureSection = false;
+    }
+
+    // Extract bullet points
+    if (inFeatureSection && line.match(/^[-*]\s+/)) {
+      const feature = line.replace(/^[-*]\s+/, '').trim();
+      if (feature) {
+        features.push(feature);
+      }
+    }
+  }
+
+  return features;
+}
+
+/**
+ * Extract open questions from PRD
+ * @param {string} content - PRD content
+ * @returns {Array} Open questions
+ */
+function extractOpenQuestions(content) {
+  const questions = [];
+  const lines = content.split('\n');
+  let inQuestionSection = false;
+
+  for (const line of lines) {
+    const lowerLine = line.toLowerCase();
+
+    // Detect question sections
+    if (lowerLine.includes('open question') || lowerLine.includes('tbd') || lowerLine.includes('to be determined')) {
+      inQuestionSection = true;
+      continue;
+    }
+
+    // New section ends question section
+    if (inQuestionSection && line.match(/^#{1,3}\s/)) {
+      inQuestionSection = false;
+    }
+
+    // Extract questions (bullet points or lines ending with ?)
+    if (line.match(/\?[\s]*$/) || (inQuestionSection && line.match(/^[-*]\s+/))) {
+      const question = line.replace(/^[-*]\s+/, '').trim();
+      if (question && question.length > 5) {
+        questions.push(question);
+      }
+    }
+  }
+
+  return questions;
+}
+
+/**
+ * Ingest design files
+ * @param {string} projectRoot - Project root directory
+ * @returns {object} Design file information
+ */
+async function ingestDesigns(projectRoot) {
+  const designsPath = path.join(projectRoot, '.bootspring', 'inputs', 'designs');
+
+  if (!fs.existsSync(designsPath)) {
+    return { files: [], count: 0 };
+  }
+
+  const files = [];
+
+  function walkDir(dir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        walkDir(fullPath);
+      } else if (entry.isFile()) {
+        const ext = path.extname(entry.name).toLowerCase();
+        const relativePath = path.relative(designsPath, fullPath);
+
+        files.push({
+          path: relativePath,
+          type: ext,
+          name: entry.name
+        });
+      }
+    }
+  }
+
+  walkDir(designsPath);
+
+  return {
+    files,
+    count: files.length,
+    imageCount: files.filter(f => ['.png', '.jpg', '.jpeg', '.svg', '.gif', '.webp'].includes(f.type)).length,
+    docCount: files.filter(f => ['.md', '.pdf', '.doc', '.docx'].includes(f.type)).length
+  };
+}
+
+/**
+ * Ingest API specifications
+ * @param {string} projectRoot - Project root directory
+ * @returns {Array} API specifications
+ */
+async function ingestAPI(projectRoot) {
+  const apiPath = path.join(projectRoot, '.bootspring', 'inputs', 'api');
+
+  if (!fs.existsSync(apiPath)) {
+    return [];
+  }
+
+  const specs = [];
+
+  function walkDir(dir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        walkDir(fullPath);
+      } else if (entry.isFile()) {
+        const ext = path.extname(entry.name).toLowerCase();
+
+        if (['.yaml', '.yml', '.json'].includes(ext)) {
+          try {
+            const content = fs.readFileSync(fullPath, 'utf-8');
+            const relativePath = path.relative(apiPath, fullPath);
+
+            // Check if it's an OpenAPI spec
+            if (content.includes('openapi') || content.includes('swagger')) {
+              specs.push({
+                file: relativePath,
+                type: 'openapi',
+                endpoints: extractOpenAPIEndpoints(content)
+              });
+            } else {
+              specs.push({
+                file: relativePath,
+                type: 'unknown',
+                endpoints: []
+              });
+            }
+          } catch {
+            // Skip files that can't be read
+          }
+        }
+      }
+    }
+  }
+
+  walkDir(apiPath);
+  return specs;
+}
+
+/**
+ * Extract endpoints from OpenAPI spec
+ * @param {string} content - OpenAPI content
+ * @returns {Array} Endpoints
+ */
+function extractOpenAPIEndpoints(content) {
+  const endpoints = [];
+
+  // Simple regex-based extraction (not full YAML parsing)
+  const pathPattern = /["']?(\/[^"'\s:]+)["']?\s*:/g;
+  const methodPattern = /(get|post|put|delete|patch):/gi;
+
+  let match;
+  const paths = new Set();
+
+  while ((match = pathPattern.exec(content)) !== null) {
+    const pathStr = match[1];
+    if (pathStr && !pathStr.includes('$') && pathStr.length < 100) {
+      paths.add(pathStr);
+    }
+  }
+
+  for (const pathStr of paths) {
+    endpoints.push({ path: pathStr });
+  }
+
+  return endpoints;
+}
+
+/**
+ * Ingest data files
+ * @param {string} projectRoot - Project root directory
+ * @returns {Array} Data files
+ */
+async function ingestData(projectRoot) {
+  const dataPath = path.join(projectRoot, '.bootspring', 'inputs', 'data');
+
+  if (!fs.existsSync(dataPath)) {
+    return [];
+  }
+
+  const dataFiles = [];
+
+  function walkDir(dir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        walkDir(fullPath);
+      } else if (entry.isFile()) {
+        const ext = path.extname(entry.name).toLowerCase();
+        const relativePath = path.relative(dataPath, fullPath);
+
+        try {
+          const content = fs.readFileSync(fullPath, 'utf-8');
+
+          if (ext === '.sql') {
+            dataFiles.push({
+              file: relativePath,
+              type: 'sql',
+              tables: extractSQLTables(content)
+            });
+          } else if (ext === '.json') {
+            const parsed = JSON.parse(content);
+            dataFiles.push({
+              file: relativePath,
+              type: 'json',
+              structure: inferJSONStructure(parsed)
+            });
+          } else if (ext === '.csv') {
+            const headers = content.split('\n')[0]?.split(',').map(h => h.trim());
+            dataFiles.push({
+              file: relativePath,
+              type: 'csv',
+              headers: headers || []
+            });
+          }
+        } catch {
+          // Skip files that can't be parsed
+        }
+      }
+    }
+  }
+
+  walkDir(dataPath);
+  return dataFiles;
+}
+
+/**
+ * Extract table definitions from SQL
+ * @param {string} content - SQL content
+ * @returns {Array} Tables
+ */
+function extractSQLTables(content) {
+  const tables = [];
+  const tablePattern = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?["'`]?(\w+)["'`]?\s*\(/gi;
+
+  let match;
+  while ((match = tablePattern.exec(content)) !== null) {
+    tables.push(match[1]);
+  }
+
+  return tables;
+}
+
+/**
+ * Infer structure from JSON
+ * @param {*} data - JSON data
+ * @returns {object} Structure description
+ */
+function inferJSONStructure(data) {
+  if (Array.isArray(data)) {
+    return {
+      type: 'array',
+      length: data.length,
+      itemType: data.length > 0 ? inferJSONStructure(data[0]) : 'unknown'
+    };
+  }
+
+  if (data === null) return { type: 'null' };
+  if (typeof data !== 'object') return { type: typeof data };
+
+  const fields = {};
+  for (const [key, value] of Object.entries(data)) {
+    fields[key] = typeof value === 'object' && value !== null
+      ? (Array.isArray(value) ? 'array' : 'object')
+      : typeof value;
+  }
+
+  return { type: 'object', fields };
+}
+
+/**
+ * Generate documents from ingested data
+ * @param {object} ingested - Ingested data
+ * @param {object} seedConfig - SEED.md configuration
+ * @param {string} projectRoot - Project root directory
+ * @returns {object} Generated documents
+ */
+async function generateDocuments(ingested, seedConfig, projectRoot) {
+  const outputs = {};
+  const generatedDir = path.join(projectRoot, '.bootspring', 'generated');
+
+  // Generate context summary
+  outputs['context-summary.md'] = generateContextSummary(ingested, seedConfig);
+  fs.writeFileSync(
+    path.join(generatedDir, 'context-summary.md'),
+    outputs['context-summary.md']
+  );
+
+  // Generate MVP analysis if MVP exists
+  if (ingested.mvp && ingested.mvp.files && ingested.mvp.files.length > 0) {
+    outputs['mvp-analysis.md'] = generateMVPAnalysis(ingested.mvp);
+    fs.mkdirSync(path.join(generatedDir, 'architecture'), { recursive: true });
+    fs.writeFileSync(
+      path.join(generatedDir, 'architecture', 'mvp-analysis.md'),
+      outputs['mvp-analysis.md']
+    );
+  }
+
+  // Generate PRD consolidation if PRDs exist
+  if (ingested.prd && ingested.prd.length > 0) {
+    outputs['consolidated-prd.md'] = generateConsolidatedPRD(ingested.prd, seedConfig);
+    fs.mkdirSync(path.join(generatedDir, 'prd'), { recursive: true });
+    fs.writeFileSync(
+      path.join(generatedDir, 'prd', 'consolidated-prd.md'),
+      outputs['consolidated-prd.md']
+    );
+  }
+
+  // Generate business summary if business docs exist
+  if (ingested.business && ingested.business.length > 0) {
+    outputs['business-summary.md'] = generateBusinessSummary(ingested.business, seedConfig);
+    fs.mkdirSync(path.join(generatedDir, 'business'), { recursive: true });
+    fs.writeFileSync(
+      path.join(generatedDir, 'business', 'business-summary.md'),
+      outputs['business-summary.md']
+    );
+  }
+
+  // Generate API summary if API specs exist
+  if (ingested.api && ingested.api.length > 0) {
+    outputs['api-summary.md'] = generateAPISummary(ingested.api);
+    fs.mkdirSync(path.join(generatedDir, 'architecture'), { recursive: true });
+    fs.writeFileSync(
+      path.join(generatedDir, 'architecture', 'api-summary.md'),
+      outputs['api-summary.md']
+    );
+  }
+
+  // Generate data model if data files exist
+  if (ingested.data && ingested.data.length > 0) {
+    outputs['data-model.md'] = generateDataModel(ingested.data);
+    fs.mkdirSync(path.join(generatedDir, 'architecture'), { recursive: true });
+    fs.writeFileSync(
+      path.join(generatedDir, 'architecture', 'data-model.md'),
+      outputs['data-model.md']
+    );
+  }
+
+  return outputs;
+}
+
+/**
+ * Generate context summary document
+ */
+function generateContextSummary(ingested, seedConfig) {
+  const projectName = seedConfig.project?.name || 'Project';
+
+  return `# ${projectName} - Context Summary
+
+> Auto-generated by Bootspring on ${new Date().toISOString().split('T')[0]}
+
+## Input Files Summary
+
+| Category | Count | Status |
+|----------|-------|--------|
+| MVP Code | ${ingested.mvp?.files?.length || 0} files | ${ingested.mvp?.files?.length > 0 ? 'Analyzed' : 'Not provided'} |
+| Business Docs | ${ingested.business?.length || 0} files | ${ingested.business?.length > 0 ? 'Analyzed' : 'Not provided'} |
+| PRD Docs | ${ingested.prd?.length || 0} files | ${ingested.prd?.length > 0 ? 'Analyzed' : 'Not provided'} |
+| Design Files | ${ingested.designs?.count || 0} files | ${ingested.designs?.count > 0 ? 'Indexed' : 'Not provided'} |
+| API Specs | ${ingested.api?.length || 0} files | ${ingested.api?.length > 0 ? 'Analyzed' : 'Not provided'} |
+| Data Files | ${ingested.data?.length || 0} files | ${ingested.data?.length > 0 ? 'Analyzed' : 'Not provided'} |
+
+## Detected Patterns
+
+${ingested.mvp?.patterns?.length > 0 ? ingested.mvp.patterns.map(p => `- ${p}`).join('\n') : '- No patterns detected'}
+
+## Key Statistics
+
+${ingested.mvp?.stats ? `
+- **Total MVP Files**: ${ingested.mvp.stats.totalFiles}
+- **Total Lines of Code**: ${ingested.mvp.stats.totalLines.toLocaleString()}
+- **Components**: ${ingested.mvp.components?.length || 0}
+- **Services**: ${ingested.mvp.services?.length || 0}
+- **Hooks**: ${ingested.mvp.hooks?.length || 0}
+` : '- No MVP code provided'}
+
+${ingested.prd?.length > 0 ? `
+## User Stories Found
+
+${ingested.prd.flatMap(p => p.userStories || []).slice(0, 10).map(s =>
+    `- As a **${s.role}**, I want **${s.want}**${s.benefit ? ` so that ${s.benefit}` : ''}`
+  ).join('\n') || '- No user stories found'}
+` : ''}
+
+---
+
+*Generated by Bootspring*
+`;
+}
+
+/**
+ * Generate MVP analysis document
+ */
+function generateMVPAnalysis(mvp) {
+  return `# MVP Code Analysis
+
+> Auto-generated by Bootspring
+
+## Overview
+
+| Metric | Value |
+|--------|-------|
+| Total Files | ${mvp.stats.totalFiles} |
+| Total Lines | ${mvp.stats.totalLines.toLocaleString()} |
+| Components | ${mvp.components.length} |
+| Services | ${mvp.services.length} |
+| Hooks | ${mvp.hooks.length} |
+| Utilities | ${mvp.utilities.length} |
+
+## Detected Patterns
+
+${mvp.patterns.map(p => `- ${p}`).join('\n') || '- None detected'}
+
+## Components
+
+${mvp.components.slice(0, 20).map(c => `- \`${c}\``).join('\n') || '- None found'}
+${mvp.components.length > 20 ? `\n*... and ${mvp.components.length - 20} more*` : ''}
+
+## Services
+
+${mvp.services.slice(0, 10).map(s => `- \`${s}\``).join('\n') || '- None found'}
+${mvp.services.length > 10 ? `\n*... and ${mvp.services.length - 10} more*` : ''}
+
+## Hooks
+
+${mvp.hooks.slice(0, 10).map(h => `- \`${h}\``).join('\n') || '- None found'}
+
+## Recommendations
+
+Based on the detected patterns:
+
+${mvp.patterns.includes('client-components') ? '- Consider reviewing client components for server-side rendering opportunities' : ''}
+${mvp.patterns.includes('prisma-orm') ? '- Prisma ORM detected - ensure schema is optimized for production' : ''}
+${mvp.patterns.includes('clerk-auth') ? '- Clerk authentication detected - verify middleware configuration' : ''}
+${mvp.patterns.includes('stripe-payments') ? '- Stripe integration detected - ensure webhook handlers are secure' : ''}
+
+---
+
+*Generated by Bootspring*
+`;
+}
+
+/**
+ * Generate consolidated PRD document
+ */
+function generateConsolidatedPRD(prds, seedConfig) {
+  const allStories = prds.flatMap(p => p.userStories || []);
+  const allRequirements = {
+    mustHave: prds.flatMap(p => p.requirements?.mustHave || []),
+    shouldHave: prds.flatMap(p => p.requirements?.shouldHave || []),
+    niceToHave: prds.flatMap(p => p.requirements?.niceToHave || [])
+  };
+  const allFeatures = prds.flatMap(p => p.features || []);
+  const allQuestions = prds.flatMap(p => p.openQuestions || []);
+
+  return `# Consolidated Product Requirements
+
+> Auto-generated from ${prds.length} PRD file(s)
+
+## User Stories
+
+${allStories.map((s, i) => `${i + 1}. As a **${s.role}**, I want **${s.want}**${s.benefit ? ` so that ${s.benefit}` : ''}`).join('\n') || '- No user stories extracted'}
+
+## Requirements
+
+### Must Have (P0)
+
+${allRequirements.mustHave.map(r => `- [ ] ${r}`).join('\n') || '- None specified'}
+
+### Should Have (P1)
+
+${allRequirements.shouldHave.map(r => `- [ ] ${r}`).join('\n') || '- None specified'}
+
+### Nice to Have (P2)
+
+${allRequirements.niceToHave.map(r => `- [ ] ${r}`).join('\n') || '- None specified'}
+
+## Features
+
+${allFeatures.map(f => `- ${f}`).join('\n') || '- No features extracted'}
+
+## Open Questions
+
+${allQuestions.map(q => `- ${q}`).join('\n') || '- No open questions found'}
+
+## Source Files
+
+${prds.map(p => `- \`${p.file}\``).join('\n')}
+
+---
+
+*Generated by Bootspring*
+`;
+}
+
+/**
+ * Generate business summary document
+ */
+function generateBusinessSummary(businessDocs, seedConfig) {
+  const byType = {};
+  for (const doc of businessDocs) {
+    if (!byType[doc.type]) byType[doc.type] = [];
+    byType[doc.type].push(doc);
+  }
+
+  return `# Business Context Summary
+
+> Auto-generated from ${businessDocs.length} business document(s)
+
+## Documents Analyzed
+
+| Document | Type | Word Count |
+|----------|------|------------|
+${businessDocs.map(d => `| ${d.file} | ${d.type} | ${d.wordCount} |`).join('\n')}
+
+## Key Sections Found
+
+${businessDocs.map(d => `
+### ${d.file}
+
+${d.sections.filter(s => s.level <= 2).map(s => `${'  '.repeat(s.level - 1)}- ${s.title}`).join('\n')}
+`).join('\n')}
+
+## Summaries
+
+${businessDocs.map(d => `
+### ${d.file}
+
+${d.summary}
+`).join('\n')}
+
+---
+
+*Generated by Bootspring*
+`;
+}
+
+/**
+ * Generate API summary document
+ */
+function generateAPISummary(apiSpecs) {
+  return `# API Specification Summary
+
+> Auto-generated from ${apiSpecs.length} API spec file(s)
+
+## Specifications
+
+${apiSpecs.map(spec => `
+### ${spec.file}
+
+**Type**: ${spec.type}
+
+**Endpoints** (${spec.endpoints.length}):
+
+${spec.endpoints.slice(0, 20).map(e => `- \`${e.path}\``).join('\n') || '- None extracted'}
+${spec.endpoints.length > 20 ? `\n*... and ${spec.endpoints.length - 20} more*` : ''}
+`).join('\n')}
+
+---
+
+*Generated by Bootspring*
+`;
+}
+
+/**
+ * Generate data model document
+ */
+function generateDataModel(dataFiles) {
+  const sqlFiles = dataFiles.filter(f => f.type === 'sql');
+  const jsonFiles = dataFiles.filter(f => f.type === 'json');
+  const csvFiles = dataFiles.filter(f => f.type === 'csv');
+
+  return `# Data Model Summary
+
+> Auto-generated from ${dataFiles.length} data file(s)
+
+## Database Tables
+
+${sqlFiles.length > 0 ? sqlFiles.map(f => `
+### ${f.file}
+
+Tables: ${f.tables.join(', ') || 'None found'}
+`).join('\n') : '- No SQL files provided'}
+
+## JSON Structures
+
+${jsonFiles.length > 0 ? jsonFiles.map(f => `
+### ${f.file}
+
+Type: ${f.structure.type}
+${f.structure.fields ? `Fields: ${Object.keys(f.structure.fields).join(', ')}` : ''}
+`).join('\n') : '- No JSON files provided'}
+
+## CSV Files
+
+${csvFiles.length > 0 ? csvFiles.map(f => `
+### ${f.file}
+
+Headers: ${f.headers.join(', ')}
+`).join('\n') : '- No CSV files provided'}
+
+---
+
+*Generated by Bootspring*
+`;
+}
+
+/**
+ * Update context index
+ * @param {string} projectRoot - Project root directory
+ * @param {object} ingested - Ingested data
+ */
+async function updateContextIndex(projectRoot, ingested) {
+  const contextDir = path.join(projectRoot, '.bootspring', 'context');
+  const indexPath = path.join(contextDir, 'context-index.json');
+
+  if (!fs.existsSync(contextDir)) {
+    fs.mkdirSync(contextDir, { recursive: true });
+  }
+
+  const index = {
+    lastUpdated: new Date().toISOString(),
+    inputsAnalyzed: {
+      mvp: {
+        fileCount: ingested.mvp?.files?.length || 0,
+        patterns: ingested.mvp?.patterns || []
+      },
+      business: {
+        fileCount: ingested.business?.length || 0,
+        types: ingested.business?.map(d => d.type) || []
+      },
+      prd: {
+        fileCount: ingested.prd?.length || 0,
+        userStoryCount: ingested.prd?.reduce((sum, p) => sum + (p.userStories?.length || 0), 0) || 0
+      },
+      designs: {
+        fileCount: ingested.designs?.count || 0
+      },
+      api: {
+        fileCount: ingested.api?.length || 0,
+        endpointCount: ingested.api?.reduce((sum, s) => sum + (s.endpoints?.length || 0), 0) || 0
+      },
+      data: {
+        fileCount: ingested.data?.length || 0
+      }
+    },
+    generatedFiles: [
+      'context-summary.md',
+      ...(ingested.mvp?.files?.length > 0 ? ['architecture/mvp-analysis.md'] : []),
+      ...(ingested.prd?.length > 0 ? ['prd/consolidated-prd.md'] : []),
+      ...(ingested.business?.length > 0 ? ['business/business-summary.md'] : []),
+      ...(ingested.api?.length > 0 ? ['architecture/api-summary.md'] : []),
+      ...(ingested.data?.length > 0 ? ['architecture/data-model.md'] : [])
+    ]
+  };
+
+  fs.writeFileSync(indexPath, JSON.stringify(index, null, 2));
+}
+
+module.exports = {
+  ingestAll,
+  ingestMVP,
+  ingestBusiness,
+  ingestPRD,
+  ingestDesigns,
+  ingestAPI,
+  ingestData,
+  generateDocuments,
+  updateContextIndex
+};