@girardmedia/bootspring 1.2.0 → 2.0.3

package/core/preseed.js

@@ -0,0 +1,1617 @@
+/**
+ * Bootspring Preseed Engine
+ *
+ * Core logic for generating foundational documents from minimal input.
+ * Creates "living documents" that can be synced with code changes.
+ *
+ * @package bootspring
+ * @module core/preseed
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Document types and their metadata
+ */
+const DOCUMENT_TYPES = {
+  vision: {
+    name: 'VISION.md',
+    title: 'Vision Document',
+    description: 'Problem statement, solution overview, and core values',
+    priority: 1,
+    required: true
+  },
+  audience: {
+    name: 'AUDIENCE.md',
+    title: 'Target Audience',
+    description: 'Target audience, personas, and ideal customer profile',
+    priority: 2,
+    required: true
+  },
+  market: {
+    name: 'MARKET.md',
+    title: 'Market Analysis',
+    description: 'TAM/SAM/SOM analysis and market opportunity',
+    priority: 3,
+    required: false
+  },
+  competitors: {
+    name: 'COMPETITORS.md',
+    title: 'Competitive Analysis',
+    description: 'Competitive landscape, positioning, and differentiation',
+    priority: 4,
+    required: false
+  },
+  'business-model': {
+    name: 'BUSINESS_MODEL.md',
+    title: 'Business Model',
+    description: 'Value proposition, revenue model, and pricing strategy',
+    priority: 5,
+    required: true
+  },
+  prd: {
+    name: 'PRD.md',
+    title: 'Product Requirements',
+    description: 'Product vision, user stories, and MVP scope',
+    priority: 6,
+    required: true
+  },
+  'technical-spec': {
+    name: 'TECHNICAL_SPEC.md',
+    title: 'Technical Specification',
+    description: 'Architecture, tech stack, and data model',
+    priority: 7,
+    required: false
+  },
+  roadmap: {
+    name: 'ROADMAP.md',
+    title: 'Product Roadmap',
+    description: 'Phased development plan and milestones',
+    priority: 8,
+    required: false
+  }
+};
+
+/**
+ * Preseed presets - different levels of document generation
+ */
+const PRESETS = {
+  // Essential documents only
+  essential: ['vision', 'audience', 'business-model', 'prd'],
+  // Standard startup pack
+  startup: ['vision', 'audience', 'market', 'competitors', 'business-model', 'prd', 'roadmap'],
+  // Full documentation suite
+  full: Object.keys(DOCUMENT_TYPES),
+  // Technical focus
+  technical: ['vision', 'prd', 'technical-spec', 'roadmap'],
+  // Investor-ready
+  investor: ['vision', 'audience', 'market', 'competitors', 'business-model', 'roadmap']
+};
+
+/**
+ * Default output directory for preseed documents
+ */
+const DEFAULT_OUTPUT_DIR = '.bootspring/preseed';
+
+/**
+ * Context input directory
+ */
+const CONTEXT_INPUT_DIR = '.bootspring/preseed/context';
+
+/**
+ * Context input folder structure
+ * Maps to DOCUMENT_TYPES for 1:1 correspondence between input folders and output documents
+ */
+const CONTEXT_FOLDERS = {
+  // Universal drop zone
+  drop: {
+    name: 'drop',
+    description: 'Drop anything here - AI will sort it out',
+    extensions: ['*'],
+    isUniversal: true
+  },
+  // General input folders
+  ideas: {
+    name: 'ideas',
+    description: 'Rough ideas, brainstorms, notes',
+    extensions: ['.md', '.txt', '.pdf']
+  },
+  research: {
+    name: 'research',
+    description: 'Market research, industry reports',
+    extensions: ['.md', '.txt', '.pdf', '.docx']
+  },
+  // Document-type specific folders (matches DOCUMENT_TYPES)
+  vision: {
+    name: 'vision',
+    description: 'Vision statements, problem/solution notes',
+    extensions: ['.md', '.txt', '.pdf'],
+    mapsTo: 'vision'
+  },
+  audience: {
+    name: 'audience',
+    description: 'User interviews, surveys, personas',
+    extensions: ['.md', '.txt', '.pdf', '.csv'],
+    mapsTo: 'audience'
+  },
+  market: {
+    name: 'market',
+    description: 'Market size, TAM/SAM/SOM analysis, trends',
+    extensions: ['.md', '.txt', '.pdf', '.csv'],
+    mapsTo: 'market'
+  },
+  competitors: {
+    name: 'competitors',
+    description: 'Competitor analysis, screenshots, comparisons',
+    extensions: ['.md', '.txt', '.pdf', '.png', '.jpg'],
+    mapsTo: 'competitors'
+  },
+  business: {
+    name: 'business',
+    description: 'Business model ideas, pricing notes, revenue',
+    extensions: ['.md', '.txt', '.pdf'],
+    mapsTo: 'business-model'
+  },
+  prd: {
+    name: 'prd',
+    description: 'Product requirements, user stories, features',
+    extensions: ['.md', '.txt', '.pdf'],
+    mapsTo: 'prd'
+  },
+  technical: {
+    name: 'technical',
+    description: 'Technical requirements, architecture notes',
+    extensions: ['.md', '.txt', '.pdf'],
+    mapsTo: 'technical-spec'
+  },
+  roadmap: {
+    name: 'roadmap',
+    description: 'Timeline notes, milestones, phasing plans',
+    extensions: ['.md', '.txt', '.pdf'],
+    mapsTo: 'roadmap'
+  }
+};
+
+/**
+ * Config file name
+ */
+const CONFIG_FILE = 'PRESEED_CONFIG.json';
+
+/**
+ * Preseed Engine class
+ */
+class PreseedEngine {
+  constructor(projectRoot, options = {}) {
+    this.projectRoot = projectRoot;
+    this.outputDir = options.outputDir || path.join(projectRoot, DEFAULT_OUTPUT_DIR);
+    this.contextDir = options.contextDir || path.join(projectRoot, CONTEXT_INPUT_DIR);
+    this.preset = options.preset || 'startup';
+    this.config = null;
+    this.documents = new Map();
+    this.contextData = null;
+  }
+
+  /**
+   * Setup context input folders
+   */
+  setupContextFolders() {
+    const created = [];
+
+    // Create main context directory
+    if (!fs.existsSync(this.contextDir)) {
+      fs.mkdirSync(this.contextDir, { recursive: true });
+      created.push(this.contextDir);
+    }
+
+    // Create subfolders
+    for (const [key, folder] of Object.entries(CONTEXT_FOLDERS)) {
+      const folderPath = path.join(this.contextDir, folder.name);
+      if (!fs.existsSync(folderPath)) {
+        fs.mkdirSync(folderPath, { recursive: true });
+        created.push(folderPath);
+      }
+    }
+
+    // Create README
+    const readmePath = path.join(this.contextDir, 'README.md');
+    if (!fs.existsSync(readmePath)) {
+      const readme = `# Preseed Context Documents
+
+Drop your existing context files here before running \`bootspring preseed init\`.
+These documents will be analyzed to pre-populate and enhance your preseed wizard.
+
+## Quick Start: The Drop Zone
+
+**Don't know where to put something?** Just drop it in the \`drop/\` folder.
+AI will analyze your files and extract relevant information for each preseed document.
+
+## Folders
+
+### Universal
+| Folder | What to put here |
+|--------|------------------|
+| \`drop/\` | **Anything!** Pitch decks, notes, docs - AI sorts it out |
+
+### General
+| Folder | What to put here |
+|--------|------------------|
+| \`ideas/\` | Rough ideas, brainstorms, notes |
+| \`research/\` | Market research, industry reports |
+
+### Document-specific (maps 1:1 to output)
+| Folder | Output Document |
+|--------|-----------------|
+| \`vision/\` | → VISION.md |
+| \`audience/\` | → AUDIENCE.md |
+| \`market/\` | → MARKET.md |
+| \`competitors/\` | → COMPETITORS.md |
+| \`business/\` | → BUSINESS_MODEL.md |
+| \`prd/\` | → PRD.md |
+| \`technical/\` | → TECHNICAL_SPEC.md |
+| \`roadmap/\` | → ROADMAP.md |
+
+## Supported Formats
+
+- Markdown (.md)
+- Text (.txt)
+- PDF (.pdf)
+- Word (.docx)
+- CSV (.csv) - for structured data
+- Images (.png, .jpg) - for screenshots
+
+## How It Works
+
+1. Drop your files in the matching folder (e.g., \`vision/\` for VISION.md sources)
+2. Or use \`drop/\` if unsure - AI will sort it out
+3. Run \`bootspring preseed init\` or \`bootspring preseed start\`
+4. The wizard will use your context to enhance document generation
+5. Your context is preserved in PRESEED_CONFIG.json
+
+## Tips
+
+- More context = better generated documents
+- Each folder maps 1:1 to an output document for easy organization
+- Even rough notes are valuable
+- **Not sure where something goes? Use \`drop/\`!**
+- Include any competitor URLs or screenshots
+- Add user interview transcripts if available
+`;
+      fs.writeFileSync(readmePath, readme);
+    }
+
+    return created;
+  }
+
+  /**
+   * Check if context documents exist
+   */
+  hasContextDocuments() {
+    if (!fs.existsSync(this.contextDir)) {
+      return false;
+    }
+
+    for (const folder of Object.values(CONTEXT_FOLDERS)) {
+      const folderPath = path.join(this.contextDir, folder.name);
+      if (fs.existsSync(folderPath)) {
+        const files = fs.readdirSync(folderPath).filter(f => !f.startsWith('.'));
+        if (files.length > 0) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Ingest context documents
+   */
+  ingestContext() {
+    const context = {
+      files: [],
+      // General folders
+      drop: [],
+      ideas: [],
+      research: [],
+      // Document-specific folders (maps to output documents)
+      vision: [],
+      audience: [],
+      market: [],
+      competitors: [],
+      business: [],
+      prd: [],
+      technical: [],
+      roadmap: [],
+      summary: {}
+    };
+
+    if (!fs.existsSync(this.contextDir)) {
+      return context;
+    }
+
+    for (const [key, folder] of Object.entries(CONTEXT_FOLDERS)) {
+      const folderPath = path.join(this.contextDir, folder.name);
+      if (!fs.existsSync(folderPath)) {
+        continue;
+      }
+
+      const files = fs.readdirSync(folderPath).filter(f => !f.startsWith('.'));
+      for (const file of files) {
+        const filePath = path.join(folderPath, file);
+        const stat = fs.statSync(filePath);
+
+        if (!stat.isFile()) continue;
+
+        const ext = path.extname(file).toLowerCase();
+        const fileInfo = {
+          name: file,
+          path: filePath,
+          category: key,
+          size: stat.size,
+          modified: stat.mtime.toISOString()
+        };
+
+        // Read text content for supported formats
+        if (['.md', '.txt'].includes(ext)) {
+          try {
+            fileInfo.content = fs.readFileSync(filePath, 'utf-8');
+            fileInfo.preview = fileInfo.content.substring(0, 500);
+          } catch (e) {
+            fileInfo.error = e.message;
+          }
+        }
+
+        context.files.push(fileInfo);
+        context[key].push(fileInfo);
+      }
+    }
+
+    // Build summary
+    context.summary = {
+      totalFiles: context.files.length,
+      byCategory: {}
+    };
+
+    for (const key of Object.keys(CONTEXT_FOLDERS)) {
+      context.summary.byCategory[key] = context[key].length;
+    }
+
+    this.contextData = context;
+    return context;
+  }
+
+  /**
+   * Extract suggestions from context
+   */
+  extractSuggestionsFromContext() {
+    if (!this.contextData || this.contextData.files.length === 0) {
+      return {};
+    }
+
+    const suggestions = {};
+
+    // Extract from ideas
+    if (this.contextData.ideas.length > 0) {
+      const ideaContent = this.contextData.ideas
+        .filter(f => f.content)
+        .map(f => f.content)
+        .join('\n\n');
+
+      if (ideaContent) {
+        suggestions.rawIdeas = ideaContent;
+      }
+    }
+
+    // Extract from research
+    if (this.contextData.research.length > 0) {
+      const researchContent = this.contextData.research
+        .filter(f => f.content)
+        .map(f => f.content)
+        .join('\n\n');
+
+      if (researchContent) {
+        suggestions.rawResearch = researchContent;
+      }
+    }
+
+    // Extract from competitors
+    if (this.contextData.competitors.length > 0) {
+      suggestions.competitorFiles = this.contextData.competitors.map(f => f.name);
+      const competitorContent = this.contextData.competitors
+        .filter(f => f.content)
+        .map(f => f.content)
+        .join('\n\n');
+
+      if (competitorContent) {
+        suggestions.rawCompetitors = competitorContent;
+      }
+    }
+
+    // Extract from audience
+    if (this.contextData.audience.length > 0) {
+      const audienceContent = this.contextData.audience
+        .filter(f => f.content)
+        .map(f => f.content)
+        .join('\n\n');
+
+      if (audienceContent) {
+        suggestions.rawAudience = audienceContent;
+      }
+    }
+
+    // Extract from business
+    if (this.contextData.business.length > 0) {
+      const businessContent = this.contextData.business
+        .filter(f => f.content)
+        .map(f => f.content)
+        .join('\n\n');
+
+      if (businessContent) {
+        suggestions.rawBusiness = businessContent;
+      }
+    }
+
+    // Extract from technical
+    if (this.contextData.technical.length > 0) {
+      const technicalContent = this.contextData.technical
+        .filter(f => f.content)
+        .map(f => f.content)
+        .join('\n\n');
+
+      if (technicalContent) {
+        suggestions.rawTechnical = technicalContent;
+      }
+    }
+
+    // Extract from vision
+    if (this.contextData.vision && this.contextData.vision.length > 0) {
+      const visionContent = this.contextData.vision
+        .filter(f => f.content)
+        .map(f => f.content)
+        .join('\n\n');
+
+      if (visionContent) {
+        suggestions.rawVision = visionContent;
+      }
+    }
+
+    // Extract from market
+    if (this.contextData.market && this.contextData.market.length > 0) {
+      const marketContent = this.contextData.market
+        .filter(f => f.content)
+        .map(f => f.content)
+        .join('\n\n');
+
+      if (marketContent) {
+        suggestions.rawMarket = marketContent;
+      }
+    }
+
+    // Extract from prd
+    if (this.contextData.prd && this.contextData.prd.length > 0) {
+      const prdContent = this.contextData.prd
+        .filter(f => f.content)
+        .map(f => f.content)
+        .join('\n\n');
+
+      if (prdContent) {
+        suggestions.rawPrd = prdContent;
+      }
+    }
+
+    // Extract from roadmap
+    if (this.contextData.roadmap && this.contextData.roadmap.length > 0) {
+      const roadmapContent = this.contextData.roadmap
+        .filter(f => f.content)
+        .map(f => f.content)
+        .join('\n\n');
+
+      if (roadmapContent) {
+        suggestions.rawRoadmap = roadmapContent;
+      }
+    }
+
+    // Extract from drop (universal folder - analyze and distribute)
+    if (this.contextData.drop && this.contextData.drop.length > 0) {
+      const dropContent = this.contextData.drop
+        .filter(f => f.content)
+        .map(f => f.content)
+        .join('\n\n');
+
+      if (dropContent) {
+        suggestions.rawDrop = dropContent;
+      }
+    }
+
+    return suggestions;
+  }
+
+  /**
+   * Get context content for a specific document type
+   * Maps document types to their corresponding context folders
+   */
+  getContextForDocument(docType) {
+    if (!this.contextData) {
+      this.ingestContext();
+    }
+
+    // Map document types to context folder keys
+    const docToFolderMap = {
+      'vision': 'vision',
+      'audience': 'audience',
+      'market': 'market',
+      'competitors': 'competitors',
+      'business-model': 'business',
+      'prd': 'prd',
+      'technical-spec': 'technical',
+      'roadmap': 'roadmap'
+    };
+
+    const folderKey = docToFolderMap[docType];
+    if (!folderKey || !this.contextData[folderKey]) {
+      return null;
+    }
+
+    const files = this.contextData[folderKey];
+    if (files.length === 0) {
+      return null;
+    }
+
+    // Combine all file contents from this folder
+    const contents = files
+      .filter(f => f.content)
+      .map(f => ({
+        filename: f.name,
+        content: f.content
+      }));
+
+    if (contents.length === 0) {
+      return null;
+    }
+
+    return {
+      fileCount: contents.length,
+      files: contents,
+      combined: contents.map(c => `--- ${c.filename} ---\n${c.content}`).join('\n\n')
+    };
+  }
+
+  /**
+   * Initialize preseed with minimal input
+   */
+  async initialize(minimalInput) {
+    // Ensure output directory exists
+    if (!fs.existsSync(this.outputDir)) {
+      fs.mkdirSync(this.outputDir, { recursive: true });
+    }
+
+    // Build configuration from minimal input
+    this.config = this.buildConfig(minimalInput);
+
+    // Save config
+    this.saveConfig();
+
+    return this.config;
+  }
+
+  /**
+   * Build full configuration from minimal input
+   */
+  buildConfig(input) {
+    const now = new Date().toISOString();
+
+    return {
+      // Metadata
+      _meta: {
+        version: '1.0.0',
+        created: now,
+        updated: now,
+        preset: this.preset,
+        bootspringVersion: require('../package.json').version
+      },
+
+      // Core identity
+      identity: {
+        name: input.name || 'Untitled Project',
+        tagline: input.tagline || '',
+        description: input.description || '',
+        category: input.category || 'saas'
+      },
+
+      // Problem/Solution
+      problem: {
+        statement: input.problem || '',
+        painPoints: input.painPoints || [],
+        currentSolutions: input.currentSolutions || [],
+        whyNow: input.whyNow || ''
+      },
+
+      // Solution
+      solution: {
+        overview: input.solution || '',
+        keyFeatures: input.keyFeatures || [],
+        uniqueValue: input.uniqueValue || '',
+        coreCapabilities: input.coreCapabilities || []
+      },
+
+      // Target audience
+      audience: {
+        primary: input.primaryAudience || '',
+        segments: input.segments || [],
+        personas: input.personas || [],
+        icp: input.icp || {}
+      },
+
+      // Market
+      market: {
+        tam: input.tam || null,
+        sam: input.sam || null,
+        som: input.som || null,
+        trends: input.trends || [],
+        growth: input.marketGrowth || ''
+      },
+
+      // Competition
+      competitors: {
+        direct: input.directCompetitors || [],
+        indirect: input.indirectCompetitors || [],
+        positioning: input.positioning || '',
+        differentiation: input.differentiation || []
+      },
+
+      // Business model
+      business: {
+        model: input.businessModel || 'subscription',
+        revenueStreams: input.revenueStreams || [],
+        pricing: input.pricing || {},
+        unitEconomics: input.unitEconomics || {}
+      },
+
+      // Product
+      product: {
+        vision: input.productVision || '',
+        mvpFeatures: input.mvpFeatures || [],
+        futureFeatures: input.futureFeatures || [],
+        userStories: input.userStories || []
+      },
+
+      // Technical
+      technical: {
+        stack: input.techStack || {},
+        architecture: input.architecture || '',
+        integrations: input.integrations || [],
+        constraints: input.constraints || []
+      },
+
+      // Roadmap
+      roadmap: {
+        phases: input.phases || [],
+        milestones: input.milestones || [],
+        timeline: input.timeline || ''
+      },
+
+      // Living document tracking
+      _sync: {
+        lastSync: null,
+        codebaseHash: null,
+        linkedFiles: [],
+        changeLog: []
+      }
+    };
+  }
+
+  /**
+   * Save configuration to file
+   */
+  saveConfig() {
+    const configPath = path.join(this.outputDir, CONFIG_FILE);
+    fs.writeFileSync(configPath, JSON.stringify(this.config, null, 2));
+    return configPath;
+  }
+
+  /**
+   * Load existing configuration
+   */
+  loadConfig() {
+    const configPath = path.join(this.outputDir, CONFIG_FILE);
+    if (fs.existsSync(configPath)) {
+      this.config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Get documents to generate based on preset
+   */
+  getDocumentsToGenerate() {
+    const docTypes = PRESETS[this.preset] || PRESETS.startup;
+    return docTypes.map(type => ({
+      type,
+      ...DOCUMENT_TYPES[type]
+    }));
+  }
+
+  /**
+   * Generate all documents
+   */
+  async generateAll() {
+    if (!this.config) {
+      throw new Error('No configuration loaded. Run initialize() first.');
+    }
+
+    const docs = this.getDocumentsToGenerate();
+    const results = [];
+
+    for (const doc of docs) {
+      const content = this.generateDocument(doc.type);
+      const filePath = path.join(this.outputDir, doc.name);
+      fs.writeFileSync(filePath, content);
+      this.documents.set(doc.type, filePath);
+      results.push({ type: doc.type, path: filePath, title: doc.title });
+    }
+
+    // Update sync metadata
+    this.config._sync.lastSync = new Date().toISOString();
+    this.saveConfig();
+
+    return results;
+  }
+
+  /**
+   * Generate a single document
+   */
+  generateDocument(type) {
+    const generators = {
+      vision: () => this.generateVision(),
+      audience: () => this.generateAudience(),
+      market: () => this.generateMarket(),
+      competitors: () => this.generateCompetitors(),
+      'business-model': () => this.generateBusinessModel(),
+      prd: () => this.generatePRD(),
+      'technical-spec': () => this.generateTechnicalSpec(),
+      roadmap: () => this.generateRoadmap()
+    };
+
+    const generator = generators[type];
+    if (!generator) {
+      throw new Error(`Unknown document type: ${type}`);
+    }
+
+    return generator();
+  }
+
+  /**
+   * Generate VISION.md
+   */
+  generateVision() {
+    const { identity, problem, solution } = this.config;
+    const sections = [];
+    const context = this.getContextForDocument('vision');
+
+    sections.push(`# ${identity.name}`);
+    sections.push('');
+    if (identity.tagline) {
+      sections.push(`> ${identity.tagline}`);
+      sections.push('');
+    }
+    sections.push(`**Category:** ${identity.category}`);
+    sections.push(`**Generated:** ${new Date().toISOString().split('T')[0]}`);
+    sections.push('');
+
+    // Problem Statement
+    sections.push('## The Problem');
+    sections.push('');
+    if (problem.statement) {
+      sections.push(problem.statement);
+      sections.push('');
+    }
+
+    if (problem.painPoints && problem.painPoints.length > 0) {
+      sections.push('### Pain Points');
+      sections.push('');
+      problem.painPoints.forEach(point => {
+        sections.push(`- ${point}`);
+      });
+      sections.push('');
+    }
+
+    if (problem.currentSolutions && problem.currentSolutions.length > 0) {
+      sections.push('### Current Solutions (and their limitations)');
+      sections.push('');
+      problem.currentSolutions.forEach(sol => {
+        if (typeof sol === 'object') {
+          sections.push(`- **${sol.name}**: ${sol.limitation || 'N/A'}`);
+        } else {
+          sections.push(`- ${sol}`);
+        }
+      });
+      sections.push('');
+    }
+
+    if (problem.whyNow) {
+      sections.push('### Why Now?');
+      sections.push('');
+      sections.push(problem.whyNow);
+      sections.push('');
+    }
+
+    // Solution
+    sections.push('## Our Solution');
+    sections.push('');
+    if (solution.overview) {
+      sections.push(solution.overview);
+      sections.push('');
+    }
+
+    if (solution.keyFeatures && solution.keyFeatures.length > 0) {
+      sections.push('### Key Features');
+      sections.push('');
+      solution.keyFeatures.forEach(feature => {
+        if (typeof feature === 'object') {
+          sections.push(`- **${feature.name}**: ${feature.description || ''}`);
+        } else {
+          sections.push(`- ${feature}`);
+        }
+      });
+      sections.push('');
+    }
+
+    if (solution.uniqueValue) {
+      sections.push('### Unique Value Proposition');
+      sections.push('');
+      sections.push(solution.uniqueValue);
+      sections.push('');
+    }
+
+    // Include source context if available
+    if (context && context.fileCount > 0) {
+      sections.push('## Source Context');
+      sections.push('');
+      sections.push(`*Generated from ${context.fileCount} source file(s) in \`context/vision/\`:*`);
+      context.files.forEach(f => {
+        sections.push(`- ${f.filename}`);
+      });
+      sections.push('');
+    }
+
+    // Footer
+    sections.push('---');
+    sections.push('');
+    sections.push('*This is a living document generated by Bootspring. Run `bootspring preseed sync` to update.*');
+
+    return sections.join('\n');
+  }
+
+  /**
+   * Generate AUDIENCE.md
+   */
+  generateAudience() {
+    const { identity, audience } = this.config;
+    const sections = [];
+    const context = this.getContextForDocument('audience');
+
+    sections.push(`# Target Audience: ${identity.name}`);
+    sections.push('');
+    sections.push(`**Generated:** ${new Date().toISOString().split('T')[0]}`);
+    sections.push('');
+
+    // Primary audience
+    sections.push('## Primary Audience');
+    sections.push('');
+    if (audience.primary) {
+      sections.push(audience.primary);
+      sections.push('');
+    }
+
+    // Segments
+    if (audience.segments && audience.segments.length > 0) {
+      sections.push('## Market Segments');
+      sections.push('');
+      audience.segments.forEach((segment, i) => {
+        if (typeof segment === 'object') {
+          sections.push(`### ${i + 1}. ${segment.name}`);
+          if (segment.description) sections.push(segment.description);
+          if (segment.size) sections.push(`- **Size**: ${segment.size}`);
+          if (segment.characteristics) {
+            sections.push(`- **Characteristics**: ${segment.characteristics.join(', ')}`);
+          }
+        } else {
+          sections.push(`- ${segment}`);
+        }
+        sections.push('');
+      });
+    }
+
+    // Personas
+    if (audience.personas && audience.personas.length > 0) {
+      sections.push('## User Personas');
+      sections.push('');
+      audience.personas.forEach((persona, i) => {
+        if (typeof persona === 'object') {
+          sections.push(`### Persona ${i + 1}: ${persona.name || 'Unnamed'}`);
+          sections.push('');
+          if (persona.role) sections.push(`**Role:** ${persona.role}`);
+          if (persona.demographics) sections.push(`**Demographics:** ${persona.demographics}`);
+          if (persona.goals && persona.goals.length > 0) {
+            sections.push('');
+            sections.push('**Goals:**');
+            persona.goals.forEach(goal => sections.push(`- ${goal}`));
+          }
+          if (persona.painPoints && persona.painPoints.length > 0) {
+            sections.push('');
+            sections.push('**Pain Points:**');
+            persona.painPoints.forEach(pain => sections.push(`- ${pain}`));
+          }
+          if (persona.quote) {
+            sections.push('');
+            sections.push(`> "${persona.quote}"`);
+          }
+        } else {
+          sections.push(`- ${persona}`);
+        }
+        sections.push('');
+      });
+    }
+
+    // ICP
+    if (audience.icp && Object.keys(audience.icp).length > 0) {
+      sections.push('## Ideal Customer Profile (ICP)');
+      sections.push('');
+      const icp = audience.icp;
+      if (icp.company) sections.push(`**Company:** ${icp.company}`);
+      if (icp.size) sections.push(`**Size:** ${icp.size}`);
+      if (icp.industry) sections.push(`**Industry:** ${icp.industry}`);
+      if (icp.budget) sections.push(`**Budget:** ${icp.budget}`);
+      if (icp.decisionMaker) sections.push(`**Decision Maker:** ${icp.decisionMaker}`);
+      if (icp.buyingProcess) sections.push(`**Buying Process:** ${icp.buyingProcess}`);
+      sections.push('');
+    }
+
+    // Include source context if available
+    if (context && context.fileCount > 0) {
+      sections.push('## Source Context');
+      sections.push('');
+      sections.push(`*Generated from ${context.fileCount} source file(s) in \`context/audience/\`:*`);
+      context.files.forEach(f => {
+        sections.push(`- ${f.filename}`);
+      });
+      sections.push('');
+    }
+
+    // Footer
+    sections.push('---');
+    sections.push('');
+    sections.push('*This is a living document generated by Bootspring. Run `bootspring preseed sync` to update.*');
+
+    return sections.join('\n');
+  }
+
+  /**
+   * Generate MARKET.md
+   */
+  generateMarket() {
+    const { identity, market } = this.config;
+    const sections = [];
+    const context = this.getContextForDocument('market');
+
+    sections.push(`# Market Analysis: ${identity.name}`);
+    sections.push('');
+    sections.push(`**Generated:** ${new Date().toISOString().split('T')[0]}`);
+    sections.push('');
+
+    // Market sizing
+    sections.push('## Market Size');
+    sections.push('');
+    sections.push('| Metric | Value | Notes |');
+    sections.push('|--------|-------|-------|');
+    sections.push(`| **TAM** (Total Addressable Market) | ${market.tam || 'TBD'} | Total market demand |`);
+    sections.push(`| **SAM** (Serviceable Addressable Market) | ${market.sam || 'TBD'} | Reachable market |`);
+    sections.push(`| **SOM** (Serviceable Obtainable Market) | ${market.som || 'TBD'} | Target in 1-3 years |`);
+    sections.push('');
+
+    // Growth
+    if (market.growth) {
+      sections.push('## Market Growth');
+      sections.push('');
+      sections.push(market.growth);
+      sections.push('');
+    }
+
+    // Trends
+    if (market.trends && market.trends.length > 0) {
+      sections.push('## Market Trends');
+      sections.push('');
+      market.trends.forEach(trend => {
+        if (typeof trend === 'object') {
+          sections.push(`### ${trend.name}`);
+          if (trend.description) sections.push(trend.description);
+          if (trend.impact) sections.push(`**Impact:** ${trend.impact}`);
+        } else {
+          sections.push(`- ${trend}`);
+        }
+        sections.push('');
+      });
+    }
+
+    // Include source context if available
+    if (context && context.fileCount > 0) {
+      sections.push('## Source Context');
+      sections.push('');
+      sections.push(`*Generated from ${context.fileCount} source file(s) in \`context/market/\`:*`);
+      context.files.forEach(f => {
+        sections.push(`- ${f.filename}`);
+      });
+      sections.push('');
+    }
+
+    // Footer
+    sections.push('---');
+    sections.push('');
+    sections.push('*This is a living document generated by Bootspring. Run `bootspring preseed sync` to update.*');
+
+    return sections.join('\n');
+  }
+
+  /**
+   * Generate COMPETITORS.md
+   */
+  generateCompetitors() {
+    const { identity, competitors } = this.config;
+    const sections = [];
+    const context = this.getContextForDocument('competitors');
+
+    sections.push(`# Competitive Analysis: ${identity.name}`);
+    sections.push('');
+    sections.push(`**Generated:** ${new Date().toISOString().split('T')[0]}`);
+    sections.push('');
+
+    // Direct competitors
+    if (competitors.direct && competitors.direct.length > 0) {
+      sections.push('## Direct Competitors');
+      sections.push('');
+      sections.push('| Company | Strengths | Weaknesses | Pricing |');
+      sections.push('|---------|-----------|------------|---------|');
+      competitors.direct.forEach(comp => {
+        if (typeof comp === 'object') {
+          sections.push(`| ${comp.name || 'N/A'} | ${comp.strengths || 'N/A'} | ${comp.weaknesses || 'N/A'} | ${comp.pricing || 'N/A'} |`);
+        } else {
+          sections.push(`| ${comp} | TBD | TBD | TBD |`);
+        }
+      });
+      sections.push('');
+    }
+
+    // Indirect competitors
+    if (competitors.indirect && competitors.indirect.length > 0) {
+      sections.push('## Indirect Competitors');
+      sections.push('');
+      sections.push('| Solution | Why Used | Limitations |');
+      sections.push('|----------|----------|-------------|');
+      competitors.indirect.forEach(comp => {
+        if (typeof comp === 'object') {
+          sections.push(`| ${comp.name || 'N/A'} | ${comp.whyUsed || 'N/A'} | ${comp.limitations || 'N/A'} |`);
+        } else {
+          sections.push(`| ${comp} | TBD | TBD |`);
+        }
+      });
+      sections.push('');
+    }
+
+    // Positioning
+    if (competitors.positioning) {
+      sections.push('## Our Positioning');
+      sections.push('');
+      sections.push(competitors.positioning);
+      sections.push('');
+    }
+
+    // Differentiation
+    if (competitors.differentiation && competitors.differentiation.length > 0) {
+      sections.push('## Key Differentiators');
+      sections.push('');
+      competitors.differentiation.forEach((diff, i) => {
+        sections.push(`${i + 1}. ${diff}`);
+      });
+      sections.push('');
+    }
+
+    // Include source context if available
+    if (context && context.fileCount > 0) {
+      sections.push('## Source Context');
+      sections.push('');
+      sections.push(`*Generated from ${context.fileCount} source file(s) in \`context/competitors/\`:*`);
+      context.files.forEach(f => {
+        sections.push(`- ${f.filename}`);
+      });
+      sections.push('');
+    }
+
+    // Footer
+    sections.push('---');
+    sections.push('');
+    sections.push('*This is a living document generated by Bootspring. Run `bootspring preseed sync` to update.*');
+
+    return sections.join('\n');
+  }
+
+  /**
+   * Generate BUSINESS_MODEL.md
+   */
+  generateBusinessModel() {
+    const { identity, business } = this.config;
+    const sections = [];
+    const context = this.getContextForDocument('business-model');
+
+    sections.push(`# Business Model: ${identity.name}`);
+    sections.push('');
+    sections.push(`**Generated:** ${new Date().toISOString().split('T')[0]}`);
+    sections.push('');
+
+    // Model type
+    sections.push('## Business Model Type');
+    sections.push('');
+    sections.push(`**Model:** ${business.model || 'Subscription SaaS'}`);
+    sections.push('');
+
+    // Revenue streams
+    if (business.revenueStreams && business.revenueStreams.length > 0) {
+      sections.push('## Revenue Streams');
+      sections.push('');
+      business.revenueStreams.forEach(stream => {
+        if (typeof stream === 'object') {
+          sections.push(`### ${stream.name}`);
+          if (stream.description) sections.push(stream.description);
+          if (stream.percentage) sections.push(`**Percentage of Revenue:** ${stream.percentage}`);
+        } else {
+          sections.push(`- ${stream}`);
+        }
+        sections.push('');
+      });
+    }
+
+    // Pricing
+    if (business.pricing && Object.keys(business.pricing).length > 0) {
+      sections.push('## Pricing Strategy');
+      sections.push('');
+      const p = business.pricing;
+      if (p.model) sections.push(`**Pricing Model:** ${p.model}`);
+      if (p.tiers && p.tiers.length > 0) {
+        sections.push('');
+        sections.push('### Pricing Tiers');
+        sections.push('');
+        sections.push('| Tier | Price | Features |');
+        sections.push('|------|-------|----------|');
+        p.tiers.forEach(tier => {
+          const features = tier.features ? tier.features.join(', ') : 'N/A';
+          sections.push(`| ${tier.name || 'N/A'} | ${tier.price || 'N/A'} | ${features} |`);
+        });
+      }
+      sections.push('');
+    }
+
+    // Unit economics
+    if (business.unitEconomics && Object.keys(business.unitEconomics).length > 0) {
+      sections.push('## Unit Economics');
+      sections.push('');
+      const ue = business.unitEconomics;
+      if (ue.cac) sections.push(`**Customer Acquisition Cost (CAC):** ${ue.cac}`);
+      if (ue.ltv) sections.push(`**Lifetime Value (LTV):** ${ue.ltv}`);
+      if (ue.ltvCacRatio) sections.push(`**LTV:CAC Ratio:** ${ue.ltvCacRatio}`);
+      if (ue.paybackPeriod) sections.push(`**Payback Period:** ${ue.paybackPeriod}`);
+      if (ue.grossMargin) sections.push(`**Gross Margin:** ${ue.grossMargin}`);
+      sections.push('');
+    }
+
+    // Include source context if available
+    if (context && context.fileCount > 0) {
+      sections.push('## Source Context');
+      sections.push('');
+      sections.push(`*Generated from ${context.fileCount} source file(s) in \`context/business/\`:*`);
+      context.files.forEach(f => {
+        sections.push(`- ${f.filename}`);
+      });
+      sections.push('');
+    }
+
+    // Footer
+    sections.push('---');
+    sections.push('');
+    sections.push('*This is a living document generated by Bootspring. Run `bootspring preseed sync` to update.*');
+
+    return sections.join('\n');
+  }
+
+  /**
+   * Generate PRD.md
+   */
+  generatePRD() {
+    const { identity, solution, product } = this.config;
+    const sections = [];
+    const context = this.getContextForDocument('prd');
+
+    sections.push(`# Product Requirements: ${identity.name}`);
+    sections.push('');
+    sections.push(`**Generated:** ${new Date().toISOString().split('T')[0]}`);
+    sections.push('**Version:** 1.0');
+    sections.push('');
+
+    // Product vision
+    sections.push('## Product Vision');
+    sections.push('');
+    if (product.vision) {
+      sections.push(product.vision);
+    } else if (solution.overview) {
+      sections.push(solution.overview);
+    }
+    sections.push('');
+
+    // MVP Features
+    if (product.mvpFeatures && product.mvpFeatures.length > 0) {
+      sections.push('## MVP Features');
+      sections.push('');
+      sections.push('| Feature | Priority | Description |');
+      sections.push('|---------|----------|-------------|');
+      product.mvpFeatures.forEach(feature => {
+        if (typeof feature === 'object') {
+          sections.push(`| ${feature.name || 'N/A'} | ${feature.priority || 'P1'} | ${feature.description || 'N/A'} |`);
+        } else {
+          sections.push(`| ${feature} | P1 | TBD |`);
+        }
+      });
+      sections.push('');
+    } else if (solution.keyFeatures && solution.keyFeatures.length > 0) {
+      sections.push('## MVP Features');
+      sections.push('');
+      solution.keyFeatures.forEach((feature, i) => {
+        if (typeof feature === 'object') {
+          sections.push(`### ${i + 1}. ${feature.name}`);
+          if (feature.description) sections.push(feature.description);
+        } else {
+          sections.push(`${i + 1}. ${feature}`);
+        }
+        sections.push('');
+      });
+    }
+
+    // User stories
+    if (product.userStories && product.userStories.length > 0) {
+      sections.push('## User Stories');
+      sections.push('');
+      product.userStories.forEach((story, i) => {
+        if (typeof story === 'object') {
+          sections.push(`### US-${String(i + 1).padStart(3, '0')}: ${story.title || 'Untitled'}`);
+          sections.push('');
+          sections.push(`**As a** ${story.actor || 'user'}`);
+          sections.push(`**I want to** ${story.action || 'TBD'}`);
+          sections.push(`**So that** ${story.benefit || 'TBD'}`);
+          if (story.acceptanceCriteria && story.acceptanceCriteria.length > 0) {
+            sections.push('');
+            sections.push('**Acceptance Criteria:**');
+            story.acceptanceCriteria.forEach(ac => sections.push(`- [ ] ${ac}`));
+          }
+        } else {
+          sections.push(`- ${story}`);
+        }
+        sections.push('');
+      });
+    }
+
+    // Future features
+    if (product.futureFeatures && product.futureFeatures.length > 0) {
+      sections.push('## Future Features (Post-MVP)');
+      sections.push('');
+      product.futureFeatures.forEach(feature => {
+        if (typeof feature === 'object') {
+          sections.push(`- **${feature.name}**: ${feature.description || ''}`);
+        } else {
+          sections.push(`- ${feature}`);
+        }
+      });
+      sections.push('');
+    }
+
+    // Include source context if available
+    if (context && context.fileCount > 0) {
+      sections.push('## Source Context');
+      sections.push('');
+      sections.push(`*Generated from ${context.fileCount} source file(s) in \`context/prd/\`:*`);
+      context.files.forEach(f => {
+        sections.push(`- ${f.filename}`);
+      });
+      sections.push('');
+    }
+
+    // Footer
+    sections.push('---');
+    sections.push('');
+    sections.push('*This is a living document generated by Bootspring. Run `bootspring preseed sync` to update.*');
+
+    return sections.join('\n');
+  }
+
+  /**
+   * Generate TECHNICAL_SPEC.md
+   */
+  generateTechnicalSpec() {
+    const { identity, technical, product } = this.config;
+    const sections = [];
+    const context = this.getContextForDocument('technical-spec');
+
+    sections.push(`# Technical Specification: ${identity.name}`);
+    sections.push('');
+    sections.push(`**Generated:** ${new Date().toISOString().split('T')[0]}`);
+    sections.push('');
+
+    // Tech stack
+    if (technical.stack && Object.keys(technical.stack).length > 0) {
+      sections.push('## Technology Stack');
+      sections.push('');
+      sections.push('| Component | Technology |');
+      sections.push('|-----------|------------|');
+      for (const [key, value] of Object.entries(technical.stack)) {
+        sections.push(`| ${key.charAt(0).toUpperCase() + key.slice(1)} | ${value} |`);
+      }
+      sections.push('');
+    }
+
+    // Architecture
+    if (technical.architecture) {
+      sections.push('## Architecture Overview');
+      sections.push('');
+      sections.push(technical.architecture);
+      sections.push('');
+    }
+
+    // Integrations
+    if (technical.integrations && technical.integrations.length > 0) {
+      sections.push('## Third-Party Integrations');
+      sections.push('');
+      technical.integrations.forEach(integration => {
+        if (typeof integration === 'object') {
+          sections.push(`- **${integration.name}**: ${integration.purpose || ''}`);
+        } else {
+          sections.push(`- ${integration}`);
+        }
+      });
+      sections.push('');
+    }
+
+    // Constraints
+    if (technical.constraints && technical.constraints.length > 0) {
+      sections.push('## Constraints & Requirements');
+      sections.push('');
+      technical.constraints.forEach(constraint => {
+        sections.push(`- ${constraint}`);
+      });
+      sections.push('');
+    }
+
+    // Include source context if available
+    if (context && context.fileCount > 0) {
+      sections.push('## Source Context');
+      sections.push('');
+      sections.push(`*Generated from ${context.fileCount} source file(s) in \`context/technical/\`:*`);
+      context.files.forEach(f => {
+        sections.push(`- ${f.filename}`);
+      });
+      sections.push('');
+    }
+
+    // Footer
+    sections.push('---');
+    sections.push('');
+    sections.push('*This is a living document generated by Bootspring. Run `bootspring preseed sync` to update.*');
+
+    return sections.join('\n');
+  }
+
+  /**
+   * Generate ROADMAP.md
+   */
+  generateRoadmap() {
+    const { identity, roadmap, product } = this.config;
+    const sections = [];
+    const context = this.getContextForDocument('roadmap');
+
+    sections.push(`# Product Roadmap: ${identity.name}`);
+    sections.push('');
+    sections.push(`**Generated:** ${new Date().toISOString().split('T')[0]}`);
+    sections.push('');
+
+    // Timeline
+    if (roadmap.timeline) {
+      sections.push('## Timeline Overview');
+      sections.push('');
+      sections.push(roadmap.timeline);
+      sections.push('');
+    }
+
+    // Phases
+    if (roadmap.phases && roadmap.phases.length > 0) {
+      sections.push('## Development Phases');
+      sections.push('');
+      roadmap.phases.forEach((phase, i) => {
+        if (typeof phase === 'object') {
+          sections.push(`### Phase ${i + 1}: ${phase.name || 'Unnamed'}`);
+          sections.push('');
+          if (phase.duration) sections.push(`**Duration:** ${phase.duration}`);
+          if (phase.goals && phase.goals.length > 0) {
+            sections.push('');
+            sections.push('**Goals:**');
+            phase.goals.forEach(goal => sections.push(`- ${goal}`));
+          }
+          if (phase.deliverables && phase.deliverables.length > 0) {
+            sections.push('');
+            sections.push('**Deliverables:**');
+            phase.deliverables.forEach(d => sections.push(`- [ ] ${d}`));
+          }
+        } else {
+          sections.push(`${i + 1}. ${phase}`);
+        }
+        sections.push('');
+      });
+    }
+
+    // Milestones
+    if (roadmap.milestones && roadmap.milestones.length > 0) {
+      sections.push('## Key Milestones');
+      sections.push('');
+      sections.push('| Milestone | Target Date | Status |');
+      sections.push('|-----------|-------------|--------|');
+      roadmap.milestones.forEach(milestone => {
+        if (typeof milestone === 'object') {
+          sections.push(`| ${milestone.name || 'N/A'} | ${milestone.date || 'TBD'} | ${milestone.status || 'Planned'} |`);
+        } else {
+          sections.push(`| ${milestone} | TBD | Planned |`);
+        }
+      });
+      sections.push('');
+    }
+
+    // Include source context if available
+    if (context && context.fileCount > 0) {
+      sections.push('## Source Context');
+      sections.push('');
+      sections.push(`*Generated from ${context.fileCount} source file(s) in \`context/roadmap/\`:*`);
+      context.files.forEach(f => {
+        sections.push(`- ${f.filename}`);
+      });
+      sections.push('');
+    }
+
+    // Footer
+    sections.push('---');
+    sections.push('');
+    sections.push('*This is a living document generated by Bootspring. Run `bootspring preseed sync` to update.*');
+
+    return sections.join('\n');
+  }
+
+  /**
+   * Sync documents with codebase changes
+   */
+  async sync() {
+    if (!this.loadConfig()) {
+      throw new Error('No preseed configuration found. Run preseed init first.');
+    }
+
+    // Record sync
+    this.config._sync.lastSync = new Date().toISOString();
+    this.config._sync.changeLog.push({
+      timestamp: new Date().toISOString(),
+      action: 'sync',
+      changes: []
+    });
+
+    // Regenerate all documents
+    const results = await this.generateAll();
+
+    return {
+      synced: results.length,
+      documents: results
+    };
+  }
+
+  /**
+   * Update a specific field in the config
+   */
+  updateConfig(path, value) {
+    if (!this.config) {
+      this.loadConfig();
+    }
+
+    // Navigate to the path and set value
+    const parts = path.split('.');
+    let current = this.config;
+    for (let i = 0; i < parts.length - 1; i++) {
+      if (!current[parts[i]]) {
+        current[parts[i]] = {};
+      }
+      current = current[parts[i]];
+    }
+    current[parts[parts.length - 1]] = value;
+
+    // Record change
+    this.config._meta.updated = new Date().toISOString();
+    this.config._sync.changeLog.push({
+      timestamp: new Date().toISOString(),
+      action: 'update',
+      path,
+      value
+    });
+
+    this.saveConfig();
+  }
+
+  /**
+   * Get status of preseed documents
+   */
+  getStatus() {
+    const configExists = this.loadConfig();
+    const docs = this.getDocumentsToGenerate();
+
+    // Check for merged documents (may exist without config)
+    let hasMergedDocs = false;
+    let mergedDocCount = 0;
+    const mergedDocNames = ['VISION.md', 'AUDIENCE.md', 'MARKET.md', 'COMPETITORS.md',
+      'BUSINESS_MODEL.md', 'PRD.md', 'TECHNICAL_SPEC.md', 'ROADMAP.md'];
+
+    for (const docName of mergedDocNames) {
+      const docPath = path.join(this.outputDir, docName);
+      if (fs.existsSync(docPath)) {
+        hasMergedDocs = true;
+        mergedDocCount++;
+      }
+    }
+
+    const status = {
+      initialized: configExists || hasMergedDocs,
+      initMode: configExists ? 'config' : (hasMergedDocs ? 'merged' : null),
+      preset: this.preset,
+      outputDir: this.outputDir,
+      documents: []
+    };
+
+    if (configExists) {
+      status.lastSync = this.config._sync.lastSync;
+      status.projectName = this.config.identity.name;
+    } else if (hasMergedDocs) {
+      status.projectName = '(Merged documents)';
+      status.mergedDocCount = mergedDocCount;
+    }
+
+    for (const doc of docs) {
+      const filePath = path.join(this.outputDir, doc.name);
+      const exists = fs.existsSync(filePath);
+      let modified = null;
+
+      if (exists) {
+        const stats = fs.statSync(filePath);
+        modified = stats.mtime.toISOString();
+      }
+
+      status.documents.push({
+        type: doc.type,
+        name: doc.name,
+        title: doc.title,
+        exists,
+        modified,
+        required: doc.required
+      });
+    }
+
+    return status;
+  }
+}
+
+module.exports = {
+  PreseedEngine,
+  DOCUMENT_TYPES,
+  PRESETS,
+  DEFAULT_OUTPUT_DIR,
+  CONTEXT_INPUT_DIR,
+  CONTEXT_FOLDERS,
+  CONFIG_FILE
+};