digital-products 2.1.3 → 2.3.0

package/test/roadmap/milestones.test.ts

@@ -1,231 +0,0 @@
-/**
- * Tests for Roadmap Milestones
- * Phase 1: RED - These tests should FAIL initially
- */
-
-import { describe, it, expect, beforeEach } from 'vitest'
-import {
-  Milestone,
-  createMilestone,
-  MilestoneRegistry,
-  createMilestoneRegistry,
-  MilestoneStatus,
-} from '../../src/roadmap/milestones.js'
-
-describe('Roadmap Milestones', () => {
-  describe('Milestone', () => {
-    it('creates a milestone', () => {
-      const milestone = createMilestone({
-        id: 'v2-release',
-        name: 'Version 2.0 Release',
-        description: 'Major version release',
-        targetDate: new Date('2024-06-01'),
-      })
-
-      expect(milestone.id).toBe('v2-release')
-      expect(milestone.name).toBe('Version 2.0 Release')
-      expect(milestone.status).toBe('planned')
-    })
-
-    it('supports feature list', () => {
-      const milestone = createMilestone({
-        id: 'q1-goals',
-        name: 'Q1 Goals',
-        features: ['dark-mode', 'api-v2', 'mobile-app'],
-        targetDate: new Date('2024-03-31'),
-      })
-
-      expect(milestone.features).toHaveLength(3)
-    })
-
-    it('supports dependencies', () => {
-      const milestone = createMilestone({
-        id: 'dependent',
-        name: 'Dependent Milestone',
-        dependencies: ['prerequisite-1', 'prerequisite-2'],
-        targetDate: new Date('2024-09-01'),
-      })
-
-      expect(milestone.dependencies).toContain('prerequisite-1')
-    })
-
-    it('tracks progress', () => {
-      const milestone = createMilestone({
-        id: 'progress-test',
-        name: 'Progress Test',
-        features: ['f1', 'f2', 'f3', 'f4'],
-        completedFeatures: ['f1', 'f2'],
-        targetDate: new Date('2024-06-01'),
-      })
-
-      expect(milestone.progress).toBe(50)
-    })
-
-    it('has customizable status', () => {
-      const milestone = createMilestone({
-        id: 'in-progress',
-        name: 'In Progress',
-        status: 'in_progress',
-        targetDate: new Date('2024-06-01'),
-      })
-
-      expect(milestone.status).toBe('in_progress')
-    })
-
-    it('supports metadata', () => {
-      const milestone = createMilestone({
-        id: 'with-meta',
-        name: 'With Metadata',
-        metadata: {
-          owner: 'product-team',
-          priority: 'high',
-        },
-        targetDate: new Date('2024-06-01'),
-      })
-
-      expect(milestone.metadata?.owner).toBe('product-team')
-    })
-  })
-
-  describe('MilestoneRegistry', () => {
-    let registry: MilestoneRegistry
-
-    beforeEach(() => {
-      registry = createMilestoneRegistry()
-    })
-
-    it('registers and retrieves milestones', () => {
-      const milestone = createMilestone({
-        id: 'test',
-        name: 'Test',
-        targetDate: new Date('2024-06-01'),
-      })
-
-      registry.register(milestone)
-      expect(registry.get('test')).toEqual(milestone)
-    })
-
-    it('lists milestones sorted by date', () => {
-      registry.register(
-        createMilestone({ id: 'm3', name: 'M3', targetDate: new Date('2024-09-01') })
-      )
-      registry.register(
-        createMilestone({ id: 'm1', name: 'M1', targetDate: new Date('2024-03-01') })
-      )
-      registry.register(
-        createMilestone({ id: 'm2', name: 'M2', targetDate: new Date('2024-06-01') })
-      )
-
-      const sorted = registry.listSorted()
-      expect(sorted[0].id).toBe('m1')
-      expect(sorted[1].id).toBe('m2')
-      expect(sorted[2].id).toBe('m3')
-    })
-
-    it('filters by status', () => {
-      registry.register(
-        createMilestone({
-          id: 'planned',
-          name: 'Planned',
-          status: 'planned',
-          targetDate: new Date('2024-06-01'),
-        })
-      )
-      registry.register(
-        createMilestone({
-          id: 'completed',
-          name: 'Completed',
-          status: 'completed',
-          targetDate: new Date('2024-03-01'),
-        })
-      )
-
-      const planned = registry.listByStatus('planned')
-      expect(planned).toHaveLength(1)
-    })
-
-    it('finds upcoming milestones', () => {
-      registry.register(
-        createMilestone({ id: 'past', name: 'Past', targetDate: new Date('2020-01-01') })
-      )
-      registry.register(
-        createMilestone({ id: 'future', name: 'Future', targetDate: new Date('2030-01-01') })
-      )
-
-      const upcoming = registry.listUpcoming()
-      expect(upcoming).toHaveLength(1)
-      expect(upcoming[0].id).toBe('future')
-    })
-
-    it('calculates overall progress', () => {
-      registry.register(
-        createMilestone({
-          id: 'm1',
-          name: 'M1',
-          features: ['f1', 'f2'],
-          completedFeatures: ['f1'],
-          targetDate: new Date('2024-06-01'),
-        })
-      )
-      registry.register(
-        createMilestone({
-          id: 'm2',
-          name: 'M2',
-          features: ['f3', 'f4'],
-          completedFeatures: ['f3', 'f4'],
-          targetDate: new Date('2024-06-01'),
-        })
-      )
-
-      const progress = registry.getOverallProgress()
-      expect(progress).toBe(75) // 3 out of 4 features
-    })
-
-    it('gets milestone timeline', () => {
-      registry.register(
-        createMilestone({ id: 'm1', name: 'M1', targetDate: new Date('2024-03-01') })
-      )
-      registry.register(
-        createMilestone({ id: 'm2', name: 'M2', targetDate: new Date('2024-06-01') })
-      )
-
-      const timeline = registry.getTimeline()
-      expect(timeline).toHaveLength(2)
-      expect(timeline[0].date).toBeDefined()
-    })
-
-    it('updates milestone progress', () => {
-      registry.register(
-        createMilestone({
-          id: 'update-test',
-          name: 'Update Test',
-          features: ['f1', 'f2', 'f3'],
-          completedFeatures: [],
-          targetDate: new Date('2024-06-01'),
-        })
-      )
-
-      registry.completeFeature('update-test', 'f1')
-      const milestone = registry.get('update-test')
-      expect(milestone?.completedFeatures).toContain('f1')
-      expect(milestone?.progress).toBeCloseTo(33, 0)
-    })
-
-    it('detects blocked milestones', () => {
-      registry.register(createMilestone({ id: 'blocker', name: 'Blocker', status: 'planned', targetDate: new Date('2024-06-01') }))
-      registry.register(
-        createMilestone({
-          id: 'blocked',
-          name: 'Blocked',
-          dependencies: ['blocker'],
-          status: 'planned',
-          targetDate: new Date('2024-09-01'),
-        })
-      )
-
-      const blocked = registry.getBlockedMilestones()
-      expect(blocked).toHaveLength(1)
-      expect(blocked[0].id).toBe('blocked')
-    })
-  })
-})

package/test/roadmap/priorities.test.ts

@@ -1,239 +0,0 @@
-/**
- * Tests for Roadmap Priorities
- * Phase 1: RED - These tests should FAIL initially
- */
-
-import { describe, it, expect, beforeEach } from 'vitest'
-import {
-  RoadmapItem,
-  createRoadmapItem,
-  PriorityMatrix,
-  createPriorityMatrix,
-  ImpactEffortScore,
-} from '../../src/roadmap/priorities.js'
-
-describe('Roadmap Priorities', () => {
-  describe('RoadmapItem', () => {
-    it('creates a roadmap item', () => {
-      const item = createRoadmapItem({
-        id: 'feature-x',
-        name: 'Feature X',
-        description: 'A new feature',
-        impact: 8,
-        effort: 5,
-      })
-
-      expect(item.id).toBe('feature-x')
-      expect(item.impact).toBe(8)
-      expect(item.effort).toBe(5)
-    })
-
-    it('calculates priority score', () => {
-      const item = createRoadmapItem({
-        id: 'high-priority',
-        name: 'High Priority',
-        impact: 10,
-        effort: 2,
-      })
-
-      expect(item.priorityScore).toBe(5) // impact / effort
-    })
-
-    it('supports custom scoring function', () => {
-      const item = createRoadmapItem({
-        id: 'custom',
-        name: 'Custom Score',
-        impact: 8,
-        effort: 4,
-        confidence: 0.9,
-        scoreFn: (i, e, c) => (i * (c || 1)) / e,
-      })
-
-      expect(item.priorityScore).toBeCloseTo(1.8, 1)
-    })
-
-    it('supports confidence level', () => {
-      const item = createRoadmapItem({
-        id: 'uncertain',
-        name: 'Uncertain',
-        impact: 8,
-        effort: 4,
-        confidence: 0.5,
-      })
-
-      expect(item.confidence).toBe(0.5)
-    })
-
-    it('supports time estimate', () => {
-      const item = createRoadmapItem({
-        id: 'timed',
-        name: 'Timed',
-        impact: 5,
-        effort: 5,
-        estimatedDays: 14,
-      })
-
-      expect(item.estimatedDays).toBe(14)
-    })
-
-    it('supports categories', () => {
-      const item = createRoadmapItem({
-        id: 'categorized',
-        name: 'Categorized',
-        impact: 5,
-        effort: 5,
-        category: 'infrastructure',
-        tags: ['backend', 'performance'],
-      })
-
-      expect(item.category).toBe('infrastructure')
-      expect(item.tags).toContain('backend')
-    })
-  })
-
-  describe('PriorityMatrix', () => {
-    let matrix: PriorityMatrix
-
-    beforeEach(() => {
-      matrix = createPriorityMatrix()
-    })
-
-    it('adds items to matrix', () => {
-      matrix.addItem(
-        createRoadmapItem({
-          id: 'item-1',
-          name: 'Item 1',
-          impact: 7,
-          effort: 3,
-        })
-      )
-
-      expect(matrix.getItem('item-1')).toBeDefined()
-    })
-
-    it('ranks items by priority score', () => {
-      matrix.addItem(createRoadmapItem({ id: 'low', name: 'Low', impact: 2, effort: 8 }))
-      matrix.addItem(createRoadmapItem({ id: 'high', name: 'High', impact: 9, effort: 2 }))
-      matrix.addItem(createRoadmapItem({ id: 'mid', name: 'Mid', impact: 5, effort: 5 }))
-
-      const ranked = matrix.getRanked()
-      expect(ranked[0].id).toBe('high')
-      expect(ranked[ranked.length - 1].id).toBe('low')
-    })
-
-    it('groups by quadrant', () => {
-      // High impact, low effort = Quick Wins
-      matrix.addItem(createRoadmapItem({ id: 'qw', name: 'Quick Win', impact: 9, effort: 2 }))
-      // High impact, high effort = Big Bets
-      matrix.addItem(createRoadmapItem({ id: 'bb', name: 'Big Bet', impact: 9, effort: 9 }))
-      // Low impact, low effort = Fill-ins
-      matrix.addItem(createRoadmapItem({ id: 'fi', name: 'Fill-in', impact: 2, effort: 2 }))
-      // Low impact, high effort = Time Sinks
-      matrix.addItem(createRoadmapItem({ id: 'ts', name: 'Time Sink', impact: 2, effort: 9 }))
-
-      const quadrants = matrix.getQuadrants()
-      expect(quadrants.quickWins[0].id).toBe('qw')
-      expect(quadrants.bigBets[0].id).toBe('bb')
-      expect(quadrants.fillIns[0].id).toBe('fi')
-      expect(quadrants.timeSinks[0].id).toBe('ts')
-    })
-
-    it('filters by category', () => {
-      matrix.addItem(
-        createRoadmapItem({
-          id: 'ux',
-          name: 'UX',
-          impact: 5,
-          effort: 5,
-          category: 'ux',
-        })
-      )
-      matrix.addItem(
-        createRoadmapItem({
-          id: 'backend',
-          name: 'Backend',
-          impact: 5,
-          effort: 5,
-          category: 'backend',
-        })
-      )
-
-      const ux = matrix.filterByCategory('ux')
-      expect(ux).toHaveLength(1)
-    })
-
-    it('suggests next items', () => {
-      matrix.addItem(createRoadmapItem({ id: 'high', name: 'High', impact: 10, effort: 2 }))
-      matrix.addItem(createRoadmapItem({ id: 'mid', name: 'Mid', impact: 5, effort: 5 }))
-      matrix.addItem(createRoadmapItem({ id: 'low', name: 'Low', impact: 2, effort: 8 }))
-
-      const suggestions = matrix.suggestNext(2)
-      expect(suggestions).toHaveLength(2)
-      expect(suggestions[0].id).toBe('high')
-    })
-
-    it('calculates capacity planning', () => {
-      matrix.addItem(
-        createRoadmapItem({
-          id: 'item-1',
-          name: 'Item 1',
-          impact: 8,
-          effort: 5,
-          estimatedDays: 10,
-        })
-      )
-      matrix.addItem(
-        createRoadmapItem({
-          id: 'item-2',
-          name: 'Item 2',
-          impact: 7,
-          effort: 3,
-          estimatedDays: 5,
-        })
-      )
-
-      const plan = matrix.planCapacity({ availableDays: 12 })
-      expect(plan.scheduled).toHaveLength(1)
-      expect(plan.scheduled[0].id).toBe('item-2') // Fits within capacity
-      expect(plan.deferred).toHaveLength(1)
-    })
-
-    it('supports custom scoring', () => {
-      matrix = createPriorityMatrix({
-        scoringFn: (item) => item.impact * (item.confidence || 1) / item.effort,
-      })
-
-      matrix.addItem(
-        createRoadmapItem({
-          id: 'confident',
-          name: 'Confident',
-          impact: 8,
-          effort: 4,
-          confidence: 1.0,
-        })
-      )
-      matrix.addItem(
-        createRoadmapItem({
-          id: 'uncertain',
-          name: 'Uncertain',
-          impact: 10,
-          effort: 4,
-          confidence: 0.5,
-        })
-      )
-
-      const ranked = matrix.getRanked()
-      expect(ranked[0].id).toBe('confident') // Higher when accounting for confidence
-    })
-
-    it('exports to formats', () => {
-      matrix.addItem(createRoadmapItem({ id: 'test', name: 'Test', impact: 5, effort: 5 }))
-
-      const json = matrix.export('json')
-      expect(JSON.parse(json)).toHaveLength(1)
-
-      const csv = matrix.export('csv')
-      expect(csv).toContain('test')
-    })
-  })
-})

package/test/tiers/define.test.ts

@@ -1,192 +0,0 @@
-/**
- * Tests for Tier definitions
- * Phase 1: RED - These tests should FAIL initially
- */
-
-import { describe, it, expect } from 'vitest'
-import {
-  Tier,
-  defineTier,
-  TierRegistry,
-  createTierRegistry,
-  TierLevel,
-} from '../../src/tiers/define.js'
-
-describe('Tier Definition', () => {
-  describe('Tier()', () => {
-    it('creates a free tier', () => {
-      const tier = Tier({
-        id: 'free',
-        name: 'Free',
-        level: 0,
-        description: 'Free forever',
-      })
-
-      expect(tier.id).toBe('free')
-      expect(tier.name).toBe('Free')
-      expect(tier.level).toBe(0)
-    })
-
-    it('creates a pro tier with higher level', () => {
-      const tier = Tier({
-        id: 'pro',
-        name: 'Pro',
-        level: 1,
-        description: 'Professional features',
-      })
-
-      expect(tier.level).toBe(1)
-    })
-
-    it('creates an enterprise tier', () => {
-      const tier = Tier({
-        id: 'enterprise',
-        name: 'Enterprise',
-        level: 2,
-        description: 'Enterprise features',
-        customPricing: true,
-      })
-
-      expect(tier.level).toBe(2)
-      expect(tier.customPricing).toBe(true)
-    })
-
-    it('supports feature limits', () => {
-      const tier = Tier({
-        id: 'starter',
-        name: 'Starter',
-        level: 0,
-        limits: {
-          users: 5,
-          storage: '1GB',
-          apiCalls: 1000,
-        },
-      })
-
-      expect(tier.limits?.users).toBe(5)
-      expect(tier.limits?.storage).toBe('1GB')
-      expect(tier.limits?.apiCalls).toBe(1000)
-    })
-
-    it('supports included features list', () => {
-      const tier = Tier({
-        id: 'business',
-        name: 'Business',
-        level: 1,
-        features: ['analytics', 'exports', 'api-access'],
-      })
-
-      expect(tier.features).toContain('analytics')
-      expect(tier.features).toHaveLength(3)
-    })
-
-    it('supports metadata', () => {
-      const tier = Tier({
-        id: 'growth',
-        name: 'Growth',
-        level: 1,
-        metadata: {
-          popular: true,
-          badge: 'Most Popular',
-        },
-      })
-
-      expect(tier.metadata?.popular).toBe(true)
-    })
-  })
-
-  describe('defineTier()', () => {
-    it('creates and validates a tier', () => {
-      const tier = defineTier({
-        id: 'custom',
-        name: 'Custom',
-        level: 3,
-        description: 'Custom tier',
-      })
-
-      expect(tier.id).toBe('custom')
-    })
-
-    it('throws for negative tier level', () => {
-      expect(() =>
-        defineTier({
-          id: 'invalid',
-          name: 'Invalid',
-          level: -1,
-        })
-      ).toThrow('Tier level must be non-negative')
-    })
-
-    it('throws for missing id', () => {
-      expect(() =>
-        defineTier({
-          id: '',
-          name: 'No ID',
-          level: 0,
-        })
-      ).toThrow('Tier ID is required')
-    })
-  })
-
-  describe('TierRegistry', () => {
-    it('registers and retrieves tiers', () => {
-      const registry = createTierRegistry()
-
-      const tier = Tier({
-        id: 'basic',
-        name: 'Basic',
-        level: 0,
-      })
-
-      registry.register(tier)
-      expect(registry.get('basic')).toEqual(tier)
-    })
-
-    it('lists tiers sorted by level', () => {
-      const registry = createTierRegistry()
-
-      registry.register(Tier({ id: 'enterprise', name: 'Enterprise', level: 2 }))
-      registry.register(Tier({ id: 'free', name: 'Free', level: 0 }))
-      registry.register(Tier({ id: 'pro', name: 'Pro', level: 1 }))
-
-      const tiers = registry.listSorted()
-      expect(tiers[0].id).toBe('free')
-      expect(tiers[1].id).toBe('pro')
-      expect(tiers[2].id).toBe('enterprise')
-    })
-
-    it('compares tiers', () => {
-      const registry = createTierRegistry()
-
-      registry.register(Tier({ id: 'free', name: 'Free', level: 0 }))
-      registry.register(Tier({ id: 'pro', name: 'Pro', level: 1 }))
-
-      expect(registry.compare('free', 'pro')).toBeLessThan(0)
-      expect(registry.compare('pro', 'free')).toBeGreaterThan(0)
-      expect(registry.compare('pro', 'pro')).toBe(0)
-    })
-
-    it('checks if tier has access to another tier features', () => {
-      const registry = createTierRegistry()
-
-      registry.register(Tier({ id: 'free', name: 'Free', level: 0 }))
-      registry.register(Tier({ id: 'pro', name: 'Pro', level: 1 }))
-      registry.register(Tier({ id: 'enterprise', name: 'Enterprise', level: 2 }))
-
-      expect(registry.hasAccessTo('enterprise', 'pro')).toBe(true)
-      expect(registry.hasAccessTo('enterprise', 'free')).toBe(true)
-      expect(registry.hasAccessTo('free', 'pro')).toBe(false)
-    })
-
-    it('gets upgrade path between tiers', () => {
-      const registry = createTierRegistry()
-
-      registry.register(Tier({ id: 'free', name: 'Free', level: 0 }))
-      registry.register(Tier({ id: 'pro', name: 'Pro', level: 1 }))
-      registry.register(Tier({ id: 'enterprise', name: 'Enterprise', level: 2 }))
-
-      const path = registry.getUpgradePath('free')
-      expect(path).toEqual(['pro', 'enterprise'])
-    })
-  })
-})