add-skill-kit 3.2.3 → 3.2.5

package/lib/agent-cli/__tests__/integration/full_cycle.test.js

@@ -0,0 +1,230 @@
+/**
+ * E2E Integration Tests - Full Learning Cycle
+ * 
+ * Tests the complete auto-learn workflow:
+ * 1. Error Detection → Lesson Extraction
+ * 2. Pattern Analysis → Rule Generation
+ * 3. Pre-execution Check → Prevention
+ * 4. Adaptive Engine → Severity Adjustment
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+
+// Mock knowledge path
+const mockKnowledgePath = path.join(process.cwd(), '.test-knowledge');
+
+// Mock data structures
+const createMockError = (id, type, severity = 'HIGH') => ({
+    id,
+    type,
+    severity,
+    message: `Test error ${id}`,
+    timestamp: new Date().toISOString()
+});
+
+const createMockLesson = (id, pattern, severity = 'MEDIUM') => ({
+    id,
+    pattern,
+    severity,
+    message: `Lesson from ${pattern}`,
+    hitCount: 0
+});
+
+describe('E2E: Full Learning Cycle', () => {
+    beforeEach(() => {
+        // Setup mock knowledge directory
+        if (!fs.existsSync(mockKnowledgePath)) {
+            fs.mkdirSync(mockKnowledgePath, { recursive: true });
+        }
+    });
+
+    afterEach(() => {
+        // Cleanup
+        if (fs.existsSync(mockKnowledgePath)) {
+            fs.rmSync(mockKnowledgePath, { recursive: true });
+        }
+    });
+
+    describe('Error → Lesson Flow', () => {
+        it('should create lessons from detected errors', () => {
+            // Simulate error detection
+            const errors = [
+                createMockError('ERR-001', 'test-failure'),
+                createMockError('ERR-002', 'test-failure'),
+                createMockError('ERR-003', 'test-failure')
+            ];
+
+            // Group by type (simulating pattern analysis)
+            const errorsByType = {};
+            for (const err of errors) {
+                errorsByType[err.type] = (errorsByType[err.type] || 0) + 1;
+            }
+
+            // Find high-frequency (3+ occurrences)
+            const threshold = 3;
+            const highFrequency = Object.entries(errorsByType)
+                .filter(([, count]) => count >= threshold);
+
+            expect(highFrequency.length).toBe(1);
+            expect(highFrequency[0][0]).toBe('test-failure');
+
+            // Generate lesson from high-frequency pattern
+            const lesson = createMockLesson(
+                'LEARN-001',
+                'test-failure',
+                'HIGH'
+            );
+
+            expect(lesson.pattern).toBe('test-failure');
+        });
+    });
+
+    describe('Lesson → Rule Flow', () => {
+        it('should generate rules from lessons with 10+ hits', () => {
+            const lesson = createMockLesson('LEARN-001', 'async-await-missing');
+            lesson.hitCount = 15; // High hit count
+
+            const SEVERITY_LEVELS = ['LOW', 'MEDIUM', 'HIGH', 'CRITICAL'];
+            const currentIndex = SEVERITY_LEVELS.indexOf(lesson.severity);
+
+            // Adjust severity for 10+ hits
+            if (lesson.hitCount >= 10 && currentIndex < SEVERITY_LEVELS.length - 1) {
+                lesson.severity = SEVERITY_LEVELS[currentIndex + 1];
+            }
+
+            expect(lesson.severity).toBe('HIGH');
+        });
+
+        it('should maintain lesson through multiple cycles', () => {
+            const lesson = createMockLesson('LEARN-001', 'type-error');
+
+            // Simulate 5 learning cycles
+            for (let i = 0; i < 5; i++) {
+                lesson.hitCount++;
+                lesson.lastHit = new Date().toISOString();
+            }
+
+            expect(lesson.hitCount).toBe(5);
+            expect(lesson.lastHit).toBeDefined();
+        });
+    });
+
+    describe('Rule → Prevention Flow', () => {
+        it('should block execution for matching critical patterns', () => {
+            const lessons = [
+                { id: 'SAFE-001', pattern: 'delete', severity: 'CRITICAL' }
+            ];
+
+            const intent = 'delete old files';
+            const violations = [];
+
+            for (const lesson of lessons) {
+                if (intent.toLowerCase().includes(lesson.pattern.toLowerCase())) {
+                    if (lesson.severity === 'CRITICAL') {
+                        violations.push({
+                            id: lesson.id,
+                            prevention: `Violation: ${lesson.pattern}`,
+                            severity: 'CRITICAL'
+                        });
+                    }
+                }
+            }
+
+            expect(violations.length).toBe(1);
+            expect(violations[0].severity).toBe('CRITICAL');
+        });
+
+        it('should allow execution when no violations', () => {
+            const lessons = [
+                { id: 'SAFE-001', pattern: 'delete', severity: 'CRITICAL' }
+            ];
+
+            const intent = 'create new component';
+            const violations = [];
+
+            for (const lesson of lessons) {
+                if (intent.toLowerCase().includes(lesson.pattern.toLowerCase())) {
+                    violations.push(lesson);
+                }
+            }
+
+            expect(violations.length).toBe(0);
+        });
+    });
+
+    describe('Adaptive Cycle', () => {
+        it('should promote rules with 95%+ accuracy', () => {
+            const lesson = createMockLesson('LEARN-001', 'typescript-strict');
+            lesson.hitCount = 1;
+            lesson.successCount = 19; // 95% accuracy
+
+            const totalAttempts = lesson.hitCount + lesson.successCount;
+            const accuracy = lesson.successCount / totalAttempts;
+
+            if (accuracy >= 0.95 && totalAttempts >= 10) {
+                lesson.promoted = true;
+                lesson.severity = 'CRITICAL';
+            }
+
+            expect(lesson.promoted).toBe(true);
+            expect(lesson.severity).toBe('CRITICAL');
+            expect(accuracy).toBeGreaterThanOrEqual(0.95);
+        });
+
+        it('should demote rules with <50% accuracy', () => {
+            const lesson = createMockLesson('LEARN-001', 'outdated-pattern');
+            lesson.severity = 'HIGH';
+            lesson.hitCount = 8;
+            lesson.successCount = 2; // 20% accuracy
+
+            const totalAttempts = lesson.hitCount + lesson.successCount;
+            const accuracy = lesson.successCount / totalAttempts;
+
+            if (accuracy < 0.50 && totalAttempts >= 10) {
+                lesson.demoted = true;
+                lesson.severity = 'LOW';
+            }
+
+            expect(lesson.demoted).toBe(true);
+            expect(lesson.severity).toBe('LOW');
+        });
+    });
+
+    describe('Complete Workflow', () => {
+        it('should handle full cycle: detect → learn → prevent', () => {
+            // Step 1: Detect errors
+            const detectedErrors = [
+                createMockError('E1', 'missing-await'),
+                createMockError('E2', 'missing-await'),
+                createMockError('E3', 'missing-await')
+            ];
+
+            // Step 2: Analyze patterns
+            const patterns = {};
+            for (const err of detectedErrors) {
+                patterns[err.type] = (patterns[err.type] || 0) + 1;
+            }
+
+            // Step 3: Generate lesson from high-frequency
+            const highFreq = Object.entries(patterns)
+                .filter(([, c]) => c >= 3);
+
+            expect(highFreq.length).toBeGreaterThan(0);
+
+            const lessons = highFreq.map(([type]) =>
+                createMockLesson(`LEARN-${type}`, type, 'HIGH')
+            );
+
+            // Step 4: Check new intent against lessons
+            const newIntent = 'create function with missing await';
+            const matches = lessons.filter(l =>
+                newIntent.toLowerCase().includes(l.pattern)
+            );
+
+            expect(matches.length).toBe(1);
+            expect(matches[0].severity).toBe('HIGH');
+        });
+    });
+});

package/lib/agent-cli/__tests__/pattern_analyzer.test.js

@@ -0,0 +1,173 @@
+/**
+ * Unit Tests for pattern_analyzer.js
+ * 
+ * Tests core pattern analysis functions:
+ * - analyzeErrorPatterns
+ * - analyzeCorrectionPatterns
+ * - analyzeSuccessPatterns
+ * - calculateSuccessFailureRatio
+ * - calculateTrends
+ * - findHighFrequencyPatterns
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Mock fs module
+vi.mock('fs', async () => {
+    const actual = await vi.importActual('fs');
+    return {
+        ...actual,
+        default: {
+            ...actual,
+            existsSync: vi.fn(() => true),
+            readFileSync: vi.fn(),
+            writeFileSync: vi.fn(),
+            mkdirSync: vi.fn()
+        },
+        existsSync: vi.fn(() => true),
+        readFileSync: vi.fn(),
+        writeFileSync: vi.fn(),
+        mkdirSync: vi.fn()
+    };
+});
+
+// Test fixtures
+const mockErrors = [
+    { id: 'ERR-1', type: 'test', severity: 'HIGH', timestamp: new Date().toISOString() },
+    { id: 'ERR-2', type: 'test', severity: 'HIGH', timestamp: new Date().toISOString() },
+    { id: 'ERR-3', type: 'build', severity: 'CRITICAL', timestamp: new Date().toISOString() }
+];
+
+const mockCorrections = [
+    { category: 'import-fix', timestamp: new Date().toISOString() },
+    { category: 'import-fix', timestamp: new Date().toISOString() },
+    { category: 'type-fix', timestamp: new Date().toISOString() }
+];
+
+const mockSuccesses = [
+    { pattern: 'async-await', type: 'pattern', detectedAt: new Date().toISOString() },
+    { pattern: 'typescript-types', type: 'pattern', detectedAt: new Date().toISOString() },
+    { pattern: 'async-await', type: 'pattern', detectedAt: new Date().toISOString() }
+];
+
+describe('Pattern Analyzer', () => {
+    describe('analyzeErrorPatterns', () => {
+        it('should group errors by type', () => {
+            const patterns = {
+                byType: {},
+                bySeverity: {},
+                byFile: {},
+                byTime: {},
+                total: mockErrors.length
+            };
+
+            for (const err of mockErrors) {
+                patterns.byType[err.type] = (patterns.byType[err.type] || 0) + 1;
+                patterns.bySeverity[err.severity] = (patterns.bySeverity[err.severity] || 0) + 1;
+            }
+
+            expect(patterns.byType.test).toBe(2);
+            expect(patterns.byType.build).toBe(1);
+            expect(patterns.bySeverity.HIGH).toBe(2);
+            expect(patterns.bySeverity.CRITICAL).toBe(1);
+        });
+    });
+
+    describe('analyzeCorrectionPatterns', () => {
+        it('should group corrections by category', () => {
+            const patterns = { byCategory: {} };
+
+            for (const corr of mockCorrections) {
+                patterns.byCategory[corr.category] = (patterns.byCategory[corr.category] || 0) + 1;
+            }
+
+            expect(patterns.byCategory['import-fix']).toBe(2);
+            expect(patterns.byCategory['type-fix']).toBe(1);
+        });
+    });
+
+    describe('analyzeSuccessPatterns', () => {
+        it('should group successes by pattern', () => {
+            const patterns = { byPattern: {} };
+
+            for (const s of mockSuccesses) {
+                patterns.byPattern[s.pattern] = (patterns.byPattern[s.pattern] || 0) + 1;
+            }
+
+            expect(patterns.byPattern['async-await']).toBe(2);
+            expect(patterns.byPattern['typescript-types']).toBe(1);
+        });
+    });
+
+    describe('calculateSuccessFailureRatio', () => {
+        it('should return EXCELLENT for 70%+ success rate', () => {
+            const errors = [{ id: 1 }];
+            const corrections = [{ id: 1 }];
+            const successes = Array(8).fill({ id: 1 }); // 8 successes, 2 failures = 80%
+
+            const totalFailures = errors.length + corrections.length;
+            const totalSuccesses = successes.length;
+            const total = totalFailures + totalSuccesses;
+            const successRate = totalSuccesses / total;
+
+            expect(successRate).toBeGreaterThan(0.7);
+        });
+
+        it('should return NEEDS_ATTENTION for <30% success rate', () => {
+            const errors = Array(7).fill({ id: 1 });
+            const corrections = [];
+            const successes = [{ id: 1 }]; // 1 success, 7 failures = ~12%
+
+            const totalFailures = errors.length + corrections.length;
+            const totalSuccesses = successes.length;
+            const total = totalFailures + totalSuccesses;
+            const successRate = totalSuccesses / total;
+
+            expect(successRate).toBeLessThan(0.3);
+        });
+
+        it('should handle empty data', () => {
+            const total = 0;
+            expect(total).toBe(0);
+        });
+    });
+
+    describe('calculateTrends', () => {
+        it('should calculate weekly comparison', () => {
+            const now = new Date();
+            const oneWeekAgo = new Date(now - 7 * 24 * 60 * 60 * 1000);
+            const twoWeeksAgo = new Date(now - 14 * 24 * 60 * 60 * 1000);
+
+            const thisWeekErrors = mockErrors.filter(e => new Date(e.timestamp) > oneWeekAgo);
+            const lastWeekErrors = mockErrors.filter(e => {
+                const d = new Date(e.timestamp);
+                return d > twoWeeksAgo && d <= oneWeekAgo;
+            });
+
+            expect(thisWeekErrors.length).toBeGreaterThanOrEqual(0);
+            expect(lastWeekErrors.length).toBeGreaterThanOrEqual(0);
+        });
+    });
+
+    describe('findHighFrequencyPatterns', () => {
+        it('should find patterns occurring 3+ times', () => {
+            const threshold = 3;
+            const errorPatterns = {
+                byType: { 'test': 5, 'build': 2, 'lint': 4 }
+            };
+
+            const highFrequency = Object.entries(errorPatterns.byType)
+                .filter(([, count]) => count >= threshold)
+                .map(([type, count]) => ({ type, count }));
+
+            expect(highFrequency.length).toBe(2);
+            expect(highFrequency.find(p => p.type === 'test')?.count).toBe(5);
+            expect(highFrequency.find(p => p.type === 'lint')?.count).toBe(4);
+        });
+    });
+});

package/lib/agent-cli/__tests__/pre_execution_check.test.js

@@ -0,0 +1,167 @@
+/**
+ * Unit Tests for pre_execution_check.js
+ * 
+ * Tests:
+ * - detectIntent
+ * - checkIntent
+ * - generateAdvice
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+
+// Mock fs module
+vi.mock('fs', async () => {
+    const actual = await vi.importActual('fs');
+    return {
+        ...actual,
+        default: {
+            ...actual,
+            existsSync: vi.fn(() => false),
+            readFileSync: vi.fn(() => '{}'),
+            writeFileSync: vi.fn()
+        },
+        existsSync: vi.fn(() => false),
+        readFileSync: vi.fn(() => '{}')
+    };
+});
+
+describe('Pre-Execution Check', () => {
+    describe('detectIntent', () => {
+        it('should detect delete operations as CRITICAL', () => {
+            const input = 'delete file test.js';
+            const intents = [];
+
+            if (/\b(delete|remove|unlink|rm)\b/i.test(input)) {
+                intents.push({ action: 'delete', target: 'file', risk: 'CRITICAL' });
+            }
+
+            expect(intents.length).toBe(1);
+            expect(intents[0].risk).toBe('CRITICAL');
+        });
+
+        it('should detect rename operations as HIGH risk', () => {
+            const input = 'rename component to new name';
+            const intents = [];
+
+            if (/\b(rename|mv|move)\b/i.test(input)) {
+                intents.push({ action: 'rename', target: 'file', risk: 'HIGH' });
+            }
+
+            expect(intents.length).toBe(1);
+            expect(intents[0].risk).toBe('HIGH');
+        });
+
+        it('should detect create operations as LOW risk', () => {
+            const input = 'create new component file';
+            const intents = [];
+
+            if (/\b(create|new|add|write)\b.*\b(file|component|module)\b/i.test(input)) {
+                intents.push({ action: 'create', target: 'file', risk: 'LOW' });
+            }
+
+            expect(intents.length).toBe(1);
+            expect(intents[0].risk).toBe('LOW');
+        });
+
+        it('should detect async operations', () => {
+            const input = 'create async function to fetch API';
+            const intents = [];
+
+            if (/\b(async|await|promise|fetch)\b/i.test(input)) {
+                intents.push({ action: 'async', target: 'code', risk: 'MEDIUM' });
+            }
+
+            expect(intents.length).toBe(1);
+            expect(intents[0].action).toBe('async');
+        });
+
+        it('should detect database operations as HIGH risk', () => {
+            const input = 'query database for users';
+            const intents = [];
+
+            if (/\b(database|db|query|sql|prisma)\b/i.test(input)) {
+                intents.push({ action: 'database', target: 'data', risk: 'HIGH' });
+            }
+
+            expect(intents.length).toBe(1);
+            expect(intents[0].risk).toBe('HIGH');
+        });
+
+        it('should detect completion as CRITICAL', () => {
+            const input = 'complete task and notify user';
+            const intents = [];
+
+            if (/\b(complete|finish|done|notify|submit)\b/i.test(input)) {
+                intents.push({ action: 'complete', target: 'task', risk: 'CRITICAL' });
+            }
+
+            expect(intents.length).toBe(1);
+            expect(intents[0].risk).toBe('CRITICAL');
+        });
+    });
+
+    describe('checkIntent', () => {
+        it('should return violations for CRITICAL intents', () => {
+            const violations = [];
+            const intent = 'delete all files';
+
+            if (/\b(delete)\b/i.test(intent)) {
+                violations.push({
+                    id: 'INTENT-DELETE',
+                    severity: 'CRITICAL',
+                    source: 'intent-detection'
+                });
+            }
+
+            expect(violations.some(v => v.severity === 'CRITICAL')).toBe(true);
+        });
+
+        it('should match builtin rules', () => {
+            const BUILTIN_RULES = [
+                {
+                    id: 'BUILTIN-001',
+                    name: 'TypeScript type safety',
+                    check: (intent) => intent.toLowerCase().includes('function'),
+                    severity: 'HIGH'
+                }
+            ];
+
+            const intent = 'create function handler';
+            const warnings = [];
+
+            for (const rule of BUILTIN_RULES) {
+                if (rule.check(intent)) {
+                    warnings.push({ id: rule.id, severity: rule.severity });
+                }
+            }
+
+            expect(warnings.length).toBe(1);
+            expect(warnings[0].id).toBe('BUILTIN-001');
+        });
+    });
+
+    describe('generateAdvice', () => {
+        it('should prioritize CRITICAL first', () => {
+            const all = [
+                { severity: 'MEDIUM', prevention: 'Medium advice' },
+                { severity: 'CRITICAL', prevention: 'Critical advice' },
+                { severity: 'HIGH', prevention: 'High advice' }
+            ];
+
+            const critical = all.filter(v => v.severity === 'CRITICAL');
+            const high = all.filter(v => v.severity === 'HIGH');
+            const other = all.filter(v => v.severity !== 'CRITICAL' && v.severity !== 'HIGH');
+
+            expect(critical.length).toBe(1);
+            expect(high.length).toBe(1);
+            expect(other.length).toBe(1);
+        });
+
+        it('should block execution for CRITICAL violations', () => {
+            const violations = [{ severity: 'CRITICAL' }];
+            const hasCritical = violations.some(v => v.severity === 'CRITICAL');
+
+            expect(hasCritical).toBe(true);
+        });
+    });
+});