@agentskillkit/agent-skills 1.0.1 → 3.2.2

package/packages/cli/src/services/learning-service.js

@@ -0,0 +1,99 @@
+/**
+ * LearningService - Application Service
+ * 
+ * Orchestrates learning workflow:
+ * - Load raw data (mistakes, improvements)
+ * - Synthesize cognitive lessons
+ * - Manage lesson CRUD operations
+ */
+
+import { LessonSynthesizer } from '../core/learning/lesson-synthesizer.js';
+
+export class LearningService {
+    constructor(lessonRepository) {
+        this.lessonRepository = lessonRepository;
+    }
+
+    /**
+     * Get all cognitive lessons
+     * @returns {Promise<Array>}
+     */
+    async getCognitiveLessons() {
+        const mistakesDb = await this.lessonRepository.loadMistakes();
+        const improvementsDb = await this.lessonRepository.loadImprovements();
+
+        return LessonSynthesizer.synthesize(
+            mistakesDb.mistakes || [],
+            improvementsDb.improvements || []
+        );
+    }
+
+    /**
+     * Add a lesson to legacy format
+     * @param {string} pattern - Regex pattern
+     * @param {string} message - Explanation message
+     * @param {string} severity - WARNING or ERROR
+     * @param {string} category - Category tag
+     * @returns {Promise<object>}
+     */
+    async addLesson(pattern, message, severity = 'WARNING', category = 'general') {
+        // Validate Regex
+        try {
+            new RegExp(pattern);
+        } catch (e) {
+            throw new Error(`Invalid Regex pattern: ${e.message}`);
+        }
+
+        // Validate severity
+        if (!['WARNING', 'ERROR'].includes(severity.toUpperCase())) {
+            throw new Error('Invalid severity. Must be WARNING or ERROR');
+        }
+
+        // Check for duplicates
+        const db = await this.lessonRepository.loadLegacyLessons();
+        const exists = db.lessons.some(l => l.pattern === pattern);
+
+        if (exists) {
+            throw new Error('Pattern already exists in knowledge base');
+        }
+
+        const id = `LEARN-${String(db.lessons.length + 1).padStart(3, '0')}`;
+
+        const lesson = {
+            id,
+            pattern,
+            message,
+            severity: severity.toUpperCase(),
+            category,
+            source: 'manual',
+            hitCount: 0,
+            lastHit: null,
+            autoEscalated: false,
+            addedAt: new Date().toISOString()
+        };
+
+        return this.lessonRepository.addLegacyLesson(lesson);
+    }
+
+    /**
+     * Remove a lesson
+     * @param {string} lessonId
+     */
+    async removeLesson(lessonId) {
+        return this.lessonRepository.removeLegacyLesson(lessonId);
+    }
+
+    /**
+     * List all lessons
+     * @param {string} category - Optional category filter
+     */
+    async listLessons(category = null) {
+        const db = await this.lessonRepository.loadLegacyLessons();
+
+        if (category) {
+            return db.lessons.filter(l => l.category === category);
+        }
+
+        return db.lessons;
+    }
+}

package/packages/cli/tests/integration/evolution-signals.test.js

@@ -0,0 +1,46 @@
+// Test script for evolution signals
+import { signalQueue, getEvolutionStats } from './packages/cli/lib/evolution-signal.js';
+
+console.log('📊 Testing Evolution Signal Layer\n');
+
+// 1. Get stats
+const stats = getEvolutionStats();
+console.log('Initial Stats:');
+console.log(`  Pending: ${stats.pending}`);
+console.log(`  Approved: ${stats.approved}`);
+console.log(`  Rejected: ${stats.rejected}`);
+console.log(`  Executed: ${stats.executed}\n`);
+
+// 2. Get pending signals
+const pending = signalQueue.getPending();
+console.log(`📡 Pending Signals (${pending.length}):`);
+pending.forEach(s => {
+    console.log(`  - ${s.lessonId}: ${s.reason} (confidence: ${(s.confidence * 100).toFixed(0)}%)`);
+});
+
+// 3. Test approve first signal
+if (pending.length > 0) {
+    const firstSignal = pending[0];
+    console.log(`\n✅ Approving signal: ${firstSignal.lessonId}`);
+    signalQueue.approve(firstSignal.id);
+
+    const statsAfter = getEvolutionStats();
+    console.log('\nStats After Approval:');
+    console.log(`  Pending: ${statsAfter.pending}`);
+    console.log(`  Approved: ${statsAfter.approved}`);
+}
+
+// 4. Test reject second signal
+if (pending.length > 1) {
+    const secondSignal = pending[1];
+    console.log(`\n❌ Rejecting signal: ${secondSignal.lessonId}`);
+    signalQueue.reject(secondSignal.id);
+
+    const statsAfter = getEvolutionStats();
+    console.log('\nStats After Rejection:');
+    console.log(`  Pending: ${statsAfter.pending}`);
+    console.log(`  Approved: ${statsAfter.approved}`);
+    console.log(`  Rejected: ${statsAfter.rejected}`);
+}
+
+console.log('\n✅ Signal Layer Test Complete!');

package/packages/cli/tests/integration/gemini-export.test.js

@@ -0,0 +1,53 @@
+// Test Gemini Integration - Export Skills
+import { LessonRepository } from './packages/cli/src/data/repositories/lesson-repository.js';
+import { YamlStorage } from './packages/cli/src/data/storage/yaml-storage.js';
+import { LearningService } from './packages/cli/src/services/learning-service.js';
+import { SkillFormatter } from './packages/cli/src/presentation/formatters/skill-formatter.js';
+import { ExportService } from './packages/cli/src/services/export-service.js';
+import { KNOWLEDGE_DIR } from './packages/cli/lib/config.js';
+import path from 'path';
+
+console.log('🚀 Testing Gemini Skills Export\n');
+
+// Create instances
+const storage = new YamlStorage(KNOWLEDGE_DIR);
+const repository = new LessonRepository(storage);
+const learningService = new LearningService(repository);
+const skillFormatter = new SkillFormatter();
+const exportService = new ExportService(learningService, skillFormatter);
+
+// 1. Get stats
+console.log('Getting export stats...');
+const stats = await exportService.getExportStats();
+
+console.log('\n📊 Export Statistics:');
+console.log(`  Total lessons: ${stats.total}`);
+console.log(`  Mature/Ideal: ${stats.mature}`);
+console.log(`  Learning: ${stats.learning}`);
+console.log(`  Raw: ${stats.raw}`);
+console.log(`  Exportable: ${stats.exportable}\n`);
+
+// 2. Preview mature skills
+console.log('Previewing mature skills...');
+const preview = await exportService.previewMatureSkills(0.8);
+
+console.log(`\n✅ Found ${preview.length} exportable skills:\n`);
+preview.forEach(skill => {
+    console.log(`📄 ${skill.id}: ${skill.title}`);
+    console.log(`   State: ${skill.state} (${(skill.confidence * 100).toFixed(0)}%)`);
+    console.log(`   File: ${skill.filename}\n`);
+});
+
+// 3. Export to test directory
+const outputDir = path.join(process.cwd(), '.agent/skills-test');
+console.log(`Exporting to: ${outputDir}\n`);
+
+const exported = await exportService.exportMatureSkills(outputDir, 0.8);
+
+console.log(`✅ Exported ${exported.length} skills:\n`);
+exported.forEach(skill => {
+    console.log(`  ✓ ${skill.filename}`);
+});
+
+console.log('\n🎉 Export Complete!');
+console.log(`\nCheck files in: ${outputDir}`);

package/packages/cli/tests/integration/learning-service.test.js

@@ -0,0 +1,33 @@
+// Test Learning module - new architecture
+import { LessonRepository } from './packages/cli/src/data/repositories/lesson-repository.js';
+import { YamlStorage } from './packages/cli/src/data/storage/yaml-storage.js';
+import { LearningService } from './packages/cli/src/services/learning-service.js';
+import { KNOWLEDGE_DIR } from './packages/cli/lib/config.js';
+
+console.log('📚 Testing Learning Module (New Architecture)\n');
+
+// Create instances
+const storage = new YamlStorage(KNOWLEDGE_DIR);
+const repository = new LessonRepository(storage);
+const learningService = new LearningService(repository);
+
+// 1. Load cognitive lessons
+console.log('Loading cognitive lessons...');
+const lessons = await learningService.getCognitiveLessons();
+
+console.log(`\n✅ Found ${lessons.length} cognitive lessons:\n`);
+
+// Show first 3
+lessons.slice(0, 3).forEach(lesson => {
+    console.log(`📖 ${lesson.id}: ${lesson.title}`);
+    console.log(`   State: ${lesson.maturity.state} (confidence: ${(lesson.maturity.confidence * 100).toFixed(0)}%)`);
+    console.log(`   Intent: ${lesson.intent.goal}`);
+    console.log(`   Coverage: ${lesson.maturity.coverage}`);
+    console.log('');
+});
+
+// 2. Load legacy lessons
+const legacy = await learningService.listLessons();
+console.log(`\n📚 Legacy lessons: ${legacy.length}`);
+
+console.log('\n✅ Learning Module Test Complete!');

package/packages/cli/tests/integration/signal-detector.test.js

@@ -0,0 +1,29 @@
+// Test new architecture directly
+import { SignalRepository } from '../../src/data/repositories/signal-repository.js';
+import { JsonStorage } from '../../src/data/storage/json-storage.js';
+import { SignalDetector } from '../../src/core/evolution/signal-detector.js';
+import { KNOWLEDGE_DIR } from '../../lib/config.js';
+
+console.log('📊 Testing New Architecture\n');
+
+// Create instances
+const storage = new JsonStorage(KNOWLEDGE_DIR);
+const repository = new SignalRepository(storage);
+const detector = new SignalDetector(repository);
+
+// 1. Get stats
+const stats = await detector.getStats();
+console.log('Initial Stats:');
+console.log(`  Pending: ${stats.pending}`);
+console.log(`  Approved: ${stats.approved}`);
+console.log(`  Rejected: ${stats.rejected}`);
+console.log(`  Executed: ${stats.executed}\n`);
+
+// 2. Get pending signals
+const pending = await detector.getPending();
+console.log(`📡 Pending Signals (${pending.length}):`);
+pending.forEach(s => {
+    console.log(`  - ${s.lessonId}: ${s.reason} (confidence: ${(s.confidence * 100).toFixed(0)}%)`);
+});
+
+console.log('\n✅ New Architecture Test Complete!');

package/packages/cli/tests/unit/cognitive-enhancer.test.js

@@ -0,0 +1,56 @@
+// Unit Tests for CognitiveEnhancer
+import { CognitiveEnhancer } from '../../src/core/learning/cognitive-enhancer.js';
+
+console.log('🧪 Testing CognitiveEnhancer\n');
+
+// Test 1: inferIntent()
+console.log('Test 1: inferIntent()');
+const tags = ['code-quality', 'imports'];
+const intent = CognitiveEnhancer.inferIntent(tags);
+
+console.assert(intent.goal, 'Should have goal');
+console.assert(intent.category, 'Should have category');
+console.assert(intent.strength >= 0 && intent.strength <= 1, 'Strength should be 0-1');
+console.log(`✅ Intent: ${intent.goal} (${intent.category})\n`);
+
+// Test 2: calculateMaturity()
+console.log('Test 2: calculateMaturity()');
+const improvements = [{ hitCount: 100, appliedCount: 100 }];
+const mistakes = [];
+const maturity = CognitiveEnhancer.calculateMaturity(mistakes, improvements, intent);
+
+console.assert(maturity.state, 'Should have state');
+console.assert(maturity.confidence >= 0 && maturity.confidence <= 1, 'Confidence should be 0-1');
+console.assert(maturity.recommendation, 'Should have recommendation');
+console.log(`✅ Maturity: ${maturity.state} (${(maturity.confidence * 100).toFixed(0)}%)\n`);
+
+// Test 3: analyzeEvolution()
+console.log('Test 3: analyzeEvolution()');
+const evolution = CognitiveEnhancer.analyzeEvolution(mistakes, improvements, intent);
+
+console.assert(Array.isArray(evolution.signals), 'Should have signals array');
+console.assert(Array.isArray(evolution.missingAreas), 'Should have missingAreas array');
+console.assert(evolution.nextAction, 'Should have nextAction');
+console.log(`✅ Evolution: ${evolution.nextAction}\n`);
+
+// Test 4: Edge cases
+console.log('Test 4: Edge Cases');
+
+// Empty tags
+const emptyIntent = CognitiveEnhancer.inferIntent([]);
+console.assert(emptyIntent.category === 'general', 'Empty tags should default to general');
+console.log(`✅ Empty tags handled\n`);
+
+// High mistake count
+const highMistakes = Array(50).fill({ hitCount: 10 });
+const highMaturity = CognitiveEnhancer.calculateMaturity(highMistakes, [], intent);
+console.assert(highMaturity.state === 'RAW', 'Many mistakes should be RAW');
+console.log(`✅ High mistakes = RAW state\n`);
+
+// Perfect state
+const perfectImprovements = [{ hitCount: 1000, appliedCount: 1000 }];
+const perfectMaturity = CognitiveEnhancer.calculateMaturity([], perfectImprovements, intent);
+console.assert(perfectMaturity.state === 'IDEAL', 'Only improvements should be IDEAL');
+console.log(`✅ Only improvements = IDEAL state\n`);
+
+console.log('🎉 All CognitiveEnhancer tests passed!');

package/packages/cli/tests/unit/lesson-synthesizer.test.js

@@ -0,0 +1,84 @@
+// Unit Tests for LessonSynthesizer
+import { LessonSynthesizer } from '../../src/core/learning/lesson-synthesizer.js';
+
+console.log('🧪 Testing LessonSynthesizer\n');
+
+// Mock data
+const mockMistakes = [
+    {
+        id: 'MISTAKE-001',
+        pattern: 'test',
+        message: 'Test mistake',
+        tags: ['testing', 'quality'],
+        hitCount: 10
+    }
+];
+
+const mockImprovements = [
+    {
+        id: 'IMPROVE-001',
+        pattern: 'test',
+        message: 'Test improvement',
+        tags: ['testing', 'quality'],
+        appliedCount: 20
+    }
+];
+
+const mockLegacy = [
+    {
+        id: 'LEGACY-001',
+        pattern: 'old',
+        message: 'Old lesson',
+        category: 'general'
+    }
+];
+
+// Test 1: synthesizeLessons()
+console.log('Test 1: synthesizeLessons()');
+const lessons = LessonSynthesizer.synthesizeLessons(mockMistakes, mockImprovements, mockLegacy);
+
+console.assert(Array.isArray(lessons), 'Should return array');
+console.assert(lessons.length > 0, 'Should have lessons');
+console.log(`✅ Generated ${lessons.length} lesson(s)\n`);
+
+// Test 2: Lesson structure
+console.log('Test 2: Lesson Structure');
+const lesson = lessons[0];
+
+console.assert(lesson.id, 'Should have ID');
+console.assert(lesson.title, 'Should have title');
+console.assert(lesson.tag, 'Should have tag');
+console.assert(lesson.intent, 'Should have intent');
+console.assert(lesson.maturity, 'Should have maturity');
+console.assert(Array.isArray(lesson.mistakes), 'Should have mistakes array');
+console.assert(Array.isArray(lesson.improvements), 'Should have improvements array');
+console.log(`✅ Lesson structure valid\n`);
+
+// Test 3: Grouping by tags
+console.log('Test 3: Tag Grouping');
+const testingLesson = lessons.find(l => l.tag === 'testing');
+console.assert(testingLesson, 'Should group by testing tag');
+console.assert(testingLesson.mistakes.length > 0 || testingLesson.improvements.length > 0, 'Should have content');
+console.log(`✅ Grouped by tags correctly\n`);
+
+// Test 4: Enhanced with cognitive data
+console.log('Test 4: Cognitive Enhancement');
+console.assert(lesson.maturity.state, 'Should have maturity state');
+console.assert(lesson.maturity.confidence >= 0, 'Should have confidence score');
+console.assert(lesson.intent.goal, 'Should have intent goal');
+console.log(`✅ Enhanced with cognitive data\n`);
+
+// Test 5: Edge cases
+console.log('Test 5: Edge Cases');
+
+// Empty inputs
+const emptyLessons = LessonSynthesizer.synthesizeLessons([], [], []);
+console.assert(Array.isArray(emptyLessons), 'Empty inputs should return array');
+console.log(`✅ Empty inputs handled\n`);
+
+// Only legacy
+const legacyOnly = LessonSynthesizer.synthesizeLessons([], [], mockLegacy);
+console.assert(legacyOnly.length > 0, 'Should include legacy lessons');
+console.log(`✅ Legacy lessons included\n`);
+
+console.log('🎉 All LessonSynthesizer tests passed!');

package/packages/cli/tests/unit/skill-formatter.test.js

@@ -0,0 +1,106 @@
+// Unit Tests for SkillFormatter
+import { SkillFormatter } from '../../src/presentation/formatters/skill-formatter.js';
+
+console.log('🧪 Testing SkillFormatter\n');
+
+// Mock lesson
+const mockLesson = {
+    id: 'LESSON-TEST',
+    title: 'Test Lesson',
+    tag: 'test-tag',
+    intent: {
+        goal: 'Test coding practices',
+        category: 'quality',
+        strength: 0.9
+    },
+    maturity: {
+        state: 'MATURE',
+        confidence: 0.85,
+        coverage: '1 mistakes / 2 improvements',
+        recommendation: 'Keep improving',
+        indicators: {
+            balance: 0.67,
+            evidence: 0.8,
+            recency: 0.9
+        }
+    },
+    mistakes: [{
+        id: 'MISTAKE-TEST',
+        pattern: 'bad-code',
+        message: 'Avoid bad code',
+        severity: 'ERROR',
+        hitCount: 5,
+        tags: ['quality']
+    }],
+    improvements: [{
+        id: 'IMPROVE-TEST',
+        pattern: 'good-code',
+        message: 'Write good code',
+        appliedCount: 10,
+        tags: ['quality']
+    }],
+    evolution: {
+        signals: [],
+        missingAreas: [],
+        nextAction: 'Continue learning'
+    }
+};
+
+const formatter = new SkillFormatter();
+
+// Test 1: format() returns correct structure
+console.log('Test 1: Format Output Structure');
+const skill = formatter.format(mockLesson);
+
+console.assert(skill.name, 'Should have name');
+console.assert(skill.filename, 'Should have filename');
+console.assert(skill.content, 'Should have content');
+console.assert(skill.filename.endsWith('.md'), 'Filename should end with .md');
+console.log(`✅ Structure: ${skill.filename}\n`);
+
+// Test 2: Frontmatter format
+console.log('Test 2: Frontmatter Format');
+const lines = skill.content.split('\n');
+console.assert(lines[0] === '---', 'Should start with ---');
+console.assert(lines.some(l => l.includes('name:')), 'Should have name field');
+console.assert(lines.some(l => l.includes('confidence:')), 'Should have confidence field');
+console.assert(lines.some(l => l.includes('maturity:')), 'Should have maturity field');
+console.log(`✅ Frontmatter valid\n`);
+
+// Test 3: Content sections
+console.log('Test 3: Content Sections');
+console.assert(skill.content.includes('# Test Lesson'), 'Should have title');
+console.assert(skill.content.includes('## 🚫 Anti-Patterns'), 'Should have anti-patterns section');
+console.assert(skill.content.includes('## ✅ Best Practices'), 'Should have best practices section');
+console.assert(skill.content.includes('## 📊 Evolution Status'), 'Should have evolution section');
+console.assert(skill.content.includes('## 🎯 When to Apply'), 'Should have application guide');
+console.assert(skill.content.includes('## 📈 Confidence Metrics'), 'Should have metrics');
+console.log(`✅ All sections present\n`);
+
+// Test 4: Mistake formatting
+console.log('Test 4: Mistake Formatting');
+console.assert(skill.content.includes('MISTAKE-TEST'), 'Should include mistake ID');
+console.assert(skill.content.includes('Avoid bad code'), 'Should include mistake message');
+console.assert(skill.content.includes('Hit Count: 5'), 'Should include hit count');
+console.log(`✅ Mistakes formatted correctly\n`);
+
+// Test 5: Improvement formatting
+console.log('Test 5: Improvement Formatting');
+console.assert(skill.content.includes('IMPROVE-TEST'), 'Should include improvement ID');
+console.assert(skill.content.includes('Write good code'), 'Should include improvement message');
+console.assert(skill.content.includes('Applied Count: 10'), 'Should include applied count');
+console.log(`✅ Improvements formatted correctly\n`);
+
+// Test 6: sanitizeName()
+console.log('Test 6: Name Sanitization');
+const sanitized = formatter.sanitizeName('Test Tag-With_Special!Chars');
+console.assert(sanitized === 'test-tag-with-special-chars', 'Should sanitize name');
+console.log(`✅ Name sanitization works\n`);
+
+// Test 7: calculateTotalHits()
+console.log('Test 7: Total Hits Calculation');
+const totalHits = formatter.calculateTotalHits(mockLesson);
+console.assert(totalHits === 15, 'Should calculate total hits (5 + 10)');
+console.log(`✅ Total hits: ${totalHits}\n`);
+
+console.log('🎉 All SkillFormatter tests passed!');

package/packages/cli/vitest.config.js

@@ -2,8 +2,35 @@ import { defineConfig } from "vitest/config";
 
 export default defineConfig({
     test: {
+        // Globals
         globals: true,
+        
+        // Environment
         environment: "node",
-        include: ["lib/**/*.test.js"]
+        
+        // Test patterns
+        include: ["lib/**/*.test.js", "tests/**/*.test.js"],
+        
+        // Timeouts
+        testTimeout: 10000,
+        hookTimeout: 10000,
+        
+        // Coverage
+        coverage: {
+            provider: 'v8',
+            reporter: ['text', 'json', 'html'],
+            include: ['lib/**/*.js'],
+            exclude: [
+                '**/*.test.js',
+                '**/node_modules/**',
+                '**/tests/**'
+            ],
+            thresholds: {
+                lines: 70,
+                functions: 70,
+                branches: 65,
+                statements: 70
+            }
+        }
     }
 });