@girardmedia/bootspring 2.0.36 → 2.0.37

package/core/planning/feature-decomposer.js

@@ -0,0 +1,772 @@
+/**
+ * Bootspring Feature Decomposer
+ *
+ * Intelligently breaks down features into layered implementation tasks
+ * with effort estimates, dependencies, critical path analysis, and risks.
+ *
+ * @package bootspring
+ * @module core/planning/feature-decomposer
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Feature patterns for intelligent decomposition
+ */
+const FEATURE_PATTERNS = {
+  auth: {
+    keywords: ['auth', 'login', 'register', 'signup', 'signin', 'password', 'session', 'jwt', 'oauth'],
+    database: [
+      { task: 'Create User model', effort: 'small', deps: [] },
+      { task: 'Create Session/Account model', effort: 'small', deps: ['User model'] },
+      { task: 'Add authentication indexes', effort: 'small', deps: ['User model'] }
+    ],
+    backend: [
+      { task: 'Configure auth provider', effort: 'medium', deps: [] },
+      { task: 'Create auth service layer', effort: 'medium', deps: ['User model'] },
+      { task: 'Create auth middleware', effort: 'small', deps: ['Auth service'] },
+      { task: 'Create login endpoint', effort: 'medium', deps: ['Auth service'] },
+      { task: 'Create register endpoint', effort: 'medium', deps: ['Auth service'] },
+      { task: 'Create logout endpoint', effort: 'small', deps: ['Auth service'] },
+      { task: 'Implement session management', effort: 'medium', deps: ['Session model'] }
+    ],
+    frontend: [
+      { task: 'Create login form component', effort: 'medium', deps: [] },
+      { task: 'Create register form component', effort: 'medium', deps: [] },
+      { task: 'Create auth context/provider', effort: 'medium', deps: ['Auth endpoints'] },
+      { task: 'Create protected route wrapper', effort: 'small', deps: ['Auth context'] },
+      { task: 'Add auth state persistence', effort: 'small', deps: ['Auth context'] }
+    ],
+    testing: [
+      { task: 'Unit tests for auth service', effort: 'medium', deps: ['Auth service'] },
+      { task: 'Integration tests for auth endpoints', effort: 'medium', deps: ['Auth endpoints'] },
+      { task: 'E2E tests for login flow', effort: 'large', deps: ['Login form', 'Login endpoint'] }
+    ],
+    risks: [
+      { risk: 'Session security vulnerabilities', severity: 'high', mitigation: 'Use httpOnly cookies, implement token rotation' },
+      { risk: 'Password storage', severity: 'high', mitigation: 'Use bcrypt with proper cost factor (12+)' },
+      { risk: 'Brute force attacks', severity: 'medium', mitigation: 'Implement rate limiting and account lockout' }
+    ],
+    patterns: ['auth/nextauth', 'auth/jwt', 'security/password-hashing', 'security/rate-limiting']
+  },
+
+  payment: {
+    keywords: ['payment', 'billing', 'stripe', 'subscription', 'checkout', 'invoice', 'pricing'],
+    database: [
+      { task: 'Create Subscription model', effort: 'small', deps: ['User model'] },
+      { task: 'Create Payment/Transaction model', effort: 'small', deps: ['User model'] },
+      { task: 'Create Invoice model', effort: 'small', deps: ['User model'] },
+      { task: 'Create Plan/Pricing model', effort: 'small', deps: [] }
+    ],
+    backend: [
+      { task: 'Configure Stripe SDK', effort: 'small', deps: [] },
+      { task: 'Create payment service layer', effort: 'large', deps: ['Subscription model'] },
+      { task: 'Create checkout session endpoint', effort: 'medium', deps: ['Payment service'] },
+      { task: 'Create webhook handler', effort: 'large', deps: ['Payment service'] },
+      { task: 'Create subscription management endpoints', effort: 'medium', deps: ['Payment service'] },
+      { task: 'Create billing portal endpoint', effort: 'small', deps: ['Payment service'] }
+    ],
+    frontend: [
+      { task: 'Create pricing page', effort: 'medium', deps: [] },
+      { task: 'Create checkout component', effort: 'medium', deps: ['Checkout endpoint'] },
+      { task: 'Create subscription management UI', effort: 'medium', deps: ['Subscription endpoints'] },
+      { task: 'Create billing history component', effort: 'medium', deps: ['Invoice model'] }
+    ],
+    testing: [
+      { task: 'Unit tests for payment service', effort: 'medium', deps: ['Payment service'] },
+      { task: 'Webhook handler tests', effort: 'medium', deps: ['Webhook handler'] },
+      { task: 'E2E checkout flow tests', effort: 'large', deps: ['Checkout component'] }
+    ],
+    risks: [
+      { risk: 'PCI compliance', severity: 'high', mitigation: 'Use Stripe Elements, never handle raw card data' },
+      { risk: 'Webhook reliability', severity: 'medium', mitigation: 'Implement idempotency, verify signatures' },
+      { risk: 'Subscription state sync', severity: 'medium', mitigation: 'Rely on webhooks as source of truth' }
+    ],
+    patterns: ['payment/stripe', 'payment/webhooks', 'billing/subscriptions']
+  },
+
+  api: {
+    keywords: ['api', 'endpoint', 'rest', 'graphql', 'crud', 'resource'],
+    database: [
+      { task: 'Create resource model', effort: 'small', deps: [] },
+      { task: 'Add model relationships', effort: 'small', deps: ['Resource model'] },
+      { task: 'Add indexes for queries', effort: 'small', deps: ['Resource model'] }
+    ],
+    backend: [
+      { task: 'Create validation schemas', effort: 'small', deps: [] },
+      { task: 'Create service layer', effort: 'medium', deps: ['Resource model'] },
+      { task: 'Create GET endpoint', effort: 'small', deps: ['Service layer'] },
+      { task: 'Create POST endpoint', effort: 'small', deps: ['Service layer', 'Validation'] },
+      { task: 'Create PUT endpoint', effort: 'small', deps: ['Service layer', 'Validation'] },
+      { task: 'Create DELETE endpoint', effort: 'small', deps: ['Service layer'] },
+      { task: 'Add pagination support', effort: 'small', deps: ['GET endpoint'] },
+      { task: 'Add filtering support', effort: 'small', deps: ['GET endpoint'] }
+    ],
+    frontend: [
+      { task: 'Create API client functions', effort: 'small', deps: ['API endpoints'] },
+      { task: 'Create data display component', effort: 'medium', deps: ['API client'] },
+      { task: 'Create form component', effort: 'medium', deps: ['API client'] }
+    ],
+    testing: [
+      { task: 'Unit tests for service layer', effort: 'medium', deps: ['Service layer'] },
+      { task: 'Integration tests for endpoints', effort: 'medium', deps: ['API endpoints'] },
+      { task: 'Validation tests', effort: 'small', deps: ['Validation schemas'] }
+    ],
+    risks: [
+      { risk: 'Input validation', severity: 'high', mitigation: 'Use Zod/Yup for all inputs' },
+      { risk: 'Authorization bypass', severity: 'high', mitigation: 'Check ownership on all mutations' },
+      { risk: 'N+1 queries', severity: 'medium', mitigation: 'Use eager loading, add query limits' }
+    ],
+    patterns: ['api/rest-crud', 'api/validation', 'api/pagination']
+  },
+
+  dashboard: {
+    keywords: ['dashboard', 'admin', 'analytics', 'metrics', 'charts', 'overview'],
+    database: [
+      { task: 'Create analytics/metrics models', effort: 'small', deps: [] },
+      { task: 'Add aggregation queries', effort: 'medium', deps: ['Metrics models'] }
+    ],
+    backend: [
+      { task: 'Create analytics service', effort: 'medium', deps: ['Metrics models'] },
+      { task: 'Create dashboard data endpoint', effort: 'medium', deps: ['Analytics service'] },
+      { task: 'Add data aggregation logic', effort: 'medium', deps: ['Analytics service'] },
+      { task: 'Add caching for metrics', effort: 'small', deps: ['Analytics service'] }
+    ],
+    frontend: [
+      { task: 'Create dashboard layout', effort: 'medium', deps: [] },
+      { task: 'Create metric cards/widgets', effort: 'medium', deps: ['Dashboard layout'] },
+      { task: 'Create charts/visualizations', effort: 'large', deps: ['Dashboard data endpoint'] },
+      { task: 'Add date range filtering', effort: 'small', deps: ['Dashboard layout'] },
+      { task: 'Add real-time updates', effort: 'medium', deps: ['Dashboard data endpoint'] }
+    ],
+    testing: [
+      { task: 'Unit tests for analytics service', effort: 'medium', deps: ['Analytics service'] },
+      { task: 'Component tests for widgets', effort: 'medium', deps: ['Widgets'] },
+      { task: 'E2E tests for dashboard', effort: 'large', deps: ['Dashboard'] }
+    ],
+    risks: [
+      { risk: 'Performance with large datasets', severity: 'medium', mitigation: 'Pre-aggregate data, add caching' },
+      { risk: 'Real-time update complexity', severity: 'low', mitigation: 'Start with polling, upgrade to WebSocket later' }
+    ],
+    patterns: ['dashboard/metrics', 'frontend/charts', 'caching/redis']
+  },
+
+  upload: {
+    keywords: ['upload', 'file', 'image', 'media', 'storage', 's3', 'cloudinary'],
+    database: [
+      { task: 'Create File/Media model', effort: 'small', deps: [] },
+      { task: 'Add file metadata fields', effort: 'small', deps: ['File model'] }
+    ],
+    backend: [
+      { task: 'Configure storage provider', effort: 'small', deps: [] },
+      { task: 'Create upload service', effort: 'medium', deps: ['File model', 'Storage provider'] },
+      { task: 'Create upload endpoint', effort: 'medium', deps: ['Upload service'] },
+      { task: 'Create delete endpoint', effort: 'small', deps: ['Upload service'] },
+      { task: 'Add file validation', effort: 'small', deps: ['Upload endpoint'] },
+      { task: 'Add image processing', effort: 'medium', deps: ['Upload service'] }
+    ],
+    frontend: [
+      { task: 'Create file upload component', effort: 'medium', deps: [] },
+      { task: 'Add drag-and-drop support', effort: 'small', deps: ['Upload component'] },
+      { task: 'Add progress indicator', effort: 'small', deps: ['Upload component'] },
+      { task: 'Create file preview component', effort: 'small', deps: ['Upload component'] }
+    ],
+    testing: [
+      { task: 'Unit tests for upload service', effort: 'medium', deps: ['Upload service'] },
+      { task: 'Integration tests with mock storage', effort: 'medium', deps: ['Upload endpoint'] },
+      { task: 'File validation tests', effort: 'small', deps: ['File validation'] }
+    ],
+    risks: [
+      { risk: 'Malicious file uploads', severity: 'high', mitigation: 'Validate file types, scan for malware' },
+      { risk: 'Storage costs', severity: 'medium', mitigation: 'Set size limits, implement cleanup' },
+      { risk: 'Large file handling', severity: 'medium', mitigation: 'Use chunked uploads, streaming' }
+    ],
+    patterns: ['upload/s3', 'upload/cloudinary', 'security/file-validation']
+  },
+
+  notification: {
+    keywords: ['notification', 'email', 'push', 'alert', 'messaging', 'sms'],
+    database: [
+      { task: 'Create Notification model', effort: 'small', deps: ['User model'] },
+      { task: 'Create NotificationPreference model', effort: 'small', deps: ['User model'] }
+    ],
+    backend: [
+      { task: 'Configure email provider', effort: 'small', deps: [] },
+      { task: 'Create notification service', effort: 'medium', deps: ['Notification model'] },
+      { task: 'Create email templates', effort: 'medium', deps: ['Email provider'] },
+      { task: 'Create push notification service', effort: 'medium', deps: ['Notification service'] },
+      { task: 'Create notification preferences endpoint', effort: 'small', deps: ['Preference model'] },
+      { task: 'Add notification queue', effort: 'medium', deps: ['Notification service'] }
+    ],
+    frontend: [
+      { task: 'Create notification bell component', effort: 'small', deps: [] },
+      { task: 'Create notification dropdown/panel', effort: 'medium', deps: ['Notification endpoint'] },
+      { task: 'Create preferences settings UI', effort: 'medium', deps: ['Preferences endpoint'] },
+      { task: 'Add real-time notification updates', effort: 'medium', deps: ['Notification panel'] }
+    ],
+    testing: [
+      { task: 'Unit tests for notification service', effort: 'medium', deps: ['Notification service'] },
+      { task: 'Email template tests', effort: 'small', deps: ['Email templates'] },
+      { task: 'Integration tests', effort: 'medium', deps: ['Notification endpoints'] }
+    ],
+    risks: [
+      { risk: 'Email deliverability', severity: 'medium', mitigation: 'Use reputable provider, set up SPF/DKIM' },
+      { risk: 'Notification spam', severity: 'medium', mitigation: 'Respect preferences, add rate limiting' }
+    ],
+    patterns: ['notification/email', 'notification/push', 'messaging/queues']
+  },
+
+  search: {
+    keywords: ['search', 'filter', 'query', 'elasticsearch', 'algolia', 'fulltext'],
+    database: [
+      { task: 'Add search indexes', effort: 'small', deps: [] },
+      { task: 'Configure full-text search', effort: 'medium', deps: [] }
+    ],
+    backend: [
+      { task: 'Create search service', effort: 'medium', deps: ['Search indexes'] },
+      { task: 'Create search endpoint', effort: 'medium', deps: ['Search service'] },
+      { task: 'Add filtering capabilities', effort: 'medium', deps: ['Search endpoint'] },
+      { task: 'Add faceted search', effort: 'medium', deps: ['Search service'] },
+      { task: 'Implement search suggestions', effort: 'medium', deps: ['Search service'] }
+    ],
+    frontend: [
+      { task: 'Create search input component', effort: 'small', deps: [] },
+      { task: 'Create search results component', effort: 'medium', deps: ['Search endpoint'] },
+      { task: 'Add autocomplete/suggestions', effort: 'medium', deps: ['Suggestions endpoint'] },
+      { task: 'Create filter sidebar', effort: 'medium', deps: ['Filtering'] }
+    ],
+    testing: [
+      { task: 'Unit tests for search service', effort: 'medium', deps: ['Search service'] },
+      { task: 'Search accuracy tests', effort: 'medium', deps: ['Search endpoint'] },
+      { task: 'Performance tests', effort: 'medium', deps: ['Search endpoint'] }
+    ],
+    risks: [
+      { risk: 'Search performance', severity: 'medium', mitigation: 'Use dedicated search engine for scale' },
+      { risk: 'Index synchronization', severity: 'medium', mitigation: 'Use event-driven indexing' }
+    ],
+    patterns: ['search/fulltext', 'search/elasticsearch', 'search/algolia']
+  }
+};
+
+/**
+ * Effort mappings to time estimates
+ */
+const EFFORT_ESTIMATES = {
+  small: { time: '30min-1h', points: 1 },
+  medium: { time: '1-3h', points: 3 },
+  large: { time: '3-6h', points: 5 },
+  xlarge: { time: '6-12h', points: 8 }
+};
+
+/**
+ * Feature Decomposer class
+ */
+class FeatureDecomposer {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+
+  /**
+   * Decompose a feature into implementation tasks
+   */
+  async decompose(feature, options = {}) {
+    const { depth = 'standard', includePatterns = true } = options;
+
+    // Classify the feature
+    const classification = this.classifyFeature(feature);
+
+    // Get base decomposition
+    let decomposition;
+    if (classification.pattern) {
+      decomposition = this.decomposeFromPattern(feature, classification);
+    } else {
+      decomposition = this.decomposeGeneric(feature);
+    }
+
+    // Analyze project context
+    const projectContext = await this.analyzeProjectContext();
+
+    // Adjust for project context
+    decomposition = this.adjustForContext(decomposition, projectContext);
+
+    // Calculate metrics
+    const metrics = this.calculateMetrics(decomposition);
+
+    // Generate critical path
+    const criticalPath = this.calculateCriticalPath(decomposition);
+
+    // Find recommended patterns
+    const patterns = includePatterns
+      ? await this.findRecommendedPatterns(feature, classification)
+      : [];
+
+    return {
+      feature,
+      classification: classification.type,
+      confidence: classification.confidence,
+      complexity: metrics.complexity,
+      estimatedEffort: metrics.totalEffort,
+      estimatedPoints: metrics.totalPoints,
+
+      layers: decomposition.layers,
+      risks: decomposition.risks,
+      criticalPath,
+
+      metrics: {
+        totalTasks: metrics.totalTasks,
+        byLayer: metrics.byLayer,
+        byEffort: metrics.byEffort
+      },
+
+      recommendedPatterns: patterns,
+      suggestedOrder: this.generateSuggestedOrder(decomposition),
+
+      // Deep analysis additions
+      ...(depth === 'deep' && {
+        dependencies: this.mapAllDependencies(decomposition),
+        parallelizableTasks: this.findParallelizable(decomposition),
+        blockers: this.identifyBlockers(decomposition, projectContext)
+      })
+    };
+  }
+
+  /**
+   * Classify the feature type
+   */
+  classifyFeature(feature) {
+    const featureLower = feature.toLowerCase();
+    let bestMatch = null;
+    let bestScore = 0;
+
+    for (const [patternName, pattern] of Object.entries(FEATURE_PATTERNS)) {
+      let score = 0;
+      for (const keyword of pattern.keywords) {
+        if (featureLower.includes(keyword)) {
+          score += keyword.length; // Longer matches = higher score
+        }
+      }
+
+      if (score > bestScore) {
+        bestScore = score;
+        bestMatch = patternName;
+      }
+    }
+
+    if (bestMatch && bestScore > 0) {
+      return {
+        type: bestMatch,
+        pattern: FEATURE_PATTERNS[bestMatch],
+        confidence: Math.min(bestScore / 10, 1)
+      };
+    }
+
+    return {
+      type: 'generic',
+      pattern: null,
+      confidence: 0
+    };
+  }
+
+  /**
+   * Decompose from a known pattern
+   */
+  decomposeFromPattern(feature, classification) {
+    const pattern = classification.pattern;
+
+    return {
+      layers: {
+        database: [...pattern.database],
+        backend: [...pattern.backend],
+        frontend: [...pattern.frontend],
+        testing: [...pattern.testing],
+        documentation: [
+          { task: 'Update API documentation', effort: 'small', deps: ['API endpoints'] },
+          { task: 'Update user guide', effort: 'small', deps: ['Frontend'] }
+        ]
+      },
+      risks: [...pattern.risks]
+    };
+  }
+
+  /**
+   * Generic decomposition for unknown features
+   */
+  decomposeGeneric(feature) {
+    // Extract likely entity name
+    const entityName = this.extractEntityName(feature);
+
+    return {
+      layers: {
+        database: [
+          { task: `Create ${entityName} model`, effort: 'small', deps: [] },
+          { task: 'Add model relationships', effort: 'small', deps: [`${entityName} model`] },
+          { task: 'Add database indexes', effort: 'small', deps: [`${entityName} model`] }
+        ],
+        backend: [
+          { task: 'Create validation schema', effort: 'small', deps: [] },
+          { task: `Create ${entityName} service`, effort: 'medium', deps: [`${entityName} model`] },
+          { task: 'Create API endpoints', effort: 'medium', deps: [`${entityName} service`] },
+          { task: 'Add business logic', effort: 'medium', deps: [`${entityName} service`] }
+        ],
+        frontend: [
+          { task: `Create ${entityName} list component`, effort: 'medium', deps: [] },
+          { task: `Create ${entityName} form component`, effort: 'medium', deps: [] },
+          { task: `Create ${entityName} detail component`, effort: 'medium', deps: [] },
+          { task: 'Connect to API', effort: 'small', deps: ['API endpoints'] }
+        ],
+        testing: [
+          { task: 'Unit tests for service', effort: 'medium', deps: [`${entityName} service`] },
+          { task: 'API integration tests', effort: 'medium', deps: ['API endpoints'] },
+          { task: 'Component tests', effort: 'medium', deps: ['Components'] }
+        ],
+        documentation: [
+          { task: 'Document API endpoints', effort: 'small', deps: ['API endpoints'] }
+        ]
+      },
+      risks: [
+        { risk: 'Scope creep', severity: 'medium', mitigation: 'Define clear acceptance criteria' },
+        { risk: 'Integration complexity', severity: 'low', mitigation: 'Build incrementally with tests' }
+      ]
+    };
+  }
+
+  /**
+   * Extract entity name from feature description
+   */
+  extractEntityName(feature) {
+    const words = feature.split(/\s+/);
+
+    // Look for capitalized words or nouns
+    for (const word of words) {
+      if (/^[A-Z][a-z]+$/.test(word)) {
+        return word;
+      }
+    }
+
+    // Fall back to first significant word
+    const stopWords = ['add', 'create', 'implement', 'build', 'make', 'the', 'a', 'an', 'for', 'to', 'with'];
+    for (const word of words) {
+      if (!stopWords.includes(word.toLowerCase()) && word.length > 2) {
+        return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+      }
+    }
+
+    return 'Entity';
+  }
+
+  /**
+   * Analyze project context
+   */
+  async analyzeProjectContext() {
+    const context = {
+      hasDatabase: false,
+      databaseType: null,
+      hasAuth: false,
+      hasTests: false,
+      framework: null
+    };
+
+    try {
+      // Check for Prisma
+      if (fs.existsSync(path.join(this.projectRoot, 'prisma', 'schema.prisma'))) {
+        context.hasDatabase = true;
+        context.databaseType = 'prisma';
+      }
+
+      // Check for auth
+      const authPaths = ['app/api/auth', 'pages/api/auth', 'src/lib/auth'];
+      for (const authPath of authPaths) {
+        if (fs.existsSync(path.join(this.projectRoot, authPath))) {
+          context.hasAuth = true;
+          break;
+        }
+      }
+
+      // Check for tests
+      const testPaths = ['__tests__', 'tests', 'test', 'spec'];
+      for (const testPath of testPaths) {
+        if (fs.existsSync(path.join(this.projectRoot, testPath))) {
+          context.hasTests = true;
+          break;
+        }
+      }
+
+      // Check for framework
+      const packageJsonPath = path.join(this.projectRoot, 'package.json');
+      if (fs.existsSync(packageJsonPath)) {
+        const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+        if (deps.next) context.framework = 'nextjs';
+        else if (deps.react) context.framework = 'react';
+        else if (deps.vue) context.framework = 'vue';
+        else if (deps.express) context.framework = 'express';
+      }
+    } catch (_err) {
+      // Context analysis failed, use defaults
+    }
+
+    return context;
+  }
+
+  /**
+   * Adjust decomposition based on project context
+   */
+  adjustForContext(decomposition, context) {
+    const adjusted = JSON.parse(JSON.stringify(decomposition));
+
+    // If no database, skip database layer or add setup task
+    if (!context.hasDatabase && adjusted.layers.database.length > 0) {
+      adjusted.layers.database.unshift({
+        task: 'Set up database (Prisma)',
+        effort: 'medium',
+        deps: []
+      });
+    }
+
+    // If no auth but feature needs it, add auth dependency
+    if (!context.hasAuth) {
+      const needsAuth = adjusted.layers.backend.some(t =>
+        t.task.toLowerCase().includes('auth') ||
+        t.deps?.some(d => d.toLowerCase().includes('user'))
+      );
+
+      if (needsAuth) {
+        adjusted.risks.push({
+          risk: 'Authentication not set up',
+          severity: 'high',
+          mitigation: 'Implement authentication first or use bootspring preseed auth'
+        });
+      }
+    }
+
+    // If no tests, add test setup task
+    if (!context.hasTests && adjusted.layers.testing.length > 0) {
+      adjusted.layers.testing.unshift({
+        task: 'Set up testing framework',
+        effort: 'medium',
+        deps: []
+      });
+    }
+
+    return adjusted;
+  }
+
+  /**
+   * Calculate metrics for decomposition
+   */
+  calculateMetrics(decomposition) {
+    let totalTasks = 0;
+    let totalPoints = 0;
+    const byLayer = {};
+    const byEffort = { small: 0, medium: 0, large: 0, xlarge: 0 };
+
+    for (const [layer, tasks] of Object.entries(decomposition.layers)) {
+      byLayer[layer] = tasks.length;
+      totalTasks += tasks.length;
+
+      for (const task of tasks) {
+        const effort = task.effort || 'medium';
+        byEffort[effort] = (byEffort[effort] || 0) + 1;
+        totalPoints += EFFORT_ESTIMATES[effort]?.points || 3;
+      }
+    }
+
+    // Determine complexity
+    let complexity = 'low';
+    if (totalTasks > 15 || totalPoints > 40) complexity = 'high';
+    else if (totalTasks > 8 || totalPoints > 20) complexity = 'medium';
+
+    // Calculate total effort
+    const totalHours = totalPoints * 1.5; // Rough estimate
+    let totalEffort;
+    if (totalHours <= 8) totalEffort = '1 day';
+    else if (totalHours <= 24) totalEffort = '2-3 days';
+    else if (totalHours <= 40) totalEffort = '1 week';
+    else totalEffort = '2+ weeks';
+
+    return {
+      totalTasks,
+      totalPoints,
+      totalEffort,
+      complexity,
+      byLayer,
+      byEffort
+    };
+  }
+
+  /**
+   * Calculate critical path
+   */
+  calculateCriticalPath(decomposition) {
+    const allTasks = [];
+    const tasksByName = {};
+
+    // Flatten all tasks
+    for (const [layer, tasks] of Object.entries(decomposition.layers)) {
+      for (const task of tasks) {
+        const taskEntry = { ...task, layer };
+        allTasks.push(taskEntry);
+        tasksByName[task.task] = taskEntry;
+      }
+    }
+
+    // Find tasks with most dependencies leading to them
+    const criticalPath = [];
+
+    // Start with database layer
+    const dbTasks = decomposition.layers.database || [];
+    if (dbTasks.length > 0) {
+      criticalPath.push(dbTasks[0].task);
+    }
+
+    // Add backend service
+    const backendTasks = decomposition.layers.backend || [];
+    const serviceTasks = backendTasks.filter(t =>
+      t.task.toLowerCase().includes('service')
+    );
+    if (serviceTasks.length > 0) {
+      criticalPath.push(serviceTasks[0].task);
+    }
+
+    // Add API endpoints
+    const endpointTasks = backendTasks.filter(t =>
+      t.task.toLowerCase().includes('endpoint')
+    );
+    if (endpointTasks.length > 0) {
+      criticalPath.push('API endpoints');
+    }
+
+    // Add frontend integration
+    const frontendTasks = decomposition.layers.frontend || [];
+    if (frontendTasks.length > 0) {
+      criticalPath.push('Frontend integration');
+    }
+
+    return criticalPath;
+  }
+
+  /**
+   * Find recommended patterns from skills library
+   */
+  async findRecommendedPatterns(feature, classification) {
+    const patterns = [];
+
+    if (classification.pattern?.patterns) {
+      patterns.push(...classification.pattern.patterns);
+    }
+
+    // Try to load patterns from skills library
+    try {
+      const skillsPath = path.join(this.projectRoot, 'node_modules', '@girardmedia', 'bootspring', 'skills', 'patterns');
+      if (fs.existsSync(skillsPath)) {
+        const catalogPath = path.join(skillsPath, 'catalog.json');
+        if (fs.existsSync(catalogPath)) {
+          const catalog = JSON.parse(fs.readFileSync(catalogPath, 'utf8'));
+          // Match patterns based on feature keywords
+          // This is a simplified version
+        }
+      }
+    } catch (_err) {
+      // Skills lookup failed, use defaults
+    }
+
+    return [...new Set(patterns)];
+  }
+
+  /**
+   * Generate suggested implementation order
+   */
+  generateSuggestedOrder(decomposition) {
+    return [
+      '1. Database models and migrations',
+      '2. Backend service layer',
+      '3. API endpoints with validation',
+      '4. Frontend components',
+      '5. Connect frontend to API',
+      '6. Testing',
+      '7. Documentation'
+    ];
+  }
+
+  /**
+   * Map all dependencies (for deep analysis)
+   */
+  mapAllDependencies(decomposition) {
+    const deps = {};
+
+    for (const [layer, tasks] of Object.entries(decomposition.layers)) {
+      for (const task of tasks) {
+        deps[task.task] = {
+          layer,
+          effort: task.effort,
+          dependsOn: task.deps || [],
+          blockedBy: []
+        };
+      }
+    }
+
+    // Calculate blockedBy (reverse dependencies)
+    for (const [taskName, taskDeps] of Object.entries(deps)) {
+      for (const dep of taskDeps.dependsOn) {
+        if (deps[dep]) {
+          deps[dep].blockedBy.push(taskName);
+        }
+      }
+    }
+
+    return deps;
+  }
+
+  /**
+   * Find parallelizable tasks
+   */
+  findParallelizable(decomposition) {
+    const parallelGroups = [];
+
+    // Tasks with no dependencies can run in parallel
+    for (const [layer, tasks] of Object.entries(decomposition.layers)) {
+      const noDeps = tasks.filter(t => !t.deps || t.deps.length === 0);
+      if (noDeps.length > 1) {
+        parallelGroups.push({
+          layer,
+          tasks: noDeps.map(t => t.task)
+        });
+      }
+    }
+
+    return parallelGroups;
+  }
+
+  /**
+   * Identify blockers
+   */
+  identifyBlockers(decomposition, context) {
+    const blockers = [];
+
+    if (!context.hasDatabase) {
+      blockers.push({
+        type: 'infrastructure',
+        blocker: 'Database not configured',
+        resolution: 'Run: npx prisma init'
+      });
+    }
+
+    if (!context.hasAuth && decomposition.risks.some(r => r.risk.toLowerCase().includes('auth'))) {
+      blockers.push({
+        type: 'feature',
+        blocker: 'Authentication required',
+        resolution: 'Implement auth or use bootspring preseed auth'
+      });
+    }
+
+    return blockers;
+  }
+}
+
+module.exports = {
+  FeatureDecomposer,
+  FEATURE_PATTERNS,
+  EFFORT_ESTIMATES
+};