add-skill-kit 3.2.4 → 3.2.5

package/lib/agent-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/lib/agent-cli/types/index.d.ts

@@ -0,0 +1,343 @@
+/**
+ * Auto-Learn System TypeScript Definitions
+ * 
+ * Provides type safety for consumers of Auto-Learn scripts.
+ * These types match the JSON structures used in .agent/knowledge/
+ */
+
+// ==================== CORE TYPES ====================
+
+/**
+ * Severity levels for rules and lessons
+ */
+export type Severity = 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
+
+/**
+ * Risk level for intent detection
+ */
+export type RiskLevel = 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
+
+/**
+ * Health status for trend analysis
+ */
+export type HealthStatus = 'IMPROVING' | 'STABLE' | 'NEUTRAL' | 'DECLINING';
+
+// ==================== LESSONS ====================
+
+/**
+ * A learned lesson from errors or corrections
+ */
+export interface Lesson {
+    id: string;
+    pattern: string;
+    message: string;
+    severity: Severity;
+    hitCount?: number;
+    successCount?: number;
+    lastHit?: string;
+    promoted?: boolean;
+    promotedAt?: string;
+    demoted?: boolean;
+    demotedAt?: string;
+    previousSeverity?: Severity;
+    confidence?: number;
+    adjustedAt?: string;
+    importedAt?: string;
+    source?: 'auto' | 'manual' | 'imported';
+}
+
+/**
+ * Collection of lessons
+ */
+export interface LessonsData {
+    lessons: Lesson[];
+    lastUpdated?: string;
+}
+
+// ==================== ERRORS ====================
+
+/**
+ * A detected error
+ */
+export interface DetectedError {
+    id: string;
+    type: string;
+    source: 'test' | 'build' | 'lint' | 'runtime' | 'code';
+    message: string;
+    file?: string;
+    line?: number;
+    severity: Severity;
+    timestamp: string;
+    context?: ErrorContext;
+}
+
+/**
+ * Error context information
+ */
+export interface ErrorContext {
+    project?: ProjectContext;
+    file?: FileContext;
+}
+
+/**
+ * Collection of errors
+ */
+export interface ErrorsData {
+    errors: DetectedError[];
+    lastUpdated?: string;
+}
+
+// ==================== SUCCESSES ====================
+
+/**
+ * A detected success pattern
+ */
+export interface SuccessPattern {
+    id: string;
+    pattern: string;
+    type: 'pattern' | 'practice' | 'test' | 'build' | 'lint';
+    file?: string;
+    detectedAt: string;
+    context?: SuccessContext;
+}
+
+/**
+ * Success context information
+ */
+export interface SuccessContext {
+    project?: ProjectContext;
+    file?: FileContext;
+}
+
+/**
+ * Collection of successes
+ */
+export interface SuccessesData {
+    successes: SuccessPattern[];
+    lastUpdated?: string;
+}
+
+// ==================== CONTEXT ====================
+
+/**
+ * Project context information
+ */
+export interface ProjectContext {
+    projectType: 'unknown' | 'nextjs' | 'react' | 'react-native' | 'backend' | 'nodejs';
+    framework?: string;
+    language: 'javascript' | 'typescript';
+    hasTypeScript?: boolean;
+    hasTesting?: boolean;
+}
+
+/**
+ * File context information
+ */
+export interface FileContext {
+    fileType: string;
+    isTypeScript: boolean;
+    isTest: boolean;
+    isComponent: boolean;
+    directory: string;
+    fullPath: string;
+    area?: 'source' | 'library' | 'test' | 'config' | 'other';
+}
+
+// ==================== RULES ====================
+
+/**
+ * A matched rule from pre-execution check
+ */
+export interface RuleMatch {
+    id: string;
+    name?: string;
+    pattern?: string;
+    prevention: string;
+    severity: Severity;
+    source: 'builtin' | 'lesson' | 'auto-rule' | 'active-rule' | 'intent-detection';
+}
+
+/**
+ * An auto-generated rule
+ */
+export interface AutoRule {
+    id: string;
+    pattern: string;
+    prevention: string;
+    severity: Severity;
+    status: 'proposed' | 'approved' | 'rejected';
+    hitCount?: number;
+    successRate?: number;
+}
+
+// ==================== INTENT DETECTION ====================
+
+/**
+ * A detected intent from user input
+ */
+export interface DetectedIntent {
+    action: string;
+    target: string;
+    risk: RiskLevel;
+}
+
+/**
+ * Result of intent check
+ */
+export interface IntentCheckResult {
+    violations: RuleMatch[];
+    warnings: RuleMatch[];
+    recommendations: RuleMatch[];
+    detectedIntents: DetectedIntent[];
+}
+
+// ==================== PATTERNS ====================
+
+/**
+ * Error patterns analysis
+ */
+export interface ErrorPatterns {
+    byType: Record<string, number>;
+    bySeverity: Record<Severity, number>;
+    byFile: Record<string, number>;
+    byTime: Record<string, number>;
+    total: number;
+}
+
+/**
+ * Correction patterns analysis
+ */
+export interface CorrectionPatterns {
+    byCategory: Record<string, number>;
+    byFile: Record<string, number>;
+    total: number;
+}
+
+/**
+ * High-frequency pattern candidate for auto-rule
+ */
+export interface HighFrequencyPattern {
+    pattern: string;
+    count: number;
+    type: 'error' | 'correction' | 'category';
+    suggestedRule?: AutoRule;
+}
+
+// ==================== TRENDS ====================
+
+/**
+ * Weekly comparison data
+ */
+export interface TrendData {
+    period: {
+        from: string;
+        to: string;
+    };
+    thisWeek: {
+        errors: number;
+        successes: number;
+    };
+    lastWeek: {
+        errors: number;
+        successes: number;
+    };
+    trends: {
+        errorChange: number;
+        successChange: number;
+    };
+    healthStatus: HealthStatus;
+    analysis: {
+        errorDirection: 'decreasing' | 'stable' | 'increasing';
+        successDirection: 'decreasing' | 'stable' | 'increasing';
+    };
+}
+
+/**
+ * Daily breakdown for charts
+ */
+export interface DailyBreakdown {
+    date: string;
+    errors: number;
+    successes: number;
+    ratio: number;
+}
+
+// ==================== SUCCESS/FAILURE RATIO ====================
+
+/**
+ * Success/failure ratio analysis
+ */
+export interface BalanceRatio {
+    ratio: number;
+    status: 'EXCELLENT' | 'GOOD' | 'LEARNING' | 'NEEDS_ATTENTION' | 'NO_DATA';
+    message: string;
+    failures: number;
+    successes: number;
+    breakdown: {
+        errors: number;
+        corrections: number;
+        successPatterns: number;
+    };
+}
+
+// ==================== ADAPTIVE ENGINE ====================
+
+/**
+ * Severity adjustment record
+ */
+export interface SeverityAdjustment {
+    id: string;
+    from: Severity;
+    to: Severity;
+    reason: string;
+}
+
+/**
+ * Promotion/demotion record
+ */
+export interface RulePromotion {
+    id: string;
+    pattern: string;
+    accuracy: number;
+    status: 'PROMOTED_TO_CORE' | 'DEMOTED_TO_LOW';
+}
+
+// ==================== SKILL INJECTION ====================
+
+/**
+ * Skill candidate for generation
+ */
+export interface SkillCandidate {
+    category: string;
+    count: number;
+    config: {
+        name: string;
+        description: string;
+    };
+}
+
+/**
+ * Generated skill result
+ */
+export interface GeneratedSkill {
+    category: string;
+    name: string;
+    path: string;
+    lessonCount: number;
+}
+
+// ==================== RULE SHARING ====================
+
+/**
+ * Exported rules in YAML format
+ */
+export interface ExportedRules {
+    metadata: {
+        project: string;
+        exportedAt: string;
+        totalRules: number;
+    };
+    lessons: Lesson[];
+    autoRules: AutoRule[];
+    highFrequency: HighFrequencyPattern[];
+}

package/lib/agent-cli/utils/benchmark.js

@@ -0,0 +1,269 @@
+/**
+ * Performance Benchmark Utility
+ * 
+ * Provides tools for measuring and reporting performance:
+ * - Execution time measurement
+ * - Memory usage tracking
+ * - Performance reports
+ * 
+ * Usage:
+ *   import { benchmark, measure, report } from './benchmark.js';
+ *   
+ *   const result = await measure('operation-name', async () => {
+ *       // code to measure
+ *   });
+ *   
+ *   report();
+ */
+
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+
+// ==================== STORAGE ====================
+
+const metrics = new Map();
+const thresholds = {
+    fast: 100,       // < 100ms
+    normal: 500,     // 100-500ms
+    slow: 1000,      // 500-1000ms
+    // > 1000ms = very slow
+};
+
+// ==================== COLORS ====================
+
+const c = {
+    reset: '\x1b[0m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    cyan: '\x1b[36m',
+    gray: '\x1b[90m',
+    bold: '\x1b[1m'
+};
+
+// ==================== TIMING ====================
+
+/**
+ * Measure execution time of a function
+ * @param {string} name - Operation name
+ * @param {Function} fn - Function to measure
+ * @returns {Promise<{result: any, duration: number, memory: object}>}
+ */
+async function measure(name, fn) {
+    const startTime = performance.now();
+    const startMemory = process.memoryUsage();
+
+    let result;
+    let error = null;
+
+    try {
+        result = await fn();
+    } catch (e) {
+        error = e;
+    }
+
+    const endTime = performance.now();
+    const endMemory = process.memoryUsage();
+
+    const duration = Math.round((endTime - startTime) * 100) / 100;
+    const memoryDelta = {
+        heapUsed: endMemory.heapUsed - startMemory.heapUsed,
+        heapTotal: endMemory.heapTotal - startMemory.heapTotal,
+        external: endMemory.external - startMemory.external
+    };
+
+    // Store metric
+    const metric = {
+        name,
+        duration,
+        memory: memoryDelta,
+        timestamp: new Date().toISOString(),
+        success: !error
+    };
+
+    if (!metrics.has(name)) {
+        metrics.set(name, []);
+    }
+    metrics.get(name).push(metric);
+
+    if (error) {
+        throw error;
+    }
+
+    return { result, duration, memory: memoryDelta };
+}
+
+/**
+ * Simple timing wrapper
+ * @param {string} label - Operation label
+ */
+function time(label) {
+    const start = performance.now();
+    return {
+        end: () => {
+            const duration = performance.now() - start;
+            console.log(`${c.gray}⏱️ ${label}: ${duration.toFixed(2)}ms${c.reset}`);
+            return duration;
+        }
+    };
+}
+
+/**
+ * Benchmark multiple iterations
+ * @param {string} name - Benchmark name
+ * @param {Function} fn - Function to benchmark
+ * @param {number} iterations - Number of iterations
+ */
+async function benchmark(name, fn, iterations = 10) {
+    const results = [];
+
+    for (let i = 0; i < iterations; i++) {
+        const start = performance.now();
+        await fn();
+        results.push(performance.now() - start);
+    }
+
+    const avg = results.reduce((a, b) => a + b, 0) / results.length;
+    const min = Math.min(...results);
+    const max = Math.max(...results);
+    const p95 = results.sort((a, b) => a - b)[Math.floor(results.length * 0.95)];
+
+    return {
+        name,
+        iterations,
+        avg: Math.round(avg * 100) / 100,
+        min: Math.round(min * 100) / 100,
+        max: Math.round(max * 100) / 100,
+        p95: Math.round(p95 * 100) / 100
+    };
+}
+
+// ==================== MEMORY ====================
+
+/**
+ * Get current memory usage
+ */
+function getMemoryUsage() {
+    const usage = process.memoryUsage();
+    return {
+        heapUsed: formatBytes(usage.heapUsed),
+        heapTotal: formatBytes(usage.heapTotal),
+        external: formatBytes(usage.external),
+        rss: formatBytes(usage.rss)
+    };
+}
+
+/**
+ * Format bytes to human readable
+ */
+function formatBytes(bytes) {
+    if (bytes < 1024) return `${bytes}B`;
+    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+
+// ==================== REPORTING ====================
+
+/**
+ * Get performance status color
+ */
+function getStatusColor(duration) {
+    if (duration < thresholds.fast) return c.green;
+    if (duration < thresholds.normal) return c.blue;
+    if (duration < thresholds.slow) return c.yellow;
+    return c.red;
+}
+
+/**
+ * Get performance status label
+ */
+function getStatusLabel(duration) {
+    if (duration < thresholds.fast) return '🚀 FAST';
+    if (duration < thresholds.normal) return '✓ NORMAL';
+    if (duration < thresholds.slow) return '⚠️ SLOW';
+    return '❌ VERY SLOW';
+}
+
+/**
+ * Print performance report
+ */
+function report() {
+    console.log(`\n${c.cyan}╔════════════════════════════════════════╗${c.reset}`);
+    console.log(`${c.cyan}║${c.reset}  📊 Performance Report                  ${c.cyan}║${c.reset}`);
+    console.log(`${c.cyan}╚════════════════════════════════════════╝${c.reset}\n`);
+
+    if (metrics.size === 0) {
+        console.log(`${c.gray}No metrics collected yet.${c.reset}`);
+        return;
+    }
+
+    for (const [name, data] of metrics) {
+        const durations = data.map(d => d.duration);
+        const avg = durations.reduce((a, b) => a + b, 0) / durations.length;
+        const color = getStatusColor(avg);
+        const status = getStatusLabel(avg);
+
+        console.log(`${c.bold}${name}${c.reset}`);
+        console.log(`  Runs: ${data.length}`);
+        console.log(`  Avg: ${color}${avg.toFixed(2)}ms${c.reset} ${status}`);
+        console.log(`  Min: ${Math.min(...durations).toFixed(2)}ms`);
+        console.log(`  Max: ${Math.max(...durations).toFixed(2)}ms`);
+        console.log('');
+    }
+
+    // Memory summary
+    const mem = getMemoryUsage();
+    console.log(`${c.bold}Memory Usage${c.reset}`);
+    console.log(`  Heap: ${mem.heapUsed} / ${mem.heapTotal}`);
+    console.log(`  RSS: ${mem.rss}`);
+}
+
+/**
+ * Get metrics as JSON
+ */
+function getMetrics() {
+    const result = {};
+    for (const [name, data] of metrics) {
+        const durations = data.map(d => d.duration);
+        result[name] = {
+            runs: data.length,
+            avg: durations.reduce((a, b) => a + b, 0) / durations.length,
+            min: Math.min(...durations),
+            max: Math.max(...durations),
+            success: data.filter(d => d.success).length
+        };
+    }
+    return result;
+}
+
+/**
+ * Clear all metrics
+ */
+function clear() {
+    metrics.clear();
+}
+
+// ==================== EXPORTS ====================
+
+export {
+    measure,
+    time,
+    benchmark,
+    getMemoryUsage,
+    report,
+    getMetrics,
+    clear,
+    thresholds
+};
+
+export default {
+    measure,
+    time,
+    benchmark,
+    getMemoryUsage,
+    report,
+    getMetrics,
+    clear
+};