@girardmedia/bootspring 2.0.21 → 2.0.23

package/cli/seed/builders/seed-builder.js

@@ -0,0 +1,272 @@
+/**
+ * Seed Builder - Generate SEED.md from preseed documents
+ * @package bootspring
+ */
+
+const {
+  extractProjectName,
+  extractTagline,
+  extractProblem,
+  extractSolution,
+  extractTechStack,
+  extractMVPFeatures,
+  extractTargetUsers,
+  extractDatabaseEntities,
+  extractImplementationPhases,
+  extractIntegrations,
+  extractAPIRoutes,
+  extractArchitecture
+} = require('../extractors');
+
+/**
+ * Generate SEED.md content from preseed documents
+ * @param {object} docs - Document map (key: doc name, value: content)
+ * @param {object} preseedConfig - Optional preseed config for fallback values
+ * @returns {string} Generated SEED.md content
+ */
+function generateSeedFromPreseed(docs, preseedConfig = {}) {
+  // Extract from documents (preferred) with config fallback
+  const projectName = extractProjectName(docs) || preseedConfig.identity?.name || 'My Project';
+  const tagline = extractTagline(docs) || preseedConfig.identity?.tagline || '';
+  const problem = extractProblem(docs) || preseedConfig.problem?.statement || '';
+  const solution = extractSolution(docs) || preseedConfig.solution?.description || '';
+  const techStack = extractTechStack(docs);
+  const mvpFeatures = extractMVPFeatures(docs);
+  const targetUsers = extractTargetUsers(docs);
+  const dbEntities = extractDatabaseEntities(docs);
+  const phases = extractImplementationPhases(docs);
+  const integrations = extractIntegrations(docs);
+  const apiRoutes = extractAPIRoutes(docs);
+  const architecture = extractArchitecture(docs);
+
+  // Build tech stack YAML with detected values
+  let stackYaml = `stack:
+  framework: ${techStack.framework}
+  language: ${techStack.language}
+  database: ${techStack.database}
+  hosting: ${techStack.hosting}
+
+frontend:
+  uiLibrary: ${techStack.uiLibrary}
+  styling: ${techStack.styling}
+
+backend:
+  orm: ${techStack.orm}
+  auth: ${techStack.auth}
+  payments: ${techStack.payments}`;
+
+  if (techStack.vector) {
+    stackYaml += `
+  vector: ${techStack.vector}`;
+  }
+
+  // Build features section
+  let featuresSection = '';
+  if (mvpFeatures.length > 0) {
+    featuresSection = mvpFeatures.map((f, i) => `${i + 1}. ${f}`).join('\n');
+  } else {
+    featuresSection = `1. User authentication and workspace management
+2. Core dashboard with analytics
+3. Data management and CRUD operations
+4. API endpoints for integrations
+5. Admin interface and settings`;
+  }
+
+  // Build target users section
+  let usersSection = '';
+  if (targetUsers.length > 0) {
+    usersSection = targetUsers.map(u => `- ${u}`).join('\n');
+  }
+
+  // Build database entities section
+  let entitiesSection = '';
+  if (dbEntities.length > 0) {
+    entitiesSection = dbEntities.map(e => `- \`${e}\``).join('\n');
+  }
+
+  // Build architecture section
+  let architectureSection = '';
+  if (architecture.length > 0) {
+    architectureSection = architecture.map((c, i) => `${i + 1}. ${c}`).join('\n');
+  }
+
+  // Build integrations section
+  let integrationsSection = '';
+  const intCats = Object.entries(integrations).filter(([_, v]) => v.length > 0);
+  if (intCats.length > 0) {
+    integrationsSection = intCats.map(([cat, services]) => {
+      const catName = cat.charAt(0).toUpperCase() + cat.slice(1);
+      return `**${catName}:** ${services.join(', ')}`;
+    }).join('\n');
+  }
+
+  // Build phases section
+  let phasesSection = '';
+  if (phases.length > 0) {
+    phasesSection = phases.map(p => {
+      let section = `### Phase ${p.phase}: ${p.name}`;
+      if (p.deliverables.length > 0) {
+        section += '\n' + p.deliverables.map(d => `- ${d}`).join('\n');
+      }
+      return section;
+    }).join('\n\n');
+  }
+
+  // Build API routes section
+  let apiRoutesSection = '';
+  if (apiRoutes.length > 0) {
+    apiRoutesSection = apiRoutes.map(r => `- \`${r}\``).join('\n');
+  }
+
+  const content = `# ${projectName}
+
+${tagline ? `> ${tagline}` : ''}
+
+## Overview
+
+${problem ? `**The Problem:** ${problem}\n\n` : ''}${solution ? `**Our Solution:** ${solution}` : ''}
+
+---
+
+## Tech Stack
+
+\`\`\`yaml
+${stackYaml}
+\`\`\`
+
+---
+${architecture.length > 0 ? `
+## Architecture
+
+${architectureSection}
+
+---
+` : ''}
+${intCats.length > 0 ? `
+## Integrations
+
+${integrationsSection}
+
+---
+` : ''}
+## MVP Features
+
+${featuresSection}
+
+---
+${phases.length > 0 ? `
+## Implementation Phases
+
+${phasesSection}
+
+---
+` : ''}
+${targetUsers.length > 0 ? `
+## Target Users
+
+${usersSection}
+
+---
+` : ''}
+${dbEntities.length > 0 ? `
+## Core Data Entities
+
+${entitiesSection}
+
+---
+` : ''}
+${apiRoutes.length > 0 ? `
+## API Routes
+
+${apiRoutesSection}
+
+---
+` : ''}
+## Development Standards
+
+### Code Style
+- Use ${techStack.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
+${techStack.framework === 'nextjs' ? `- Use Server Components by default
+- Prefer Server Actions over API routes for mutations` : `- Follow ${techStack.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 format: \`feat:\`, \`fix:\`, \`docs:\`, \`refactor:\`
+- Keep commits focused and atomic
+- Never commit sensitive data or API keys
+
+---
+
+## Project Structure
+
+\`\`\`
+${projectName.toLowerCase().replace(/\s+/g, '-')}/
+├── app/                    # Next.js App Router
+│   ├── (auth)/             # Auth pages${techStack.auth === 'clerk' ? ' (Clerk)' : ''}
+│   ├── (dashboard)/        # Main dashboard
+│   ├── (marketing)/        # Landing pages
+│   └── api/                # API routes
+├── components/
+│   ├── ui/                 # UI components${techStack.uiLibrary === 'shadcn' ? ' (shadcn/ui)' : ''}
+│   └── [feature]/          # Feature components
+├── lib/
+│   ├── db.ts               # Database client${techStack.orm === 'prisma' ? ' (Prisma)' : ''}
+│   ├── auth.ts             # Auth utilities
+│   └── utils.ts            # Helpers
+├── prisma/
+│   └── schema.prisma       # Database schema
+└── public/                 # Static assets
+\`\`\`
+
+---
+
+## Source Documents
+
+This SEED.md was synthesized from:
+${Object.keys(docs).map(name => `- \`.bootspring/preseed/${name}.md\``).join('\n')}
+
+---
+
+*Generated with [Bootspring](https://bootspring.com)*
+`;
+
+  return content;
+}
+
+/**
+ * Generate AI enhancement prompt for SEED.md
+ * @param {object} docs - Document map
+ * @param {object} preseedConfig - Preseed config
+ * @returns {string} Enhancement prompt
+ */
+function generateEnhancementPrompt(docs, preseedConfig) {
+  return `# Enhance SEED.md
+
+I've created a basic SEED.md from my preseed documents. Please review and enhance it with:
+
+1. **More specific tech stack recommendations** based on my requirements
+2. **Detailed file structure** for the project
+3. **Implementation order** - which features to build first
+4. **API endpoints** we'll need
+5. **Database schema** suggestions
+6. **Third-party services** recommendations
+
+Here are my preseed documents for context:
+
+${Object.entries(docs).map(([name, content]) => `## ${name}\n\n${content}`).join('\n\n---\n\n')}
+
+---
+
+Please provide an enhanced SEED.md that a developer (or AI assistant) can follow to build this project from scratch.`;
+}
+
+module.exports = {
+  generateSeedFromPreseed,
+  generateEnhancementPrompt
+};

package/cli/seed/extractors/content-extractors.js

@@ -0,0 +1,383 @@
+/**
+ * Content Extractors - Extract features, users, entities, phases, routes
+ * @package bootspring
+ */
+
+const { extractSection } = require('./section-extractor');
+
+/**
+ * Extract MVP features from PRD
+ * @param {object} docs - Document map
+ * @returns {string[]} Array of feature names
+ */
+function extractMVPFeatures(docs) {
+  const prdDoc = docs['PRD'] || docs['prd'];
+  if (!prdDoc) return [];
+
+  const features = [];
+
+  // Look for MVP Features section
+  const mvpSection = extractSection(prdDoc, 'MVP\\s+Features|P1\\s+.*Features|Must\\s+Ship', { maxLength: 5000 });
+  if (mvpSection) {
+    // Extract feature names from headers like "#### F-001: Feature Name"
+    const featureHeaders = mvpSection.match(/^#{1,4}\s+F-\d+:\s*(.+)$/gm);
+    if (featureHeaders && featureHeaders.length > 0) {
+      featureHeaders.forEach(h => {
+        const match = h.match(/F-\d+:\s*(.+)/);
+        if (match) features.push(match[1].trim());
+      });
+    }
+  }
+
+  // Also look for Feature Requirements section
+  const featureReqSection = extractSection(prdDoc, 'Feature\\s+Requirements', { maxLength: 5000 });
+  if (featureReqSection && features.length === 0) {
+    // Look for **FR-XX:** patterns
+    const frMatches = featureReqSection.match(/\*{0,2}FR-\d+:?\*{0,2}\s*(.+)/g);
+    if (frMatches) {
+      frMatches.forEach(m => {
+        const match = m.match(/FR-\d+:?\*{0,2}\s*(.+)/);
+        if (match) features.push(match[1].replace(/\*+/g, '').trim());
+      });
+    }
+  }
+
+  // Fallback: look for numbered Core User Journeys
+  if (features.length === 0) {
+    const journeySection = extractSection(prdDoc, 'Core\\s+User\\s+Journeys|User\\s+Journeys', { maxLength: 3000 });
+    if (journeySection) {
+      const journeyHeaders = journeySection.match(/^#{1,4}\s+\d+\.\d+\s+Journey\s+\d+\s*[—-]\s*(.+)$/gm);
+      if (journeyHeaders) {
+        journeyHeaders.forEach(h => {
+          const match = h.match(/Journey\s+\d+\s*[—-]\s*(.+)/);
+          if (match) features.push(match[1].trim());
+        });
+      }
+    }
+  }
+
+  // Limit to top 15 features
+  return features.slice(0, 15);
+}
+
+/**
+ * Extract target users/personas from documents
+ * @param {object} docs - Document map
+ * @returns {string[]} Array of persona names
+ */
+function extractTargetUsers(docs) {
+  const visionDoc = docs['VISION'] || docs['vision'];
+  const prdDoc = docs['PRD'] || docs['prd'];
+  const audienceDoc = docs['AUDIENCE'] || docs['audience'];
+
+  const personas = [];
+
+  // Try AUDIENCE doc first - look for "## X.X Persona PX — Name" pattern
+  if (audienceDoc) {
+    const personaMatches = audienceDoc.match(/^#{1,4}\s+\d+\.\d+\s+Persona\s+P?\d+\s*[—-]\s*(.+)$/gm);
+    if (personaMatches) {
+      personaMatches.forEach(m => {
+        const match = m.match(/[—-]\s*(.+)/);
+        if (match && match[1]) personas.push(match[1].trim());
+      });
+    }
+    // Also look for ICP definitions like "## 3.1 ICP-A: AI Agency Operator"
+    if (personas.length === 0) {
+      const icpMatches = audienceDoc.match(/^#{1,4}\s+\d+\.\d+\s+ICP-[A-Z]:\s*(.+?)(?:\s*\(|$)/gm);
+      if (icpMatches) {
+        icpMatches.forEach(m => {
+          const match = m.match(/ICP-[A-Z]:\s*(.+?)(?:\s*\(|$)/);
+          if (match && match[1]) personas.push(match[1].trim());
+        });
+      }
+    }
+  }
+
+  // Try VISION
+  if (visionDoc && personas.length === 0) {
+    const targetSection = extractSection(visionDoc, 'Target\\s+Users|Who\\s+This\\s+Is\\s+For', { maxLength: 2000 });
+    if (targetSection) {
+      // Look for bold text patterns like "- **AI Agencies & AI Arbitrage Specialists**"
+      const boldMatches = targetSection.match(/^\s*[-*]\s*\*{2}([^*]+)\*{2}/gm);
+      if (boldMatches) {
+        boldMatches.forEach(m => {
+          const match = m.match(/\*{2}([^*]+)\*{2}/);
+          if (match && match[1]) personas.push(match[1].trim());
+        });
+      }
+    }
+  }
+
+  // Try PRD
+  if (prdDoc && personas.length === 0) {
+    const personaSection = extractSection(prdDoc, 'Personas|Who\\s+We\\s+Serve', { maxLength: 2000 });
+    if (personaSection) {
+      const personaMatches = personaSection.match(/^#{1,4}\s+\d+\.\d+\s+Persona\s+[A-Z]\s*[—-]\s*(.+)$/gm);
+      if (personaMatches) {
+        personaMatches.forEach(m => {
+          const match = m.match(/[—-]\s*(.+)/);
+          if (match && match[1]) personas.push(match[1].trim());
+        });
+      }
+    }
+  }
+
+  return personas.slice(0, 6);
+}
+
+/**
+ * Extract database entities from technical spec
+ * @param {object} docs - Document map
+ * @returns {string[]} Array of entity/table names
+ */
+function extractDatabaseEntities(docs) {
+  const techDoc = docs['TECHNICAL_SPEC'] || docs['TECHNICAL-SPEC'] || docs['technical_spec'];
+  if (!techDoc) return [];
+
+  const entities = [];
+
+  // Strategy 1: Look specifically for "Key tables" or "Data Model" sections
+  // This avoids capturing run types like `interactive_chat` which are not tables
+  const tableSection = extractSection(techDoc, 'Key\\s+tables|Data\\s+Model|Database\\s+Schema', { maxLength: 3000 });
+  if (tableSection) {
+    // Extract backticked table names from bullet points in this specific section
+    const bulletTableMatches = tableSection.match(/^\s*[-*]\s*`(\w+)`/gm);
+    if (bulletTableMatches) {
+      bulletTableMatches.forEach(m => {
+        const match = m.match(/`(\w+)`/);
+        if (match && match[1] && match[1].length > 2) {
+          const word = match[1].toLowerCase();
+          // Filter out common non-entity words and known run types
+          const skipWords = [
+            'and', 'the', 'for', 'with', 'from', 'optional', 'static', 'primary', 'key', 'index', 'indexes',
+            'interactive_chat', 'widget_chat', 'lead_qualify_async', 'sequence_send_async', 'batch_eval'
+          ];
+          if (!skipWords.includes(word)) {
+            entities.push(match[1]);
+          }
+        }
+      });
+    }
+  }
+
+  // Strategy 2: Extract model names from Prisma schema blocks
+  if (entities.length === 0) {
+    const prismaModels = techDoc.match(/model\s+(\w+)\s*\{/g);
+    if (prismaModels) {
+      prismaModels.forEach(m => {
+        const match = m.match(/model\s+(\w+)/);
+        if (match && match[1]) {
+          entities.push(match[1]);
+        }
+      });
+    }
+  }
+
+  // Strategy 3: Fallback - look for backticked snake_case names in general text
+  // but only if they look like table names (contain underscore or end with 's')
+  if (entities.length === 0) {
+    const generalMatches = techDoc.match(/`([a-z][a-z_]*(?:_[a-z]+)+)`/g);
+    if (generalMatches) {
+      generalMatches.forEach(m => {
+        const match = m.match(/`([a-z_]+)`/);
+        if (match && match[1] && match[1].length > 4) {
+          const word = match[1].toLowerCase();
+          // Skip known run types
+          const runTypes = ['interactive_chat', 'widget_chat', 'lead_qualify_async', 'sequence_send_async', 'batch_eval'];
+          if (!runTypes.includes(word) && !entities.includes(match[1])) {
+            entities.push(match[1]);
+          }
+        }
+      });
+    }
+  }
+
+  // Deduplicate and return
+  return [...new Set(entities)].slice(0, 25);
+}
+
+/**
+ * Extract implementation phases from ROADMAP
+ * @param {object} docs - Document map
+ * @returns {object[]} Array of phase objects with name and deliverables
+ */
+function extractImplementationPhases(docs) {
+  const roadmapDoc = docs['ROADMAP'] || docs['roadmap'];
+  if (!roadmapDoc) return [];
+
+  const phases = [];
+  const seenPhases = new Set();
+
+  // Prioritize full phase sections: "## X. Phase N —" (with section number)
+  // These have the actual deliverables, unlike brief summaries
+  const fullPhaseMatches = roadmapDoc.match(/^##\s+\d+\.\s+Phase\s+\d+\s*[—-]+\s*(.+)$/gm);
+
+  if (fullPhaseMatches) {
+    fullPhaseMatches.forEach(m => {
+      const match = m.match(/Phase\s+(\d+)\s*[—-]+\s*(.+)$/);
+      if (match && match[1] && match[2]) {
+        const phaseNum = match[1];
+        if (seenPhases.has(phaseNum)) return;
+        seenPhases.add(phaseNum);
+
+        // Clean up the name - remove parenthetical suffix
+        const phaseName = match[2].trim().replace(/\s*\([^)]+\)\s*$/, '').trim();
+
+        // Try to get deliverables for this phase
+        const deliverables = [];
+
+        // Find the full section for this specific phase (## X. Phase N — until next ## X. Phase)
+        const phaseRegex = new RegExp(`##\\s+\\d+\\.\\s+Phase\\s+${phaseNum}\\s*[—-][\\s\\S]*?(?=##\\s+\\d+\\.\\s+Phase\\s+\\d+|$)`, 'i');
+        const phaseSectionMatch = roadmapDoc.match(phaseRegex);
+
+        if (phaseSectionMatch) {
+          const phaseContent = phaseSectionMatch[0];
+
+          // Look for "### X.X Deliverables" subsection
+          const deliverablesRegex = /###\s+[\d.]+\s*Deliverables[\s\S]*?(?=###|##|$)/i;
+          const deliverablesMatch = phaseContent.match(deliverablesRegex);
+
+          if (deliverablesMatch) {
+            // Extract bullet points
+            const bullets = deliverablesMatch[0].match(/^[-*]\s+(.+)$/gm);
+            if (bullets) {
+              bullets.slice(0, 6).forEach(b => {
+                const text = b.replace(/^[-*]\s+/, '').trim();
+                if (text.length > 3) deliverables.push(text);
+              });
+            }
+          }
+
+          // If no deliverables found, try "MVP feature set" or "feature set"
+          if (deliverables.length === 0) {
+            // Look for #### A) B) C) patterns anywhere in phase content
+            const featureHeaders = phaseContent.match(/^####\s+[A-Z]\)\s+(.+)$/gm);
+            if (featureHeaders && featureHeaders.length > 0) {
+              featureHeaders.slice(0, 6).forEach(h => {
+                const hMatch = h.match(/####\s+[A-Z]\)\s+(.+)/);
+                if (hMatch && hMatch[1]) {
+                  // Clean up the title - remove trailing parenthetical like "(prebuilt)"
+                  const title = hMatch[1].trim();
+                  deliverables.push(title);
+                }
+              });
+            }
+          }
+
+          // Strategy 3: Look for Exit Criteria items
+          if (deliverables.length === 0) {
+            const exitCriteriaRegex = /###\s+[\d.]+\s*Exit\s+Criteria[\s\S]*?(?=###|##|$)/i;
+            const exitMatch = phaseContent.match(exitCriteriaRegex);
+            if (exitMatch) {
+              // Extract checkmark items like "- ✅ Description"
+              const checkItems = exitMatch[0].match(/^[-*]\s+[✅✓]\s*(.+)$/gm);
+              if (checkItems) {
+                checkItems.slice(0, 5).forEach(item => {
+                  const text = item.replace(/^[-*]\s+[✅✓]\s*/, '').trim();
+                  if (text.length > 5) deliverables.push(text);
+                });
+              }
+            }
+          }
+
+          // Strategy 3: Look for "### X.X Phase goal" and extract key items
+          if (deliverables.length === 0) {
+            const goalRegex = /###\s+[\d.]+\s*(?:Phase\s+)?goal[\s\S]*?(?=###|$)/i;
+            const goalMatch = phaseContent.match(goalRegex);
+            if (goalMatch) {
+              // Extract bullet points or bold items
+              const bullets = goalMatch[0].match(/^[-*]\s+(.+)$/gm);
+              if (bullets) {
+                bullets.slice(0, 4).forEach(b => {
+                  const text = b.replace(/^[-*]\s+/, '').trim();
+                  if (text.length > 3) deliverables.push(text);
+                });
+              }
+            }
+          }
+        }
+
+        phases.push({
+          phase: phaseNum,
+          name: phaseName,
+          deliverables
+        });
+      }
+    });
+  }
+
+  return phases.slice(0, 5);
+}
+
+/**
+ * Extract API routes from PRD/technical spec
+ * @param {object} docs - Document map
+ * @returns {string[]} Array of route paths
+ */
+function extractAPIRoutes(docs) {
+  const techDoc = docs['TECHNICAL_SPEC'] || docs['TECHNICAL-SPEC'] || docs['technical_spec'];
+
+  const routes = [];
+
+  if (techDoc) {
+    // Look for Application Structure section with app/ routes
+    const appStructureSection = extractSection(techDoc, 'Application\\s+Structure|Directory\\s+Structure', { maxLength: 3000 });
+
+    if (appStructureSection) {
+      // Extract page routes like "- `/dashboard`" or "- `/agents`" or "- `/agents/[id]`"
+      const pageRoutes = appStructureSection.match(/[-*]\s*`\/([\w/[\]]+)`/g);
+      if (pageRoutes) {
+        pageRoutes.forEach(r => {
+          const match = r.match(/`(\/[\w/[\]]+)`/);
+          if (match && match[1]) {
+            const route = match[1];
+            // Skip if it looks like a citation URL
+            if (!route.includes('docs/') && !route.includes('guides/')) {
+              if (!routes.includes(route)) routes.push(route);
+            }
+          }
+        });
+      }
+
+      // Extract API route handler descriptions like "agents CRUD", "runs endpoints"
+      const apiHandlers = appStructureSection.match(/app\/api\/.*?handlers?:[\s\S]*?(?=###|##|$)/i);
+      if (apiHandlers) {
+        const handlerLines = apiHandlers[0].match(/[-*]\s+(\w[\w\s]+)(?:endpoints?|CRUD|callbacks?|handlers?)?/g);
+        if (handlerLines) {
+          handlerLines.forEach(line => {
+            const match = line.match(/[-*]\s+([\w\s]+)/);
+            if (match && match[1]) {
+              const name = match[1].trim().split(/\s+/)[0].toLowerCase();
+              if (name.length > 2 && !['auth', 'the', 'for', 'and'].includes(name)) {
+                const route = `/api/${name}`;
+                if (!routes.includes(route)) routes.push(route);
+              }
+            }
+          });
+        }
+      }
+    }
+
+    // Also look for explicit /api/ routes in backticks
+    const explicitRoutes = techDoc.match(/`\/api\/[\w/[\]-]+`/g);
+    if (explicitRoutes) {
+      explicitRoutes.forEach(r => {
+        const route = r.replace(/`/g, '');
+        // Skip citation URLs
+        if (!route.includes('docs/') && !route.includes('guides/')) {
+          if (!routes.includes(route)) routes.push(route);
+        }
+      });
+    }
+  }
+
+  return routes.slice(0, 20);
+}
+
+module.exports = {
+  extractMVPFeatures,
+  extractTargetUsers,
+  extractDatabaseEntities,
+  extractImplementationPhases,
+  extractAPIRoutes
+};

package/cli/seed/extractors/index.js

@@ -0,0 +1,47 @@
+/**
+ * Seed Extractors - Re-export all extraction functions
+ * @package bootspring
+ */
+
+const { extractSection } = require('./section-extractor');
+const {
+  extractProjectName,
+  extractTagline,
+  extractProblem,
+  extractSolution
+} = require('./metadata-extractors');
+const {
+  extractTechStack,
+  extractIntegrations,
+  extractArchitecture
+} = require('./stack-extractors');
+const {
+  extractMVPFeatures,
+  extractTargetUsers,
+  extractDatabaseEntities,
+  extractImplementationPhases,
+  extractAPIRoutes
+} = require('./content-extractors');
+
+module.exports = {
+  // Section utilities
+  extractSection,
+
+  // Metadata
+  extractProjectName,
+  extractTagline,
+  extractProblem,
+  extractSolution,
+
+  // Tech stack
+  extractTechStack,
+  extractIntegrations,
+  extractArchitecture,
+
+  // Content
+  extractMVPFeatures,
+  extractTargetUsers,
+  extractDatabaseEntities,
+  extractImplementationPhases,
+  extractAPIRoutes
+};