add-skill-kit 3.2.4 → 3.2.6

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);
+        });
+    });
+});

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

@@ -0,0 +1,191 @@
+/**
+ * Unit Tests for skill_injector.js
+ * 
+ * Tests:
+ * - analyzeLessons
+ * - getSkillCandidates
+ * - generateSkillContent
+ * - generateSkills
+ */
+
+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(),
+            mkdirSync: vi.fn(),
+            readdirSync: vi.fn(() => [])
+        },
+        existsSync: vi.fn(() => false),
+        readFileSync: vi.fn(() => '{}'),
+        writeFileSync: vi.fn(),
+        mkdirSync: vi.fn(),
+        readdirSync: vi.fn(() => [])
+    };
+});
+
+// Category config constant
+const CATEGORY_CONFIG = {
+    'SAFE': { name: 'safety-rules', description: 'Auto-learned safety rules' },
+    'CODE': { name: 'code-patterns', description: 'Auto-learned code patterns' },
+    'FLOW': { name: 'workflow-rules', description: 'Auto-learned workflow rules' },
+    'INT': { name: 'integration-rules', description: 'Auto-learned integration rules' },
+    'PERF': { name: 'performance-rules', description: 'Auto-learned performance rules' },
+    'TEST': { name: 'testing-rules', description: 'Auto-learned testing rules' },
+    'LEARN': { name: 'general-lessons', description: 'General lessons learned' }
+};
+
+describe('Skill Injector', () => {
+    describe('analyzeLessons', () => {
+        it('should group lessons by category', () => {
+            const lessons = [
+                { id: 'SAFE-001', pattern: 'delete check' },
+                { id: 'SAFE-002', pattern: 'file backup' },
+                { id: 'CODE-001', pattern: 'typescript' },
+                { id: 'TEST-001', pattern: 'unit test' }
+            ];
+
+            const categories = {};
+
+            for (const lesson of lessons) {
+                const category = lesson.id?.split('-')[0] || 'LEARN';
+                if (!categories[category]) {
+                    categories[category] = [];
+                }
+                categories[category].push(lesson);
+            }
+
+            expect(categories['SAFE'].length).toBe(2);
+            expect(categories['CODE'].length).toBe(1);
+            expect(categories['TEST'].length).toBe(1);
+        });
+
+        it('should default to LEARN for unknown categories', () => {
+            const lessons = [{ id: 'UNKNOWN-001', pattern: 'something' }];
+
+            const categories = {};
+            for (const lesson of lessons) {
+                const category = lesson.id?.split('-')[0] || 'LEARN';
+                if (!categories[category]) {
+                    categories[category] = [];
+                }
+                categories[category].push(lesson);
+            }
+
+            expect(categories['UNKNOWN'].length).toBe(1);
+        });
+    });
+
+    describe('getSkillCandidates', () => {
+        it('should require minimum 3 lessons for skill generation', () => {
+            const categories = {
+                'SAFE': [{ id: 1 }, { id: 2 }, { id: 3 }], // 3 - eligible
+                'CODE': [{ id: 1 }, { id: 2 }], // 2 - not eligible
+                'TEST': [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }] // 4 - eligible
+            };
+
+            const candidates = [];
+            for (const [category, lessons] of Object.entries(categories)) {
+                if (lessons.length >= 3) {
+                    candidates.push({
+                        category,
+                        count: lessons.length,
+                        config: CATEGORY_CONFIG[category] || {
+                            name: `${category.toLowerCase()}-rules`,
+                            description: `Auto-learned ${category.toLowerCase()} rules`
+                        }
+                    });
+                }
+            }
+
+            expect(candidates.length).toBe(2);
+            expect(candidates.find(c => c.category === 'SAFE')).toBeDefined();
+            expect(candidates.find(c => c.category === 'TEST')).toBeDefined();
+            expect(candidates.find(c => c.category === 'CODE')).toBeUndefined();
+        });
+    });
+
+    describe('generateSkillContent', () => {
+        it('should generate valid SKILL.md content', () => {
+            const category = 'SAFE';
+            const lessons = [
+                { id: 'SAFE-001', pattern: 'delete check', severity: 'CRITICAL', message: 'Check before delete' },
+                { id: 'SAFE-002', pattern: 'backup first', severity: 'HIGH', message: 'Backup before modify' }
+            ];
+            const config = CATEGORY_CONFIG['SAFE'];
+
+            // Generate YAML frontmatter
+            const content = `---
+name: ${config.name}
+description: ${config.description}
+---
+
+# ${config.name}
+`;
+
+            expect(content).toContain('name: safety-rules');
+            expect(content).toContain('Auto-learned safety rules');
+        });
+
+        it('should include severity icons', () => {
+            const severityIcons = {
+                'CRITICAL': '🔴',
+                'HIGH': '🟠',
+                'MEDIUM': '🟡',
+                'LOW': '🟢'
+            };
+
+            expect(severityIcons['CRITICAL']).toBe('🔴');
+            expect(severityIcons['HIGH']).toBe('🟠');
+        });
+    });
+
+    describe('generateSkills', () => {
+        it('should generate skills for eligible categories', () => {
+            const candidates = [
+                { category: 'SAFE', count: 5, config: CATEGORY_CONFIG['SAFE'] },
+                { category: 'CODE', count: 3, config: CATEGORY_CONFIG['CODE'] }
+            ];
+
+            const generated = candidates.map(c => ({
+                category: c.category,
+                name: c.config.name,
+                lessonCount: c.count
+            }));
+
+            expect(generated.length).toBe(2);
+            expect(generated[0].name).toBe('safety-rules');
+            expect(generated[1].name).toBe('code-patterns');
+        });
+
+        it('should support dry-run mode', () => {
+            const dryRun = true;
+            const writeOperations = [];
+
+            if (!dryRun) {
+                writeOperations.push('write');
+            }
+
+            expect(writeOperations.length).toBe(0);
+        });
+    });
+
+    describe('Category Mapping', () => {
+        it('should have all standard categories', () => {
+            expect(CATEGORY_CONFIG['SAFE']).toBeDefined();
+            expect(CATEGORY_CONFIG['CODE']).toBeDefined();
+            expect(CATEGORY_CONFIG['FLOW']).toBeDefined();
+            expect(CATEGORY_CONFIG['INT']).toBeDefined();
+            expect(CATEGORY_CONFIG['PERF']).toBeDefined();
+            expect(CATEGORY_CONFIG['TEST']).toBeDefined();
+            expect(CATEGORY_CONFIG['LEARN']).toBeDefined();
+        });
+    });
+});

package/lib/agent-cli/bin/{ag-smart.js → agent.js}

@@ -24,6 +24,8 @@ const ARGS = process.argv.slice(2);
 const COMMAND = ARGS[0];
 const SCRIPTS_DIR = path.join(__dirname, "..", "lib");
 const HOOKS_DIR = path.join(SCRIPTS_DIR, "hooks");
+const DASHBOARD_DIR = path.join(__dirname, "..", "dashboard");
+const AUTO_LEARN_DIR = path.join(__dirname, "..", "scripts");
 
 /**
  * Run a script with given arguments
@@ -52,46 +54,54 @@ function printHelp() {
     console.log(`
 🤖 Agent Skill Kit CLI v${VERSION}
 
-Usage: ag-smart <command> [options]
+Usage: agent <command> [options]
 
 ${"─".repeat(50)}
 
 📚 CORE COMMANDS:
 
   learn          Teach a new lesson to the memory
-                 ag-smart learn --add --pattern "var " --message "Use let/const"
-                 ag-smart learn --list
-                 ag-smart learn --remove LEARN-001
+                 agent learn --add --pattern "var " --message "Use let/const"
+                 agent learn --list
+                 agent learn --remove LEARN-001
 
   recall         Check file(s) against learned patterns
-                 ag-smart recall src/app.js
-                 ag-smart recall ./src
+                 agent recall src/app.js
+                 agent recall ./src
 
   audit          Run full compliance audit
-                 ag-smart audit [directory]
+                 agent audit [directory]
 
 ${"─".repeat(50)}
 
 🚀 PRODUCTION FEATURES:
 
   watch          Real-time file monitoring
-                 ag-smart watch [directory]
+                 agent watch [directory]
 
   stats          Knowledge base statistics
-                 ag-smart stats
+                 agent stats
 
   install-hooks  Install git pre-commit hook
-                 ag-smart install-hooks
-                 ag-smart install-hooks --remove
+                 agent install-hooks
+                 agent install-hooks --remove
 
   lint-learn     Auto-learn from ESLint JSON output
-                 npx eslint . --format json | ag-smart lint-learn
+                 npx eslint . --format json | agent lint-learn
 
   fix            🆕 Auto-fix violations
-                 ag-smart fix <file|dir> [--mode safe|aggressive]
+                 agent fix <file|dir> [--mode safe|aggressive]
 
   sync-skills    🆕 Sync hot patterns to SKILL.md
-                 ag-smart sync-skills
+                 agent sync-skills
+
+  dashboard      🆕 Start Auto-Learn dashboard
+                 agent dashboard
+
+  auto-learn     🆕 Run auto-learn scripts
+                 agent auto-learn --scan
+                 agent auto-learn --analyze
+                 agent auto-learn --check "intent"
 
 ${"─".repeat(50)}
 
@@ -137,6 +147,29 @@ switch (COMMAND) {
         run("skill-learn.js", ARGS.slice(1));
         break;
 
+    // Auto-Learn features
+    case "dashboard":
+        run("dashboard_server.js", ARGS.slice(1), DASHBOARD_DIR);
+        break;
+    case "auto-learn":
+        const subCmd = ARGS[1];
+        if (subCmd === "--scan" || subCmd === "-s") {
+            run("error_sensor.js", ARGS.slice(2), AUTO_LEARN_DIR);
+        } else if (subCmd === "--success") {
+            run("success_sensor.js", ARGS.slice(2), AUTO_LEARN_DIR);
+        } else if (subCmd === "--analyze" || subCmd === "-a") {
+            run("pattern_analyzer.js", ARGS.slice(2), AUTO_LEARN_DIR);
+        } else if (subCmd === "--check" || subCmd === "-c") {
+            run("pre_execution_check.js", ARGS.slice(2), AUTO_LEARN_DIR);
+        } else if (subCmd === "--adapt") {
+            run("adaptive_engine.js", ARGS.slice(2), AUTO_LEARN_DIR);
+        } else if (subCmd === "--inject") {
+            run("skill_injector.js", ARGS.slice(2), AUTO_LEARN_DIR);
+        } else {
+            console.log("Usage: agent auto-learn [--scan|--success|--analyze|--check|--adapt|--inject]");
+        }
+        break;
+
     // Meta
     case "--version":
     case "-v":
@@ -153,6 +186,6 @@ switch (COMMAND) {
         break;
     default:
         console.log(`❌ Unknown command: ${COMMAND}`);
-        console.log("   Run 'ag-smart help' for available commands.\n");
+        console.log("   Run 'agent help' for available commands.\n");
         process.exit(1);
 }