@girardmedia/bootspring 2.0.21 → 2.0.23

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

@@ -0,0 +1,167 @@
+/**
+ * Metadata Extractors - Extract project name, tagline, problem, solution
+ * @package bootspring
+ */
+
+const { extractSection } = require('./section-extractor');
+
+/**
+ * Extract project name from preseed documents
+ * @param {object} docs - Document map (key: doc name, value: content)
+ * @returns {string} Project name or 'My Project' if not found
+ */
+function extractProjectName(docs) {
+  // Try VISION first
+  const visionDoc = docs['VISION'] || docs['vision'];
+  if (visionDoc) {
+    // Look for "Application Name:" or "**Application Name:**"
+    const nameMatch = visionDoc.match(/\*{0,2}Application\s+Name:?\*{0,2}\s*(.+)/i);
+    if (nameMatch) return nameMatch[1].trim();
+
+    // Look for "# ProjectName —" pattern
+    const titleMatch = visionDoc.match(/^#\s+([^—\-\n]+)/m);
+    if (titleMatch) return titleMatch[1].trim();
+  }
+
+  // Try PRD
+  const prdDoc = docs['PRD'] || docs['prd'];
+  if (prdDoc) {
+    const nameMatch = prdDoc.match(/\*{0,2}Application\s+Name:?\*{0,2}\s*(.+)/i);
+    if (nameMatch) return nameMatch[1].trim();
+
+    const titleMatch = prdDoc.match(/^#\s+([^—\-\n]+)/m);
+    if (titleMatch) return titleMatch[1].trim();
+  }
+
+  return 'My Project';
+}
+
+/**
+ * Extract tagline/description from documents
+ * @param {object} docs - Document map
+ * @returns {string} Tagline or empty string
+ */
+function extractTagline(docs) {
+  const visionDoc = docs['VISION'] || docs['vision'];
+  if (visionDoc) {
+    // Look for "is a..." or "is an..." sentence - capture the whole description
+    // Pattern: "is an **agentic AI platform** that makes it simple..."
+    const isMatch = visionDoc.match(/is\s+an?\s+\*{0,2}([^*]+?)\*{0,2}\s+that\s+([^.—\n]+)/i);
+    if (isMatch) {
+      let tagline = `${isMatch[1].trim()} that ${isMatch[2].trim()}`;
+      tagline = tagline.replace(/\*+/g, '');
+      if (tagline.length > 200) tagline = tagline.slice(0, 200) + '...';
+      if (tagline.length > 20) return tagline;
+    }
+
+    // Fallback: just get "is an X" pattern without "that" clause
+    const simpleMatch = visionDoc.match(/is\s+an?\s+\*{0,2}([^*\n—:]+?)\*{0,2}(?:\s|—|:|$)/i);
+    if (simpleMatch) {
+      let tagline = simpleMatch[1].replace(/\*+/g, '').trim();
+      if (tagline.length > 200) tagline = tagline.slice(0, 200) + '...';
+      if (tagline.length > 10) return tagline;
+    }
+
+    // Look for executive summary first paragraph
+    const summarySection = extractSection(visionDoc, 'Executive\\s+Vision|Vision\\s+Summary|Summary', { maxLength: 800 });
+    if (summarySection) {
+      const firstPara = summarySection.split(/\n\n/)[0].replace(/\*+/g, '').trim();
+      if (firstPara.length > 20 && firstPara.length < 250) return firstPara;
+    }
+  }
+  return '';
+}
+
+/**
+ * Extract problem statement from documents
+ * @param {object} docs - Document map
+ * @returns {string} Problem statement or empty string
+ */
+function extractProblem(docs) {
+  const visionDoc = docs['VISION'] || docs['vision'];
+  const prdDoc = docs['PRD'] || docs['prd'];
+
+  // Try VISION first
+  if (visionDoc) {
+    const problemSection = extractSection(visionDoc, '(The\\s+)?Problem|Pain\\s+Points|Market\\s+Reality', { maxLength: 800 });
+    if (problemSection) {
+      // Clean up and get first substantial paragraph
+      const cleaned = problemSection
+        // Remove subsection headers like "### 2.1 The market reality"
+        .replace(/^#{1,4}\s+[\d.]+\s+[^\n]+\n/gm, '')
+        // Remove section number prefixes like "2.1 " at start of content
+        .replace(/^[\d.]+\s+[A-Z][a-z]+\s+[a-z]+\n/m, '')
+        // Convert bullet points to flowing text
+        .replace(/^[-*]\s+\*{0,2}([^*\n:]+):?\*{0,2}\s*/gm, '$1: ')
+        // Remove remaining markdown
+        .replace(/\*+/g, '')
+        .trim();
+
+      // Get first substantial paragraph or combine bullet points
+      const paragraphs = cleaned.split(/\n\n/).filter(p => p.trim().length > 30);
+      if (paragraphs.length > 0) {
+        let result = paragraphs[0].replace(/\n/g, ' ').replace(/\s+/g, ' ').trim();
+        // Limit length
+        if (result.length > 500) result = result.slice(0, 500) + '...';
+        return result;
+      }
+    }
+  }
+
+  // Try PRD
+  if (prdDoc) {
+    const problemSection = extractSection(prdDoc, '(The\\s+)?Problem|Pain\\s+Points', { maxLength: 800 });
+    if (problemSection) {
+      const cleaned = problemSection
+        .replace(/^#{1,4}\s+[\d.]+\s+[^\n]+\n/gm, '')
+        .replace(/^[\d.]+\s+[A-Z][a-z]+\s+[a-z]+\n/m, '')
+        .replace(/^[-*]\s+\*{0,2}([^*\n:]+):?\*{0,2}\s*/gm, '$1: ')
+        .replace(/\*+/g, '')
+        .trim();
+
+      const paragraphs = cleaned.split(/\n\n/).filter(p => p.trim().length > 30);
+      if (paragraphs.length > 0) {
+        let result = paragraphs[0].replace(/\n/g, ' ').replace(/\s+/g, ' ').trim();
+        if (result.length > 500) result = result.slice(0, 500) + '...';
+        return result;
+      }
+    }
+  }
+
+  return '';
+}
+
+/**
+ * Extract solution description from documents
+ * @param {object} docs - Document map
+ * @returns {string} Solution description or empty string
+ */
+function extractSolution(docs) {
+  const visionDoc = docs['VISION'] || docs['vision'];
+
+  if (visionDoc) {
+    // Look for "Our Solution" or "The Solution" or "What We Build"
+    const solutionSection = extractSection(visionDoc, '(Our\\s+)?Solution|What\\s+We\\s+Build|Core\\s+Product', { maxLength: 1000 });
+    if (solutionSection) {
+      const paragraphs = solutionSection.split(/\n\n/).filter(p => p.trim().length > 50);
+      if (paragraphs.length > 0) {
+        return paragraphs[0].replace(/^[#*\d.-]+\s*/gm, '').replace(/\*+/g, '').trim();
+      }
+    }
+
+    // Look for "in one sentence" pattern
+    const oneLineMatch = visionDoc.match(/in\s+one\s+sentence[:\s]*\*{0,2}([^*\n]+(?:\*{0,2}[^*\n]+)?)/i);
+    if (oneLineMatch) {
+      return oneLineMatch[1].replace(/\*+/g, '').trim();
+    }
+  }
+
+  return '';
+}
+
+module.exports = {
+  extractProjectName,
+  extractTagline,
+  extractProblem,
+  extractSolution
+};

package/cli/seed/extractors/section-extractor.js

@@ -0,0 +1,54 @@
+/**
+ * Section Extractor - Base extraction utility for markdown content
+ * @package bootspring
+ */
+
+/**
+ * Extract a section from markdown content by heading
+ * @param {string} content - Markdown content to search
+ * @param {string} headingPattern - Regex pattern for heading to match
+ * @param {object} options - Extraction options
+ * @param {number} options.maxLength - Maximum length of extracted content (default: 2000)
+ * @param {string} options.stopAt - Pattern to stop extraction at
+ * @returns {string|null} Extracted section content or null if not found
+ */
+function extractSection(content, headingPattern, options = {}) {
+  const { maxLength = 2000, stopAt = null } = options;
+
+  // Match the heading (## or ### or ####)
+  // Wrap headingPattern in non-capturing group to ensure | alternation works correctly
+  // Handle optional section numbers like "## 10. Application Structure"
+  const headingRegex = new RegExp(`^(#{1,4})\\s*(?:\\d+\\.\\s*)?(?:${headingPattern})[^\\n]*\\n`, 'im');
+  const match = content.match(headingRegex);
+  if (!match || !match[1]) return null;
+
+  const startIndex = match.index + match[0].length;
+  const headingLevel = match[1].length;
+
+  // Find the next heading of same or higher level
+  const restContent = content.slice(startIndex);
+  const nextHeadingRegex = new RegExp(`^#{1,${headingLevel}}\\s+`, 'm');
+  const nextMatch = restContent.match(nextHeadingRegex);
+
+  let sectionContent = nextMatch
+    ? restContent.slice(0, nextMatch.index)
+    : restContent;
+
+  // Stop at a specific pattern if provided
+  if (stopAt) {
+    const stopMatch = sectionContent.match(new RegExp(stopAt, 'i'));
+    if (stopMatch) {
+      sectionContent = sectionContent.slice(0, stopMatch.index);
+    }
+  }
+
+  // Clean and truncate
+  sectionContent = sectionContent.trim();
+  if (sectionContent.length > maxLength) {
+    sectionContent = sectionContent.slice(0, maxLength) + '...';
+  }
+
+  return sectionContent || null;
+}
+
+module.exports = { extractSection };

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

@@ -0,0 +1,228 @@
+/**
+ * Stack Extractors - Extract tech stack, integrations, architecture
+ * @package bootspring
+ */
+
+const { extractSection } = require('./section-extractor');
+
+/**
+ * Extract tech stack from technical spec
+ * @param {object} docs - Document map
+ * @returns {object} Tech stack configuration
+ */
+function extractTechStack(docs) {
+  const techDoc = docs['TECHNICAL_SPEC'] || docs['TECHNICAL-SPEC'] || docs['technical_spec'];
+
+  const stack = {
+    framework: 'nextjs',
+    language: 'typescript',
+    database: 'postgresql',
+    styling: 'tailwind',
+    uiLibrary: 'shadcn',
+    orm: 'prisma',
+    auth: 'clerk',
+    payments: 'stripe',
+    hosting: 'vercel',
+    vector: null
+  };
+
+  if (!techDoc) return stack;
+
+  // Framework detection
+  if (techDoc.match(/Next\.?js/i)) stack.framework = 'nextjs';
+  else if (techDoc.match(/Nuxt/i)) stack.framework = 'nuxt';
+  else if (techDoc.match(/Vue/i)) stack.framework = 'vue';
+  else if (techDoc.match(/Remix/i)) stack.framework = 'remix';
+  else if (techDoc.match(/\bReact\b/) && !techDoc.match(/Next\.?js/i)) stack.framework = 'react';
+  else if (techDoc.match(/Express|Fastify|Hono/i)) stack.framework = 'node';
+
+  // Language
+  if (techDoc.match(/TypeScript/i)) stack.language = 'typescript';
+  else if (techDoc.match(/JavaScript/i) && !techDoc.match(/TypeScript/i)) stack.language = 'javascript';
+
+  // Database
+  if (techDoc.match(/Postgres|PostgreSQL/i)) stack.database = 'postgresql';
+  else if (techDoc.match(/MongoDB/i)) stack.database = 'mongodb';
+  else if (techDoc.match(/MySQL/i)) stack.database = 'mysql';
+  else if (techDoc.match(/Supabase/i)) stack.database = 'supabase';
+  else if (techDoc.match(/PlanetScale/i)) stack.database = 'planetscale';
+  else if (techDoc.match(/Firebase/i)) stack.database = 'firebase';
+
+  // Vector store
+  if (techDoc.match(/pgvector/i)) stack.vector = 'pgvector';
+  else if (techDoc.match(/Pinecone/i)) stack.vector = 'pinecone';
+  else if (techDoc.match(/Weaviate/i)) stack.vector = 'weaviate';
+
+  // Styling
+  if (techDoc.match(/Tailwind/i)) stack.styling = 'tailwind';
+  else if (techDoc.match(/styled-components/i)) stack.styling = 'styled-components';
+  else if (techDoc.match(/CSS\s+Modules/i)) stack.styling = 'css-modules';
+
+  // UI Library
+  if (techDoc.match(/Shadcn|shadcn\/ui/i)) stack.uiLibrary = 'shadcn';
+  else if (techDoc.match(/Chakra/i)) stack.uiLibrary = 'chakra';
+  else if (techDoc.match(/MUI|Material[- ]UI/i)) stack.uiLibrary = 'mui';
+  else if (techDoc.match(/Radix/i)) stack.uiLibrary = 'radix';
+
+  // ORM
+  if (techDoc.match(/Prisma/i)) stack.orm = 'prisma';
+  else if (techDoc.match(/Drizzle/i)) stack.orm = 'drizzle';
+  else if (techDoc.match(/TypeORM/i)) stack.orm = 'typeorm';
+
+  // Auth
+  if (techDoc.match(/Clerk/i)) stack.auth = 'clerk';
+  else if (techDoc.match(/NextAuth|Auth\.js/i)) stack.auth = 'nextauth';
+  else if (techDoc.match(/Supabase\s+Auth/i)) stack.auth = 'supabase';
+  else if (techDoc.match(/Firebase\s+Auth/i)) stack.auth = 'firebase';
+
+  // Payments
+  if (techDoc.match(/Stripe/i)) stack.payments = 'stripe';
+  else if (techDoc.match(/Paddle/i)) stack.payments = 'paddle';
+  else if (techDoc.match(/Lemon\s*Squeezy/i)) stack.payments = 'lemonsqueezy';
+
+  // Hosting
+  if (techDoc.match(/Vercel/i)) stack.hosting = 'vercel';
+  else if (techDoc.match(/Netlify/i)) stack.hosting = 'netlify';
+  else if (techDoc.match(/Railway/i)) stack.hosting = 'railway';
+  else if (techDoc.match(/Fly\.io/i)) stack.hosting = 'fly';
+  else if (techDoc.match(/AWS/i)) stack.hosting = 'aws';
+
+  return stack;
+}
+
+/**
+ * Extract third-party integrations from technical spec
+ * @param {object} docs - Document map
+ * @returns {object} Integrations by category
+ */
+function extractIntegrations(docs) {
+  const techDoc = docs['TECHNICAL_SPEC'] || docs['TECHNICAL-SPEC'] || docs['technical_spec'];
+  const prdDoc = docs['PRD'] || docs['prd'];
+  const allDocs = (techDoc || '') + '\n' + (prdDoc || '');
+
+  const integrations = {
+    voice: [],
+    email: [],
+    calendar: [],
+    crm: [],
+    payments: [],
+    auth: [],
+    ai: [],
+    other: []
+  };
+
+  // Voice/Telephony
+  if (allDocs.match(/\bTwilio\b/i)) integrations.voice.push('Twilio');
+  if (allDocs.match(/\bRetell\b/i)) integrations.voice.push('Retell');
+  if (allDocs.match(/\bVapi\b/i)) integrations.voice.push('Vapi');
+  if (allDocs.match(/\bElevenLabs\b/i)) integrations.voice.push('ElevenLabs');
+  if (allDocs.match(/\bDeepgram\b/i)) integrations.voice.push('Deepgram');
+
+  // Email
+  if (allDocs.match(/\bGmail\b/i)) integrations.email.push('Gmail');
+  if (allDocs.match(/\bSendGrid\b/i)) integrations.email.push('SendGrid');
+  if (allDocs.match(/\bResend\b/i)) integrations.email.push('Resend');
+  if (allDocs.match(/\bPostmark\b/i)) integrations.email.push('Postmark');
+
+  // Calendar
+  if (allDocs.match(/Google\s*Calendar/i)) integrations.calendar.push('Google Calendar');
+  if (allDocs.match(/\bCalendly\b/i)) integrations.calendar.push('Calendly');
+  if (allDocs.match(/\bCal\.com\b/i)) integrations.calendar.push('Cal.com');
+
+  // CRM
+  if (allDocs.match(/\bHubSpot\b/i)) integrations.crm.push('HubSpot');
+  if (allDocs.match(/\bSalesforce\b/i)) integrations.crm.push('Salesforce');
+  if (allDocs.match(/\bAttio\b/i)) integrations.crm.push('Attio');
+  if (allDocs.match(/\bPipedrive\b/i)) integrations.crm.push('Pipedrive');
+
+  // Payments
+  if (allDocs.match(/\bStripe\b/i)) integrations.payments.push('Stripe');
+  if (allDocs.match(/\bPaddle\b/i)) integrations.payments.push('Paddle');
+
+  // Auth
+  if (allDocs.match(/\bClerk\b/i)) integrations.auth.push('Clerk');
+  if (allDocs.match(/\bNextAuth\b|Auth\.js/i)) integrations.auth.push('NextAuth');
+  if (allDocs.match(/\bSupabase\s*Auth/i)) integrations.auth.push('Supabase Auth');
+
+  // AI/LLM
+  if (allDocs.match(/\bOpenAI\b|GPT-4/i)) integrations.ai.push('OpenAI');
+  if (allDocs.match(/\bAnthropic\b|Claude/i)) integrations.ai.push('Anthropic');
+  if (allDocs.match(/\bGemini\b/i)) integrations.ai.push('Google Gemini');
+
+  // Other
+  if (allDocs.match(/\bZapier\b/i)) integrations.other.push('Zapier');
+  if (allDocs.match(/\bSlack\b/i)) integrations.other.push('Slack');
+  if (allDocs.match(/\bWhatsApp\b/i)) integrations.other.push('WhatsApp');
+
+  return integrations;
+}
+
+/**
+ * Extract core architecture components from technical spec
+ * @param {object} docs - Document map
+ * @returns {string[]} Array of architecture component descriptions
+ */
+function extractArchitecture(docs) {
+  const techDoc = docs['TECHNICAL_SPEC'] || docs['TECHNICAL-SPEC'] || docs['technical_spec'];
+  if (!techDoc) return [];
+
+  const components = [];
+
+  // Strategy 1: Look specifically for "Core system components" section first
+  // This is more specific than "Architecture" which may be a high-level overview
+  const coreSection = extractSection(techDoc, 'Core\\s+system\\s+components', { maxLength: 1500 });
+  if (coreSection) {
+    // Extract numbered items like "1) Web App (Next.js)"
+    const compMatches = coreSection.match(/^\s*\d+\)\s*(.+)$/gm);
+    if (compMatches) {
+      compMatches.forEach(m => {
+        const match = m.match(/\d+\)\s*(.+)/);
+        if (match && match[1]) {
+          components.push(match[1].trim());
+        }
+      });
+    }
+  }
+
+  // Strategy 2: If no components found, look within "Architectural Overview" for subsections
+  if (components.length === 0) {
+    // Search the entire doc for numbered component patterns within Architecture context
+    const archMatch = techDoc.match(/(?:Architectural|Architecture)\s+Overview[\s\S]*?Core\s+system\s+components[\s\S]*?(?=##\s+\d+\.|$)/i);
+    if (archMatch) {
+      const compMatches = archMatch[0].match(/^\s*\d+\)\s*(.+)$/gm);
+      if (compMatches) {
+        compMatches.forEach(m => {
+          const match = m.match(/\d+\)\s*(.+)/);
+          if (match && match[1]) {
+            components.push(match[1].trim());
+          }
+        });
+      }
+    }
+  }
+
+  // Strategy 3: Look for bullet-point architecture components
+  if (components.length === 0) {
+    const archSection = extractSection(techDoc, 'Architecture|System\\s+Components', { maxLength: 2000 });
+    if (archSection) {
+      // Look for bold component names like "- **Component Name**"
+      const boldMatches = archSection.match(/^\s*[-*]\s+\*{2}([^*]+)\*{2}/gm);
+      if (boldMatches) {
+        boldMatches.forEach(m => {
+          const match = m.match(/\*{2}([^*]+)\*{2}/);
+          if (match && match[1] && match[1].length > 3) {
+            components.push(match[1].trim());
+          }
+        });
+      }
+    }
+  }
+
+  return components.slice(0, 10);
+}
+
+module.exports = {
+  extractTechStack,
+  extractIntegrations,
+  extractArchitecture
+};

package/cli/seed/index.js

@@ -0,0 +1,18 @@
+/**
+ * Seed Module Index - Re-export all seed submodules
+ * @package bootspring
+ */
+
+const extractors = require('./extractors');
+const builders = require('./builders');
+const utils = require('./utils');
+
+module.exports = {
+  extractors,
+  builders,
+  utils,
+  // Re-export commonly used functions at top level
+  ...extractors,
+  ...builders,
+  ...utils
+};

package/cli/seed/utils/folder-structure.js

@@ -0,0 +1,84 @@
+/**
+ * Folder Structure - Seed folder constants and creation utilities
+ * @package bootspring
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+/**
+ * Seed folder structure
+ */
+const SEED_FOLDERS = [
+  '.bootspring',
+  '.bootspring/inputs',
+  '.bootspring/inputs/mvp',
+  '.bootspring/inputs/mvp/source',
+  '.bootspring/inputs/business',
+  '.bootspring/inputs/prd',
+  '.bootspring/inputs/prd/features',
+  '.bootspring/inputs/designs',
+  '.bootspring/inputs/designs/figma-exports',
+  '.bootspring/inputs/designs/wireframes',
+  '.bootspring/inputs/legal',
+  '.bootspring/inputs/api',
+  '.bootspring/inputs/data',
+  '.bootspring/generated',
+  '.bootspring/generated/prd',
+  '.bootspring/generated/master-plan',
+  '.bootspring/generated/business',
+  '.bootspring/generated/architecture',
+  '.bootspring/generated/legal',
+  '.bootspring/context',
+  '.bootspring/logs',
+  '.bootspring/logs/agents',
+  '.bootspring/logs/decisions',
+  '.bootspring/logs/code',
+  '.bootspring/config'
+];
+
+/**
+ * Create seed folder structure (used by both setup and init)
+ * @param {string} projectRoot - Project root path
+ * @returns {number} Number of folders created
+ */
+function createSeedFolders(projectRoot) {
+  let dirsCreated = 0;
+
+  for (const folder of SEED_FOLDERS) {
+    const folderPath = path.join(projectRoot, folder);
+    if (!fs.existsSync(folderPath)) {
+      fs.mkdirSync(folderPath, { recursive: true });
+      dirsCreated++;
+    }
+  }
+
+  // Create README for inputs
+  const inputsReadmePath = path.join(projectRoot, '.bootspring/inputs/README.md');
+  if (!fs.existsSync(inputsReadmePath)) {
+    const readme = `# Input Files
+
+Drop your existing files here before running \`bootspring seed generate\`.
+
+## Folders
+
+| Folder | What to put here |
+|--------|------------------|
+| \`mvp/source/\` | AI-generated MVP code (Lovable, Bolt, V0, etc.) |
+| \`business/\` | Business plans, pitch decks, market research |
+| \`prd/\` | Product requirements documents |
+| \`designs/\` | Figma exports, wireframes, mockups |
+| \`legal/\` | Existing terms, privacy policies |
+| \`api/\` | OpenAPI specs, API documentation |
+| \`data/\` | Sample data, database schemas |
+`;
+    fs.writeFileSync(inputsReadmePath, readme);
+  }
+
+  return dirsCreated;
+}
+
+module.exports = {
+  SEED_FOLDERS,
+  createSeedFolders
+};

package/cli/seed/utils/index.js

@@ -0,0 +1,11 @@
+/**
+ * Seed Utils - Re-export all utility functions
+ * @package bootspring
+ */
+
+const { SEED_FOLDERS, createSeedFolders } = require('./folder-structure');
+
+module.exports = {
+  SEED_FOLDERS,
+  createSeedFolders
+};