add-skill-kit 3.2.3 → 3.2.4

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

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+/**
+ * ESLint Fix Integration
+ * 
+ * Wrapper around ESLint --fix to combine with pattern-based fix.
+ * Auto-detects ESLint config and runs fixes.
+ * 
+ * Usage: ag-smart fix --eslint <path>
+ */
+
+import { execSync, spawnSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import { VERSION } from "./config.js";
+
+// ============================================================================
+// ESLINT DETECTION
+// ============================================================================
+
+/**
+ * Find ESLint config file in project
+ * @param {string} dir 
+ * @returns {string|null}
+ */
+function findEslintConfig(dir) {
+    const configFiles = [
+        ".eslintrc.js",
+        ".eslintrc.cjs",
+        ".eslintrc.json",
+        ".eslintrc.yaml",
+        ".eslintrc.yml",
+        ".eslintrc",
+        "eslint.config.js",
+        "eslint.config.mjs"
+    ];
+
+    let current = dir;
+    while (current !== path.dirname(current)) {
+        for (const config of configFiles) {
+            const configPath = path.join(current, config);
+            if (fs.existsSync(configPath)) {
+                return configPath;
+            }
+        }
+        // Check package.json for eslintConfig
+        const pkgPath = path.join(current, "package.json");
+        if (fs.existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+                if (pkg.eslintConfig) {
+                    return pkgPath; // ESLint config in package.json
+                }
+            } catch (e) { }
+        }
+        current = path.dirname(current);
+    }
+    return null;
+}
+
+/**
+ * Check if ESLint is available
+ * @returns {boolean}
+ */
+function isEslintAvailable() {
+    try {
+        execSync("npx eslint --version", { stdio: "ignore" });
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+
+// ============================================================================
+// ESLINT FIX
+// ============================================================================
+
+/**
+ * Run ESLint --fix on a path
+ * @param {string} targetPath 
+ * @param {object} options
+ * @returns {{ success: boolean, fixed: number, errors: number }}
+ */
+export function runEslintFix(targetPath, options = {}) {
+    const result = {
+        success: false,
+        fixed: 0,
+        errors: 0,
+        output: ""
+    };
+
+    if (!isEslintAvailable()) {
+        console.log("⚠️  ESLint not found. Install with: npm install eslint -D");
+        return result;
+    }
+
+    const configPath = findEslintConfig(process.cwd());
+    if (!configPath && !options.noConfig) {
+        console.log("⚠️  No ESLint config found. Run: npx eslint --init");
+        return result;
+    }
+
+    console.log(`\n🔧 Running ESLint --fix...`);
+    if (configPath) {
+        console.log(`   Config: ${path.relative(process.cwd(), configPath)}`);
+    }
+
+    try {
+        // Run ESLint with --fix
+        const args = [
+            "eslint",
+            targetPath,
+            "--fix",
+            "--format", "json"
+        ];
+
+        const proc = spawnSync("npx", args, {
+            encoding: "utf8",
+            shell: true,
+            maxBuffer: 10 * 1024 * 1024
+        });
+
+        // Parse output
+        if (proc.stdout) {
+            try {
+                const results = JSON.parse(proc.stdout);
+                let totalFixed = 0;
+                let totalErrors = 0;
+
+                results.forEach(file => {
+                    if (file.output) {
+                        // File was fixed (output contains fixed content)
+                        totalFixed++;
+                    }
+                    totalErrors += file.errorCount || 0;
+                });
+
+                result.fixed = totalFixed;
+                result.errors = totalErrors;
+                result.success = true;
+                result.output = proc.stdout;
+
+                console.log(`   ✅ Fixed: ${totalFixed} file(s)`);
+                if (totalErrors > 0) {
+                    console.log(`   ⚠️  Remaining errors: ${totalErrors}`);
+                }
+            } catch (e) {
+                // JSON parse failed, but fix might still have worked
+                result.success = proc.status === 0;
+            }
+        }
+
+        if (proc.status === 0) {
+            result.success = true;
+            console.log("   ✅ ESLint fix completed");
+        }
+
+    } catch (error) {
+        console.error(`   ❌ ESLint error: ${error.message}`);
+    }
+
+    return result;
+}
+
+// ============================================================================
+// COMBINED FIX
+// ============================================================================
+
+/**
+ * Run combined fix (ESLint + pattern-based)
+ * @param {string} targetPath 
+ * @param {object} options 
+ */
+export async function runCombinedFix(targetPath, options = {}) {
+    console.log(`\n🔧 Combined Fix v${VERSION}`);
+    console.log(`📂 Target: ${targetPath}`);
+    console.log("─".repeat(50));
+
+    // Step 1: ESLint fix
+    if (options.eslint !== false) {
+        runEslintFix(targetPath, options);
+    }
+
+    // Step 2: Pattern-based fix (import dynamically)
+    console.log("\n🧠 Running pattern-based fix...");
+    try {
+        const { fixDirectory } = await import("./fix.js");
+        const { loadKnowledge } = await import("./recall.js");
+
+        const db = loadKnowledge();
+        const results = fixDirectory(targetPath, db, options.mode || "safe");
+
+        if (results.length > 0) {
+            let total = 0;
+            results.forEach(r => total += r.fixes);
+            console.log(`   ✅ Pattern fixes: ${total}`);
+        } else {
+            console.log("   ✅ No pattern violations to fix");
+        }
+    } catch (e) {
+        console.log(`   ⚠️  Pattern fix skipped: ${e.message}`);
+    }
+
+    console.log("\n" + "─".repeat(50));
+    console.log("🎉 Combined fix completed!");
+}
+
+// ============================================================================
+// CLI
+// ============================================================================
+
+const args = process.argv.slice(2);
+
+if (args.includes("--help") || args.length === 0) {
+    console.log(`
+🔧 ESLint Fix Integration v${VERSION}
+
+Usage:
+  node eslint-fix.js <path> [options]
+
+Options:
+  --no-eslint    Skip ESLint fix
+  --no-pattern   Skip pattern-based fix
+  --mode <mode>  Pattern fix mode (safe|aggressive)
+  --help         Show this help
+
+This combines ESLint --fix with pattern-based fixes.
+`);
+    process.exit(0);
+}
+
+const target = args[0];
+const options = {
+    eslint: !args.includes("--no-eslint"),
+    pattern: !args.includes("--no-pattern"),
+    mode: args.includes("--mode") ? args[args.indexOf("--mode") + 1] : "safe"
+};
+
+runCombinedFix(target, options);

package/lib/agent-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/lib/agent-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/lib/agent-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);
+        });
+    });
+});