dino-spec 17.4.3 → 17.6.0

package/dist/core/agents/__tests__/learning-loop.test.js

@@ -0,0 +1,663 @@
+/**
+ * Tests for Learning Loop from Corrections (MAC-9)
+ */
+import { existsSync, mkdirSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { formatLearnedPattern, formatLearningStats, formatPatternsForSession, LearningStore, } from '../../memory/learning-store.js';
+import { CorrectionTracker, detectCorrection, formatCluster, formatCorrection, } from '../correction-tracker.js';
+import { calculateConfidenceAdjustment, formatDetectedPattern, formatSuggestionsForSession, PatternDetector, } from '../pattern-detector.js';
+// =============================================================================
+// Test Fixtures
+// =============================================================================
+const testDir = join(process.cwd(), '.test-learning-loop');
+function createTestContext(original, corrected) {
+    return {
+        original,
+        corrected,
+        filePath: 'src/test.ts',
+        focusArea: 'src/',
+    };
+}
+// =============================================================================
+// CorrectionTracker Tests
+// =============================================================================
+describe('CorrectionTracker', () => {
+    let tracker;
+    beforeEach(() => {
+        tracker = new CorrectionTracker();
+    });
+    describe('basic tracking', () => {
+        it('should track a correction', () => {
+            const context = createTestContext('const x = 1;', 'const x = 1');
+            const correction = tracker.track(context, 'explicit');
+            expect(correction.id).toBeDefined();
+            expect(correction.type).toBe('explicit');
+            expect(correction.context.original).toBe('const x = 1;');
+            expect(correction.context.corrected).toBe('const x = 1');
+            expect(correction.keywords.length).toBeGreaterThan(0);
+        });
+        it('should get all corrections', () => {
+            tracker.track(createTestContext('a', 'b'), 'explicit');
+            tracker.track(createTestContext('c', 'd'), 'implicit');
+            const corrections = tracker.getCorrections();
+            expect(corrections).toHaveLength(2);
+        });
+        it('should get correction by ID', () => {
+            const correction = tracker.track(createTestContext('x', 'y'), 'explicit');
+            const retrieved = tracker.getCorrection(correction.id);
+            expect(retrieved).toBeDefined();
+            expect(retrieved?.id).toBe(correction.id);
+        });
+    });
+    describe('correction detection', () => {
+        it('should detect "no, use X" pattern', () => {
+            const result = detectCorrection('no, use single quotes');
+            expect(result.detected).toBe(true);
+            expect(result.pattern).toBe('use single quotes');
+        });
+        it('should detect "actually, X" pattern', () => {
+            const result = detectCorrection('actually, it should be camelCase');
+            expect(result.detected).toBe(true);
+        });
+        it('should detect "change X to Y" pattern', () => {
+            const result = detectCorrection('change tabs to spaces');
+            expect(result.detected).toBe(true);
+            expect(result.pattern).toBe('tabs');
+            expect(result.replacement).toBe('spaces');
+        });
+        it('should return false for non-corrections', () => {
+            const result = detectCorrection('looks good to me');
+            expect(result.detected).toBe(false);
+        });
+    });
+    describe('clustering', () => {
+        it('should cluster similar corrections', () => {
+            // Track multiple similar corrections
+            tracker.track(createTestContext('var x', 'const x'), 'explicit');
+            tracker.track(createTestContext('var y', 'const y'), 'explicit');
+            tracker.track(createTestContext('var z', 'const z'), 'explicit');
+            const clusters = tracker.getClusters();
+            expect(clusters.length).toBeGreaterThan(0);
+        });
+        it('should identify promotable clusters', () => {
+            // Create tracker with low threshold for testing
+            const testTracker = new CorrectionTracker({ automationThreshold: 2 });
+            testTracker.track(createTestContext('semicolon;', 'no semicolon'), 'explicit');
+            testTracker.track(createTestContext('add semicolon;', 'remove semicolon'), 'explicit');
+            const promotable = testTracker.getPromotableClusters();
+            // May or may not be promotable depending on similarity
+            expect(Array.isArray(promotable)).toBe(true);
+        });
+        it('should find similar corrections', () => {
+            tracker.track(createTestContext('use npm', 'use bun'), 'explicit');
+            tracker.track(createTestContext('npm install', 'bun install'), 'explicit');
+            const similar = tracker.findSimilar(createTestContext('npm run', 'bun run'), 0.3);
+            expect(similar.length).toBeGreaterThanOrEqual(0);
+        });
+    });
+    describe('statistics', () => {
+        it('should return correct stats', () => {
+            tracker.track(createTestContext('a', 'b'), 'explicit');
+            tracker.track(createTestContext('c', 'd'), 'implicit');
+            tracker.track(createTestContext('e', 'f'), 'style');
+            const stats = tracker.getStats();
+            expect(stats.totalCorrections).toBe(3);
+            expect(stats.byType.explicit).toBe(1);
+            expect(stats.byType.implicit).toBe(1);
+            expect(stats.byType.style).toBe(1);
+        });
+    });
+    describe('export/import', () => {
+        it('should export and import state', () => {
+            tracker.track(createTestContext('x', 'y'), 'explicit');
+            tracker.track(createTestContext('a', 'b'), 'implicit');
+            const exported = tracker.export();
+            expect(exported.corrections).toHaveLength(2);
+            const newTracker = new CorrectionTracker();
+            newTracker.import(exported);
+            expect(newTracker.getCorrections()).toHaveLength(2);
+        });
+    });
+    describe('formatting', () => {
+        it('should format correction', () => {
+            const correction = tracker.track(createTestContext('old', 'new'), 'explicit');
+            const formatted = formatCorrection(correction);
+            expect(formatted).toContain('Correction');
+            expect(formatted).toContain('old');
+            expect(formatted).toContain('new');
+        });
+        it('should format cluster', () => {
+            tracker.track(createTestContext('x', 'y'), 'explicit');
+            const clusters = tracker.getClusters();
+            if (clusters.length > 0) {
+                const formatted = formatCluster(clusters[0]);
+                expect(formatted).toContain('Cluster');
+                expect(formatted).toContain('occurrences');
+            }
+        });
+    });
+});
+// =============================================================================
+// PatternDetector Tests
+// =============================================================================
+describe('PatternDetector', () => {
+    let detector;
+    let tracker;
+    beforeEach(() => {
+        detector = new PatternDetector();
+        tracker = new CorrectionTracker({ automationThreshold: 2 });
+    });
+    describe('pattern detection', () => {
+        it('should detect pattern from cluster', () => {
+            // Create enough similar corrections
+            tracker.track(createTestContext('use semicolons;', 'no semicolons'), 'explicit');
+            tracker.track(createTestContext('add semicolon;', 'remove semicolon'), 'explicit');
+            tracker.track(createTestContext('with semicolon;', 'without semicolon'), 'explicit');
+            const clusters = tracker.getClusters().filter((c) => c.count >= 2);
+            if (clusters.length > 0) {
+                const pattern = detector.detectFromCluster(clusters[0]);
+                if (pattern) {
+                    expect(pattern.trigger).toBeDefined();
+                    expect(pattern.preference).toBeDefined();
+                    expect(pattern.type).toBeDefined();
+                }
+            }
+        });
+        it('should detect patterns from multiple clusters', () => {
+            tracker.track(createTestContext('double quotes', 'single quotes'), 'explicit');
+            tracker.track(createTestContext('"hello"', "'hello'"), 'explicit');
+            const clusters = tracker.getClusters();
+            const patterns = detector.detectFromClusters(clusters);
+            expect(Array.isArray(patterns)).toBe(true);
+        });
+        it('should classify pattern types correctly', () => {
+            // Create style-related corrections
+            const styleTracker = new CorrectionTracker({ automationThreshold: 1 });
+            styleTracker.track(createTestContext('2 space indent', '4 space indent'), 'style');
+            styleTracker.track(createTestContext('tabs', 'spaces'), 'style');
+            styleTracker.track(createTestContext('tabs indent', 'space indent'), 'style');
+            const clusters = styleTracker.getClusters();
+            if (clusters.length > 0) {
+                const pattern = detector.detectFromCluster(clusters[0]);
+                if (pattern) {
+                    expect(['style', 'preference']).toContain(pattern.type);
+                }
+            }
+        });
+    });
+    describe('suggestions', () => {
+        it('should provide context-aware suggestions', () => {
+            // Add a pattern manually
+            const mockPattern = {
+                id: 'test-1',
+                type: 'style',
+                trigger: 'semicolons',
+                preference: 'no semicolons',
+                confidence: 'high',
+                occurrences: 5,
+                examples: [],
+                keywords: ['semicolon', 'style'],
+                sourceClusterId: 'cluster-1',
+                detectedAt: new Date(),
+            };
+            detector.import([mockPattern]);
+            const suggestions = detector.getSuggestions({
+                focusArea: 'src/',
+                currentTask: 'fix semicolon issues',
+            });
+            expect(suggestions.length).toBeGreaterThan(0);
+            expect(suggestions[0].pattern.id).toBe('test-1');
+        });
+        it('should return empty for no relevant patterns', () => {
+            const suggestions = detector.getSuggestions({
+                focusArea: 'test/',
+                currentTask: 'write tests',
+            });
+            expect(suggestions).toHaveLength(0);
+        });
+    });
+    describe('confidence adjustment', () => {
+        it('should calculate positive adjustment for patterns', () => {
+            const patterns = [
+                {
+                    id: 'p1',
+                    type: 'style',
+                    trigger: 't',
+                    preference: 'p',
+                    confidence: 'high',
+                    occurrences: 5,
+                    examples: [],
+                    keywords: [],
+                    sourceClusterId: 'c1',
+                    detectedAt: new Date(),
+                },
+                {
+                    id: 'p2',
+                    type: 'naming',
+                    trigger: 't2',
+                    preference: 'p2',
+                    confidence: 'medium',
+                    occurrences: 3,
+                    examples: [],
+                    keywords: [],
+                    sourceClusterId: 'c2',
+                    detectedAt: new Date(),
+                },
+            ];
+            const adjustment = calculateConfidenceAdjustment(patterns);
+            expect(adjustment).toBeGreaterThan(0);
+            expect(adjustment).toBeLessThanOrEqual(0.1);
+        });
+        it('should return 0 for no patterns', () => {
+            const adjustment = calculateConfidenceAdjustment([]);
+            expect(adjustment).toBe(0);
+        });
+    });
+    describe('formatting', () => {
+        it('should format detected pattern', () => {
+            const pattern = {
+                id: 'test',
+                type: 'style',
+                trigger: 'semicolons',
+                preference: 'no semicolons',
+                confidence: 'high',
+                occurrences: 5,
+                examples: [],
+                keywords: ['semi', 'style'],
+                sourceClusterId: 'c1',
+                detectedAt: new Date(),
+            };
+            const formatted = formatDetectedPattern(pattern);
+            expect(formatted).toContain('style');
+            expect(formatted).toContain('5 occurrences');
+            expect(formatted).toContain('semicolons');
+        });
+        it('should format suggestions for session', () => {
+            const suggestions = [
+                {
+                    pattern: {
+                        id: 'test',
+                        type: 'style',
+                        trigger: 'tabs',
+                        preference: 'spaces',
+                        confidence: 'high',
+                        occurrences: 3,
+                        examples: [],
+                        keywords: [],
+                        sourceClusterId: 'c1',
+                        detectedAt: new Date(),
+                    },
+                    relevance: 0.8,
+                    reason: 'frequently corrected',
+                },
+            ];
+            const formatted = formatSuggestionsForSession(suggestions);
+            expect(formatted).toContain('Learned Patterns');
+            expect(formatted).toContain('tabs');
+            expect(formatted).toContain('spaces');
+        });
+    });
+});
+// =============================================================================
+// LearningStore Tests
+// =============================================================================
+describe('LearningStore', () => {
+    let store;
+    beforeEach(() => {
+        // Clean up test directory
+        if (existsSync(testDir)) {
+            rmSync(testDir, { recursive: true });
+        }
+        mkdirSync(testDir, { recursive: true });
+        store = new LearningStore(testDir, { autoSave: false });
+    });
+    afterEach(() => {
+        if (existsSync(testDir)) {
+            rmSync(testDir, { recursive: true });
+        }
+    });
+    describe('pattern storage', () => {
+        it('should add and retrieve patterns', () => {
+            const pattern = {
+                id: 'test-pattern',
+                type: 'style',
+                trigger: 'semicolons',
+                preference: 'no semicolons',
+                confidence: 'high',
+                occurrences: 5,
+                examples: [{ original: 'x;', corrected: 'x' }],
+                keywords: ['semicolon'],
+                sourceClusterId: 'cluster-1',
+                detectedAt: new Date(),
+            };
+            const learned = store.addPattern(pattern);
+            expect(learned.id).toBe('test-pattern');
+            expect(learned.active).toBe(true);
+            expect(learned.applyCount).toBe(0);
+            const retrieved = store.getPattern('test-pattern');
+            expect(retrieved).toBeDefined();
+            expect(retrieved?.trigger).toBe('semicolons');
+        });
+        it('should get active patterns only', () => {
+            const pattern1 = {
+                id: 'p1',
+                type: 'style',
+                trigger: 't1',
+                preference: 'p1',
+                confidence: 'high',
+                occurrences: 3,
+                examples: [],
+                keywords: [],
+                sourceClusterId: 'c1',
+                detectedAt: new Date(),
+            };
+            const pattern2 = {
+                id: 'p2',
+                type: 'naming',
+                trigger: 't2',
+                preference: 'p2',
+                confidence: 'medium',
+                occurrences: 2,
+                examples: [],
+                keywords: [],
+                sourceClusterId: 'c2',
+                detectedAt: new Date(),
+            };
+            store.addPattern(pattern1);
+            store.addPattern(pattern2);
+            store.deactivatePattern('p2');
+            const active = store.getActivePatterns();
+            expect(active).toHaveLength(1);
+            expect(active[0].id).toBe('p1');
+        });
+        it('should record pattern application', () => {
+            const pattern = {
+                id: 'apply-test',
+                type: 'tool',
+                trigger: 'npm',
+                preference: 'bun',
+                confidence: 'high',
+                occurrences: 5,
+                examples: [],
+                keywords: [],
+                sourceClusterId: 'c1',
+                detectedAt: new Date(),
+            };
+            store.addPattern(pattern);
+            store.recordApplication('apply-test');
+            store.recordApplication('apply-test');
+            const retrieved = store.getPattern('apply-test');
+            expect(retrieved?.applyCount).toBe(2);
+            expect(retrieved?.lastApplied).toBeDefined();
+        });
+    });
+    describe('persistence', () => {
+        it('should save and load state', () => {
+            const pattern = {
+                id: 'persist-test',
+                type: 'workflow',
+                trigger: 'before commit',
+                preference: 'run tests',
+                confidence: 'high',
+                occurrences: 4,
+                examples: [],
+                keywords: ['test', 'commit'],
+                sourceClusterId: 'c1',
+                detectedAt: new Date(),
+            };
+            store.addPattern(pattern);
+            store.save();
+            // Create new store and load
+            const newStore = new LearningStore(testDir);
+            newStore.load();
+            const retrieved = newStore.getPattern('persist-test');
+            expect(retrieved).toBeDefined();
+            expect(retrieved?.trigger).toBe('before commit');
+        });
+    });
+    describe('suggestions', () => {
+        it('should provide context-relevant suggestions', () => {
+            const pattern = {
+                id: 'suggest-test',
+                type: 'style',
+                trigger: 'formatting',
+                preference: 'use prettier',
+                confidence: 'high',
+                occurrences: 5,
+                examples: [],
+                keywords: ['format', 'prettier', 'style'],
+                sourceClusterId: 'c1',
+                detectedAt: new Date(),
+            };
+            store.addPattern(pattern);
+            const suggestions = store.getSuggestions({
+                focusArea: 'src/',
+                currentTask: 'fix formatting issues',
+            });
+            expect(suggestions.length).toBeGreaterThan(0);
+        });
+    });
+    describe('confidence boost', () => {
+        it('should calculate confidence boost from patterns', () => {
+            const patterns = [
+                {
+                    id: 'boost1',
+                    type: 'style',
+                    trigger: 't1',
+                    preference: 'p1',
+                    confidence: 'high',
+                    occurrences: 5,
+                    examples: [],
+                    keywords: ['test', 'style'],
+                    sourceClusterId: 'c1',
+                    detectedAt: new Date(),
+                },
+                {
+                    id: 'boost2',
+                    type: 'naming',
+                    trigger: 't2',
+                    preference: 'p2',
+                    confidence: 'medium',
+                    occurrences: 3,
+                    examples: [],
+                    keywords: ['name', 'convention'],
+                    sourceClusterId: 'c2',
+                    detectedAt: new Date(),
+                },
+            ];
+            for (const p of patterns) {
+                store.addPattern(p);
+            }
+            const boost = store.calculateConfidenceBoost({
+                focusArea: 'src/',
+                currentTask: 'test style improvements',
+            });
+            expect(boost).toBeGreaterThanOrEqual(0);
+            expect(boost).toBeLessThanOrEqual(0.1);
+        });
+    });
+    describe('statistics', () => {
+        it('should return correct stats', () => {
+            const patterns = [
+                {
+                    id: 's1',
+                    type: 'style',
+                    trigger: 't1',
+                    preference: 'p1',
+                    confidence: 'high',
+                    occurrences: 5,
+                    examples: [],
+                    keywords: [],
+                    sourceClusterId: 'c1',
+                    detectedAt: new Date(),
+                },
+                {
+                    id: 's2',
+                    type: 'style',
+                    trigger: 't2',
+                    preference: 'p2',
+                    confidence: 'medium',
+                    occurrences: 3,
+                    examples: [],
+                    keywords: [],
+                    sourceClusterId: 'c2',
+                    detectedAt: new Date(),
+                },
+                {
+                    id: 'n1',
+                    type: 'naming',
+                    trigger: 't3',
+                    preference: 'p3',
+                    confidence: 'low',
+                    occurrences: 2,
+                    examples: [],
+                    keywords: [],
+                    sourceClusterId: 'c3',
+                    detectedAt: new Date(),
+                },
+            ];
+            for (const p of patterns) {
+                store.addPattern(p);
+            }
+            const stats = store.getStats();
+            expect(stats.totalPatterns).toBe(3);
+            expect(stats.activePatterns).toBe(3);
+            expect(stats.patternsByType.style).toBe(2);
+            expect(stats.patternsByType.naming).toBe(1);
+        });
+    });
+    describe('formatting', () => {
+        it('should format learned pattern', () => {
+            const pattern = {
+                id: 'fmt-test',
+                type: 'tool',
+                trigger: 'npm',
+                preference: 'bun',
+                confidence: 'high',
+                occurrences: 5,
+                examples: [],
+                keywords: [],
+                sourceClusterId: 'c1',
+                detectedAt: new Date(),
+            };
+            const learned = store.addPattern(pattern);
+            const formatted = formatLearnedPattern(learned);
+            expect(formatted).toContain('tool');
+            expect(formatted).toContain('npm');
+            expect(formatted).toContain('bun');
+        });
+        it('should format patterns for session', () => {
+            const patterns = [
+                {
+                    id: 'sess1',
+                    type: 'style',
+                    trigger: 'tabs',
+                    preference: 'spaces',
+                    confidence: 'high',
+                    occurrences: 5,
+                    examples: [],
+                    keywords: [],
+                    sourceClusterId: 'c1',
+                    detectedAt: new Date(),
+                },
+            ];
+            for (const p of patterns) {
+                store.addPattern(p);
+            }
+            const formatted = formatPatternsForSession(store.getActivePatterns());
+            expect(formatted).toContain('Learned Preferences');
+            expect(formatted).toContain('tabs');
+            expect(formatted).toContain('spaces');
+        });
+        it('should format stats', () => {
+            const pattern = {
+                id: 'stat-fmt',
+                type: 'workflow',
+                trigger: 't',
+                preference: 'p',
+                confidence: 'high',
+                occurrences: 3,
+                examples: [],
+                keywords: [],
+                sourceClusterId: 'c1',
+                detectedAt: new Date(),
+            };
+            store.addPattern(pattern);
+            const formatted = formatLearningStats(store.getStats());
+            expect(formatted).toContain('Learning Store Stats');
+            expect(formatted).toContain('Patterns');
+        });
+    });
+});
+// =============================================================================
+// Integration Tests
+// =============================================================================
+describe('Learning Loop Integration', () => {
+    let tracker;
+    let detector;
+    let store;
+    beforeEach(() => {
+        if (existsSync(testDir)) {
+            rmSync(testDir, { recursive: true });
+        }
+        mkdirSync(testDir, { recursive: true });
+        tracker = new CorrectionTracker({ automationThreshold: 2 });
+        detector = new PatternDetector({ minClusterSize: 2 });
+        store = new LearningStore(testDir, { autoSave: false });
+    });
+    afterEach(() => {
+        if (existsSync(testDir)) {
+            rmSync(testDir, { recursive: true });
+        }
+    });
+    it('should complete full learning loop', () => {
+        // Step 1: Track corrections
+        tracker.track(createTestContext('use var', 'use const'), 'explicit');
+        tracker.track(createTestContext('var x', 'const x'), 'explicit');
+        tracker.track(createTestContext('declare var', 'declare const'), 'explicit');
+        // Step 2: Get promotable clusters
+        const clusters = tracker.getClusters();
+        expect(clusters.length).toBeGreaterThan(0);
+        // Step 3: Detect patterns from clusters
+        const patterns = detector.detectFromClusters(clusters);
+        // Step 4: Store patterns
+        for (const pattern of patterns) {
+            store.addPattern(pattern);
+        }
+        // Step 5: Verify patterns are stored
+        const storedPatterns = store.getAllPatterns();
+        expect(storedPatterns.length).toBeGreaterThanOrEqual(0);
+        // Step 6: Get suggestions for context
+        const suggestions = store.getSuggestions({
+            focusArea: 'src/',
+            currentTask: 'refactor variables',
+        });
+        // Suggestions may or may not be returned depending on keyword matching
+        expect(Array.isArray(suggestions)).toBe(true);
+    });
+    it('should integrate with confidence scoring', () => {
+        // Add some patterns
+        const pattern = {
+            id: 'conf-int',
+            type: 'style',
+            trigger: 'formatting',
+            preference: 'prettier',
+            confidence: 'high',
+            occurrences: 5,
+            examples: [],
+            keywords: ['format', 'style'],
+            sourceClusterId: 'c1',
+            detectedAt: new Date(),
+        };
+        store.addPattern(pattern);
+        // Calculate confidence boost
+        const boost = store.calculateConfidenceBoost({
+            focusArea: 'src/',
+            currentTask: 'format code',
+        });
+        expect(boost).toBeGreaterThanOrEqual(0);
+        expect(boost).toBeLessThanOrEqual(0.1);
+    });
+});
+//# sourceMappingURL=learning-loop.test.js.map