@girardmedia/bootspring 2.1.3 → 2.2.1

package/core/task-extractor.js

@@ -1,1098 +0,0 @@
-/**
- * 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 });
-}
-
-function normalizeQueueTaskStatus(value) {
-  const normalized = String(value || 'pending')
-    .trim()
-    .toLowerCase()
-    .replace(/[\s-]+/g, '_');
-
-  if (normalized === 'done' || normalized === 'complete' || normalized === 'completed') {
-    return 'completed';
-  }
-  if (normalized === 'inprogress' || normalized === 'in_progress') {
-    return 'in_progress';
-  }
-  return normalized === 'pending' ? 'pending' : 'pending';
-}
-
-function normalizeQueueTaskPhase(value) {
-  const normalized = String(value || 'mvp')
-    .trim()
-    .toLowerCase()
-    .replace(/[\s-]+/g, '_');
-
-  return ['foundation', 'mvp', 'launch'].includes(normalized) ? normalized : 'mvp';
-}
-
-function normalizeQueueComplexity(value) {
-  const normalized = String(value || 'medium').trim().toLowerCase();
-  return ['low', 'medium', 'high'].includes(normalized) ? normalized : 'medium';
-}
-
-function parseDependencyIds(rawText) {
-  const ids = [];
-  const seen = new Set();
-  const tokenMatches = rawText.match(/[a-z0-9][a-z0-9_-]*/gi) || [];
-
-  for (const rawToken of tokenMatches) {
-    const token = rawToken.trim().replace(/[.,;:]+$/, '');
-    if (!token || !token.includes('-') || !/\d/.test(token)) continue;
-    if (seen.has(token)) continue;
-    seen.add(token);
-    ids.push(token);
-  }
-
-  return ids;
-}
-
-function extractDependenciesFromSection(sectionContent) {
-  const dependencies = [];
-  const seen = new Set();
-
-  const inlineMatch = sectionContent.match(/\*{0,2}(?:Dependencies|Depends on):\*{0,2}\s*([^\n]+)/i);
-  if (inlineMatch && inlineMatch[1]) {
-    for (const depId of parseDependencyIds(inlineMatch[1])) {
-      if (!seen.has(depId)) {
-        seen.add(depId);
-        dependencies.push(depId);
-      }
-    }
-  }
-
-  const blockMatch = sectionContent.match(/\*{0,2}(?:Dependencies|Depends on):\*{0,2}\s*\n([\s\S]*?)(?=\n\*{0,2}[A-Z]|\n---|\n###|$)/i);
-  if (blockMatch && blockMatch[1]) {
-    const bullets = blockMatch[1].matchAll(/^\s*[-*]\s*(?:\[[ xX]\]\s*)?(.+)$/gm);
-    for (const bullet of bullets) {
-      for (const depId of parseDependencyIds(bullet[1] || '')) {
-        if (!seen.has(depId)) {
-          seen.add(depId);
-          dependencies.push(depId);
-        }
-      }
-    }
-
-    if (dependencies.length === 0) {
-      for (const depId of parseDependencyIds(blockMatch[1])) {
-        if (!seen.has(depId)) {
-          seen.add(depId);
-          dependencies.push(depId);
-        }
-      }
-    }
-  }
-
-  return dependencies;
-}
-
-function sortTasksWithDependencyChecks(tasks) {
-  const taskById = new Map();
-  const orderById = new Map();
-  const orderedByInput = [];
-
-  tasks.forEach((task, index) => {
-    orderedByInput.push(task);
-    if (task.id) {
-      taskById.set(task.id, task);
-      orderById.set(task.id, index);
-    }
-  });
-
-  const visited = new Set();
-  const visiting = new Set();
-  const ordered = [];
-
-  function visit(task) {
-    const taskId = task.id || '';
-    if (visited.has(taskId)) return;
-    if (visiting.has(taskId)) return;
-
-    visiting.add(taskId);
-
-    const deps = (task.dependencies || [])
-      .filter(depId => taskById.has(depId))
-      .sort((a, b) => (orderById.get(a) ?? Number.MAX_SAFE_INTEGER) - (orderById.get(b) ?? Number.MAX_SAFE_INTEGER));
-
-    for (const depId of deps) {
-      const depTask = taskById.get(depId);
-      if (depTask) {
-        visit(depTask);
-      }
-    }
-
-    visiting.delete(taskId);
-    visited.add(taskId);
-    ordered.push(task);
-  }
-
-  for (const task of orderedByInput) {
-    visit(task);
-  }
-
-  for (const task of orderedByInput) {
-    if (!ordered.includes(task)) {
-      ordered.push(task);
-    }
-  }
-
-  return ordered;
-}
-
-/**
- * Extract tasks from TASK_QUEUE.md
- * Parses both table format and detailed task sections
- * @param {string} content - TASK_QUEUE.md content
- * @returns {Array} Parsed tasks
- */
-function extractFromTaskQueue(content) {
-  const tasks = [];
-
-  const tableMatches = content.matchAll(/^\|\s*([^|]+)\s*\|\s*([a-z0-9][a-z0-9_-]*)\s*\|\s*([^|]+)\s*\|\s*([^|]+)\s*\|\s*([^|]+)\s*\|\s*([^|]+)\s*\|$/gmi);
-
-  for (const match of tableMatches) {
-    const id = match[2]?.trim() || '';
-    const title = match[3]?.trim() || '';
-    const phase = normalizeQueueTaskPhase(match[4]?.trim());
-    const complexity = normalizeQueueComplexity(match[5]?.trim());
-    const status = normalizeQueueTaskStatus(match[6]?.trim());
-
-    if (
-      id.toLowerCase() === 'id' ||
-      title.toLowerCase() === 'task' ||
-      id.includes('---') ||
-      title.includes('---')
-    ) continue;
-
-    tasks.push({
-      id,
-      title,
-      source: 'TASK_QUEUE.md',
-      sourceSection: 'Queue Status',
-      phase,
-      status,
-      acceptanceCriteria: [],
-      estimatedComplexity: complexity
-    });
-  }
-
-  const detailMatches = content.matchAll(/^###\s+(task-\d+|[\w-]+):\s*(.+)$/gm);
-
-  for (const match of detailMatches) {
-    const id = match[1]?.trim() || '';
-    const title = match[2]?.trim() || '';
-
-    const sectionStart = (match.index || 0) + match[0].length;
-    const nextSection = content.slice(sectionStart).search(/^###\s+/m);
-    const sectionContent = nextSection === -1
-      ? content.slice(sectionStart)
-      : content.slice(sectionStart, sectionStart + nextSection);
-
-    const phaseMatch = sectionContent.match(/\*{0,2}Phase:\*{0,2}\s*(\w+(?:\s*\d+)?)/i);
-    const phase = normalizeQueueTaskPhase(phaseMatch?.[1]?.trim());
-
-    const complexityMatch = sectionContent.match(/\*{0,2}Complexity:\*{0,2}\s*(\w+)/i);
-    const complexity = normalizeQueueComplexity(complexityMatch?.[1]?.trim());
-
-    const statusMatch = sectionContent.match(/\*{0,2}Status:\*{0,2}\s*([^\n]+)/i);
-    const status = normalizeQueueTaskStatus(statusMatch?.[1]?.trim());
-
-    const criteriaSection = sectionContent.match(/\*{0,2}Acceptance\s+Criteria:\*{0,2}\s*([\s\S]*?)(?=\n\*{0,2}[A-Z]|\n---|\n###|$)/i);
-    const acceptanceCriteria = [];
-    if (criteriaSection && criteriaSection[1]) {
-      const criteriaMatches = criteriaSection[1].matchAll(/[-*]\s*\[[ x]\]\s*(.+)/g);
-      for (const cm of criteriaMatches) {
-        acceptanceCriteria.push(cm[1]?.trim() || '');
-      }
-
-      if (acceptanceCriteria.length === 0) {
-        const bulletMatches = criteriaSection[1].matchAll(/^\s*[-*]\s+(.+)$/gm);
-        for (const bm of bulletMatches) {
-          const criterion = bm[1]?.trim() || '';
-          if (criterion) {
-            acceptanceCriteria.push(criterion);
-          }
-        }
-      }
-    }
-
-    const dependencies = extractDependenciesFromSection(sectionContent);
-
-    const existingIndex = tasks.findIndex(t => t.id === id);
-    const existingTask = existingIndex >= 0 ? tasks[existingIndex] : null;
-
-    if (existingTask) {
-      tasks[existingIndex] = {
-        ...existingTask,
-        acceptanceCriteria: acceptanceCriteria.length > 0 ? acceptanceCriteria : existingTask.acceptanceCriteria,
-        dependencies: dependencies.length > 0 ? dependencies : existingTask.dependencies
-      };
-    } else {
-      tasks.push({
-        id,
-        title,
-        source: 'TASK_QUEUE.md',
-        sourceSection: 'Task Details',
-        phase,
-        status,
-        acceptanceCriteria,
-        estimatedComplexity: complexity,
-        dependencies
-      });
-    }
-  }
-
-  return sortTasksWithDependencyChecks(tasks);
-}
-
-/**
- * Load and extract from TASK_QUEUE.md in planning directory
- * @param {string} projectRoot - Project root path
- * @returns {object} Extracted queue tasks
- */
-function extractFromTaskQueueFile(projectRoot) {
-  const queuePath = path.join(projectRoot, 'planning', 'TASK_QUEUE.md');
-
-  if (!fs.existsSync(queuePath)) {
-    return {
-      tasks: [],
-      phases: [],
-      mvpCriteria: [],
-      metadata: { extractedAt: new Date().toISOString(), sources: [] },
-      error: 'No TASK_QUEUE.md found'
-    };
-  }
-
-  const queueContent = fs.readFileSync(queuePath, 'utf-8');
-  const tasks = extractFromTaskQueue(queueContent);
-
-  return {
-    tasks,
-    phases: [],
-    mvpCriteria: [],
-    metadata: {
-      extractedAt: new Date().toISOString(),
-      sources: ['TASK_QUEUE.md']
-    }
-  };
-}
-
-/**
- * Sync tasks from TASK_QUEUE.md to BUILD_STATE.json
- * @param {string} projectRoot - Project root path
- * @param {object} options - Sync options
- * @returns {{added:number,updated:number,total:number}} Sync result
- */
-function syncFromTaskQueue(projectRoot, options = {}) {
-  const result = extractFromTaskQueueFile(projectRoot);
-
-  if (result.error || result.tasks.length === 0) {
-    return { added: 0, updated: 0, total: 0 };
-  }
-
-  const statePath = path.join(projectRoot, 'planning', 'BUILD_STATE.json');
-  let state = {};
-
-  if (fs.existsSync(statePath)) {
-    try {
-      state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
-    } catch {
-      state = {};
-    }
-  }
-
-  const replace = options.replace === true;
-  const existingQueue = replace ? [] : (state.implementationQueue || []);
-  const existingIds = new Set(existingQueue.map(t => t.id));
-
-  let added = 0;
-  let updated = 0;
-
-  for (const task of result.tasks) {
-    if (existingIds.has(task.id)) {
-      const index = existingQueue.findIndex(t => t.id === task.id);
-      const existing = index >= 0 ? existingQueue[index] : null;
-      if (existing) {
-        const existingDeps = (existing.dependencies || []).join(',');
-        const nextDeps = (task.dependencies || []).join(',');
-        const criteriaAdded = task.acceptanceCriteria.length > 0 && (existing.acceptanceCriteria?.length || 0) === 0;
-        const metadataChanged = existing.title !== task.title ||
-          existing.phase !== task.phase ||
-          existing.estimatedComplexity !== task.estimatedComplexity;
-
-        if (existing.status !== task.status || criteriaAdded || metadataChanged || existingDeps !== nextDeps) {
-          existingQueue[index] = { ...existing, ...task };
-          updated++;
-        }
-      }
-    } else {
-      existingQueue.push(task);
-      added++;
-    }
-  }
-
-  const orderedQueue = sortTasksWithDependencyChecks(existingQueue);
-
-  state.implementationQueue = orderedQueue;
-  fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
-
-  return { added, updated, total: orderedQueue.length };
-}
-
-module.exports = {
-  extractFromDocs,
-  extractFromPrd,
-  extractFromRoadmap,
-  extractFromTechnicalSpec,
-  extractFromSeed,
-  extractMvpCriteria,
-  orderByDependencies,
-  deduplicateTasks,
-  extractAcceptanceCriteria,
-  estimateComplexity,
-  extractSection,
-  extractIntegrations,
-  extractFromPreseedDir,
-  extractFromSeedFile,
-  extractFromTaskQueue,
-  extractFromTaskQueueFile,
-  syncFromTaskQueue
-};