add-skill-kit 3.2.4 → 3.2.5

package/README.md

@@ -38,7 +38,7 @@ Với Add Skill Kit:
 
 ```bash
 # Dạy AI một lesson mới
-npx ag-smart learn --pattern "var " --message "Use const/let instead"
+npx agent learn --pattern "var " --message "Use const/let instead"
 
 # Từ nay AI sẽ nhớ mãi và không lặp lại
 ```

package/bin/lib/commands/help.js

@@ -12,10 +12,6 @@ export async function run() {
   let running = true;
 
   while (running) {
-    stepLine();
-    step(c.bold("kit") + c.dim(` v${VERSION}`));
-    step(c.dim("What would you like to know?"));
-    stepLine();
 
     const choice = await select({
       message: "Select a topic",

package/bin/lib/commands/install.js

@@ -630,17 +630,37 @@ export async function run(spec) {
 
     fs.rmSync(tmp, { recursive: true, force: true });
 
+    // Ask user about AutoLearn installation
+    stepLine();
+    const installAutoLearn = await confirm({
+        message: "Install AutoLearn (enables 'agent' command for learning & self-improvement)?",
+        initialValue: true
+    });
+
+    if (isCancel(installAutoLearn)) {
+        cancel("Installation cancelled");
+        process.exit(0);
+    }
+
     // Install CLI package
     stepLine();
     const cliSpinner = spinner();
-    const cliPackage = "agentskillskit-cli";
+    const cliPackage = "add-skill-kit";
 
     if (isGlobal) {
-        cliSpinner.start(`Installing Agent CLI globally (${cliPackage})`);
+        if (installAutoLearn) {
+            cliSpinner.start(`Installing CLI globally (${cliPackage})`);
+        } else {
+            cliSpinner.start(`Installing kit CLI globally (${cliPackage})`);
+        }
         try {
             await execAsync(`npm install -g ${cliPackage}`, { timeout: 120000 });
-            cliSpinner.stop("Agent CLI installed globally");
-            step(c.dim("Run: agent"));
+            cliSpinner.stop("CLI installed globally");
+            if (installAutoLearn) {
+                step(c.dim("Commands: agent, kit"));
+            } else {
+                step(c.dim("Command: kit"));
+            }
         } catch (e) {
             cliSpinner.stop(c.yellow("Global CLI installation failed"));
             step(c.dim(`Try running manually: npm i -g ${cliPackage}`));
@@ -649,7 +669,7 @@ export async function run(spec) {
         cliSpinner.start(`Installing Agent CLI locally (${cliPackage})`);
         try {
             await execAsync(`npm install -D ${cliPackage}`, { timeout: 120000 });
-            cliSpinner.stop("Agent CLI installed locally");
+            cliSpinner.stop("CLI installed locally");
 
             // Add npm scripts to package.json
             try {
@@ -658,25 +678,86 @@ export async function run(spec) {
                     const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
                     pkg.scripts = pkg.scripts || {};
 
-                    // Add agent script if not exists
-                    if (!pkg.scripts.agent) {
+                    // Always add kit script
+                    if (!pkg.scripts.kit) {
+                        pkg.scripts.kit = "kit";
+                    }
+
+                    // Add agent script only if AutoLearn enabled
+                    if (installAutoLearn && !pkg.scripts.agent) {
                         pkg.scripts.agent = "agent";
                     }
 
                     fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
-                    step(c.green("✓ Added npm script: 'agent'"));
+                    if (installAutoLearn) {
+                        step(c.green("✓ Added npm scripts: 'agent', 'kit'"));
+                    } else {
+                        step(c.green("✓ Added npm script: 'kit'"));
+                    }
                 }
             } catch (scriptErr) {
                 step(c.yellow("⚠ Could not add npm scripts automatically"));
             }
 
-            step(c.dim("Run: npm run agent"));
+            // Create wrapper scripts for direct command access (Windows + Unix)
+            try {
+                const projectRoot = process.cwd();
+
+                // Always create kit wrappers
+                const kitCmd = `@echo off\nnode "%~dp0node_modules\\add-skill-kit\\bin\\kit.js" %*`;
+                const kitSh = `#!/bin/sh\nnode "$(dirname "$0")/node_modules/add-skill-kit/bin/kit.js" "$@"`;
+                fs.writeFileSync(path.join(projectRoot, "kit.cmd"), kitCmd);
+                fs.writeFileSync(path.join(projectRoot, "kit"), kitSh, { mode: 0o755 });
+
+                if (installAutoLearn) {
+                    // Create agent wrappers only if AutoLearn enabled
+                    const agentCmd = `@echo off\nnode "%~dp0node_modules\\add-skill-kit\\lib\\agent-cli\\bin\\agent.js" %*`;
+                    const agentSh = `#!/bin/sh\nnode "$(dirname "$0")/node_modules/add-skill-kit/lib/agent-cli/bin/agent.js" "$@"`;
+                    fs.writeFileSync(path.join(projectRoot, "agent.cmd"), agentCmd);
+                    fs.writeFileSync(path.join(projectRoot, "agent"), agentSh, { mode: 0o755 });
+
+                    step(c.green("✓ Created wrapper scripts: agent, kit"));
+                    step(c.dim("Run directly: ./agent or ./kit (Unix) | agent or kit (Windows)"));
+                } else {
+                    step(c.green("✓ Created wrapper script: kit"));
+                    step(c.dim("Run directly: ./kit (Unix) | kit (Windows)"));
+                }
+            } catch (wrapperErr) {
+                step(c.dim("Run: npx kit"));
+            }
         } catch (e) {
             cliSpinner.stop(c.yellow("Local CLI installation skipped"));
             step(c.dim(`Run manually: npm i -D ${cliPackage}`));
         }
     }
 
+    // Run npm install to ensure all skill dependencies are available
+    stepLine();
+    const depsSpinner = spinner();
+    depsSpinner.start("Installing skill dependencies (csv-parse, etc.)");
+    try {
+        await execAsync("npm install", { timeout: 120000 });
+        depsSpinner.stop("Skill dependencies installed");
+    } catch (e) {
+        depsSpinner.stop(c.yellow("Dependencies installation skipped"));
+        step(c.dim("Run manually: npm install"));
+    }
+
+    // Install Python dependencies if requirements.txt exists
+    const pythonReqPath = path.join(WORKSPACE, "..", "skills", "requirements.txt");
+    if (fs.existsSync(pythonReqPath)) {
+        stepLine();
+        const pySpinner = spinner();
+        pySpinner.start("Installing Python dependencies (PyYAML, etc.)");
+        try {
+            await execAsync(`pip install -r "${pythonReqPath}"`, { timeout: 120000 });
+            pySpinner.stop("Python dependencies installed");
+        } catch (e) {
+            pySpinner.stop(c.yellow("Python dependencies skipped"));
+            step(c.dim(`Run manually: pip install -r .agent/skills/requirements.txt`));
+        }
+    }
+
     stepLine();
     console.log(` ${c.cyan("Done!")}`);
     console.log();

package/bin/lib/ui.js

@@ -177,7 +177,7 @@ export function brandedIntro(version, status = "") {
     // Last line: gradient ASCII + dim version (aligned at bottom)
     const lastLine = bannerLines[bannerLines.length - 1];
     console.log(pikaGradient(lastLine) + `  ${c.dim(`v${version}`)}`);
-    console.log(''); // Empty line after banner
+
 
     if (status) {
         console.log(`${c.dim(status)}`);

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

@@ -0,0 +1,190 @@
+/**
+ * Unit Tests for adaptive_engine.js
+ * 
+ * Tests:
+ * - adjustSeverity
+ * - promoteRules
+ * - demoteRules
+ * - analyzeRules
+ * - runAdaptiveCycle
+ */
+
+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(() => '{}')
+    };
+});
+
+// Severity levels constant
+const SEVERITY_LEVELS = ['LOW', 'MEDIUM', 'HIGH', 'CRITICAL'];
+
+describe('Adaptive Engine', () => {
+    describe('adjustSeverity', () => {
+        it('should increase severity for 10+ hits', () => {
+            const lesson = {
+                id: 'TEST-001',
+                hitCount: 15,
+                severity: 'MEDIUM'
+            };
+
+            const currentIndex = SEVERITY_LEVELS.indexOf(lesson.severity);
+
+            if (lesson.hitCount >= 10 && currentIndex < SEVERITY_LEVELS.length - 1) {
+                lesson.severity = SEVERITY_LEVELS[currentIndex + 1];
+            }
+
+            expect(lesson.severity).toBe('HIGH');
+        });
+
+        it('should increase to CRITICAL for 25+ hits', () => {
+            const lesson = {
+                id: 'TEST-001',
+                hitCount: 30,
+                severity: 'LOW'
+            };
+
+            const currentIndex = SEVERITY_LEVELS.indexOf(lesson.severity);
+
+            if (lesson.hitCount >= 25 && currentIndex < SEVERITY_LEVELS.length - 2) {
+                lesson.severity = SEVERITY_LEVELS[currentIndex + 2];
+            }
+
+            expect(lesson.severity).toBe('HIGH');
+        });
+
+        it('should decrease severity for 0 hits in 30 days', () => {
+            const thirtyDaysAgo = new Date(Date.now() - 31 * 24 * 60 * 60 * 1000);
+            const lesson = {
+                id: 'TEST-001',
+                hitCount: 0,
+                severity: 'HIGH',
+                lastHit: thirtyDaysAgo.toISOString()
+            };
+
+            const lastHit = new Date(lesson.lastHit);
+            const thresholdDate = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
+            const currentIndex = SEVERITY_LEVELS.indexOf(lesson.severity);
+
+            if (lastHit < thresholdDate && currentIndex > 0) {
+                lesson.severity = SEVERITY_LEVELS[currentIndex - 1];
+            }
+
+            expect(lesson.severity).toBe('MEDIUM');
+        });
+
+        it('should not decrease LOW severity further', () => {
+            const lesson = {
+                id: 'TEST-001',
+                severity: 'LOW'
+            };
+
+            const currentIndex = SEVERITY_LEVELS.indexOf(lesson.severity);
+            expect(currentIndex).toBe(0);
+        });
+    });
+
+    describe('promoteRules', () => {
+        it('should promote rules with 95%+ accuracy', () => {
+            const lesson = {
+                id: 'TEST-001',
+                hitCount: 1,
+                successCount: 19, // 19/20 = 95%
+                severity: 'MEDIUM'
+            };
+
+            const totalAttempts = lesson.hitCount + lesson.successCount;
+            const accuracy = lesson.successCount / totalAttempts;
+
+            if (accuracy >= 0.95 && lesson.severity !== 'CRITICAL') {
+                lesson.promoted = true;
+                lesson.severity = 'CRITICAL';
+            }
+
+            expect(lesson.promoted).toBe(true);
+            expect(lesson.severity).toBe('CRITICAL');
+        });
+
+        it('should not promote rules with <10 attempts', () => {
+            const lesson = {
+                id: 'TEST-001',
+                hitCount: 1,
+                successCount: 5, // Only 6 attempts
+                severity: 'MEDIUM'
+            };
+
+            const totalAttempts = lesson.hitCount + lesson.successCount;
+
+            // Need 10+ attempts to evaluate
+            const shouldEvaluate = totalAttempts >= 10;
+
+            expect(shouldEvaluate).toBe(false);
+        });
+    });
+
+    describe('demoteRules', () => {
+        it('should demote rules with <50% accuracy', () => {
+            const lesson = {
+                id: 'TEST-001',
+                hitCount: 8,
+                successCount: 2, // 2/10 = 20%
+                severity: 'HIGH'
+            };
+
+            const totalAttempts = lesson.hitCount + lesson.successCount;
+            const accuracy = lesson.successCount / totalAttempts;
+
+            if (accuracy < 0.50 && lesson.severity !== 'LOW') {
+                lesson.demoted = true;
+                lesson.severity = 'LOW';
+            }
+
+            expect(lesson.demoted).toBe(true);
+            expect(lesson.severity).toBe('LOW');
+        });
+
+        it('should not demote LOW severity rules', () => {
+            const lesson = {
+                id: 'TEST-001',
+                severity: 'LOW'
+            };
+
+            const shouldDemote = lesson.severity !== 'LOW';
+
+            expect(shouldDemote).toBe(false);
+        });
+    });
+
+    describe('analyzeRules', () => {
+        it('should group lessons by severity', () => {
+            const lessons = [
+                { severity: 'LOW' },
+                { severity: 'MEDIUM' },
+                { severity: 'MEDIUM' },
+                { severity: 'HIGH' },
+                { severity: 'CRITICAL' }
+            ];
+
+            const bySeverity = {};
+            for (const lesson of lessons) {
+                bySeverity[lesson.severity] = (bySeverity[lesson.severity] || 0) + 1;
+            }
+
+            expect(bySeverity.LOW).toBe(1);
+            expect(bySeverity.MEDIUM).toBe(2);
+            expect(bySeverity.HIGH).toBe(1);
+            expect(bySeverity.CRITICAL).toBe(1);
+        });
+    });
+});

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

@@ -0,0 +1,222 @@
+/**
+ * E2E Integration Tests - Cross-Script Integration
+ * 
+ * Tests integration between different scripts:
+ * - error_sensor ↔ pattern_analyzer
+ * - pattern_analyzer ↔ pre_execution_check
+ * - adaptive_engine ↔ skill_injector
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+
+describe('E2E: Cross-Script Integration', () => {
+    describe('Error Sensor → Pattern Analyzer', () => {
+        it('should pass error format between scripts', () => {
+            // Error format from error_sensor
+            const sensorOutput = {
+                id: 'ERR-001',
+                type: 'test-failure',
+                source: 'test',
+                message: 'Test failed',
+                severity: 'HIGH',
+                timestamp: new Date().toISOString(),
+                context: {
+                    project: { projectType: 'nextjs' },
+                    file: { fileType: '.tsx' }
+                }
+            };
+
+            // Pattern analyzer input format
+            const analyzerInput = [sensorOutput];
+
+            // Verify format compatibility
+            expect(analyzerInput[0].type).toBeDefined();
+            expect(analyzerInput[0].severity).toBeDefined();
+            expect(analyzerInput[0].context).toBeDefined();
+        });
+
+        it('should aggregate errors correctly', () => {
+            const errors = [
+                { type: 'lint', severity: 'LOW' },
+                { type: 'lint', severity: 'LOW' },
+                { type: 'test', severity: 'HIGH' },
+                { type: 'lint', severity: 'LOW' }
+            ];
+
+            // Pattern analyzer aggregation
+            const byType = {};
+            const bySeverity = {};
+
+            for (const err of errors) {
+                byType[err.type] = (byType[err.type] || 0) + 1;
+                bySeverity[err.severity] = (bySeverity[err.severity] || 0) + 1;
+            }
+
+            expect(byType.lint).toBe(3);
+            expect(byType.test).toBe(1);
+            expect(bySeverity.LOW).toBe(3);
+            expect(bySeverity.HIGH).toBe(1);
+        });
+    });
+
+    describe('Pattern Analyzer → Pre-Execution Check', () => {
+        it('should generate rules compatible with checker', () => {
+            // Pattern analyzer output
+            const highFrequency = [
+                { pattern: 'missing-await', count: 5, type: 'error' },
+                { pattern: 'no-try-catch', count: 4, type: 'error' }
+            ];
+
+            // Generate rules for pre-execution check
+            const rules = highFrequency.map(hf => ({
+                id: `AUTO-${hf.pattern.toUpperCase()}`,
+                pattern: hf.pattern,
+                prevention: `Avoid ${hf.pattern}`,
+                severity: hf.count >= 5 ? 'HIGH' : 'MEDIUM',
+                status: 'proposed'
+            }));
+
+            expect(rules[0].id).toBe('AUTO-MISSING-AWAIT');
+            expect(rules[0].severity).toBe('HIGH');
+            expect(rules[1].severity).toBe('MEDIUM');
+        });
+
+        it('should match rules against intent', () => {
+            const rules = [
+                { pattern: 'delete', severity: 'CRITICAL' },
+                { pattern: 'async', severity: 'MEDIUM' }
+            ];
+
+            const intent = 'create async function';
+            const matches = rules.filter(r =>
+                intent.toLowerCase().includes(r.pattern)
+            );
+
+            expect(matches.length).toBe(1);
+            expect(matches[0].pattern).toBe('async');
+        });
+    });
+
+    describe('Adaptive Engine → Skill Injector', () => {
+        it('should pass promoted lessons for skill generation', () => {
+            // Adaptive engine output
+            const promotedLessons = [
+                { id: 'SAFE-001', pattern: 'backup-first', severity: 'CRITICAL', promoted: true },
+                { id: 'SAFE-002', pattern: 'confirm-delete', severity: 'CRITICAL', promoted: true },
+                { id: 'SAFE-003', pattern: 'check-exists', severity: 'CRITICAL', promoted: true }
+            ];
+
+            // Skill injector categorization
+            const categories = {};
+            for (const lesson of promotedLessons) {
+                const category = lesson.id.split('-')[0];
+                if (!categories[category]) {
+                    categories[category] = [];
+                }
+                categories[category].push(lesson);
+            }
+
+            expect(categories.SAFE.length).toBe(3);
+            expect(categories.SAFE.every(l => l.promoted)).toBe(true);
+        });
+
+        it('should generate skill from 3+ lessons', () => {
+            const lessons = [
+                { id: 'CODE-001', pattern: 'type-annotation' },
+                { id: 'CODE-002', pattern: 'null-check' },
+                { id: 'CODE-003', pattern: 'error-handling' }
+            ];
+
+            const canGenerateSkill = lessons.length >= 3;
+            expect(canGenerateSkill).toBe(true);
+
+            // Mock skill generation
+            const skill = {
+                name: 'code-patterns',
+                lessonCount: lessons.length,
+                generatedAt: new Date().toISOString()
+            };
+
+            expect(skill.name).toBe('code-patterns');
+            expect(skill.lessonCount).toBe(3);
+        });
+    });
+
+    describe('Success Sensor → Pattern Analyzer', () => {
+        it('should pass success format for balance calculation', () => {
+            const successes = [
+                { pattern: 'async-await', type: 'pattern' },
+                { pattern: 'typescript', type: 'pattern' }
+            ];
+
+            const errors = [
+                { type: 'test', severity: 'HIGH' }
+            ];
+
+            // Calculate balance
+            const totalSuccesses = successes.length;
+            const totalFailures = errors.length;
+            const total = totalSuccesses + totalFailures;
+            const ratio = totalSuccesses / total;
+
+            expect(ratio).toBeCloseTo(0.67, 1);
+        });
+    });
+
+    describe('Rule Sharing → Pre-Execution Check', () => {
+        it('should import rules in correct format', () => {
+            // Exported rule format
+            const exportedRule = {
+                id: 'SAFE-001',
+                pattern: 'delete-without-backup',
+                severity: 'CRITICAL',
+                source: 'imported'
+            };
+
+            // Verify format for pre-execution
+            expect(exportedRule.id).toBeDefined();
+            expect(exportedRule.pattern).toBeDefined();
+            expect(exportedRule.severity).toBeDefined();
+            expect(['LOW', 'MEDIUM', 'HIGH', 'CRITICAL']).toContain(exportedRule.severity);
+        });
+    });
+
+    describe('Full Cross-Script Pipeline', () => {
+        it('should maintain data integrity through pipeline', () => {
+            // 1. Error sensor detects
+            const error = {
+                id: 'ERR-001',
+                type: 'missing-return-type',
+                severity: 'MEDIUM',
+                timestamp: new Date().toISOString()
+            };
+
+            // 2. Pattern analyzer creates lesson
+            const lesson = {
+                id: 'CODE-001',
+                pattern: error.type,
+                severity: error.severity,
+                hitCount: 1
+            };
+
+            // 3. After multiple hits, adaptive engine promotes
+            lesson.hitCount = 25;
+            if (lesson.hitCount >= 25) {
+                lesson.severity = 'CRITICAL';
+                lesson.promoted = true;
+            }
+
+            // 4. Pre-execution check uses promoted rule
+            const intent = 'create function missing-return-type';
+            const matches = intent.includes(lesson.pattern);
+
+            // 5. Skill injector can use for skill
+            const canMakeSkill = lesson.promoted;
+
+            expect(error.type).toBe(lesson.pattern);
+            expect(lesson.severity).toBe('CRITICAL');
+            expect(matches).toBe(true);
+            expect(canMakeSkill).toBe(true);
+        });
+    });
+});