add-skill-kit 3.2.3 → 3.2.5

package/lib/agent-cli/lib/watcher.js

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+/**
+ * Smart Watcher - Real-Time File Monitoring
+ * 
+ * Watches for file changes and runs recall automatically.
+ * Features:
+ * - Debounced file change detection
+ * - Pattern frequency tracking
+ * - Live feedback on violations
+ * 
+ * Usage: agent watch [directory]
+ */
+
+import fs from "fs";
+import path from "path";
+import { scanFile, loadKnowledge, saveKnowledge } from "./recall.js";
+import { VERSION } from "./config.js";
+
+// ============================================================================
+// CONFIGURATION
+// ============================================================================
+
+const WATCH_EXTENSIONS = [".js", ".ts", ".tsx", ".jsx", ".mjs"];
+const DEBOUNCE_MS = 300;
+const SKIP_DIRS = ["node_modules", ".git", "dist", "build", ".next", "coverage"];
+
+// ============================================================================
+// WATCHER
+// ============================================================================
+
+class SmartWatcher {
+    constructor(rootDir) {
+        this.rootDir = path.resolve(rootDir);
+        this.db = loadKnowledge();
+        this.debounceTimers = new Map();
+        this.sessionStats = {
+            filesChecked: 0,
+            violationsFound: 0,
+            startTime: Date.now()
+        };
+    }
+
+    /**
+     * Start watching
+     */
+    start() {
+        console.log(`\n👁️  Smart Watcher v${VERSION}`);
+        console.log(`📂 Watching: ${this.rootDir}`);
+        console.log(`📚 Loaded ${this.db.lessons.length} pattern(s) from memory`);
+        console.log("─".repeat(50));
+        console.log("Watching for changes... (Ctrl+C to stop)\n");
+
+        this.watch(this.rootDir);
+    }
+
+    /**
+     * Recursively watch directories
+     */
+    watch(dir) {
+        try {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+            // Watch current directory
+            fs.watch(dir, { persistent: true }, (eventType, filename) => {
+                if (filename && eventType === "change") {
+                    this.handleChange(path.join(dir, filename));
+                }
+            });
+
+            // Recurse into subdirs
+            for (const entry of entries) {
+                if (entry.isDirectory() && !SKIP_DIRS.includes(entry.name)) {
+                    this.watch(path.join(dir, entry.name));
+                }
+            }
+        } catch (error) {
+            // Ignore permission errors
+        }
+    }
+
+    /**
+     * Handle file change with debouncing
+     */
+    handleChange(filePath) {
+        const ext = path.extname(filePath);
+        if (!WATCH_EXTENSIONS.includes(ext)) return;
+        if (!fs.existsSync(filePath)) return;
+
+        // Debounce
+        if (this.debounceTimers.has(filePath)) {
+            clearTimeout(this.debounceTimers.get(filePath));
+        }
+
+        this.debounceTimers.set(filePath, setTimeout(() => {
+            this.checkFile(filePath);
+            this.debounceTimers.delete(filePath);
+        }, DEBOUNCE_MS));
+    }
+
+    /**
+     * Check a file against memory
+     */
+    checkFile(filePath) {
+        const relativePath = path.relative(this.rootDir, filePath);
+        const result = scanFile(filePath, this.db, true);
+
+        this.sessionStats.filesChecked++;
+
+        if (result.violations.length === 0) {
+            console.log(`✅ ${relativePath}`);
+            return;
+        }
+
+        console.log(`\n⚠️  ${relativePath}`);
+
+        result.violations.forEach(({ lesson, matches }) => {
+            this.sessionStats.violationsFound += matches.length;
+
+            const icon = lesson.severity === "ERROR" ? "❌" : "⚠️";
+            console.log(`   ${icon} [${lesson.id}] ${lesson.message}`);
+
+            matches.slice(0, 3).forEach(m => {
+                console.log(`      L${m.line}: ${m.content}`);
+            });
+
+            if (matches.length > 3) {
+                console.log(`      ... and ${matches.length - 3} more`);
+            }
+        });
+
+        console.log("");
+
+        // Save updated stats
+        saveKnowledge(this.db);
+    }
+
+    /**
+     * Print session summary
+     */
+    printSummary() {
+        const duration = Math.round((Date.now() - this.sessionStats.startTime) / 1000);
+        console.log("\n" + "─".repeat(50));
+        console.log("📊 Session Summary:");
+        console.log(`   ⏱️  Duration: ${duration}s`);
+        console.log(`   📄 Files checked: ${this.sessionStats.filesChecked}`);
+        console.log(`   ⚠️  Violations found: ${this.sessionStats.violationsFound}`);
+    }
+}
+
+// ============================================================================
+// CLI
+// ============================================================================
+
+const args = process.argv.slice(2);
+const targetDir = args[0] || process.cwd();
+
+if (args.includes("--help")) {
+    console.log(`
+👁️  Smart Watcher - Real-Time Monitor
+
+Usage:
+  agent watch [directory]
+
+Options:
+  --help    Show this help
+
+The watcher monitors file changes and checks them against
+learned patterns in real-time.
+`);
+    process.exit(0);
+}
+
+const watcher = new SmartWatcher(targetDir);
+
+// Handle graceful shutdown
+process.on("SIGINT", () => {
+    watcher.printSummary();
+    process.exit(0);
+});
+
+watcher.start();

package/lib/agent-cli/lib/watcher.test.js

@@ -0,0 +1,85 @@
+/**
+ * @fileoverview Tests for watcher.js functionality
+ */
+import { describe, it, expect } from "vitest";
+import path from "path";
+
+describe("Watcher - Extension Filtering", () => {
+    const WATCH_EXTENSIONS = [".js", ".ts", ".tsx", ".jsx", ".mjs"];
+
+    it("includes JavaScript files", () => {
+        const file = "app.js";
+        const ext = path.extname(file);
+        expect(WATCH_EXTENSIONS.includes(ext)).toBe(true);
+    });
+
+    it("includes TypeScript files", () => {
+        const file = "app.tsx";
+        const ext = path.extname(file);
+        expect(WATCH_EXTENSIONS.includes(ext)).toBe(true);
+    });
+
+    it("excludes CSS files", () => {
+        const file = "styles.css";
+        const ext = path.extname(file);
+        expect(WATCH_EXTENSIONS.includes(ext)).toBe(false);
+    });
+
+    it("excludes markdown files", () => {
+        const file = "README.md";
+        const ext = path.extname(file);
+        expect(WATCH_EXTENSIONS.includes(ext)).toBe(false);
+    });
+});
+
+describe("Watcher - Directory Filtering", () => {
+    const SKIP_DIRS = ["node_modules", ".git", "dist", "build", ".next", "coverage"];
+
+    it("skips node_modules", () => {
+        expect(SKIP_DIRS.includes("node_modules")).toBe(true);
+    });
+
+    it("skips .git directory", () => {
+        expect(SKIP_DIRS.includes(".git")).toBe(true);
+    });
+
+    it("skips dist directory", () => {
+        expect(SKIP_DIRS.includes("dist")).toBe(true);
+    });
+
+    it("allows src directory", () => {
+        expect(SKIP_DIRS.includes("src")).toBe(false);
+    });
+
+    it("allows lib directory", () => {
+        expect(SKIP_DIRS.includes("lib")).toBe(false);
+    });
+});
+
+describe("Watcher - Session Stats", () => {
+    it("initializes session stats correctly", () => {
+        const sessionStats = {
+            filesChecked: 0,
+            violationsFound: 0,
+            startTime: Date.now()
+        };
+
+        expect(sessionStats.filesChecked).toBe(0);
+        expect(sessionStats.violationsFound).toBe(0);
+        expect(typeof sessionStats.startTime).toBe("number");
+    });
+
+    it("increments file count correctly", () => {
+        const sessionStats = { filesChecked: 0 };
+        sessionStats.filesChecked++;
+        sessionStats.filesChecked++;
+        expect(sessionStats.filesChecked).toBe(2);
+    });
+
+    it("calculates duration correctly", () => {
+        const startTime = Date.now() - 5000; // 5 seconds ago
+        const duration = Math.round((Date.now() - startTime) / 1000);
+        expect(duration).toBeGreaterThanOrEqual(4);
+        expect(duration).toBeLessThanOrEqual(6);
+    });
+});

package/lib/agent-cli/package.json

@@ -0,0 +1,51 @@
+{
+    "name": "agentskillskit-cli",
+    "version": "3.2.4",
+    "description": "CLI for Agent Skill Kit",
+    "type": "module",
+    "main": "lib/config.js",
+    "bin": {
+        "agent": "bin/agent.js",
+        "agent": "bin/agent.js",
+        "agent-skills-kit": "bin/agent.js"
+    },
+    "scripts": {
+        "test": "vitest run",
+        "test:watch": "vitest"
+    },
+    "dependencies": {
+        "@clack/core": "^0.5.0",
+        "@clack/prompts": "^0.11.0",
+        "boxen": "^8.0.1",
+        "clipboardy": "^5.1.0",
+        "js-yaml": "^4.1.0",
+        "ora": "^9.1.0",
+        "picocolors": "^1.1.1"
+    },
+    "devDependencies": {
+        "vitest": "^1.6.0"
+    },
+    "author": "Agent Skill Kit Authors",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/agentskillkit/agent-skills.git",
+        "directory": "packages/cli"
+    },
+    "keywords": [
+        "agent",
+        "ai",
+        "skills",
+        "cli",
+        "tooling",
+        "antigravity"
+    ],
+    "files": [
+        "bin",
+        "lib",
+        "README.md"
+    ],
+    "publishConfig": {
+        "access": "public"
+    }
+}

package/lib/agent-cli/scripts/adaptive_engine.js

@@ -0,0 +1,381 @@
+#!/usr/bin/env node
+/**
+ * Adaptive Engine - Auto-adjust severity and promote/demote rules
+ * 
+ * Part of FAANG-Grade Auto-Learn System Phase 5
+ * 
+ * Features:
+ * - Auto-adjust severity based on hit count
+ * - Auto-promote rules with 95%+ accuracy to core
+ * - Auto-demote rules with <50% accuracy
+ * - Track rule effectiveness
+ * 
+ * Usage:
+ *   node adaptive_engine.js --analyze
+ *   node adaptive_engine.js --promote
+ *   node adaptive_engine.js --demote
+ */
+
+import fs from 'fs';
+import path from 'path';
+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',
+    blue: '\x1b[34m',
+    cyan: '\x1b[36m',
+    gray: '\x1b[90m',
+    bold: '\x1b[1m'
+};
+
+// Paths
+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();
+}
+
+const projectRoot = findProjectRoot();
+const knowledgePath = path.join(projectRoot, '.agent', 'knowledge');
+
+// Severity levels
+const SEVERITY_LEVELS = ['LOW', 'MEDIUM', 'HIGH', 'CRITICAL'];
+
+// Load JSON file
+function loadJson(filename) {
+    const filePath = path.join(knowledgePath, filename);
+    try {
+        if (fs.existsSync(filePath)) {
+            return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        }
+    } catch { }
+    return null;
+}
+
+// Save JSON file
+function saveJson(filename, data) {
+    const filePath = path.join(knowledgePath, filename);
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+}
+
+// ==================== SEVERITY ADJUSTMENT ====================
+
+/**
+ * Auto-adjust severity based on hit count
+ * Rules hit 10+ times -> increase severity
+ * Rules hit 0 times in 30 days -> decrease severity
+ */
+function adjustSeverity() {
+    const lessons = loadJson('lessons-learned.json');
+    if (!lessons?.lessons?.length) {
+        console.log(`${c.gray}No lessons to analyze${c.reset}`);
+        return [];
+    }
+
+    const adjustments = [];
+    const thirtyDaysAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
+
+    for (const lesson of lessons.lessons) {
+        const hitCount = lesson.hitCount || 0;
+        const currentSeverity = lesson.severity || 'MEDIUM';
+        const currentIndex = SEVERITY_LEVELS.indexOf(currentSeverity);
+        const lastHit = lesson.lastHit ? new Date(lesson.lastHit) : null;
+
+        let newSeverity = currentSeverity;
+        let reason = null;
+
+        // Increase severity if hit 10+ times
+        if (hitCount >= 10 && currentIndex < SEVERITY_LEVELS.length - 1) {
+            newSeverity = SEVERITY_LEVELS[currentIndex + 1];
+            reason = `Hit ${hitCount} times - increasing severity`;
+        }
+        // Further increase if hit 25+ times
+        else if (hitCount >= 25 && currentIndex < SEVERITY_LEVELS.length - 2) {
+            newSeverity = SEVERITY_LEVELS[currentIndex + 2];
+            reason = `Hit ${hitCount} times - promoting to ${newSeverity}`;
+        }
+        // Decrease severity if not hit in 30 days
+        else if (lastHit && lastHit < thirtyDaysAgo && currentIndex > 0) {
+            newSeverity = SEVERITY_LEVELS[currentIndex - 1];
+            reason = `Not hit in 30 days - decreasing severity`;
+        }
+
+        if (reason) {
+            lesson.severity = newSeverity;
+            lesson.adjustedAt = new Date().toISOString();
+            adjustments.push({
+                id: lesson.id,
+                from: currentSeverity,
+                to: newSeverity,
+                reason
+            });
+        }
+    }
+
+    if (adjustments.length > 0) {
+        saveJson('lessons-learned.json', lessons);
+    }
+
+    return adjustments;
+}
+
+// ==================== AUTO-PROMOTION ====================
+
+/**
+ * Promote rules with 95%+ accuracy to core rules
+ */
+function promoteRules() {
+    const lessons = loadJson('lessons-learned.json');
+    if (!lessons?.lessons?.length) {
+        console.log(`${c.gray}No lessons to analyze${c.reset}`);
+        return [];
+    }
+
+    const promoted = [];
+
+    for (const lesson of lessons.lessons) {
+        const hitCount = lesson.hitCount || 0;
+        const successCount = lesson.successCount || 0;
+        const totalAttempts = hitCount + successCount;
+
+        // Need at least 10 attempts to evaluate
+        if (totalAttempts < 10) continue;
+
+        const accuracy = successCount / totalAttempts;
+
+        // Promote if 95%+ accuracy and not already CRITICAL
+        if (accuracy >= 0.95 && lesson.severity !== 'CRITICAL' && !lesson.promoted) {
+            lesson.promoted = true;
+            lesson.promotedAt = new Date().toISOString();
+            lesson.previousSeverity = lesson.severity;
+            lesson.severity = 'CRITICAL';
+
+            promoted.push({
+                id: lesson.id,
+                pattern: lesson.pattern,
+                accuracy: Math.round(accuracy * 100),
+                status: 'PROMOTED_TO_CORE'
+            });
+        }
+    }
+
+    if (promoted.length > 0) {
+        saveJson('lessons-learned.json', lessons);
+    }
+
+    return promoted;
+}
+
+/**
+ * Demote rules with <50% accuracy
+ */
+function demoteRules() {
+    const lessons = loadJson('lessons-learned.json');
+    if (!lessons?.lessons?.length) {
+        console.log(`${c.gray}No lessons to analyze${c.reset}`);
+        return [];
+    }
+
+    const demoted = [];
+
+    for (const lesson of lessons.lessons) {
+        const hitCount = lesson.hitCount || 0;
+        const successCount = lesson.successCount || 0;
+        const totalAttempts = hitCount + successCount;
+
+        // Need at least 10 attempts to evaluate
+        if (totalAttempts < 10) continue;
+
+        const accuracy = successCount / totalAttempts;
+
+        // Demote if <50% accuracy and higher than LOW
+        if (accuracy < 0.50 && lesson.severity !== 'LOW' && !lesson.demoted) {
+            lesson.demoted = true;
+            lesson.demotedAt = new Date().toISOString();
+            lesson.previousSeverity = lesson.severity;
+            lesson.severity = 'LOW';
+
+            demoted.push({
+                id: lesson.id,
+                pattern: lesson.pattern,
+                accuracy: Math.round(accuracy * 100),
+                status: 'DEMOTED_TO_LOW'
+            });
+        }
+    }
+
+    if (demoted.length > 0) {
+        saveJson('lessons-learned.json', lessons);
+    }
+
+    return demoted;
+}
+
+// ==================== ANALYSIS ====================
+
+/**
+ * Analyze all rules and provide recommendations
+ */
+function analyzeRules() {
+    const lessons = loadJson('lessons-learned.json');
+
+    console.log(`${c.cyan}╔════════════════════════════════════════╗${c.reset}`);
+    console.log(`${c.cyan}║${c.reset}  🧠 Adaptive Engine Analysis            ${c.cyan}║${c.reset}`);
+    console.log(`${c.cyan}╚════════════════════════════════════════╝${c.reset}\n`);
+
+    if (!lessons?.lessons?.length) {
+        console.log(`${c.gray}No lessons found. Run error_sensor first.${c.reset}`);
+        return;
+    }
+
+    // Group by severity
+    const bySeverity = {};
+    for (const lesson of lessons.lessons) {
+        const sev = lesson.severity || 'MEDIUM';
+        bySeverity[sev] = (bySeverity[sev] || 0) + 1;
+    }
+
+    console.log(`${c.bold}Current Distribution:${c.reset}`);
+    for (const sev of SEVERITY_LEVELS) {
+        const count = bySeverity[sev] || 0;
+        const bar = '█'.repeat(Math.min(count, 20));
+        const color = { LOW: c.gray, MEDIUM: c.blue, HIGH: c.yellow, CRITICAL: c.red }[sev];
+        console.log(`  ${color}${sev.padEnd(8)}${c.reset} ${bar} ${count}`);
+    }
+
+    // Find candidates for promotion/demotion
+    const promotionCandidates = [];
+    const demotionCandidates = [];
+
+    for (const lesson of lessons.lessons) {
+        const hitCount = lesson.hitCount || 0;
+
+        if (hitCount >= 10 && lesson.severity !== 'CRITICAL') {
+            promotionCandidates.push(lesson);
+        }
+        if (hitCount === 0 && lesson.severity !== 'LOW') {
+            demotionCandidates.push(lesson);
+        }
+    }
+
+    if (promotionCandidates.length > 0) {
+        console.log(`\n${c.green}${c.bold}Promotion Candidates (high hit count):${c.reset}`);
+        for (const l of promotionCandidates.slice(0, 5)) {
+            console.log(`  ${c.green}↑${c.reset} ${l.id}: ${l.pattern?.slice(0, 40)}... (${l.hitCount} hits)`);
+        }
+    }
+
+    if (demotionCandidates.length > 0) {
+        console.log(`\n${c.yellow}${c.bold}Demotion Candidates (no hits):${c.reset}`);
+        for (const l of demotionCandidates.slice(0, 5)) {
+            console.log(`  ${c.yellow}↓${c.reset} ${l.id}: ${l.pattern?.slice(0, 40)}...`);
+        }
+    }
+
+    console.log(`\n${c.gray}Total lessons: ${lessons.lessons.length}${c.reset}`);
+    console.log(`${c.gray}Run --adjust to apply severity changes${c.reset}`);
+}
+
+/**
+ * Run full adaptive cycle
+ */
+function runAdaptiveCycle() {
+    console.log(`${c.cyan}🔄 Running Adaptive Cycle...${c.reset}\n`);
+
+    // Step 1: Adjust severity
+    console.log(`${c.bold}Step 1: Severity Adjustment${c.reset}`);
+    const adjustments = adjustSeverity();
+    if (adjustments.length > 0) {
+        for (const adj of adjustments) {
+            console.log(`  ${adj.id}: ${adj.from} → ${adj.to} (${adj.reason})`);
+        }
+    } else {
+        console.log(`  ${c.gray}No adjustments needed${c.reset}`);
+    }
+
+    // Step 2: Promote high-performers
+    console.log(`\n${c.bold}Step 2: Auto-Promotion${c.reset}`);
+    const promoted = promoteRules();
+    if (promoted.length > 0) {
+        for (const p of promoted) {
+            console.log(`  ${c.green}↑ PROMOTED${c.reset}: ${p.id} (${p.accuracy}% accuracy)`);
+        }
+    } else {
+        console.log(`  ${c.gray}No rules meet promotion threshold (95%+)${c.reset}`);
+    }
+
+    // Step 3: Demote low-performers
+    console.log(`\n${c.bold}Step 3: Auto-Demotion${c.reset}`);
+    const demoted = demoteRules();
+    if (demoted.length > 0) {
+        for (const d of demoted) {
+            console.log(`  ${c.yellow}↓ DEMOTED${c.reset}: ${d.id} (${d.accuracy}% accuracy)`);
+        }
+    } else {
+        console.log(`  ${c.gray}No rules meet demotion threshold (<50%)${c.reset}`);
+    }
+
+    console.log(`\n${c.green}✓ Adaptive cycle complete!${c.reset}`);
+    console.log(`  Adjusted: ${adjustments.length}`);
+    console.log(`  Promoted: ${promoted.length}`);
+    console.log(`  Demoted: ${demoted.length}`);
+}
+
+// ==================== MAIN ====================
+
+const args = process.argv.slice(2);
+
+if (args.includes('--analyze') || args.includes('-a')) {
+    analyzeRules();
+} else if (args.includes('--adjust')) {
+    console.log(`${c.cyan}Adjusting severity levels...${c.reset}`);
+    const adjustments = adjustSeverity();
+    console.log(`${c.green}✓ Made ${adjustments.length} adjustments${c.reset}`);
+    for (const adj of adjustments) {
+        console.log(`  ${adj.id}: ${adj.from} → ${adj.to}`);
+    }
+} else if (args.includes('--promote')) {
+    console.log(`${c.cyan}Checking for promotion candidates...${c.reset}`);
+    const promoted = promoteRules();
+    console.log(`${c.green}✓ Promoted ${promoted.length} rules${c.reset}`);
+} else if (args.includes('--demote')) {
+    console.log(`${c.cyan}Checking for demotion candidates...${c.reset}`);
+    const demoted = demoteRules();
+    console.log(`${c.yellow}✓ Demoted ${demoted.length} rules${c.reset}`);
+} else if (args.includes('--run') || args.includes('-r')) {
+    runAdaptiveCycle();
+} else {
+    console.log(`${c.cyan}adaptive_engine - Auto-adjust severity and promote/demote rules${c.reset}
+
+${c.bold}Usage:${c.reset}
+  node adaptive_engine.js --analyze    Analyze rules and show recommendations
+  node adaptive_engine.js --adjust     Adjust severity based on hit count
+  node adaptive_engine.js --promote    Promote high-accuracy rules
+  node adaptive_engine.js --demote     Demote low-accuracy rules
+  node adaptive_engine.js --run        Run full adaptive cycle
+
+${c.bold}Thresholds:${c.reset}
+  Severity increase: 10+ hits
+  Severity decrease: 0 hits in 30 days
+  Promotion: 95%+ accuracy with 10+ attempts
+  Demotion: <50% accuracy with 10+ attempts
+
+${c.bold}Examples:${c.reset}
+  node adaptive_engine.js --analyze    View current state
+  node adaptive_engine.js --run        Apply all adaptations
+`);
+}
+
+export { adjustSeverity, promoteRules, demoteRules, analyzeRules, runAdaptiveCycle };