@agentskillkit/agent-skills 1.0.1 → 3.2.1

package/packages/cli/lib/recall.test.js

@@ -0,0 +1,107 @@
+/**
+ * @fileoverview Tests for recall.js functionality
+ */
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+const TEST_DIR = path.join(os.tmpdir(), "agent-skill-kit-recall-test");
+const KNOWLEDGE_DIR = path.join(TEST_DIR, ".agent", "knowledge");
+const LESSONS_PATH = path.join(KNOWLEDGE_DIR, "lessons-learned.yaml");
+const TEST_FILE = path.join(TEST_DIR, "test-code.js");
+
+describe("Recall - Pattern Matching", () => {
+    beforeEach(() => {
+        fs.mkdirSync(KNOWLEDGE_DIR, { recursive: true });
+    });
+
+    afterEach(() => {
+        fs.rmSync(TEST_DIR, { recursive: true, force: true });
+    });
+
+    it("detects pattern matches in code", () => {
+        const codeContent = `
+            console.log("debug");
+            const x = 1;
+        `;
+        const pattern = /console\.log/g;
+        const matches = codeContent.match(pattern);
+
+        expect(matches).not.toBeNull();
+        expect(matches.length).toBe(1);
+    });
+
+    it("returns null when no pattern matches", () => {
+        const codeContent = `const x = 1;`;
+        const pattern = /console\.log/g;
+        const matches = codeContent.match(pattern);
+
+        expect(matches).toBeNull();
+    });
+
+    it("counts multiple occurrences", () => {
+        const codeContent = `
+            console.log("one");
+            console.log("two");
+            console.log("three");
+        `;
+        const pattern = /console\.log/g;
+        const matches = codeContent.match(pattern);
+
+        expect(matches).not.toBeNull();
+        expect(matches.length).toBe(3);
+    });
+
+    it("can scan files from filesystem", () => {
+        const testCode = `console.log("test");`;
+        fs.writeFileSync(TEST_FILE, testCode, "utf8");
+
+        const content = fs.readFileSync(TEST_FILE, "utf8");
+        expect(content).toContain("console.log");
+    });
+
+    it("finds line numbers for matches", () => {
+        const lines = [
+            "const a = 1;",
+            "console.log('found');",
+            "const b = 2;"
+        ];
+        const pattern = /console\.log/;
+
+        const matchingLines = lines
+            .map((line, idx) => ({ line, num: idx + 1 }))
+            .filter(({ line }) => pattern.test(line));
+
+        expect(matchingLines.length).toBe(1);
+        expect(matchingLines[0].num).toBe(2);
+    });
+});
+
+describe("Recall - Directory Scanning", () => {
+    beforeEach(() => {
+        fs.mkdirSync(KNOWLEDGE_DIR, { recursive: true });
+    });
+
+    afterEach(() => {
+        fs.rmSync(TEST_DIR, { recursive: true, force: true });
+    });
+
+    it("filters files by extension", () => {
+        const extensions = [".js", ".ts", ".tsx"];
+        const testFiles = ["app.js", "util.ts", "readme.md", "style.css"];
+
+        const filtered = testFiles.filter(f =>
+            extensions.some(ext => f.endsWith(ext))
+        );
+
+        expect(filtered).toEqual(["app.js", "util.ts"]);
+    });
+
+    it("skips node_modules directory", () => {
+        const skipDirs = ["node_modules", ".git", "dist"];
+        const testDir = "node_modules";
+
+        expect(skipDirs.includes(testDir)).toBe(true);
+    });
+});

package/packages/cli/lib/selfevolution-bridge.js

@@ -0,0 +1,167 @@
+/**
+ * SelfEvolution Bridge Module
+ * Connects Settings API keys with SelfEvolution's AI-powered optimization
+ * 
+ * @module selfevolution-bridge
+ */
+
+import { getApiKey } from './settings.js';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { spawn } from 'child_process';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PROJECT_ROOT = path.resolve(__dirname, '../../..');
+const SELFEVOLUTION_DIR = path.join(PROJECT_ROOT, '.agent/skills/self-evolution');
+
+/**
+ * Export API keys from Settings to SelfEvolution .env file
+ * This allows Python scripts to auto-detect and use the keys
+ * 
+ * @returns {{success: boolean, exported?: {gemini: boolean, claude: boolean}, path?: string, reason?: string}}
+ */
+export function exportApiKeysToSelfEvolution() {
+    try {
+        const geminiKey = getApiKey('gemini');
+        const claudeKey = getApiKey('claude');
+
+        // Check if any keys are configured
+        if (!geminiKey && !claudeKey) {
+            return {
+                success: false,
+                reason: 'No API keys configured in Settings'
+            };
+        }
+
+        // Ensure SelfEvolution directory exists
+        if (!fs.existsSync(SELFEVOLUTION_DIR)) {
+            return {
+                success: false,
+                reason: 'SelfEvolution skill directory not found'
+            };
+        }
+
+        // Build .env content
+        const envContent = [];
+
+        if (geminiKey) {
+            envContent.push(`GEMINI_API_KEY=${geminiKey}`);
+        }
+
+        if (claudeKey) {
+            envContent.push(`CLAUDE_API_KEY=${claudeKey}`);
+            envContent.push(`ANTHROPIC_API_KEY=${claudeKey}`); // Alternative name
+        }
+
+        envContent.push('');
+        envContent.push('# Auto-generated from Settings');
+        envContent.push(`# Last updated: ${new Date().toISOString()}`);
+        envContent.push('# DO NOT EDIT - Managed by CLI Settings');
+
+        // Write .env file
+        const envPath = path.join(SELFEVOLUTION_DIR, '.env');
+        fs.writeFileSync(envPath, envContent.join('\n'), 'utf8');
+
+        return {
+            success: true,
+            exported: {
+                gemini: !!geminiKey,
+                claude: !!claudeKey
+            },
+            path: envPath
+        };
+    } catch (error) {
+        return {
+            success: false,
+            reason: `Export failed: ${error.message}`
+        };
+    }
+}
+
+/**
+ * Verify that SelfEvolution can access the exported API keys
+ * Runs Python api_key_resolver.py --test
+ * 
+ * @returns {Promise<{success: boolean, output?: string, error?: string, keyDetected?: boolean}>}
+ */
+export async function verifySelfEvolutionAccess() {
+    return new Promise((resolve) => {
+        const scriptPath = path.join(SELFEVOLUTION_DIR, 'scripts/api_key_resolver.py');
+
+        // Check if script exists
+        if (!fs.existsSync(scriptPath)) {
+            resolve({
+                success: false,
+                error: 'api_key_resolver.py not found'
+            });
+            return;
+        }
+
+        // Run Python script with --test flag
+        const python = spawn('python', [scriptPath, '--test'], {
+            cwd: PROJECT_ROOT,
+            env: { ...process.env }
+        });
+
+        let stdout = '';
+        let stderr = '';
+
+        python.stdout.on('data', (data) => {
+            stdout += data.toString();
+        });
+
+        python.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+
+        python.on('close', (code) => {
+            const success = code === 0;
+            const keyDetected = stdout.includes('✓') || stdout.includes('detected');
+
+            resolve({
+                success,
+                output: stdout.trim(),
+                error: stderr.trim(),
+                keyDetected
+            });
+        });
+
+        python.on('error', (error) => {
+            resolve({
+                success: false,
+                error: `Failed to run Python: ${error.message}`
+            });
+        });
+    });
+}
+
+/**
+ * Remove SelfEvolution .env file (cleanup)
+ * Called when user removes all API keys from Settings
+ * 
+ * @returns {{success: boolean, reason?: string}}
+ */
+export function cleanupSelfEvolutionEnv() {
+    try {
+        const envPath = path.join(SELFEVOLUTION_DIR, '.env');
+
+        if (fs.existsSync(envPath)) {
+            fs.unlinkSync(envPath);
+        }
+
+        return { success: true };
+    } catch (error) {
+        return {
+            success: false,
+            reason: `Cleanup failed: ${error.message}`
+        };
+    }
+}
+
+export default {
+    exportApiKeysToSelfEvolution,
+    verifySelfEvolutionAccess,
+    cleanupSelfEvolutionEnv
+};

package/packages/cli/lib/settings.js

@@ -0,0 +1,203 @@
+/**
+ * @fileoverview Settings management for Agent Skill Kit
+ * Handles Auto-Learning and Auto-Updating preferences
+ */
+
+import fs from "fs";
+import yaml from "js-yaml";
+import path from "path";
+import { KNOWLEDGE_DIR } from "./config.js";
+
+/** Path to settings file */
+export const SETTINGS_PATH = path.join(KNOWLEDGE_DIR, "settings.yaml");
+
+/** Default settings */
+const DEFAULT_SETTINGS = {
+    version: 1,
+    autoLearning: true,   // ON by default - learn from mistakes
+    autoUpdating: false,  // OFF by default - requires user trust
+    updateThreshold: 5,   // Hits before proposing update
+    lastUpdateCheck: null,
+    apiKeys: {
+        gemini: null,     // Gemini API key for agent coding
+        claude: null,     // Claude API key (alternative)
+    }
+};
+
+/**
+ * Load settings from YAML file
+ * @returns {object} Settings object
+ */
+export function loadSettings() {
+    try {
+        if (fs.existsSync(SETTINGS_PATH)) {
+            const content = fs.readFileSync(SETTINGS_PATH, "utf8");
+            return { ...DEFAULT_SETTINGS, ...yaml.load(content) };
+        }
+    } catch (e) {
+        console.error("Failed to load settings:", e.message);
+    }
+    return { ...DEFAULT_SETTINGS };
+}
+
+/**
+ * Save settings to YAML file
+ * @param {object} settings - Settings to save
+ */
+export function saveSettings(settings) {
+    try {
+        fs.mkdirSync(KNOWLEDGE_DIR, { recursive: true });
+        fs.writeFileSync(SETTINGS_PATH, yaml.dump(settings), "utf8");
+        return true;
+    } catch (e) {
+        console.error("Failed to save settings:", e.message);
+        return false;
+    }
+}
+
+/**
+ * Toggle Auto-Learning setting
+ * @returns {boolean} New value
+ */
+export function toggleAutoLearning() {
+    const settings = loadSettings();
+    settings.autoLearning = !settings.autoLearning;
+    saveSettings(settings);
+    return settings.autoLearning;
+}
+
+/**
+ * Toggle Auto-Updating setting
+ * @returns {boolean} New value
+ */
+export function toggleAutoUpdating() {
+    const settings = loadSettings();
+    settings.autoUpdating = !settings.autoUpdating;
+    saveSettings(settings);
+    return settings.autoUpdating;
+}
+
+/**
+ * Check if Auto-Learning is enabled
+ * @returns {boolean}
+ */
+export function isAutoLearningEnabled() {
+    return loadSettings().autoLearning;
+}
+
+/**
+ * Check if Auto-Updating is enabled
+ * @returns {boolean}
+ */
+export function isAutoUpdatingEnabled() {
+    return loadSettings().autoUpdating;
+}
+
+/**
+ * Get update threshold
+ * @returns {number}
+ */
+export function getUpdateThreshold() {
+    return loadSettings().updateThreshold;
+}
+
+/**
+ * Initialize settings file if not exists
+ */
+export function initSettings() {
+    if (!fs.existsSync(SETTINGS_PATH)) {
+        saveSettings(DEFAULT_SETTINGS);
+    }
+}
+
+/**
+ * Set API key for a provider
+ * Auto-exports to SelfEvolution for AI-powered optimization
+ * @param {'gemini' | 'claude'} provider - API provider
+ * @param {string} apiKey - The API key
+ * @returns {boolean} Success status
+ */
+export function setApiKey(provider, apiKey) {
+    try {
+        const settings = loadSettings();
+        if (!settings.apiKeys) {
+            settings.apiKeys = { gemini: null, claude: null };
+        }
+        settings.apiKeys[provider] = apiKey;
+        saveSettings(settings);
+
+        // Auto-export to SelfEvolution (async, non-blocking)
+        import('./selfevolution-bridge.js')
+            .then(({ exportApiKeysToSelfEvolution }) => {
+                exportApiKeysToSelfEvolution();
+            })
+            .catch(() => {
+                // Silent fail - SelfEvolution might not be present
+            });
+
+        return true;
+    } catch (e) {
+        console.error(`Failed to set ${provider} API key:`, e.message);
+        return false;
+    }
+}
+
+/**
+ * Get API key for a provider
+ * @param {'gemini' | 'claude'} provider - API provider
+ * @returns {string | null} The API key or null
+ */
+export function getApiKey(provider) {
+    const settings = loadSettings();
+    return settings.apiKeys?.[provider] || null;
+}
+
+/**
+ * Remove API key for a provider
+ * Auto-syncs with SelfEvolution
+ * @param {'gemini' | 'claude'} provider - API provider
+ * @returns {boolean} Success status
+ */
+export function removeApiKey(provider) {
+    try {
+        const settings = loadSettings();
+        if (settings.apiKeys) {
+            settings.apiKeys[provider] = null;
+            saveSettings(settings);
+
+            // Re-export or cleanup if no keys left
+            import('./selfevolution-bridge.js')
+                .then(({ exportApiKeysToSelfEvolution, cleanupSelfEvolutionEnv }) => {
+                    const hasAnyKey = settings.apiKeys.gemini || settings.apiKeys.claude;
+                    if (hasAnyKey) {
+                        exportApiKeysToSelfEvolution();
+                    } else {
+                        cleanupSelfEvolutionEnv();
+                    }
+                })
+                .catch(() => {
+                    // Silent fail
+                });
+        }
+        return true;
+    } catch (e) {
+        console.error(`Failed to remove ${provider} API key:`, e.message);
+        return false;
+    }
+}
+
+export default {
+    loadSettings,
+    saveSettings,
+    toggleAutoLearning,
+    toggleAutoUpdating,
+    isAutoLearningEnabled,
+    isAutoUpdatingEnabled,
+    getUpdateThreshold,
+    initSettings,
+    setApiKey,
+    getApiKey,
+    removeApiKey,
+    SETTINGS_PATH
+};
+

package/packages/cli/lib/skill-learn.js

@@ -12,7 +12,7 @@
 
 import fs from "fs";
 import path from "path";
-import { loadKnowledge, saveKnowledge } from "./recall.v2.js";
+import { loadKnowledge, saveKnowledge } from "./recall.js";
 import { AGENT_DIR, VERSION } from "./config.js";
 
 // ============================================================================

package/packages/cli/lib/stats.js

@@ -10,8 +10,10 @@
  * Usage: ag-smart stats
  */
 
-import { loadKnowledge } from "./recall.v2.js";
+import { loadKnowledge } from "./recall.js";
 import { VERSION } from "./config.js";
+import * as p from "@clack/prompts";
+import pc from "picocolors";
 
 // ============================================================================
 // STATS DISPLAY
@@ -20,74 +22,61 @@ import { VERSION } from "./config.js";
 function displayStats() {
     const db = loadKnowledge();
 
-    console.log(`\n📊 Smart Agent Knowledge Base v${VERSION}\n`);
-    console.log("─".repeat(50));
+    p.intro(pc.cyan(`📊 Agent Skill Kit Knowledge Base v${VERSION}`));
 
     if (!db.lessons || db.lessons.length === 0) {
-        console.log("\nℹ️  No lessons learned yet.");
-        console.log("   Use 'ag-smart learn' to add patterns.\n");
+        p.note("No lessons learned yet.\nUse 'ag-smart learn' to add patterns.", pc.dim("Empty"));
         return;
     }
 
     // Summary
-    console.log(`\n📚 Total Lessons: ${db.lessons.length}`);
-
     const totalHits = db.lessons.reduce((sum, l) => sum + (l.hitCount || 0), 0);
-    console.log(`🎯 Total Violations Detected: ${totalHits}`);
-
     const errorCount = db.lessons.filter(l => l.severity === "ERROR").length;
     const warningCount = db.lessons.filter(l => l.severity === "WARNING").length;
-    console.log(`❌ ERROR patterns: ${errorCount}`);
-    console.log(`⚠️  WARNING patterns: ${warningCount}`);
 
-    // Most triggered
-    console.log("\n" + "─".repeat(50));
-    console.log("🔥 Most Triggered Patterns:\n");
+    const summaryLines = [
+        `📚 Total Lessons: ${pc.bold(db.lessons.length)}`,
+        `🎯 Total Violations: ${pc.bold(totalHits)}`,
+        `${pc.red("❌")} ERROR patterns: ${errorCount}`,
+        `${pc.yellow("⚠️")} WARNING patterns: ${warningCount}`
+    ];
+    p.note(summaryLines.join("\n"), pc.dim("Summary"));
 
+    // Most triggered
     const sorted = [...db.lessons]
         .filter(l => l.hitCount > 0)
         .sort((a, b) => (b.hitCount || 0) - (a.hitCount || 0))
         .slice(0, 5);
 
-    if (sorted.length === 0) {
-        console.log("   No violations detected yet.\n");
-    } else {
-        sorted.forEach((lesson, idx) => {
-            const bar = "█".repeat(Math.min(20, Math.ceil((lesson.hitCount / (sorted[0].hitCount || 1)) * 20)));
-            console.log(`   ${idx + 1}. [${lesson.id}] ${lesson.hitCount} hits`);
-            console.log(`      ${bar}`);
-            console.log(`      ${lesson.message}`);
-            console.log("");
+    if (sorted.length > 0) {
+        const triggeredLines = sorted.map((lesson, idx) => {
+            const bar = "█".repeat(Math.min(15, Math.ceil((lesson.hitCount / (sorted[0].hitCount || 1)) * 15)));
+            return `${idx + 1}. [${lesson.id}] ${lesson.hitCount} hits\n   ${pc.green(bar)}\n   ${pc.dim(lesson.message)}`;
         });
+        p.note(triggeredLines.join("\n\n"), pc.dim("🔥 Most Triggered"));
     }
 
     // Auto-escalated
     const escalated = db.lessons.filter(l => l.autoEscalated);
     if (escalated.length > 0) {
-        console.log("─".repeat(50));
-        console.log("⚡ Auto-Escalated Patterns:\n");
-        escalated.forEach(l => {
-            console.log(`   [${l.id}] ${l.pattern} → Escalated to ERROR after ${l.hitCount} violations`);
-        });
-        console.log("");
+        const escalatedLines = escalated.map(l =>
+            `[${l.id}] → Escalated after ${l.hitCount} violations`
+        );
+        p.note(escalatedLines.join("\n"), pc.dim("⚡ Auto-Escalated"));
     }
 
     // Recent activity
     const withHits = db.lessons.filter(l => l.lastHit);
     if (withHits.length > 0) {
-        console.log("─".repeat(50));
-        console.log("🕐 Recent Activity:\n");
-
         const recent = [...withHits]
             .sort((a, b) => new Date(b.lastHit) - new Date(a.lastHit))
             .slice(0, 3);
 
-        recent.forEach(l => {
-            const date = new Date(l.lastHit);
-            const timeAgo = getTimeAgo(date);
-            console.log(`   [${l.id}] Last hit: ${timeAgo}`);
+        const recentLines = recent.map(l => {
+            const timeAgo = getTimeAgo(new Date(l.lastHit));
+            return `[${l.id}] Last hit: ${timeAgo}`;
         });
-        console.log("");
+        p.note(recentLines.join("\n"), pc.dim("🕐 Recent Activity"));
     }
 
     // Sources breakdown
@@ -97,13 +86,13 @@ function displayStats() {
         sources[src] = (sources[src] || 0) + 1;
     });
 
-    console.log("─".repeat(50));
-    console.log("📥 Lesson Sources:\n");
-    Object.entries(sources).forEach(([src, count]) => {
+    const sourceLines = Object.entries(sources).map(([src, count]) => {
         const icon = src === "manual" ? "✍️" : src === "eslint" ? "🔧" : "🧪";
-        console.log(`   ${icon} ${src}: ${count}`);
+        return `${icon} ${src}: ${count}`;
     });
-    console.log("");
+    p.note(sourceLines.join("\n"), pc.dim("📥 Lesson Sources"));
+
+    p.outro(pc.green("Stats complete"));
 }
 
 /**