@agentskillkit/agent-skills 1.0.1 → 3.2.2

package/packages/cli/lib/config.js

@@ -4,8 +4,10 @@
 
 import path from "path";
 import { fileURLToPath } from "url";
+import { createRequire } from "module";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
 
 /** Current working directory */
 export const cwd = process.cwd();
@@ -22,8 +24,12 @@ export const LESSONS_PATH = path.join(KNOWLEDGE_DIR, "lessons-learned.yaml");
 /** Path to rules directory */
 export const RULES_DIR = path.join(AGENT_DIR, "rules");
 
-/** CLI version */
-export const VERSION = "2.0.0";
+/** CLI version - read from package.json */
+export const VERSION = (() => {
+    try { return require("../package.json").version; }
+    catch { return "2.2.0"; }
+})();
 
 /** Debug mode */
 export const DEBUG = process.env.DEBUG === "true";
+

package/packages/cli/lib/eslint-fix.js

@@ -184,7 +184,7 @@ export async function runCombinedFix(targetPath, options = {}) {
     console.log("\n🧠 Running pattern-based fix...");
     try {
         const { fixDirectory } = await import("./fix.js");
-        const { loadKnowledge } = await import("./recall.v2.js");
+        const { loadKnowledge } = await import("./recall.js");
 
         const db = loadKnowledge();
         const results = fixDirectory(targetPath, db, options.mode || "safe");

package/packages/cli/lib/evolution-signal.js

@@ -0,0 +1,215 @@
+/**
+ * Evolution Signal Layer - Backward Compatibility Adapter
+ * 
+ * This file maintains the old API while delegating to the new architecture.
+ * Allows gradual migration without breaking existing code.
+ * 
+ * OLD LOCATION: lib/evolution-signal.js
+ * NEW LOCATION: src/core/evolution/* + src/data/repositories/*
+ * 
+ * @deprecated Use new architecture: import from 'src/core/evolution'
+ */
+
+// Import new architecture components
+import { EvolutionSignal } from '../src/core/evolution/evolution-signal.js';
+import { ThresholdChecker } from '../src/core/evolution/threshold-checker.js';
+import { ReviewGate } from '../src/core/evolution/review-gate.js';
+import { SignalRepository } from '../src/data/repositories/signal-repository.js';
+import { JsonStorage } from '../src/data/storage/json-storage.js';
+import { SignalDetector as SignalService } from '../src/core/evolution/signal-detector.js';
+import { KNOWLEDGE_DIR } from './config.js';
+
+// ============================================================================
+// BACKWARD COMPATIBLE EXPORTS
+// ============================================================================
+
+// Re-export EvolutionSignal class
+export { EvolutionSignal };
+
+// Lazy-initialized singleton instances
+let _storage = null;
+let _repository = null;
+let _detector = null;
+
+function getDetector() {
+    if (!_detector) {
+        _storage = new JsonStorage(KNOWLEDGE_DIR);
+        _repository = new SignalRepository(_storage);
+        _detector = new SignalService(_repository);
+    }
+    return _detector;
+}
+
+// ============================================================================
+// THRESHOLD CHECKER (Backward Compatible)
+// ============================================================================
+
+/**
+ * @deprecated Use ThresholdChecker.check() from src/core/evolution
+ */
+export function checkEvolutionThreshold(lesson, threshold = 10) {
+    return ThresholdChecker.check(lesson, threshold);
+}
+
+/**
+ * @deprecated Use ThresholdChecker.calculateStability() from src/core/evolution
+ */
+export function calculatePatternStability(violationHistory = []) {
+    return ThresholdChecker.calculateStability(violationHistory);
+}
+
+// ============================================================================
+// SIGNAL QUEUE (Backward Compatible)
+// ============================================================================
+
+/**
+ * SignalQueue - Backward compatible class
+ * @deprecated Use SignalRepository + SignalDetector from new architecture
+ */
+class SignalQueueCompat {
+    get signals() {
+        // Return cached signals (sync access)
+        if (!this._cachedSignals) {
+            // Synchronous fallback - load on first access
+            this._cachedSignals = [];
+            this.load().then(signals => {
+                this._cachedSignals = signals;
+            });
+        }
+        return this._cachedSignals;
+    }
+
+    async load() {
+        const detector = getDetector();
+        const all = await detector.signalRepository.findAll();
+        this._cachedSignals = all;
+        return all;
+    }
+
+    async save() {
+        // Auto-save through repository (no-op for compatibility)
+        return;
+    }
+
+    async add(signal) {
+        const detector = getDetector();
+        const result = await detector.queue(
+            signal.lessonId,
+            { ready: true, reason: signal.reason, confidence: signal.confidence },
+            signal.metadata
+        );
+        await this.load(); // Refresh cache
+        return result;
+    }
+
+    getPending() {
+        return this.signals.filter(s => s.status === 'pending');
+    }
+
+    getByLesson(lessonId) {
+        return this.signals.filter(s => s.lessonId === lessonId);
+    }
+
+    async approve(signalId) {
+        const detector = getDetector();
+        const result = await detector.approve(signalId);
+        await this.load(); // Refresh cache
+        return result;
+    }
+
+    async reject(signalId) {
+        const detector = getDetector();
+        const result = await detector.reject(signalId);
+        await this.load(); // Refresh cache
+        return result;
+    }
+
+    async execute(signalId) {
+        const detector = getDetector();
+        const result = await detector.execute(signalId);
+        await this.load(); // Refresh cache
+        return result;
+    }
+
+    async cleanup() {
+        const detector = getDetector();
+        await detector.signalRepository.cleanup();
+        await this.load(); // Refresh cache
+    }
+}
+
+// Singleton instance for backward compatibility
+const signalQueueInstance = new SignalQueueCompat();
+
+// Initialize on module load
+signalQueueInstance.load().catch(err => {
+    console.error('Failed to initialize signal queue:', err);
+});
+
+export { signalQueueInstance as signalQueue };
+
+// ============================================================================
+// REVIEW GATE (Backward Compatible)
+// ============================================================================
+
+/**
+ * @deprecated Use ReviewGate.evaluate() from src/core/evolution
+ */
+export function reviewGate(signal, settings = {}) {
+    return ReviewGate.evaluate(signal, settings);
+}
+
+// ============================================================================
+// HELPER FUNCTIONS (Backward Compatible)
+// ============================================================================
+
+/**
+ * @deprecated Use SignalDetector.queue() from new architecture
+ */
+export async function queueEvolutionSignal(lessonId, checkResult, metadata = {}) {
+    if (!checkResult.ready) return null;
+
+    const signal = new EvolutionSignal(
+        lessonId,
+        checkResult.reason,
+        checkResult.confidence,
+        metadata
+    );
+
+    return signalQueueInstance.add(signal);
+}
+
+/**
+ * @deprecated Use SignalDetector.getStats() from new architecture
+ */
+export async function getEvolutionStats() {
+    const detector = getDetector();
+    return detector.getStats();
+}
+
+// ============================================================================
+// MIGRATION GUIDE
+// ============================================================================
+
+/**
+ * HOW TO MIGRATE TO NEW ARCHITECTURE:
+ * 
+ * OLD CODE:
+ * ```
+ * import { signalQueue, checkEvolutionThreshold } from './evolution-signal.js';
+ * 
+ * const check = checkEvolutionThreshold(lesson, 10);
+ * await signalQueue.add(signal);
+ * ```
+ * 
+ * NEW CODE:
+ * ```
+ * import { ThresholdChecker } from '../src/core/evolution/threshold-checker.js';
+ * import { SignalRepository } from '../src/data/repositories/signal-repository.js';
+ * import { SignalDetector } from '../src/core/evolution/signal-detector.js';
+ * 
+ * const check = ThresholdChecker.check(lesson, 10);
+ * const detector = new SignalDetector(repository);
+ * await detector.queue(lessonId, check, metadata);
+ * ```
+ */

package/packages/cli/lib/export.js

@@ -0,0 +1,86 @@
+/**
+ * @fileoverview Export and Import for Agent Skill Kit
+ * Share settings between projects
+ */
+
+import fs from "fs";
+import path from "path";
+import yaml from "js-yaml";
+import { LESSONS_PATH } from "./config.js";
+import { SETTINGS_PATH, loadSettings } from "./settings.js";
+import { loadKnowledge, saveKnowledge } from "./recall.js";
+
+/**
+ * Export lessons and settings to JSON file
+ * @param {string} outputPath - Output file path
+ * @returns {boolean}
+ */
+export function exportData(outputPath) {
+    try {
+        const data = {
+            version: 1,
+            exportedAt: new Date().toISOString(),
+            lessons: loadKnowledge().lessons || [],
+            settings: loadSettings()
+        };
+
+        fs.writeFileSync(outputPath, JSON.stringify(data, null, 2), "utf8");
+        return true;
+    } catch (e) {
+        console.error("Failed to export:", e.message);
+        return false;
+    }
+}
+
+/**
+ * Import data from JSON file
+ * @param {string} inputPath - Input file path
+ * @param {"merge" | "replace"} mode - Import mode
+ * @returns {{ success: boolean, lessonsCount: number, hasSettings: boolean }}
+ */
+export function importData(inputPath, mode = "merge") {
+    try {
+        if (!fs.existsSync(inputPath)) {
+            return { success: false, lessonsCount: 0, hasSettings: false };
+        }
+
+        const content = fs.readFileSync(inputPath, "utf8");
+        const data = JSON.parse(content);
+
+        // Import lessons
+        const currentDb = loadKnowledge();
+
+        if (mode === "replace") {
+            currentDb.lessons = data.lessons || [];
+        } else {
+            // Merge - add new lessons, skip duplicates by pattern
+            const existingPatterns = new Set(currentDb.lessons.map(l => l.pattern));
+            for (const lesson of (data.lessons || [])) {
+                if (!existingPatterns.has(lesson.pattern)) {
+                    currentDb.lessons.push(lesson);
+                }
+            }
+        }
+
+        saveKnowledge(currentDb);
+
+        // Import settings if present
+        let hasSettings = false;
+        if (data.settings) {
+            const settingsPath = SETTINGS_PATH;
+            fs.writeFileSync(settingsPath, yaml.dump(data.settings), "utf8");
+            hasSettings = true;
+        }
+
+        return {
+            success: true,
+            lessonsCount: data.lessons?.length || 0,
+            hasSettings
+        };
+    } catch (e) {
+        console.error("Failed to import:", e.message);
+        return { success: false, lessonsCount: 0, hasSettings: false };
+    }
+}
+
+export default { exportData, importData };

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

@@ -0,0 +1,65 @@
+/**
+ * @fileoverview Tests for export module
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+describe("export", () => {
+    const testDir = path.join(os.tmpdir(), "test-export-" + Date.now());
+
+    beforeEach(() => {
+        fs.mkdirSync(testDir, { recursive: true });
+    });
+
+    afterEach(() => {
+        if (fs.existsSync(testDir)) {
+            fs.rmSync(testDir, { recursive: true, force: true });
+        }
+    });
+
+    describe("export format", () => {
+        it("creates valid JSON structure", () => {
+            const data = {
+                version: 1,
+                exportedAt: new Date().toISOString(),
+                lessons: [{ id: "TEST", pattern: "x" }]
+            };
+
+            const outputPath = path.join(testDir, "export.json");
+            fs.writeFileSync(outputPath, JSON.stringify(data, null, 2));
+
+            const loaded = JSON.parse(fs.readFileSync(outputPath, "utf8"));
+            expect(loaded.version).toBe(1);
+            expect(loaded.lessons).toHaveLength(1);
+        });
+
+        it("supports lesson array format", () => {
+            const lessons = [
+                { id: "L1", pattern: "a", message: "msg" },
+                { id: "L2", pattern: "b", message: "msg2" }
+            ];
+
+            const data = { version: 1, lessons };
+            const json = JSON.stringify(data);
+            const parsed = JSON.parse(json);
+
+            expect(parsed.lessons).toHaveLength(2);
+            expect(parsed.lessons[0].id).toBe("L1");
+        });
+    });
+
+    describe("import validation", () => {
+        it("validates version field", () => {
+            const valid = { version: 1, lessons: [] };
+            expect(valid.version).toBe(1);
+        });
+
+        it("validates lessons array", () => {
+            const valid = { version: 1, lessons: [{ id: "X", pattern: "y" }] };
+            expect(Array.isArray(valid.lessons)).toBe(true);
+        });
+    });
+});

package/packages/cli/lib/fix.js

@@ -14,7 +14,7 @@
 
 import fs from "fs";
 import path from "path";
-import { loadKnowledge, saveKnowledge, scanFile, scanDirectory } from "./recall.v2.js";
+import { loadKnowledge, saveKnowledge, scanFile, scanDirectory } from "./recall.js";
 import { VERSION } from "./config.js";
 
 // ============================================================================
@@ -38,20 +38,79 @@ const FIX_RULES = {
         type: "comment",
         replacement: (line) => `// REMOVED: ${line.trim()}`
     },
+    "console.debug": {
+        type: "comment",
+        replacement: (line) => `// REMOVED: ${line.trim()}`
+    },
+    "console.info": {
+        type: "comment",
+        replacement: (line) => `// REMOVED: ${line.trim()}`
+    },
+
     // var → const
     "\\bvar\\s+": {
         type: "replace",
         replacement: (line) => line.replace(/\bvar\s+/, "const ")
     },
-    // == → ===
+
+    // == → === (loose equality)
     "[^!=]==[^=]": {
         type: "replace",
         replacement: (line) => line.replace(/([^!=])==([^=])/g, "$1===$2")
     },
+
+    // != → !== (loose inequality)
+    "[^!]=!=[^=]": {
+        type: "replace",
+        replacement: (line) => line.replace(/([^!])!=([^=])/g, "$1!==$2")
+    },
+
     // debugger → remove
     "\\bdebugger\\b": {
         type: "remove",
         replacement: () => ""
+    },
+
+    // alert → comment out
+    "\\balert\\(": {
+        type: "comment",
+        replacement: (line) => `// REMOVED: ${line.trim()}`
+    },
+
+    // TODO/FIXME in production → warn only
+    "TODO|FIXME": {
+        type: "comment",
+        replacement: (line) => line // Leave as is, just flag
+    },
+
+    // Empty catch blocks → add comment
+    "catch\\s*\\([^)]*\\)\\s*\\{\\s*\\}": {
+        type: "replace",
+        replacement: (line) => line.replace(/\{\s*\}/, "{ /* Intentionally empty */ }")
+    },
+
+    // Promise without catch → add comment
+    "\\.then\\([^)]*\\)(?!.*\\.catch)": {
+        type: "comment",
+        replacement: (line) => `${line} // TODO: Add .catch()`
+    },
+
+    // Hardcoded localhost → flag
+    "localhost:\\d+": {
+        type: "comment",
+        replacement: (line) => `// REVIEW: ${line.trim()} // Hardcoded URL`
+    },
+
+    // @ts-ignore → flag for review
+    "@ts-ignore": {
+        type: "comment",
+        replacement: (line) => `${line} // TODO: Fix instead of ignoring`
+    },
+
+    // any type in TypeScript → flag
+    ": any": {
+        type: "comment",
+        replacement: (line) => `${line} // TODO: Replace 'any' with proper type`
     }
 };
 

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

@@ -0,0 +1,80 @@
+/**
+ * @fileoverview Tests for fix.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-fix-test");
+
+describe("Fix - Pattern Replacement", () => {
+    beforeEach(() => {
+        fs.mkdirSync(TEST_DIR, { recursive: true });
+    });
+
+    afterEach(() => {
+        fs.rmSync(TEST_DIR, { recursive: true, force: true });
+    });
+
+    it("comments out console.log statements", () => {
+        const line = 'console.log("debug");';
+        const fixed = `// ${line}`;
+        expect(fixed).toBe('// console.log("debug");');
+    });
+
+    it("replaces var with const", () => {
+        const line = "var x = 1;";
+        const fixed = line.replace(/\bvar\s+/, "const ");
+        expect(fixed).toBe("const x = 1;");
+    });
+
+    it("replaces == with ===", () => {
+        const line = "if (a == b) {";
+        const fixed = line.replace(/([^!=])==([^=])/g, "$1===$2");
+        expect(fixed).toBe("if (a === b) {");
+    });
+
+    it("removes debugger statements", () => {
+        const lines = [
+            "const x = 1;",
+            "debugger;",
+            "const y = 2;"
+        ];
+        const filtered = lines.filter(l => !/\bdebugger\b/.test(l));
+        expect(filtered.length).toBe(2);
+    });
+});
+
+describe("Fix - Backup Creation", () => {
+    beforeEach(() => {
+        fs.mkdirSync(TEST_DIR, { recursive: true });
+    });
+
+    afterEach(() => {
+        fs.rmSync(TEST_DIR, { recursive: true, force: true });
+    });
+
+    it("creates backup file with .bak extension", () => {
+        const testFile = path.join(TEST_DIR, "test.js");
+        const backupFile = path.join(TEST_DIR, "test.js.bak");
+
+        fs.writeFileSync(testFile, "original content", "utf8");
+        fs.copyFileSync(testFile, backupFile);
+
+        expect(fs.existsSync(backupFile)).toBe(true);
+        expect(fs.readFileSync(backupFile, "utf8")).toBe("original content");
+    });
+});
+
+describe("Fix - Mode Selection", () => {
+    it("identifies safe mode correctly", () => {
+        const mode = "safe";
+        expect(mode === "safe").toBe(true);
+    });
+
+    it("identifies aggressive mode correctly", () => {
+        const mode = "aggressive";
+        expect(mode === "aggressive").toBe(true);
+    });
+});

package/packages/cli/lib/gemini-export.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+/**
+ * Export Skills to Gemini - CLI Tool
+ * 
+ * Gemini-specific export functionality
+ */
+
+import { LessonRepository } from '../src/data/repositories/lesson-repository.js';
+import { YamlStorage } from '../src/data/storage/yaml-storage.js';
+import { LearningService } from '../src/services/learning-service.js';
+import { SkillFormatter } from '../src/presentation/formatters/skill-formatter.js';
+import { ExportService } from '../src/services/export-service.js';
+import { KNOWLEDGE_DIR } from './config.js';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PROJECT_ROOT = path.join(__dirname, '../../..');
+const SKILLS_DIR = path.join(PROJECT_ROOT, '.agent/skills');
+
+/**
+ * Export all mature skills
+ */
+export async function exportGeminiSkills() {
+    console.log('🚀 Exporting Mature Skills to Gemini\n');
+
+    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);
+
+    const stats = await exportService.getExportStats();
+
+    console.log('📊 Export Statistics:');
+    console.log(`  Total lessons: ${stats.total}`);
+    console.log(`  Exportable (MATURE/IDEAL, ≥80%): ${stats.exportable}\n`);
+
+    if (stats.exportable === 0) {
+        console.log('ℹ️  No skills ready for export.\n');
+        return { skills: [], count: 0 };
+    }
+
+    const exported = await exportService.exportMatureSkills(SKILLS_DIR, 0.8);
+
+    console.log(`✅ Successfully exported ${exported.length} skill(s) to Gemini:\n`);
+    exported.forEach(skill => {
+        console.log(`  ✓ ${skill.filename}`);
+    });
+
+    console.log('\n🎉 Export Complete!');
+    console.log('💡 Gemini AI will now use these skills when coding.\n');
+
+    return { skills: exported, count: exported.length };
+}
+
+/**
+ * Preview exportable skills
+ */
+export async function previewGeminiSkills() {
+    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);
+
+    const preview = await exportService.previewMatureSkills(0.8);
+
+    if (preview.length === 0) {
+        console.log('ℹ️  No skills ready for export.\n');
+        return [];
+    }
+
+    console.log(`\n✅ ${preview.length} skill(s) ready for Gemini:\n`);
+
+    preview.forEach(skill => {
+        console.log(`📄 ${skill.id}: ${skill.title}`);
+        console.log(`   ${skill.state} (${(skill.confidence * 100).toFixed(0)}%)`);
+        console.log(`   → ${skill.filename}\n`);
+    });
+
+    return preview;
+}