add-skill-kit 3.2.4 → 3.2.5

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

package/lib/agent-cli/dashboard/dashboard_server.js

@@ -0,0 +1,340 @@
+#!/usr/bin/env node
+/**
+ * Dashboard Server - Local web server for Auto-Learn Dashboard
+ * 
+ * Bundled with Agent Skill Kit CLI
+ * 
+ * Serves:
+ * - Static dashboard HTML
+ * - API endpoints for data
+ * 
+ * Usage:
+ *   node dashboard_server.js --port 3030
+ */
+
+import fs from 'fs';
+import path from 'path';
+import http from 'http';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Colors
+const c = {
+    reset: '\x1b[0m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m',
+    gray: '\x1b[90m',
+    bold: '\x1b[1m'
+};
+
+// Find project root (where .agent folder exists)
+function findProjectRoot() {
+    let current = process.cwd();
+    while (current !== path.dirname(current)) {
+        if (fs.existsSync(path.join(current, '.agent'))) {
+            return current;
+        }
+        current = path.dirname(current);
+    }
+    return process.cwd();
+}
+
+// Find knowledge path - check multiple locations
+function findKnowledgePath() {
+    const projectRoot = findProjectRoot();
+    const possiblePaths = [
+        path.join(projectRoot, '.agent', 'knowledge'),
+        path.join(projectRoot, '.agent', 'agentskillskit', '.agent', 'knowledge'),
+    ];
+
+    for (const p of possiblePaths) {
+        if (fs.existsSync(p)) {
+            return p;
+        }
+    }
+
+    // Create default if none exists
+    const defaultPath = path.join(projectRoot, '.agent', 'knowledge');
+    fs.mkdirSync(defaultPath, { recursive: true });
+    return defaultPath;
+}
+
+const knowledgePath = findKnowledgePath();
+// Dashboard is in same directory as this server
+const dashboardPath = __dirname;
+
+// Load JSON files
+function loadJson(filename) {
+    const filePath = path.join(knowledgePath, filename);
+    try {
+        if (fs.existsSync(filePath)) {
+            return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        }
+    } catch { }
+    return null;
+}
+
+// API handlers
+const api = {
+    '/api/errors': () => {
+        const data = loadJson('detected-errors.json');
+        return data || { errors: [], totalErrors: 0 };
+    },
+
+    '/api/corrections': () => {
+        const data = loadJson('user-corrections.json');
+        return data || { corrections: [], totalCorrections: 0 };
+    },
+
+    '/api/lessons': () => {
+        const data = loadJson('lessons-learned.json');
+        return data || { lessons: [] };
+    },
+
+    '/api/patterns': () => {
+        const data = loadJson('patterns.json');
+        return data || { errors: {}, corrections: {}, highFrequency: [] };
+    },
+
+    '/api/successes': () => {
+        const data = loadJson('successes.json');
+        return data || { successes: [], totalSuccesses: 0 };
+    },
+
+    '/api/summary': () => {
+        const errors = loadJson('detected-errors.json');
+        const corrections = loadJson('user-corrections.json');
+        const lessons = loadJson('lessons-learned.json');
+        const patterns = loadJson('patterns.json');
+        const successes = loadJson('successes.json');
+
+        // Calculate success/failure ratio
+        const totalErrors = errors?.errors?.length || 0;
+        const totalCorrections = corrections?.corrections?.length || 0;
+        const totalSuccesses = successes?.successes?.length || 0;
+        const totalFailures = totalErrors + totalCorrections;
+        const total = totalFailures + totalSuccesses;
+
+        let ratio = 0;
+        let status = 'NO_DATA';
+        if (total > 0) {
+            ratio = Math.round((totalSuccesses / total) * 100) / 100;
+            if (ratio > 0.7) status = 'EXCELLENT';
+            else if (ratio > 0.5) status = 'GOOD';
+            else if (ratio > 0.3) status = 'LEARNING';
+            else status = 'NEEDS_ATTENTION';
+        }
+
+        // Group successes by pattern
+        const successesByPattern = {};
+        for (const s of (successes?.successes || [])) {
+            successesByPattern[s.pattern] = (successesByPattern[s.pattern] || 0) + 1;
+        }
+
+        return {
+            errors: {
+                total: totalErrors,
+                byType: patterns?.errors?.byType || {},
+                bySeverity: patterns?.errors?.bySeverity || {}
+            },
+            corrections: {
+                total: totalCorrections,
+                byCategory: patterns?.corrections?.byCategory || {}
+            },
+            successes: {
+                total: totalSuccesses,
+                byPattern: successesByPattern
+            },
+            balance: {
+                ratio,
+                status,
+                failures: totalFailures,
+                successes: totalSuccesses
+            },
+            lessons: lessons?.lessons?.length || 0,
+            highFrequency: patterns?.highFrequency || [],
+            lastUpdated: patterns?.analyzedAt || null,
+            knowledgePath: knowledgePath
+        };
+    },
+
+    '/api/trends': () => {
+        const errors = loadJson('detected-errors.json');
+        const successes = loadJson('successes.json');
+
+        const errorList = errors?.errors || [];
+        const successList = successes?.successes || [];
+
+        // Calculate trends
+        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 = errorList.filter(e => new Date(e.timestamp) > oneWeekAgo).length;
+        const lastWeekErrors = errorList.filter(e => {
+            const d = new Date(e.timestamp);
+            return d > twoWeeksAgo && d <= oneWeekAgo;
+        }).length;
+
+        const thisWeekSuccesses = successList.filter(s => {
+            const d = new Date(s.detectedAt || s.timestamp);
+            return d > oneWeekAgo;
+        }).length;
+
+        // Daily breakdown (last 7 days)
+        const daily = [];
+        for (let i = 6; i >= 0; i--) {
+            const date = new Date(now - i * 24 * 60 * 60 * 1000);
+            const dateStr = date.toISOString().split('T')[0];
+
+            const dayErrors = errorList.filter(e =>
+                e.timestamp && e.timestamp.startsWith(dateStr)
+            ).length;
+
+            const daySuccesses = successList.filter(s =>
+                (s.detectedAt || s.timestamp || '').startsWith(dateStr)
+            ).length;
+
+            daily.push({ date: dateStr, errors: dayErrors, successes: daySuccesses });
+        }
+
+        const errorTrend = lastWeekErrors > 0
+            ? Math.round(((thisWeekErrors - lastWeekErrors) / lastWeekErrors) * 100)
+            : 0;
+
+        let healthStatus = 'STABLE';
+        if (errorTrend < 0) healthStatus = 'IMPROVING';
+        else if (errorTrend > 20) healthStatus = 'DECLINING';
+
+        return {
+            thisWeek: { errors: thisWeekErrors, successes: thisWeekSuccesses },
+            lastWeek: { errors: lastWeekErrors },
+            trends: { errorChange: errorTrend },
+            healthStatus,
+            daily
+        };
+    }
+};
+
+// MIME types
+const mimeTypes = {
+    '.html': 'text/html',
+    '.css': 'text/css',
+    '.js': 'application/javascript',
+    '.json': 'application/json',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.svg': 'image/svg+xml'
+};
+
+// Create server
+function createServer(port) {
+    const server = http.createServer((req, res) => {
+        const url = req.url.split('?')[0];
+
+        // CORS headers for local development
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+
+        // Handle API requests
+        if (url.startsWith('/api/')) {
+            const handler = api[url];
+            if (handler) {
+                res.setHeader('Content-Type', 'application/json');
+                res.writeHead(200);
+                res.end(JSON.stringify(handler()));
+            } else {
+                res.writeHead(404);
+                res.end(JSON.stringify({ error: 'Not found' }));
+            }
+            return;
+        }
+
+        // Serve static files
+        let filePath = url === '/' ? '/index.html' : url;
+        filePath = path.join(dashboardPath, filePath);
+
+        if (fs.existsSync(filePath)) {
+            const ext = path.extname(filePath);
+            const mimeType = mimeTypes[ext] || 'text/plain';
+
+            res.setHeader('Content-Type', mimeType);
+            res.writeHead(200);
+            res.end(fs.readFileSync(filePath));
+        } else {
+            res.writeHead(404);
+            res.end('Not found');
+        }
+    });
+
+    return server;
+}
+
+function startServer(port = 3030) {
+    const server = createServer(port);
+
+    server.listen(port, () => {
+        console.log(`${c.cyan}╔════════════════════════════════════════╗${c.reset}`);
+        console.log(`${c.cyan}║${c.reset}  🧠 Auto-Learn Dashboard Server         ${c.cyan}║${c.reset}`);
+        console.log(`${c.cyan}╚════════════════════════════════════════╝${c.reset}\n`);
+        console.log(`${c.green}✓ Server running at:${c.reset}`);
+        console.log(`  ${c.bold}http://localhost:${port}${c.reset}\n`);
+        console.log(`${c.gray}API Endpoints:${c.reset}`);
+        console.log(`  GET /api/errors       - Detected errors`);
+        console.log(`  GET /api/corrections  - User corrections`);
+        console.log(`  GET /api/lessons      - Lessons learned`);
+        console.log(`  GET /api/patterns     - Pattern analysis`);
+        console.log(`  GET /api/summary      - Dashboard summary\n`);
+        console.log(`${c.yellow}Press Ctrl+C to stop${c.reset}`);
+    });
+
+    server.on('error', (err) => {
+        if (err.code === 'EADDRINUSE') {
+            console.log(`${c.red}Error: Port ${port} is already in use${c.reset}`);
+            console.log(`${c.gray}Try: node dashboard_server.js --port ${port + 1}${c.reset}`);
+        } else {
+            console.error(`${c.red}Server error:${c.reset}`, err);
+        }
+        process.exit(1);
+    });
+
+    return server;
+}
+
+// Parse CLI args
+const args = process.argv.slice(2);
+
+if (args.includes('--start') || args.includes('-s') || args.length === 0 || args.includes('--port') || args.includes('-p')) {
+    let port = 3030;
+    const portIdx = args.findIndex(a => a === '--port' || a === '-p');
+    if (portIdx >= 0 && args[portIdx + 1]) {
+        port = parseInt(args[portIdx + 1], 10);
+    }
+    startServer(port);
+} else if (args.includes('--help') || args.includes('-h')) {
+    console.log(`${c.cyan}dashboard_server - Auto-Learn Dashboard Web Server${c.reset}
+
+${c.bold}Usage:${c.reset}
+  node dashboard_server.js                  Start server (default port 3030)
+  node dashboard_server.js --port 8080      Start on custom port
+  node dashboard_server.js --help           Show this help
+
+${c.bold}API Endpoints:${c.reset}
+  GET /api/errors       - All detected errors
+  GET /api/corrections  - All user corrections
+  GET /api/lessons      - All lessons learned
+  GET /api/patterns     - Pattern analysis results
+  GET /api/summary      - Dashboard summary data
+
+${c.bold}Example:${c.reset}
+  node dashboard_server.js --port 3030
+  # Open http://localhost:3030 in browser
+`);
+}
+
+export { createServer, startServer };