@girardmedia/bootspring 1.2.0 → 2.0.3

package/core/task-extractor.js

@@ -0,0 +1,758 @@
+/**
+ * Bootspring Task Extractor
+ *
+ * Extracts implementation tasks from seed documents (SEED.md, PRD.md, ROADMAP.md, etc.)
+ * and organizes them into an ordered implementation queue.
+ *
+ * @package bootspring
+ * @module core/task-extractor
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Main extraction function - parse all seed documents
+ * @param {object} docs - Document contents { SEED: string, PRD: string, ROADMAP: string, ... }
+ * @param {object} options - Extraction options
+ * @returns {object} Extracted tasks and metadata
+ */
+function extractFromDocs(docs, options = {}) {
+  const result = {
+    tasks: [],
+    phases: [],
+    mvpCriteria: [],
+    metadata: {
+      extractedAt: new Date().toISOString(),
+      sources: Object.keys(docs)
+    }
+  };
+
+  // Extract from PRD (primary source for features)
+  if (docs.PRD || docs.prd) {
+    const prdContent = docs.PRD || docs.prd;
+    const prdTasks = extractFromPrd(prdContent);
+    result.tasks.push(...prdTasks);
+    result.mvpCriteria.push(...extractMvpCriteria(prdContent));
+  }
+
+  // Extract from ROADMAP (phases and milestones)
+  if (docs.ROADMAP || docs.roadmap) {
+    const roadmapContent = docs.ROADMAP || docs.roadmap;
+    const { phases, phaseTasks } = extractFromRoadmap(roadmapContent);
+    result.phases = phases;
+    result.tasks.push(...phaseTasks);
+  }
+
+  // Extract from TECHNICAL_SPEC (architecture tasks)
+  if (docs.TECHNICAL_SPEC || docs.technical_spec) {
+    const techContent = docs.TECHNICAL_SPEC || docs.technical_spec;
+    const techTasks = extractFromTechnicalSpec(techContent);
+    result.tasks.push(...techTasks);
+  }
+
+  // Extract from SEED.md (may have additional features)
+  if (docs.SEED || docs.seed) {
+    const seedContent = docs.SEED || docs.seed;
+    const seedTasks = extractFromSeed(seedContent);
+    result.tasks.push(...seedTasks);
+  }
+
+  // Deduplicate tasks
+  result.tasks = deduplicateTasks(result.tasks);
+
+  // Order by dependencies
+  result.tasks = orderByDependencies(result.tasks);
+
+  // Assign IDs if not present
+  result.tasks = result.tasks.map((task, index) => ({
+    ...task,
+    id: task.id || `task-${(index + 1).toString().padStart(3, '0')}`
+  }));
+
+  return result;
+}
+
+/**
+ * Extract tasks from PRD.md
+ * @param {string} content - PRD content
+ * @returns {array} Tasks
+ */
+function extractFromPrd(content) {
+  const tasks = [];
+
+  // Extract from MVP Features section (#### F-XXX: Feature Name pattern)
+  const mvpSection = extractSection(content, 'MVP\\s+Features|P1\\s+.*Features|Must\\s+Ship', { maxLength: 10000 });
+  if (mvpSection) {
+    // Look for feature headers like "#### F-001: Feature Name"
+    const featureMatches = mvpSection.matchAll(/^#{1,4}\s+(F-\d+):\s*(.+)$/gm);
+    for (const match of featureMatches) {
+      const featureId = match[1];
+      const featureName = match[2].trim();
+
+      // Try to find acceptance criteria for this feature
+      const acceptanceCriteria = extractAcceptanceCriteria(mvpSection, featureId);
+
+      tasks.push({
+        title: `Implement ${featureName}`,
+        source: 'PRD.md',
+        sourceSection: `${featureId}: ${featureName}`,
+        phase: 'mvp',
+        status: 'pending',
+        acceptanceCriteria,
+        estimatedComplexity: estimateComplexity(featureName, acceptanceCriteria)
+      });
+    }
+  }
+
+  // Extract from Feature Requirements section (FR-XX patterns)
+  const frSection = extractSection(content, 'Feature\\s+Requirements', { maxLength: 10000 });
+  if (frSection) {
+    const frMatches = frSection.matchAll(/\*{0,2}(FR-\d+):?\*{0,2}\s*(.+)/g);
+    for (const match of frMatches) {
+      const frId = match[1];
+      const frName = match[2].replace(/\*+/g, '').trim();
+
+      // Skip if we already have a similar task
+      if (!tasks.some(t => t.title.toLowerCase().includes(frName.toLowerCase().slice(0, 20)))) {
+        tasks.push({
+          title: frName,
+          source: 'PRD.md',
+          sourceSection: frId,
+          phase: 'mvp',
+          status: 'pending',
+          acceptanceCriteria: [],
+          estimatedComplexity: 'medium'
+        });
+      }
+    }
+  }
+
+  // Extract from User Stories section
+  const storiesSection = extractSection(content, 'User\\s+Stories|Stories', { maxLength: 10000 });
+  if (storiesSection) {
+    // Look for "As a... I want... so that..." patterns
+    const storyMatches = storiesSection.matchAll(/As\s+a[n]?\s+([^,]+),\s*I\s+want\s+([^,]+?)(?:,\s*so\s+that|$)/gi);
+    for (const match of storyMatches) {
+      const role = match[1].trim();
+      const want = match[2].trim();
+
+      const title = `${want.charAt(0).toUpperCase() + want.slice(1)}`;
+
+      if (!tasks.some(t => t.title.toLowerCase().includes(want.toLowerCase().slice(0, 15)))) {
+        tasks.push({
+          title,
+          description: `As a ${role}, I want ${want}`,
+          source: 'PRD.md',
+          sourceSection: 'User Stories',
+          phase: 'mvp',
+          status: 'pending',
+          acceptanceCriteria: [],
+          estimatedComplexity: 'medium'
+        });
+      }
+    }
+  }
+
+  // Extract from Core User Journeys
+  const journeySection = extractSection(content, 'Core\\s+User\\s+Journeys|User\\s+Journeys', { maxLength: 5000 });
+  if (journeySection) {
+    const journeyMatches = journeySection.matchAll(/^#{1,4}\s+\d+\.\d+\s+Journey\s+\d+\s*[—\-]\s*(.+)$/gm);
+    for (const match of journeyMatches) {
+      const journeyName = match[1].trim();
+
+      if (!tasks.some(t => t.title.toLowerCase().includes(journeyName.toLowerCase().slice(0, 15)))) {
+        tasks.push({
+          title: `Implement ${journeyName} journey`,
+          source: 'PRD.md',
+          sourceSection: 'User Journeys',
+          phase: 'mvp',
+          status: 'pending',
+          acceptanceCriteria: [],
+          estimatedComplexity: 'high'
+        });
+      }
+    }
+  }
+
+  return tasks;
+}
+
+/**
+ * Extract tasks and phases from ROADMAP.md
+ * @param {string} content - ROADMAP content
+ * @returns {object} { phases: array, phaseTasks: array }
+ */
+function extractFromRoadmap(content) {
+  const phases = [];
+  const phaseTasks = [];
+  const seenPhases = new Set();
+
+  // Extract phase headers: "## X. Phase N — Name"
+  const phaseMatches = content.matchAll(/^##\s+\d+\.\s+Phase\s+(\d+)\s*[—\-]+\s*(.+)$/gm);
+
+  for (const match of phaseMatches) {
+    const phaseNum = match[1];
+    const phaseName = match[2].trim().replace(/\s*\([^)]+\)\s*$/, '');
+
+    if (seenPhases.has(phaseNum)) continue;
+    seenPhases.add(phaseNum);
+
+    // Determine phase type
+    const phaseType = phaseNum === '1' ? 'foundation' :
+      phaseNum === '2' ? 'mvp' :
+        phaseNum === '3' ? 'launch' : `phase${phaseNum}`;
+
+    // Extract deliverables for this phase
+    const phaseRegex = new RegExp(
+      `##\\s+\\d+\\.\\s+Phase\\s+${phaseNum}\\s*[—\\-][\\s\\S]*?(?=##\\s+\\d+\\.\\s+Phase\\s+\\d+|$)`,
+      'i'
+    );
+    const phaseSectionMatch = content.match(phaseRegex);
+
+    const deliverables = [];
+    if (phaseSectionMatch) {
+      const phaseContent = phaseSectionMatch[0];
+
+      // Look for deliverables subsection
+      const deliverablesRegex = /###\s+[\d.]+\s*Deliverables[\s\S]*?(?=###|##|$)/i;
+      const deliverablesMatch = phaseContent.match(deliverablesRegex);
+
+      if (deliverablesMatch) {
+        const bullets = deliverablesMatch[0].match(/^[\-\*]\s+(.+)$/gm);
+        if (bullets) {
+          bullets.slice(0, 8).forEach(b => {
+            const text = b.replace(/^[\-\*]\s+/, '').trim();
+            if (text.length > 3) {
+              deliverables.push(text);
+
+              // Create task for each deliverable
+              phaseTasks.push({
+                title: text,
+                source: 'ROADMAP.md',
+                sourceSection: `Phase ${phaseNum}: ${phaseName}`,
+                phase: phaseType,
+                status: 'pending',
+                acceptanceCriteria: [],
+                estimatedComplexity: 'medium'
+              });
+            }
+          });
+        }
+      }
+
+      // If no deliverables, look for feature headers (#### A) B) C) patterns)
+      if (deliverables.length === 0) {
+        const featureHeaders = phaseContent.match(/^####\s+[A-Z]\)\s+(.+)$/gm);
+        if (featureHeaders) {
+          featureHeaders.slice(0, 6).forEach(h => {
+            const hMatch = h.match(/####\s+[A-Z]\)\s+(.+)/);
+            if (hMatch && hMatch[1]) {
+              const title = hMatch[1].trim();
+              deliverables.push(title);
+
+              phaseTasks.push({
+                title: `Implement ${title}`,
+                source: 'ROADMAP.md',
+                sourceSection: `Phase ${phaseNum}: ${phaseName}`,
+                phase: phaseType,
+                status: 'pending',
+                acceptanceCriteria: [],
+                estimatedComplexity: 'high'
+              });
+            }
+          });
+        }
+      }
+
+      // Look for exit criteria
+      const exitCriteriaRegex = /###\s+[\d.]+\s*Exit\s+Criteria[\s\S]*?(?=###|##|$)/i;
+      const exitMatch = phaseContent.match(exitCriteriaRegex);
+      if (exitMatch) {
+        const checkItems = exitMatch[0].match(/^[\-\*]\s+[✅✓⬜]\s*(.+)$/gm);
+        if (checkItems) {
+          checkItems.forEach(item => {
+            const text = item.replace(/^[\-\*]\s+[✅✓⬜]\s*/, '').trim();
+            if (text.length > 5 && !deliverables.includes(text)) {
+              deliverables.push(text);
+            }
+          });
+        }
+      }
+    }
+
+    phases.push({
+      phase: phaseNum,
+      name: phaseName,
+      type: phaseType,
+      deliverables
+    });
+  }
+
+  return { phases, phaseTasks };
+}
+
+/**
+ * Extract tasks from TECHNICAL_SPEC.md
+ * @param {string} content - Technical spec content
+ * @returns {array} Tasks
+ */
+function extractFromTechnicalSpec(content) {
+  const tasks = [];
+
+  // Extract database setup tasks
+  const dbSection = extractSection(content, 'Data\\s+Model|Database|Key\\s+tables', { maxLength: 3000 });
+  if (dbSection) {
+    // Look for table names
+    const tableMatches = dbSection.match(/^\s*[\-\*]\s*`(\w+)`/gm);
+    if (tableMatches && tableMatches.length > 0) {
+      tasks.push({
+        title: 'Set up database schema with Prisma',
+        description: `Create database models for: ${tableMatches.slice(0, 5).map(m => m.match(/`(\w+)`/)?.[1]).filter(Boolean).join(', ')}`,
+        source: 'TECHNICAL_SPEC.md',
+        sourceSection: 'Database Schema',
+        phase: 'foundation',
+        status: 'pending',
+        acceptanceCriteria: [
+          'Prisma schema defined with all models',
+          'Database migrations generated',
+          'Seed data scripts created'
+        ],
+        estimatedComplexity: 'high'
+      });
+    }
+  }
+
+  // Extract API route tasks
+  const apiSection = extractSection(content, 'API\\s+Routes|Application\\s+Structure', { maxLength: 3000 });
+  if (apiSection) {
+    // Group related API routes
+    const apiGroups = new Map();
+    const apiMatches = apiSection.matchAll(/`\/api\/([^`\/]+)/g);
+
+    for (const match of apiMatches) {
+      const group = match[1];
+      if (!apiGroups.has(group)) {
+        apiGroups.set(group, []);
+      }
+    }
+
+    if (apiGroups.size > 0) {
+      tasks.push({
+        title: 'Implement core API endpoints',
+        description: `Set up API routes for: ${[...apiGroups.keys()].slice(0, 5).join(', ')}`,
+        source: 'TECHNICAL_SPEC.md',
+        sourceSection: 'API Routes',
+        phase: 'mvp',
+        status: 'pending',
+        acceptanceCriteria: [
+          'All CRUD endpoints implemented',
+          'Input validation with Zod',
+          'Error handling middleware',
+          'API documentation updated'
+        ],
+        estimatedComplexity: 'high'
+      });
+    }
+  }
+
+  // Extract architecture setup tasks
+  const archSection = extractSection(content, 'Core\\s+system\\s+components|Architecture', { maxLength: 2000 });
+  if (archSection) {
+    const compMatches = archSection.match(/^\s*\d+\)\s*(.+)$/gm);
+    if (compMatches && compMatches.length > 0) {
+      tasks.push({
+        title: 'Set up project architecture and scaffolding',
+        description: 'Configure project structure, linting, testing, and CI/CD',
+        source: 'TECHNICAL_SPEC.md',
+        sourceSection: 'Architecture',
+        phase: 'foundation',
+        status: 'pending',
+        acceptanceCriteria: [
+          'Project structure follows conventions',
+          'ESLint and Prettier configured',
+          'Testing framework set up',
+          'CI/CD pipeline configured'
+        ],
+        estimatedComplexity: 'medium',
+        dependencies: []
+      });
+    }
+  }
+
+  // Extract third-party integration tasks
+  const integrations = extractIntegrations(content);
+  const intCategories = Object.entries(integrations).filter(([_, v]) => v.length > 0);
+
+  if (intCategories.length > 0) {
+    for (const [category, services] of intCategories) {
+      if (services.length > 0) {
+        tasks.push({
+          title: `Integrate ${category} services (${services.join(', ')})`,
+          source: 'TECHNICAL_SPEC.md',
+          sourceSection: 'Integrations',
+          phase: 'mvp',
+          status: 'pending',
+          acceptanceCriteria: services.map(s => `${s} integration working`),
+          estimatedComplexity: services.length > 2 ? 'high' : 'medium'
+        });
+      }
+    }
+  }
+
+  return tasks;
+}
+
+/**
+ * Extract tasks from SEED.md
+ * @param {string} content - SEED content
+ * @returns {array} Tasks
+ */
+function extractFromSeed(content) {
+  const tasks = [];
+
+  // Extract MVP Features section
+  const mvpSection = extractSection(content, 'MVP\\s+Features', { maxLength: 5000 });
+  if (mvpSection) {
+    // Look for numbered list items
+    const featureMatches = mvpSection.matchAll(/^\d+\.\s+(.+)$/gm);
+    for (const match of featureMatches) {
+      const featureName = match[1].trim();
+
+      tasks.push({
+        title: `Implement ${featureName}`,
+        source: 'SEED.md',
+        sourceSection: 'MVP Features',
+        phase: 'mvp',
+        status: 'pending',
+        acceptanceCriteria: [],
+        estimatedComplexity: 'medium'
+      });
+    }
+  }
+
+  return tasks;
+}
+
+/**
+ * Extract MVP completion criteria
+ * @param {string} content - Document content
+ * @returns {array} MVP criteria
+ */
+function extractMvpCriteria(content) {
+  const criteria = [];
+
+  // Look for MVP Success Criteria or similar sections
+  const successSection = extractSection(content, 'MVP\\s+Success|Success\\s+Criteria|Definition\\s+of\\s+Done', { maxLength: 3000 });
+
+  if (successSection) {
+    const bulletMatches = successSection.match(/^[\-\*]\s+(.+)$/gm);
+    if (bulletMatches) {
+      bulletMatches.forEach(b => {
+        const text = b.replace(/^[\-\*]\s+/, '').replace(/\*+/g, '').trim();
+        if (text.length > 5) {
+          criteria.push({
+            name: text,
+            status: 'pending'
+          });
+        }
+      });
+    }
+  }
+
+  // Also extract from MVP Features as criteria
+  const mvpSection = extractSection(content, 'MVP\\s+Features|P1\\s+.*Features', { maxLength: 5000 });
+  if (mvpSection) {
+    const featureHeaders = mvpSection.match(/^#{1,4}\s+F-\d+:\s*(.+)$/gm);
+    if (featureHeaders) {
+      featureHeaders.forEach(h => {
+        const match = h.match(/F-\d+:\s*(.+)/);
+        if (match && match[1]) {
+          criteria.push({
+            name: match[1].trim(),
+            status: 'pending'
+          });
+        }
+      });
+    }
+  }
+
+  return criteria;
+}
+
+/**
+ * Order tasks by dependencies (topological sort)
+ * @param {array} tasks - Tasks to order
+ * @returns {array} Ordered tasks
+ */
+function orderByDependencies(tasks) {
+  // Build dependency graph
+  const taskMap = new Map(tasks.map((t, i) => [t.id || `task-${i}`, t]));
+  const visited = new Set();
+  const result = [];
+
+  // Add foundation tasks first
+  const foundationTasks = tasks.filter(t => t.phase === 'foundation');
+  const mvpTasks = tasks.filter(t => t.phase === 'mvp');
+  const launchTasks = tasks.filter(t => t.phase === 'launch');
+  const otherTasks = tasks.filter(t => !['foundation', 'mvp', 'launch'].includes(t.phase));
+
+  // Order by priority within phases
+  const priorityOrder = [
+    // Foundation tasks first
+    ...foundationTasks.filter(t => t.title.toLowerCase().includes('setup') || t.title.toLowerCase().includes('scaffold')),
+    ...foundationTasks.filter(t => t.title.toLowerCase().includes('database') || t.title.toLowerCase().includes('schema')),
+    ...foundationTasks.filter(t => !t.title.toLowerCase().includes('setup') && !t.title.toLowerCase().includes('database')),
+
+    // MVP tasks
+    ...mvpTasks.filter(t => t.title.toLowerCase().includes('auth')),
+    ...mvpTasks.filter(t => t.title.toLowerCase().includes('api')),
+    ...mvpTasks.filter(t => !t.title.toLowerCase().includes('auth') && !t.title.toLowerCase().includes('api')),
+
+    // Launch tasks
+    ...launchTasks,
+
+    // Other tasks
+    ...otherTasks
+  ];
+
+  return priorityOrder;
+}
+
+/**
+ * Deduplicate tasks based on title similarity
+ * @param {array} tasks - Tasks to deduplicate
+ * @returns {array} Deduplicated tasks
+ */
+function deduplicateTasks(tasks) {
+  const seen = new Map();
+
+  return tasks.filter(task => {
+    // Normalize title for comparison
+    const normalizedTitle = task.title
+      .toLowerCase()
+      .replace(/^implement\s+/i, '')
+      .replace(/\s+/g, ' ')
+      .trim();
+
+    // Check first 30 chars for similarity
+    const key = normalizedTitle.slice(0, 30);
+
+    if (seen.has(key)) {
+      // Merge acceptance criteria
+      const existing = seen.get(key);
+      if (task.acceptanceCriteria?.length > existing.acceptanceCriteria?.length) {
+        existing.acceptanceCriteria = task.acceptanceCriteria;
+      }
+      return false;
+    }
+
+    seen.set(key, task);
+    return true;
+  });
+}
+
+/**
+ * Extract acceptance criteria for a feature
+ * @param {string} content - Section content
+ * @param {string} featureId - Feature ID
+ * @returns {array} Acceptance criteria
+ */
+function extractAcceptanceCriteria(content, featureId) {
+  const criteria = [];
+
+  // Look for acceptance criteria section after feature header
+  const featureRegex = new RegExp(
+    `#{1,4}\\s+${featureId}:[\\s\\S]*?(?=#{1,4}\\s+F-\\d+:|$)`,
+    'i'
+  );
+  const featureMatch = content.match(featureRegex);
+
+  if (featureMatch) {
+    const featureContent = featureMatch[0];
+
+    // Look for bullet points
+    const bulletMatches = featureContent.match(/^[\-\*]\s+(.+)$/gm);
+    if (bulletMatches) {
+      bulletMatches.slice(0, 5).forEach(b => {
+        const text = b.replace(/^[\-\*]\s+/, '').replace(/\*+/g, '').trim();
+        if (text.length > 5 && text.length < 200) {
+          criteria.push(text);
+        }
+      });
+    }
+  }
+
+  return criteria;
+}
+
+/**
+ * Estimate task complexity
+ * @param {string} title - Task title
+ * @param {array} acceptanceCriteria - Acceptance criteria
+ * @returns {string} Complexity: low, medium, high
+ */
+function estimateComplexity(title, acceptanceCriteria = []) {
+  const titleLower = title.toLowerCase();
+
+  // High complexity indicators
+  const highIndicators = [
+    'authentication', 'payment', 'integration', 'real-time',
+    'voice', 'agent', 'workflow', 'pipeline', 'migration',
+    'security', 'encryption', 'multi-tenant'
+  ];
+
+  // Low complexity indicators
+  const lowIndicators = [
+    'ui', 'style', 'button', 'form', 'display', 'show',
+    'list', 'view', 'page', 'component', 'typo', 'fix'
+  ];
+
+  if (highIndicators.some(i => titleLower.includes(i))) {
+    return 'high';
+  }
+
+  if (lowIndicators.some(i => titleLower.includes(i))) {
+    return 'low';
+  }
+
+  // Also consider acceptance criteria count
+  if (acceptanceCriteria.length > 5) {
+    return 'high';
+  }
+
+  return 'medium';
+}
+
+/**
+ * Extract a section from markdown content
+ * @param {string} content - Markdown content
+ * @param {string} headingPattern - Heading pattern to match
+ * @param {object} options - Options
+ * @returns {string|null} Section content or null
+ */
+function extractSection(content, headingPattern, options = {}) {
+  const { maxLength = 2000 } = options;
+
+  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;
+
+  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;
+
+  sectionContent = sectionContent.trim();
+  if (sectionContent.length > maxLength) {
+    sectionContent = sectionContent.slice(0, maxLength);
+  }
+
+  return sectionContent || null;
+}
+
+/**
+ * Extract third-party integrations from content
+ * @param {string} content - Document content
+ * @returns {object} Integrations by category
+ */
+function extractIntegrations(content) {
+  const integrations = {
+    auth: [],
+    payments: [],
+    email: [],
+    ai: []
+  };
+
+  // Auth
+  if (content.match(/\bClerk\b/i)) integrations.auth.push('Clerk');
+  if (content.match(/\bNextAuth|Auth\.js/i)) integrations.auth.push('NextAuth');
+
+  // Payments
+  if (content.match(/\bStripe\b/i)) integrations.payments.push('Stripe');
+  if (content.match(/\bPaddle\b/i)) integrations.payments.push('Paddle');
+
+  // Email
+  if (content.match(/\bSendGrid\b/i)) integrations.email.push('SendGrid');
+  if (content.match(/\bResend\b/i)) integrations.email.push('Resend');
+
+  // AI
+  if (content.match(/\bOpenAI\b|GPT-4/i)) integrations.ai.push('OpenAI');
+  if (content.match(/\bAnthropic\b|Claude/i)) integrations.ai.push('Anthropic');
+
+  return integrations;
+}
+
+/**
+ * Load and extract from preseed directory
+ * @param {string} projectRoot - Project root path
+ * @returns {object} Extracted tasks and metadata
+ */
+function extractFromPreseedDir(projectRoot) {
+  const preseedDir = path.join(projectRoot, '.bootspring', 'preseed');
+
+  if (!fs.existsSync(preseedDir)) {
+    return { tasks: [], phases: [], mvpCriteria: [], error: 'No preseed directory found' };
+  }
+
+  const validDocs = [
+    'VISION.md', 'AUDIENCE.md', 'MARKET.md', 'COMPETITORS.md',
+    'BUSINESS_MODEL.md', 'PRD.md', 'TECHNICAL_SPEC.md', 'ROADMAP.md'
+  ];
+
+  const docs = {};
+
+  for (const file of validDocs) {
+    const filePath = path.join(preseedDir, file);
+    if (fs.existsSync(filePath)) {
+      const docName = file.replace('.md', '');
+      docs[docName] = fs.readFileSync(filePath, 'utf-8');
+    }
+  }
+
+  if (Object.keys(docs).length === 0) {
+    return { tasks: [], phases: [], mvpCriteria: [], error: 'No preseed documents found' };
+  }
+
+  return extractFromDocs(docs);
+}
+
+/**
+ * Load and extract from SEED.md
+ * @param {string} projectRoot - Project root path
+ * @returns {object} Extracted tasks and metadata
+ */
+function extractFromSeedFile(projectRoot) {
+  const seedPath = path.join(projectRoot, 'SEED.md');
+
+  if (!fs.existsSync(seedPath)) {
+    return { tasks: [], phases: [], mvpCriteria: [], error: 'No SEED.md found' };
+  }
+
+  const seedContent = fs.readFileSync(seedPath, 'utf-8');
+
+  return extractFromDocs({ SEED: seedContent });
+}
+
+module.exports = {
+  extractFromDocs,
+  extractFromPrd,
+  extractFromRoadmap,
+  extractFromTechnicalSpec,
+  extractFromSeed,
+  extractMvpCriteria,
+  orderByDependencies,
+  deduplicateTasks,
+  extractAcceptanceCriteria,
+  estimateComplexity,
+  extractSection,
+  extractIntegrations,
+  extractFromPreseedDir,
+  extractFromSeedFile
+};