@iservu-inc/adf-cli 0.9.1 → 0.11.0

package/tests/analytics.test.js

@@ -0,0 +1,712 @@
+const fs = require('fs-extra');
+const path = require('path');
+const analytics = require('../lib/learning/analytics');
+const storage = require('../lib/learning/storage');
+
+describe('Learning Analytics', () => {
+  const tempDir = path.join(__dirname, 'temp-analytics-test');
+
+  beforeEach(async () => {
+    await fs.ensureDir(tempDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tempDir);
+  });
+
+  describe('generateAnalytics', () => {
+    test('should generate analytics with no data', async () => {
+      const result = await analytics.generateAnalytics(tempDir);
+
+      expect(result.version).toBe('1.0');
+      expect(result.exportedAt).toBeTruthy();
+      expect(result.overview.totalSessions).toBe(0);
+      expect(result.overview.totalSkips).toBe(0);
+      expect(result.overview.totalAnswers).toBe(0);
+      // skipTrends always returns 12 weeks (with 0 values when no data)
+      expect(result.skipTrends.length).toBe(12);
+      expect(result.skipTrends[0].totalSkips).toBe(0);
+      expect(result.categoryPreferences).toEqual([]);
+    });
+
+    test('should generate complete analytics with real data', async () => {
+      // Set up test data
+      const skipHistory = {
+        sessions: [
+          {
+            sessionId: 's1',
+            timestamp: new Date('2025-01-01').toISOString(),
+            skips: [
+              { questionId: 'q1', text: 'Deploy?', category: 'deployment', reason: 'manual' },
+              { questionId: 'q2', text: 'CI/CD?', category: 'deployment', reason: 'manual' }
+            ]
+          },
+          {
+            sessionId: 's2',
+            timestamp: new Date('2025-01-08').toISOString(),
+            skips: [
+              { questionId: 'q1', text: 'Deploy?', category: 'deployment', reason: 'filtered' }
+            ]
+          }
+        ]
+      };
+
+      const answerHistory = {
+        sessions: [
+          {
+            sessionId: 's1',
+            timestamp: new Date('2025-01-01').toISOString(),
+            answers: [
+              { questionId: 'q3', text: 'Testing?', category: 'testing', answer: 'Jest', wordCount: 10 }
+            ]
+          }
+        ]
+      };
+
+      const patterns = {
+        patterns: [
+          {
+            id: 'p1',
+            questionId: 'q1',
+            confidence: 95,
+            timesApplied: 10,
+            createdAt: new Date('2025-01-01').toISOString(),
+            lastSeen: new Date('2025-01-08').toISOString()
+          },
+          {
+            id: 'p2',
+            questionId: 'q2',
+            confidence: 60,
+            timesApplied: 2,
+            createdAt: new Date('2024-06-01').toISOString(),
+            lastSeen: new Date('2024-06-15').toISOString()
+          }
+        ]
+      };
+
+      const rules = {
+        rules: [
+          { id: 'r1', enabled: true, timesApplied: 15 },
+          { id: 'r2', enabled: true, timesApplied: 8 }
+        ]
+      };
+
+      await storage.writeLearningData(tempDir, 'skip-history.json', skipHistory);
+      await storage.writeLearningData(tempDir, 'answer-history.json', answerHistory);
+      await storage.writeLearningData(tempDir, 'patterns.json', patterns);
+      await storage.writeLearningData(tempDir, 'learned-rules.json', rules);
+      await storage.updateLearningStats(tempDir, {
+        totalSessions: 2,
+        totalSkips: 3,
+        totalAnswers: 1
+      });
+
+      const result = await analytics.generateAnalytics(tempDir);
+
+      expect(result.overview.totalSessions).toBe(2);
+      expect(result.overview.totalSkips).toBe(3);
+      expect(result.overview.manualSkips).toBe(2);
+      expect(result.overview.filteredSkips).toBe(1);
+      expect(result.overview.totalAnswers).toBe(1);
+      expect(result.overview.activePatterns).toBe(2);
+      expect(result.overview.activeRules).toBe(2);
+      expect(result.skipTrends.length).toBeGreaterThan(0);
+      expect(result.categoryPreferences.length).toBeGreaterThan(0);
+      expect(result.patternDistribution.totalPatterns).toBe(2);
+      expect(result.decayStatus).toBeTruthy();
+      expect(result.effectiveness).toBeTruthy();
+    });
+
+    test('should handle missing data files gracefully', async () => {
+      // Only create skip history, leave others missing
+      await storage.writeLearningData(tempDir, 'skip-history.json', {
+        sessions: [
+          {
+            sessionId: 's1',
+            timestamp: new Date().toISOString(),
+            skips: [{ questionId: 'q1', reason: 'manual' }]
+          }
+        ]
+      });
+
+      const result = await analytics.generateAnalytics(tempDir);
+
+      expect(result.overview.totalSkips).toBeGreaterThan(0);
+      expect(result.overview.totalAnswers).toBe(0);
+      expect(result.overview.activePatterns).toBe(0);
+    });
+  });
+
+  describe('Overview Statistics', () => {
+    test('should calculate learning age correctly', async () => {
+      const skipHistory = {
+        sessions: [
+          {
+            sessionId: 's1',
+            timestamp: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString(), // 30 days ago
+            skips: []
+          }
+        ]
+      };
+
+      await storage.writeLearningData(tempDir, 'skip-history.json', skipHistory);
+
+      const result = await analytics.generateAnalytics(tempDir);
+
+      expect(result.overview.learningAge).toBe(30);
+    });
+
+    test('should separate manual and filtered skips', async () => {
+      const skipHistory = {
+        sessions: [
+          {
+            sessionId: 's1',
+            skips: [
+              { questionId: 'q1', reason: 'manual' },
+              { questionId: 'q2', reason: 'manual' },
+              { questionId: 'q3', reason: 'filtered' },
+              { questionId: 'q4', reason: 'filtered' },
+              { questionId: 'q5', reason: 'filtered' }
+            ]
+          }
+        ]
+      };
+
+      await storage.writeLearningData(tempDir, 'skip-history.json', skipHistory);
+
+      const result = await analytics.generateAnalytics(tempDir);
+
+      expect(result.overview.totalSkips).toBe(5);
+      expect(result.overview.manualSkips).toBe(2);
+      expect(result.overview.filteredSkips).toBe(3);
+    });
+  });
+
+  describe('Skip Trends', () => {
+    test('should group sessions by week', async () => {
+      const now = new Date();
+      const skipHistory = {
+        sessions: [
+          {
+            sessionId: 's1',
+            timestamp: new Date(now - 0 * 24 * 60 * 60 * 1000).toISOString(), // This week
+            skips: [{ questionId: 'q1', reason: 'manual' }]
+          },
+          {
+            sessionId: 's2',
+            timestamp: new Date(now - 7 * 24 * 60 * 60 * 1000).toISOString(), // Last week
+            skips: [{ questionId: 'q2', reason: 'manual' }]
+          },
+          {
+            sessionId: 's3',
+            timestamp: new Date(now - 14 * 24 * 60 * 60 * 1000).toISOString(), // 2 weeks ago
+            skips: [{ questionId: 'q3', reason: 'filtered' }]
+          }
+        ]
+      };
+
+      await storage.writeLearningData(tempDir, 'skip-history.json', skipHistory);
+
+      const result = await analytics.generateAnalytics(tempDir);
+
+      expect(result.skipTrends.length).toBe(12);
+      // Check that skips are distributed across weeks (may vary based on week boundaries)
+      const totalSkipsAcrossWeeks = result.skipTrends.reduce((sum, week) => sum + week.totalSkips, 0);
+      expect(totalSkipsAcrossWeeks).toBeGreaterThanOrEqual(2); // At least 2 skips captured
+      expect(totalSkipsAcrossWeeks).toBeLessThanOrEqual(3); // At most 3 skips
+    });
+
+    test('should calculate skip rate correctly', async () => {
+      const skipHistory = {
+        sessions: [
+          {
+            sessionId: 's1',
+            timestamp: new Date().toISOString(),
+            skips: [{ questionId: 'q1', reason: 'manual' }]
+          }
+        ]
+      };
+
+      const answerHistory = {
+        sessions: [
+          {
+            sessionId: 's1',
+            timestamp: new Date().toISOString(),
+            answers: [
+              { questionId: 'q2' },
+              { questionId: 'q3' },
+              { questionId: 'q4' }
+            ]
+          }
+        ]
+      };
+
+      await storage.writeLearningData(tempDir, 'skip-history.json', skipHistory);
+      await storage.writeLearningData(tempDir, 'answer-history.json', answerHistory);
+
+      const result = await analytics.generateAnalytics(tempDir);
+
+      // Skip rate is calculated from sessions with both skips and answers
+      // Since skipHistory sessions don't have answers, skipRate will be 100% (skips only)
+      const currentWeek = result.skipTrends[result.skipTrends.length - 1];
+      expect(currentWeek.skipRate).toBeGreaterThanOrEqual(0);
+      expect(currentWeek.skipRate).toBeLessThanOrEqual(100);
+    });
+
+    test('should limit to last 12 weeks', async () => {
+      const sessions = [];
+      for (let i = 0; i < 20; i++) {
+        sessions.push({
+          sessionId: `s${i}`,
+          timestamp: new Date(Date.now() - i * 7 * 24 * 60 * 60 * 1000).toISOString(),
+          skips: [{ questionId: `q${i}`, reason: 'manual' }]
+        });
+      }
+
+      await storage.writeLearningData(tempDir, 'skip-history.json', { sessions });
+
+      const result = await analytics.generateAnalytics(tempDir);
+
+      expect(result.skipTrends.length).toBeLessThanOrEqual(12);
+    });
+  });
+
+  describe('Category Preferences', () => {
+    test('should aggregate skips and answers by category', async () => {
+      const skipHistory = {
+        sessions: [
+          {
+            sessionId: 's1',
+            skips: [
+              { questionId: 'q1', category: 'deployment', reason: 'manual' },
+              { questionId: 'q2', category: 'deployment', reason: 'manual' }
+            ]
+          }
+        ]
+      };
+
+      const answerHistory = {
+        sessions: [
+          {
+            sessionId: 's1',
+            answers: [
+              { questionId: 'q3', category: 'deployment' },
+              { questionId: 'q4', category: 'testing' }
+            ]
+          }
+        ]
+      };
+
+      await storage.writeLearningData(tempDir, 'skip-history.json', skipHistory);
+      await storage.writeLearningData(tempDir, 'answer-history.json', answerHistory);
+
+      const result = await analytics.generateAnalytics(tempDir);
+
+      const deployment = result.categoryPreferences.find(c => c.category === 'deployment');
+      const testing = result.categoryPreferences.find(c => c.category === 'testing');
+
+      expect(deployment.skips).toBe(2);
+      expect(deployment.answers).toBe(1);
+      expect(deployment.total).toBe(3);
+      expect(deployment.skipRate).toBeCloseTo(67, 0); // 2/3 = 66.666... rounds to 67
+
+      expect(testing.skips).toBe(0);
+      expect(testing.answers).toBe(1);
+      expect(testing.skipRate).toBe(0);
+    });
+
+    test('should categorize preference levels correctly', async () => {
+      const skipHistory = {
+        sessions: [
+          {
+            sessionId: 's1',
+            skips: [
+              // High skip rate (80%)
+              { questionId: 'q1', category: 'cat1', reason: 'manual' },
+              { questionId: 'q2', category: 'cat1', reason: 'manual' },
+              { questionId: 'q3', category: 'cat1', reason: 'manual' },
+              { questionId: 'q4', category: 'cat1', reason: 'manual' },
+              // Low skip rate (20%)
+              { questionId: 'q5', category: 'cat2', reason: 'manual' }
+            ]
+          }
+        ]
+      };
+
+      const answerHistory = {
+        sessions: [
+          {
+            sessionId: 's1',
+            answers: [
+              { questionId: 'q6', category: 'cat1' }, // 4 skips, 1 answer = 80%
+              { questionId: 'q7', category: 'cat2' },
+              { questionId: 'q8', category: 'cat2' },
+              { questionId: 'q9', category: 'cat2' },
+              { questionId: 'q10', category: 'cat2' } // 1 skip, 4 answers = 20%
+            ]
+          }
+        ]
+      };
+
+      await storage.writeLearningData(tempDir, 'skip-history.json', skipHistory);
+      await storage.writeLearningData(tempDir, 'answer-history.json', answerHistory);
+
+      const result = await analytics.generateAnalytics(tempDir);
+
+      const cat1 = result.categoryPreferences.find(c => c.category === 'cat1');
+      const cat2 = result.categoryPreferences.find(c => c.category === 'cat2');
+
+      expect(cat1.level).toBe('high');
+      expect(cat2.level).toBe('low');
+    });
+
+    test('should sort categories by skip rate descending', async () => {
+      const skipHistory = {
+        sessions: [
+          {
+            sessionId: 's1',
+            skips: [
+              { questionId: 'q1', category: 'low', reason: 'manual' },
+              { questionId: 'q2', category: 'medium', reason: 'manual' },
+              { questionId: 'q3', category: 'medium', reason: 'manual' },
+              { questionId: 'q4', category: 'high', reason: 'manual' },
+              { questionId: 'q5', category: 'high', reason: 'manual' },
+              { questionId: 'q6', category: 'high', reason: 'manual' }
+            ]
+          }
+        ]
+      };
+
+      const answerHistory = {
+        sessions: [
+          {
+            sessionId: 's1',
+            answers: [
+              { questionId: 'q7', category: 'low' },
+              { questionId: 'q8', category: 'low' },
+              { questionId: 'q9', category: 'low' }, // 1 skip, 3 answers = 25%
+              { questionId: 'q10', category: 'medium' }, // 2 skips, 1 answer = 66%
+              { questionId: 'q11', category: 'high' } // 3 skips, 1 answer = 75%
+            ]
+          }
+        ]
+      };
+
+      await storage.writeLearningData(tempDir, 'skip-history.json', skipHistory);
+      await storage.writeLearningData(tempDir, 'answer-history.json', answerHistory);
+
+      const result = await analytics.generateAnalytics(tempDir);
+
+      expect(result.categoryPreferences[0].category).toBe('high');
+      expect(result.categoryPreferences[1].category).toBe('medium');
+      expect(result.categoryPreferences[2].category).toBe('low');
+    });
+  });
+
+  describe('Pattern Distribution', () => {
+    test('should categorize patterns by confidence level', async () => {
+      const patterns = {
+        patterns: [
+          { id: 'p1', confidence: 95, timesApplied: 10 }, // High (90%+)
+          { id: 'p2', confidence: 92, timesApplied: 5 },  // High
+          { id: 'p3', confidence: 85, timesApplied: 3 },  // Medium (75-89%)
+          { id: 'p4', confidence: 80, timesApplied: 2 },  // Medium
+          { id: 'p5', confidence: 65, timesApplied: 1 },  // Low (50-74%)
+          { id: 'p6', confidence: 45, timesApplied: 1 }   // Very Low (<50%)
+        ]
+      };
+
+      await storage.writeLearningData(tempDir, 'patterns.json', patterns);
+
+      const result = await analytics.generateAnalytics(tempDir);
+
+      expect(result.patternDistribution.totalPatterns).toBe(6);
+      expect(result.patternDistribution.distribution.high).toBe(2);
+      expect(result.patternDistribution.distribution.medium).toBe(2);
+      expect(result.patternDistribution.distribution.low).toBe(1);
+      expect(result.patternDistribution.distribution.veryLow).toBe(1);
+    });
+
+    test('should calculate average confidence correctly', async () => {
+      const patterns = {
+        patterns: [
+          { id: 'p1', confidence: 100, timesApplied: 1 },
+          { id: 'p2', confidence: 80, timesApplied: 1 },
+          { id: 'p3', confidence: 60, timesApplied: 1 }
+        ]
+      };
+
+      await storage.writeLearningData(tempDir, 'patterns.json', patterns);
+
+      const result = await analytics.generateAnalytics(tempDir);
+
+      expect(result.patternDistribution.avgConfidence).toBe(80); // (100 + 80 + 60) / 3
+    });
+
+    test('should count patterns at risk (confidence < 50)', async () => {
+      const now = Date.now();
+      const patterns = {
+        patterns: [
+          { id: 'p1', confidence: 48, timesApplied: 1, lastSeen: new Date(now - 10 * 24 * 60 * 60 * 1000).toISOString() }, // 10 days ago
+          { id: 'p2', confidence: 42, timesApplied: 1, lastSeen: new Date(now - 10 * 24 * 60 * 60 * 1000).toISOString() }, // 10 days ago
+          { id: 'p3', confidence: 90, timesApplied: 1, lastSeen: new Date(now - 10 * 24 * 60 * 60 * 1000).toISOString() }  // 10 days ago
+        ]
+      };
+
+      await storage.writeLearningData(tempDir, 'patterns.json', patterns);
+
+      const result = await analytics.generateAnalytics(tempDir);
+
+      expect(result.patternDistribution.atRiskCount).toBe(2); // Only p1 and p2 (< 50 confidence)
+    });
+  });
+
+  describe('Effectiveness Metrics', () => {
+    test('should calculate time saved based on filtered skips', async () => {
+      const skipHistory = {
+        sessions: [
+          {
+            sessionId: 's1',
+            skips: [
+              { questionId: 'q1', reason: 'filtered' },
+              { questionId: 'q2', reason: 'filtered' },
+              { questionId: 'q3', reason: 'filtered' }
+            ]
+          }
+        ]
+      };
+
+      await storage.writeLearningData(tempDir, 'skip-history.json', skipHistory);
+
+      const result = await analytics.generateAnalytics(tempDir);
+
+      // 3 filtered skips * 2.5 minutes average = 7.5, rounds to 8 minutes
+      expect(result.effectiveness.timeSavedMinutes).toBe(8);
+      expect(result.effectiveness.timeSavedHours).toBe("0.1"); // 8/60 = 0.133, formatted to 1 decimal = "0.1"
+      expect(result.effectiveness.questionsFiltered).toBe(3);
+    });
+
+    test('should calculate pattern accuracy', async () => {
+      const patterns = {
+        patterns: [
+          { id: 'p1', confidence: 95, timesApplied: 10, userApproved: true },
+          { id: 'p2', confidence: 85, timesApplied: 5, userApproved: true },
+          { id: 'p3', confidence: 70, timesApplied: 3, userApproved: false }
+        ]
+      };
+
+      await storage.writeLearningData(tempDir, 'patterns.json', patterns);
+
+      const result = await analytics.generateAnalytics(tempDir);
+
+      // Pattern accuracy = (user-approved patterns / total patterns) * 100
+      // 2 approved / 3 total = 66.67%, rounds to 67%
+      expect(result.effectiveness.patternAccuracy).toBe(67);
+    });
+
+    test('should calculate rule application statistics', async () => {
+      const rules = {
+        rules: [
+          { id: 'r1', enabled: true, appliedCount: 15 },
+          { id: 'r2', enabled: true, appliedCount: 10 },
+          { id: 'r3', enabled: true, appliedCount: 5 },
+          { id: 'r4', enabled: false, appliedCount: 100 } // Disabled, but appliedCount is still counted
+        ]
+      };
+
+      await storage.writeLearningData(tempDir, 'learned-rules.json', rules);
+
+      const result = await analytics.generateAnalytics(tempDir);
+
+      expect(result.effectiveness.totalRuleApplications).toBe(130); // All rules counted (15+10+5+100)
+      expect(result.effectiveness.avgApplicationsPerRule).toBe(33); // 130 / 4 rules = 32.5, rounds to 33
+    });
+
+    test('should calculate overall effectiveness score', async () => {
+      const skipHistory = {
+        sessions: [
+          {
+            sessionId: 's1',
+            skips: [
+              { questionId: 'q1', reason: 'filtered' },
+              { questionId: 'q2', reason: 'manual' }
+            ]
+          }
+        ]
+      };
+
+      const patterns = {
+        patterns: [
+          { id: 'p1', confidence: 90, timesApplied: 10, userApproved: true }
+        ]
+      };
+
+      await storage.writeLearningData(tempDir, 'skip-history.json', skipHistory);
+      await storage.writeLearningData(tempDir, 'patterns.json', patterns);
+
+      const result = await analytics.generateAnalytics(tempDir);
+
+      expect(result.effectiveness.overallEffectiveness).toBe(100); // 1/1 patterns approved = 100%
+      expect(result.effectiveness.overallEffectiveness).toBeLessThanOrEqual(100);
+    });
+  });
+
+  describe('Decay Status', () => {
+    test('should categorize pattern health correctly', async () => {
+      const now = Date.now();
+      const patterns = {
+        patterns: [
+          // Healthy: high confidence, recent
+          {
+            id: 'p1',
+            confidence: 90,
+            createdAt: new Date(now - 30 * 24 * 60 * 60 * 1000).toISOString(),
+            lastSeen: new Date(now - 5 * 24 * 60 * 60 * 1000).toISOString()
+          },
+          // Warning: medium confidence or older
+          {
+            id: 'p2',
+            confidence: 65,
+            createdAt: new Date(now - 60 * 24 * 60 * 60 * 1000).toISOString(),
+            lastSeen: new Date(now - 35 * 24 * 60 * 60 * 1000).toISOString()
+          },
+          // Critical: low confidence, old
+          {
+            id: 'p3',
+            confidence: 45,
+            createdAt: new Date(now - 120 * 24 * 60 * 60 * 1000).toISOString(),
+            lastSeen: new Date(now - 100 * 24 * 60 * 60 * 1000).toISOString()
+          }
+        ]
+      };
+
+      await storage.writeLearningData(tempDir, 'patterns.json', patterns);
+
+      const result = await analytics.generateAnalytics(tempDir);
+
+      expect(result.decayStatus.healthy).toBe(1);
+      expect(result.decayStatus.warning).toBe(1);
+      expect(result.decayStatus.critical).toBe(1);
+    });
+
+    test('should count recently renewed patterns', async () => {
+      const now = Date.now();
+      const patterns = {
+        patterns: [
+          {
+            id: 'p1',
+            confidence: 90,
+            createdAt: new Date(now - 60 * 24 * 60 * 60 * 1000).toISOString(),
+            lastSeen: new Date(now - 10 * 24 * 60 * 60 * 1000).toISOString(), // Recent
+            timesRenewed: 2
+          },
+          {
+            id: 'p2',
+            confidence: 85,
+            createdAt: new Date(now - 90 * 24 * 60 * 60 * 1000).toISOString(),
+            lastSeen: new Date(now - 40 * 24 * 60 * 60 * 1000).toISOString(), // Not recent
+            timesRenewed: 1
+          }
+        ]
+      };
+
+      await storage.writeLearningData(tempDir, 'patterns.json', patterns);
+
+      const result = await analytics.generateAnalytics(tempDir);
+
+      expect(result.decayStatus.recentlyRenewed).toBeGreaterThan(0);
+    });
+
+    test('should calculate average pattern age', async () => {
+      const now = Date.now();
+      const patterns = {
+        patterns: [
+          {
+            id: 'p1',
+            confidence: 90,
+            createdAt: new Date(now - 30 * 24 * 60 * 60 * 1000).toISOString() // 30 days old
+          },
+          {
+            id: 'p2',
+            confidence: 85,
+            createdAt: new Date(now - 60 * 24 * 60 * 60 * 1000).toISOString() // 60 days old
+          }
+        ]
+      };
+
+      await storage.writeLearningData(tempDir, 'patterns.json', patterns);
+
+      const result = await analytics.generateAnalytics(tempDir);
+
+      expect(result.decayStatus.avgAge).toBe(45); // (30 + 60) / 2
+    });
+  });
+
+  describe('Edge Cases', () => {
+    test('should handle empty pattern array', async () => {
+      await storage.writeLearningData(tempDir, 'patterns.json', { patterns: [] });
+
+      const result = await analytics.generateAnalytics(tempDir);
+
+      expect(result.patternDistribution.totalPatterns).toBe(0);
+      expect(result.patternDistribution.avgConfidence).toBe(0);
+      expect(result.decayStatus.avgAge).toBe(0);
+    });
+
+    test('should handle sessions without timestamps', async () => {
+      const skipHistory = {
+        sessions: [
+          {
+            sessionId: 's1',
+            // No timestamp
+            skips: [{ questionId: 'q1', reason: 'manual' }]
+          }
+        ]
+      };
+
+      await storage.writeLearningData(tempDir, 'skip-history.json', skipHistory);
+
+      const result = await analytics.generateAnalytics(tempDir);
+
+      expect(result.overview.totalSkips).toBe(1);
+      expect(result.skipTrends.length).toBeGreaterThanOrEqual(0);
+    });
+
+    test('should handle patterns without metadata', async () => {
+      const patterns = {
+        patterns: [
+          {
+            id: 'p1',
+            confidence: 90
+            // No createdAt, lastSeen, timesApplied
+          }
+        ]
+      };
+
+      await storage.writeLearningData(tempDir, 'patterns.json', patterns);
+
+      const result = await analytics.generateAnalytics(tempDir);
+
+      expect(result.patternDistribution.totalPatterns).toBe(1);
+      expect(result.effectiveness.patternAccuracy).toBeGreaterThanOrEqual(0);
+    });
+
+    test('should handle very large datasets', async () => {
+      const sessions = [];
+      for (let i = 0; i < 1000; i++) {
+        sessions.push({
+          sessionId: `s${i}`,
+          timestamp: new Date(Date.now() - i * 24 * 60 * 60 * 1000).toISOString(),
+          skips: [{ questionId: `q${i}`, reason: 'manual' }]
+        });
+      }
+
+      await storage.writeLearningData(tempDir, 'skip-history.json', { sessions });
+
+      const result = await analytics.generateAnalytics(tempDir);
+
+      expect(result.overview.totalSessions).toBe(1000);
+      expect(result.skipTrends.length).toBeLessThanOrEqual(12); // Should still cap at 12 weeks
+    });
+  });
+});