yoda-mcp/tests/lean-core.test.ts

Intelligent Planning MCP with Optional Dependencies and Graceful Fallbacks - wise planning through the Force of lean excellence

/**
 * Lean Planning Core Test Suite
 * 
 * Tests the essential lean planning functionality
 * Focus: User value, simplicity, anti-over-engineering
 */

import { LeanPlannerCore, LeanPlanRequest, FocusedPlan } from '../src/core/lean-planner';
import { ComplexityGate } from '../src/core/complexity-gate';

describe('Lean Planning Core', () => {
  let planner: LeanPlannerCore;

  beforeEach(async () => {
    planner = new LeanPlannerCore();
    await planner.initialize();
  });

  describe('Simple Planning Requests', () => {
    test('generates focused plan for todo app', async () => {
      const request: LeanPlanRequest = {
        goal: 'Create a simple todo list app',
        context: 'Learning React, want something basic'
      };

      const plan = await planner.generatePlan(request);

      expect(plan.requirements.length).toBeLessThanOrEqual(5);
      expect(plan.tasks.length).toBeLessThanOrEqual(8);
      expect(plan.metadata.complexity).toBe('simple');
      expect(plan.qualityGates.completeness.passed).toBe(true);
      expect(plan.enhancements).toBeUndefined();
    });

    test('handles minimal planning requests', async () => {
      const request: LeanPlanRequest = {
        goal: 'Build a landing page --minimal',
        constraints: { timeline: '1 day' }
      };

      const plan = await planner.generatePlan(request);

      expect(plan.timeline.totalEstimate).toMatch(/1(-2)? day/);
      expect(plan.tasks.length).toBeLessThanOrEqual(5);
    });
  });

  describe('Quality Gates Validation', () => {
    test('validates plan completeness', async () => {
      const request: LeanPlanRequest = {
        goal: 'Build e-commerce website'
      };

      const plan = await planner.generatePlan(request);
      
      expect(plan.qualityGates.completeness.score).toBeGreaterThan(70);
      expect(plan.qualityGates.clarity.score).toBeGreaterThan(70);
      expect(plan.qualityGates.feasibility.score).toBeGreaterThan(60);
      expect(plan.qualityGates.value.score).toBeGreaterThan(60);
    });

    test('identifies unrealistic timelines', async () => {
      const request: LeanPlanRequest = {
        goal: 'Build social media platform',
        constraints: { timeline: '1 week' }
      };

      const plan = await planner.generatePlan(request);
      
      expect(plan.qualityGates.feasibility.passed).toBe(false);
    });
  });

  describe('Anti-Over-Engineering', () => {
    test('prevents task complexity explosion', async () => {
      const request: LeanPlanRequest = {
        goal: 'Build a simple contact form'
      };

      const plan = await planner.generatePlan(request);
      
      expect(plan.tasks.length).toBeLessThanOrEqual(5);
      expect(plan.tasks.every(task => task.estimatedHours <= 16)).toBe(true);
    });

    test('limits nice-to-have features', async () => {
      const request: LeanPlanRequest = {
        goal: 'Create personal portfolio website'
      };

      const plan = await planner.generatePlan(request);
      
      const niceToHave = plan.requirements.filter(req => req.priority === 'nice-to-have');
      expect(niceToHave.length).toBeLessThanOrEqual(2);
    });
  });

  describe('Complexity Gate', () => {
    test('detects over-engineering attempts', async () => {
      const request: LeanPlanRequest = {
        goal: 'Simple calculator app',
        enhancements: [
          { type: 'architecture', priority: 'critical' },
          { type: 'security', priority: 'critical' },
          { type: 'performance', priority: 'critical' }
        ]
      };

      const analysis = ComplexityGate.analyzeComplexityNeeds(request);
      
      expect(analysis.warnings.some(w => w.includes('over-engineering'))).toBe(true);
    });
  });

  describe('Performance', () => {
    test('generates plans quickly', async () => {
      const request: LeanPlanRequest = {
        goal: 'Create a weather app'
      };

      const startTime = Date.now();
      const plan = await planner.generatePlan(request);
      const endTime = Date.now();
      
      expect(endTime - startTime).toBeLessThan(5000);
      expect(plan).toBeDefined();
    });
  });
});