add-skill-kit 3.2.2 → 3.2.4

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);
+        });
+    });
+});

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

@@ -0,0 +1,337 @@
+#!/usr/bin/env node
+/**
+ * Smart Fix - Auto-fix Detected Violations
+ * 
+ * Automatically fixes code violations based on learned patterns.
+ * 
+ * Features:
+ * - Comment out violations (safe mode)
+ * - Remove violations (aggressive mode)
+ * - Replace patterns (custom fix rules)
+ * 
+ * Usage: ag-smart fix <file|directory> [--mode safe|aggressive]
+ */
+
+import fs from "fs";
+import path from "path";
+import { loadKnowledge, saveKnowledge, scanFile, scanDirectory } from "./recall.js";
+import { VERSION } from "./config.js";
+
+// ============================================================================
+// FIX RULES
+// ============================================================================
+
+/**
+ * Built-in fix rules for common patterns
+ */
+const FIX_RULES = {
+    // Console statements → comment out
+    "console.log": {
+        type: "comment",
+        replacement: (line) => `// REMOVED: ${line.trim()}`
+    },
+    "console.warn": {
+        type: "comment",
+        replacement: (line) => `// REMOVED: ${line.trim()}`
+    },
+    "console.error": {
+        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`
+    }
+};
+
+// ============================================================================
+// FIX ENGINE
+// ============================================================================
+
+/**
+ * Fix a single file
+ * @param {string} filePath 
+ * @param {object} db - Knowledge base
+ * @param {string} mode - 'safe' or 'aggressive'
+ * @returns {{ file: string, fixes: number, backup: string }}
+ */
+function fixFile(filePath, db, mode = "safe") {
+    if (!fs.existsSync(filePath)) {
+        return { file: filePath, fixes: 0, error: "File not found" };
+    }
+
+    const content = fs.readFileSync(filePath, "utf8");
+    const lines = content.split("\n");
+    let fixCount = 0;
+    let modified = false;
+
+    // Scan for violations
+    const result = scanFile(filePath, db, false);
+
+    if (result.violations.length === 0) {
+        return { file: filePath, fixes: 0 };
+    }
+
+    // Create backup
+    const backupPath = filePath + ".backup";
+    fs.writeFileSync(backupPath, content, "utf8");
+
+    // Apply fixes
+    result.violations.forEach(({ lesson, matches }) => {
+        const rule = FIX_RULES[lesson.pattern] || {
+            type: mode === "aggressive" ? "remove" : "comment",
+            replacement: (line) => mode === "aggressive" ? "" : `// FLAGGED: ${line.trim()}`
+        };
+
+        matches.forEach(match => {
+            const lineIdx = match.line - 1;
+            if (lineIdx >= 0 && lineIdx < lines.length) {
+                const originalLine = lines[lineIdx];
+
+                if (rule.type === "remove") {
+                    lines[lineIdx] = "";
+                    fixCount++;
+                    modified = true;
+                } else if (rule.type === "comment") {
+                    if (!originalLine.trim().startsWith("//")) {
+                        lines[lineIdx] = rule.replacement(originalLine);
+                        fixCount++;
+                        modified = true;
+                    }
+                } else if (rule.type === "replace") {
+                    const newLine = rule.replacement(originalLine);
+                    if (newLine !== originalLine) {
+                        lines[lineIdx] = newLine;
+                        fixCount++;
+                        modified = true;
+                    }
+                }
+            }
+        });
+    });
+
+    // Write fixed content
+    if (modified) {
+        const newContent = lines.filter(l => l !== "" || mode !== "aggressive").join("\n");
+        fs.writeFileSync(filePath, newContent, "utf8");
+    } else {
+        // Remove backup if no changes
+        fs.unlinkSync(backupPath);
+    }
+
+    return {
+        file: filePath,
+        fixes: fixCount,
+        backup: modified ? backupPath : null
+    };
+}
+
+/**
+ * Fix all files in directory
+ */
+function fixDirectory(dirPath, db, mode = "safe") {
+    const results = [];
+    const extensions = [".js", ".ts", ".tsx", ".jsx", ".mjs"];
+
+    function walk(dir) {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+
+            if (entry.isDirectory()) {
+                if (!["node_modules", ".git", "dist", "build"].includes(entry.name)) {
+                    walk(fullPath);
+                }
+            } else if (entry.isFile()) {
+                const ext = path.extname(entry.name);
+                if (extensions.includes(ext)) {
+                    const result = fixFile(fullPath, db, mode);
+                    if (result.fixes > 0) {
+                        results.push(result);
+                    }
+                }
+            }
+        }
+    }
+
+    if (fs.statSync(dirPath).isDirectory()) {
+        walk(dirPath);
+    } else {
+        const result = fixFile(dirPath, db, mode);
+        if (result.fixes > 0) {
+            results.push(result);
+        }
+    }
+
+    return results;
+}
+
+// ============================================================================
+// CLI
+// ============================================================================
+
+async function main() {
+    const args = process.argv.slice(2);
+
+    if (args.length === 0 || args.includes("--help")) {
+        console.log(`
+🔧 Smart Fix v${VERSION} - Auto-fix Violations
+
+Usage:
+  ag-smart fix <file|directory> [options]
+
+Options:
+  --mode safe        Comment out violations (default)
+  --mode aggressive  Remove violations entirely
+  --eslint           Also run ESLint --fix
+  --dry-run          Show what would be fixed without changing files
+  --help             Show this help
+
+Examples:
+  ag-smart fix src/
+  ag-smart fix app.js --mode aggressive
+  ag-smart fix src/ --eslint
+`);
+        process.exit(0);
+    }
+
+    const target = args[0];
+    const mode = args.includes("--mode")
+        ? args[args.indexOf("--mode") + 1]
+        : "safe";
+    const dryRun = args.includes("--dry-run");
+    const useEslint = args.includes("--eslint");
+
+    const db = loadKnowledge();
+
+    if (!db.lessons || db.lessons.length === 0) {
+        console.log("ℹ️  No lessons learned yet. Nothing to fix.");
+        process.exit(0);
+    }
+
+    console.log(`\n🔧 Smart Fix v${VERSION}`);
+    console.log(`📂 Target: ${target}`);
+    console.log(`🎯 Mode: ${mode}`);
+    if (useEslint) console.log(`🔧 ESLint: enabled`);
+    console.log(`${"─".repeat(50)}\n`);
+
+    // Run ESLint fix first if enabled
+    if (useEslint && !dryRun) {
+        try {
+            const { runEslintFix } = await import("./eslint-fix.js");
+            runEslintFix(target);
+        } catch (e) {
+            console.log(`⚠️  ESLint fix skipped: ${e.message}`);
+        }
+    }
+
+    if (dryRun) {
+        console.log("🔍 DRY RUN - showing what would be fixed:\n");
+        const scanResults = scanDirectory(target, db);
+        scanResults.forEach(r => {
+            console.log(`📄 ${path.relative(process.cwd(), r.file)}`);
+            r.violations.forEach(v => {
+                console.log(`   Would fix ${v.matches.length} violation(s) of [${v.lesson.id}]`);
+            });
+        });
+        process.exit(0);
+    }
+
+    const results = fixDirectory(target, db, mode);
+
+    if (results.length === 0) {
+        console.log("✅ No pattern violations to fix.");
+        process.exit(0);
+    }
+
+    let totalFixes = 0;
+    results.forEach(r => {
+        totalFixes += r.fixes;
+        console.log(`✅ ${path.relative(process.cwd(), r.file)}: ${r.fixes} fix(es)`);
+        if (r.backup) {
+            console.log(`   📦 Backup: ${path.basename(r.backup)}`);
+        }
+    });
+
+    console.log(`\n${"─".repeat(50)}`);
+    console.log(`🎉 Fixed ${totalFixes} violation(s) in ${results.length} file(s)`);
+    console.log(`💡 Backups created with .backup extension`);
+}
+
+// Run if executed directly (as async)
+if (process.argv[1].includes("fix")) {
+    main().catch(console.error);
+}
+
+export { fixFile, fixDirectory, FIX_RULES };

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

package/lib/agent-cli/lib/generate-registry.js

@@ -0,0 +1,42 @@
+const fs = require('fs');
+const path = require('path');
+
+const SKILLS_DIR = path.join(__dirname, '../../..', '.agent', 'skills');
+const OUTPUT_FILE = path.join(SKILLS_DIR, 'registry.json');
+
+const registry = {
+    updatedAt: new Date().toISOString(),
+    skills: []
+};
+
+if (fs.existsSync(SKILLS_DIR)) {
+    const skills = fs.readdirSync(SKILLS_DIR, { withFileTypes: true })
+        .filter(dirent => dirent.isDirectory())
+        .map(dirent => dirent.name);
+
+    skills.forEach(skill => {
+        const skillPath = path.join(SKILLS_DIR, skill);
+        const skillData = {
+            name: skill,
+            rules: [],
+            scripts: []
+        };
+
+        // Find rules
+        const rulesDir = path.join(skillPath, 'rules');
+        if (fs.existsSync(rulesDir)) {
+            skillData.rules = fs.readdirSync(rulesDir).filter(f => f.endsWith('.md'));
+        }
+
+        // Find scripts
+        const scriptsDir = path.join(skillPath, 'scripts');
+        if (fs.existsSync(scriptsDir)) {
+            skillData.scripts = fs.readdirSync(scriptsDir).filter(f => f.endsWith('.js') || f.endsWith('.py'));
+        }
+
+        registry.skills.push(skillData);
+    });
+}
+
+fs.writeFileSync(OUTPUT_FILE, JSON.stringify(registry, null, 2));
+console.log(`Registry generated at ${OUTPUT_FILE}`);