@girardmedia/bootspring 2.0.21 → 2.0.22

package/src/core/ingest.ts

@@ -0,0 +1,1186 @@
+/**
+ * Bootspring File Ingestion System
+ *
+ * Processes user-provided files from .bootspring/inputs/ and extracts
+ * structured information for document generation.
+ *
+ * @package bootspring
+ * @module core/ingest
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface ParsedYaml {
+  [key: string]: string;
+}
+
+export interface MvpStats {
+  totalFiles: number;
+  totalLines: number;
+}
+
+export interface MvpIngestion {
+  files: string[];
+  stats: MvpStats;
+  patterns: string[];
+  components: string[];
+  services: string[];
+  hooks: string[];
+  utilities: string[];
+}
+
+export interface MarkdownSection {
+  level: number;
+  title: string;
+}
+
+export interface BusinessDocument {
+  file: string;
+  type: string;
+  sections: MarkdownSection[];
+  summary: string;
+  wordCount: number;
+}
+
+export interface UserStory {
+  role: string;
+  want: string;
+  benefit: string;
+}
+
+export interface Requirements {
+  mustHave: string[];
+  shouldHave: string[];
+  niceToHave: string[];
+}
+
+export interface PrdDocument {
+  file: string;
+  userStories: UserStory[];
+  requirements: Requirements;
+  features: string[];
+  openQuestions: string[];
+  sections: MarkdownSection[];
+}
+
+export interface DesignFile {
+  path: string;
+  type: string;
+  name: string;
+}
+
+export interface DesignsIngestion {
+  files: DesignFile[];
+  count: number;
+  imageCount: number;
+  docCount: number;
+}
+
+export interface ApiEndpoint {
+  path: string;
+}
+
+export interface ApiSpec {
+  file: string;
+  type: string;
+  endpoints: ApiEndpoint[];
+}
+
+export interface JsonStructure {
+  type: string;
+  length?: number | undefined;
+  itemType?: JsonStructure | string | undefined;
+  fields?: Record<string, string> | undefined;
+}
+
+export interface SqlDataFile {
+  file: string;
+  type: 'sql';
+  tables: string[];
+}
+
+export interface JsonDataFile {
+  file: string;
+  type: 'json';
+  structure: JsonStructure;
+}
+
+export interface CsvDataFile {
+  file: string;
+  type: 'csv';
+  headers: string[];
+}
+
+export type DataFile = SqlDataFile | JsonDataFile | CsvDataFile;
+
+export interface IngestionResult {
+  mvp: MvpIngestion;
+  business: BusinessDocument[];
+  prd: PrdDocument[];
+  designs: DesignsIngestion;
+  api: ApiSpec[];
+  data: DataFile[];
+  timestamp: string;
+}
+
+export interface SeedConfig {
+  project?: {
+    name?: string | undefined;
+  } | undefined;
+}
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+/**
+ * Simple YAML parser for basic key-value pairs
+ */
+export function parseYamlSimple(content: string): ParsedYaml {
+  const result: ParsedYaml = {};
+  const lines = content.split('\n');
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+
+    const match = line.match(/^(\s*)(\w+):\s*(.*)/);
+    if (match) {
+      const key = match[2];
+      const value = match[3]?.trim();
+
+      if (key && value) {
+        result[key] = value.replace(/^["']|["']$/g, '');
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Detect business document type from filename and content
+ */
+function detectBusinessDocType(filename: string, content: string): string {
+  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
+ */
+function parseMarkdownSections(content: string): MarkdownSection[] {
+  const sections: MarkdownSection[] = [];
+  const lines = content.split('\n');
+
+  for (const line of lines) {
+    const match = line.match(/^(#{1,3})\s+(.+)/);
+    if (match && match[1] && match[2]) {
+      sections.push({
+        level: match[1].length,
+        title: match[2].trim()
+      });
+    }
+  }
+
+  return sections;
+}
+
+/**
+ * Extract summary from document
+ */
+function extractSummary(content: string): string {
+  // 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 ? '...' : '');
+}
+
+/**
+ * Extract user stories from PRD
+ */
+function extractUserStories(content: string): UserStory[] {
+  const stories: UserStory[] = [];
+
+  // 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) {
+    if (match[1] && match[2] && match[3]) {
+      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 && bulletMatch[1] && bulletMatch[2]) {
+        stories.push({
+          role: bulletMatch[1].trim(),
+          want: bulletMatch[2].trim(),
+          benefit: bulletMatch[3]?.trim() || ''
+        });
+      }
+    }
+  }
+
+  return stories;
+}
+
+/**
+ * Extract requirements from PRD
+ */
+function extractRequirements(content: string): Requirements {
+  const requirements: Requirements = {
+    mustHave: [],
+    shouldHave: [],
+    niceToHave: []
+  };
+
+  const lines = content.split('\n');
+  let currentPriority: keyof Requirements | null = 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
+ */
+function extractFeatures(content: string): string[] {
+  const features: string[] = [];
+  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
+ */
+function extractOpenQuestions(content: string): string[] {
+  const questions: string[] = [];
+  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;
+}
+
+/**
+ * Extract endpoints from OpenAPI spec
+ */
+function extractOpenAPIEndpoints(content: string): ApiEndpoint[] {
+  const endpoints: ApiEndpoint[] = [];
+
+  // Simple regex-based extraction (not full YAML parsing)
+  const pathPattern = /["']?(\/[^"'\s:]+)["']?\s*:/g;
+  const paths = new Set<string>();
+
+  let match;
+  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;
+}
+
+/**
+ * Extract table definitions from SQL
+ */
+function extractSQLTables(content: string): string[] {
+  const tables: string[] = [];
+  const tablePattern = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?["'`]?(\w+)["'`]?\s*\(/gi;
+
+  let match;
+  while ((match = tablePattern.exec(content)) !== null) {
+    if (match[1]) {
+      tables.push(match[1]);
+    }
+  }
+
+  return tables;
+}
+
+/**
+ * Infer structure from JSON
+ */
+function inferJSONStructure(data: unknown): JsonStructure {
+  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: Record<string, string> = {};
+  for (const [key, value] of Object.entries(data as Record<string, unknown>)) {
+    fields[key] = typeof value === 'object' && value !== null
+      ? (Array.isArray(value) ? 'array' : 'object')
+      : typeof value;
+  }
+
+  return { type: 'object', fields };
+}
+
+// ============================================================================
+// Ingestion Functions
+// ============================================================================
+
+/**
+ * Ingest all files from .bootspring/inputs
+ */
+export async function ingestAll(projectRoot: string): Promise<IngestionResult> {
+  const results: IngestionResult = {
+    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
+ */
+export async function ingestMVP(projectRoot: string): Promise<MvpIngestion> {
+  const mvpPath = path.join(projectRoot, '.bootspring', 'inputs', 'mvp', 'source');
+
+  if (!fs.existsSync(mvpPath)) {
+    return { files: [], stats: { totalFiles: 0, totalLines: 0 }, patterns: [], components: [], services: [], hooks: [], utilities: [] };
+  }
+
+  const files: string[] = [];
+  const stats: MvpStats = { totalFiles: 0, totalLines: 0 };
+  const patterns: string[] = [];
+  const components: string[] = [];
+  const services: string[] = [];
+  const hooks: string[] = [];
+  const utilities: string[] = [];
+
+  // Walk the directory
+  function walkDir(dir: string, relativePath: string = ''): void {
+    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
+ */
+export async function ingestBusiness(projectRoot: string): Promise<BusinessDocument[]> {
+  const businessPath = path.join(projectRoot, '.bootspring', 'inputs', 'business');
+
+  if (!fs.existsSync(businessPath)) {
+    return [];
+  }
+
+  const documents: BusinessDocument[] = [];
+
+  function walkDir(dir: string): void {
+    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;
+}
+
+/**
+ * Ingest PRD documents
+ */
+export async function ingestPRD(projectRoot: string): Promise<PrdDocument[]> {
+  const prdPath = path.join(projectRoot, '.bootspring', 'inputs', 'prd');
+
+  if (!fs.existsSync(prdPath)) {
+    return [];
+  }
+
+  const prds: PrdDocument[] = [];
+
+  function walkDir(dir: string): void {
+    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;
+}
+
+/**
+ * Ingest design files
+ */
+export async function ingestDesigns(projectRoot: string): Promise<DesignsIngestion> {
+  const designsPath = path.join(projectRoot, '.bootspring', 'inputs', 'designs');
+
+  if (!fs.existsSync(designsPath)) {
+    return { files: [], count: 0, imageCount: 0, docCount: 0 };
+  }
+
+  const files: DesignFile[] = [];
+
+  function walkDir(dir: string): void {
+    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
+ */
+export async function ingestAPI(projectRoot: string): Promise<ApiSpec[]> {
+  const apiPath = path.join(projectRoot, '.bootspring', 'inputs', 'api');
+
+  if (!fs.existsSync(apiPath)) {
+    return [];
+  }
+
+  const specs: ApiSpec[] = [];
+
+  function walkDir(dir: string): void {
+    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;
+}
+
+/**
+ * Ingest data files
+ */
+export async function ingestData(projectRoot: string): Promise<DataFile[]> {
+  const dataPath = path.join(projectRoot, '.bootspring', 'inputs', 'data');
+
+  if (!fs.existsSync(dataPath)) {
+    return [];
+  }
+
+  const dataFiles: DataFile[] = [];
+
+  function walkDir(dir: string): void {
+    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) as unknown;
+            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
+            });
+          }
+        } catch {
+          // Skip files that can't be parsed
+        }
+      }
+    }
+  }
+
+  walkDir(dataPath);
+  return dataFiles;
+}
+
+// ============================================================================
+// Document Generation
+// ============================================================================
+
+/**
+ * Generate context summary document
+ */
+function generateContextSummary(ingested: IngestionResult, seedConfig: SeedConfig): string {
+  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) > 0 ? 'Analyzed' : 'Not provided'} |
+| Business Docs | ${ingested.business?.length || 0} files | ${(ingested.business?.length ?? 0) > 0 ? 'Analyzed' : 'Not provided'} |
+| PRD Docs | ${ingested.prd?.length || 0} files | ${(ingested.prd?.length ?? 0) > 0 ? 'Analyzed' : 'Not provided'} |
+| Design Files | ${ingested.designs?.count || 0} files | ${(ingested.designs?.count ?? 0) > 0 ? 'Indexed' : 'Not provided'} |
+| API Specs | ${ingested.api?.length || 0} files | ${(ingested.api?.length ?? 0) > 0 ? 'Analyzed' : 'Not provided'} |
+| Data Files | ${ingested.data?.length || 0} files | ${(ingested.data?.length ?? 0) > 0 ? 'Analyzed' : 'Not provided'} |
+
+## Detected Patterns
+
+${(ingested.mvp?.patterns?.length ?? 0) > 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) > 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: MvpIngestion): string {
+  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: PrdDocument[], _seedConfig: SeedConfig): string {
+  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: BusinessDocument[], _seedConfig: SeedConfig): string {
+  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: ApiSpec[]): string {
+  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: DataFile[]): string {
+  const sqlFiles = dataFiles.filter((f): f is SqlDataFile => f.type === 'sql');
+  const jsonFiles = dataFiles.filter((f): f is JsonDataFile => f.type === 'json');
+  const csvFiles = dataFiles.filter((f): f is CsvDataFile => 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*
+`;
+}
+
+/**
+ * Generate documents from ingested data
+ */
+export async function generateDocuments(
+  ingested: IngestionResult,
+  seedConfig: SeedConfig,
+  projectRoot: string
+): Promise<Record<string, string>> {
+  const outputs: Record<string, string> = {};
+  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;
+}
+
+/**
+ * Update context index
+ */
+export async function updateContextIndex(projectRoot: string, ingested: IngestionResult): Promise<void> {
+  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) > 0 ? ['architecture/mvp-analysis.md'] : []),
+      ...((ingested.prd?.length ?? 0) > 0 ? ['prd/consolidated-prd.md'] : []),
+      ...((ingested.business?.length ?? 0) > 0 ? ['business/business-summary.md'] : []),
+      ...((ingested.api?.length ?? 0) > 0 ? ['architecture/api-summary.md'] : []),
+      ...((ingested.data?.length ?? 0) > 0 ? ['architecture/data-model.md'] : [])
+    ]
+  };
+
+  fs.writeFileSync(indexPath, JSON.stringify(index, null, 2));
+}