add-skill-kit 3.2.3 → 3.2.4

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

package/lib/agent-cli/lib/hooks/install-hooks.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+/**
+ * Git Hooks Installer
+ * 
+ * Installs pre-commit hook that runs recall on staged files.
+ * 
+ * Usage: ag-smart install-hooks
+ */
+
+import fs from "fs";
+import path from "path";
+import { VERSION } from "../config.js";
+
+// ============================================================================
+// HOOK TEMPLATES
+// ============================================================================
+
+const PRE_COMMIT_HOOK = `#!/bin/sh
+# Smart Agent Pre-Commit Hook v${VERSION}
+
+# Get staged JS/TS files
+STAGED_FILES=$(git diff --cached --name-only --diff-filter=ACM | grep -E "\\\\.(js|ts|tsx|jsx|mjs)$")
+
+if [ -z "$STAGED_FILES" ]; then
+    exit 0
+fi
+
+# Run recall (Clack handles all output)
+npx ag-smart recall . 2>/dev/null
+exit $?
+`;
+
+// ============================================================================
+// INSTALLER
+// ============================================================================
+
+/**
+ * Find .git directory
+ * @returns {string|null}
+ */
+function findGitDir() {
+    let dir = process.cwd();
+
+    while (dir !== path.dirname(dir)) {
+        const gitDir = path.join(dir, ".git");
+        if (fs.existsSync(gitDir)) {
+            return gitDir;
+        }
+        dir = path.dirname(dir);
+    }
+
+    return null;
+}
+
+/**
+ * Install git hooks
+ */
+function installHooks() {
+    console.log(`\n🔧 Smart Agent Hooks Installer v${VERSION}\n`);
+
+    const gitDir = findGitDir();
+
+    if (!gitDir) {
+        console.log("❌ Not a git repository. Initialize git first:");
+        console.log("   git init\n");
+        process.exit(1);
+    }
+
+    const hooksDir = path.join(gitDir, "hooks");
+    const preCommitPath = path.join(hooksDir, "pre-commit");
+
+    // Create hooks directory if missing
+    if (!fs.existsSync(hooksDir)) {
+        fs.mkdirSync(hooksDir, { recursive: true });
+    }
+
+    // Backup existing hook
+    if (fs.existsSync(preCommitPath)) {
+        const backupPath = preCommitPath + ".backup";
+        fs.copyFileSync(preCommitPath, backupPath);
+        console.log(`📦 Backed up existing hook to: pre-commit.backup`);
+    }
+
+    // Write new hook
+    fs.writeFileSync(preCommitPath, PRE_COMMIT_HOOK, { mode: 0o755 });
+
+    console.log("✅ Installed pre-commit hook");
+    console.log(`   Location: ${preCommitPath}\n`);
+
+    console.log("📋 What it does:");
+    console.log("   • Runs on every commit");
+    console.log("   • Checks staged JS/TS files against memory");
+    console.log("   • Shows violations (does NOT block commits)\n");
+
+    console.log("💡 Tips:");
+    console.log("   • Skip hook: git commit --no-verify");
+    console.log("   • Uninstall: rm .git/hooks/pre-commit\n");
+}
+
+/**
+ * Uninstall hooks
+ */
+function uninstallHooks() {
+    const gitDir = findGitDir();
+
+    if (!gitDir) {
+        console.log("❌ Not a git repository.\n");
+        process.exit(1);
+    }
+
+    const preCommitPath = path.join(gitDir, "hooks", "pre-commit");
+
+    if (fs.existsSync(preCommitPath)) {
+        fs.unlinkSync(preCommitPath);
+        console.log("✅ Removed pre-commit hook.\n");
+
+        // Restore backup if exists
+        const backupPath = preCommitPath + ".backup";
+        if (fs.existsSync(backupPath)) {
+            fs.renameSync(backupPath, preCommitPath);
+            console.log("📦 Restored previous hook from backup.\n");
+        }
+    } else {
+        console.log("ℹ️  No hook installed.\n");
+    }
+}
+
+// ============================================================================
+// CLI
+// ============================================================================
+
+const args = process.argv.slice(2);
+
+if (args.includes("--help")) {
+    console.log(`
+🔧 Smart Agent Hooks Installer
+
+Usage:
+  ag-smart install-hooks           Install git hooks
+  ag-smart install-hooks --remove  Remove installed hooks
+
+The pre-commit hook checks staged files against learned
+patterns before each commit.
+`);
+    process.exit(0);
+}
+
+if (args.includes("--remove") || args.includes("--uninstall")) {
+    uninstallHooks();
+} else {
+    installHooks();
+}