@agentskillkit/agent-skills 1.0.1

package/packages/cli/lib/config.js

@@ -0,0 +1,29 @@
+/**
+ * @fileoverview Configuration for agent-skill-kit CLI
+ */
+
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+/** Current working directory */
+export const cwd = process.cwd();
+
+/** Path to .agent directory (configurable via AGENT_DIR env) */
+export const AGENT_DIR = process.env.AGENT_DIR || path.join(cwd, ".agent");
+
+/** Path to knowledge directory */
+export const KNOWLEDGE_DIR = path.join(AGENT_DIR, "knowledge");
+
+/** Path to lessons learned file */
+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";
+
+/** Debug mode */
+export const DEBUG = process.env.DEBUG === "true";

package/packages/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.v2.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/packages/cli/lib/fix.js

@@ -0,0 +1,278 @@
+#!/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.v2.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()}`
+    },
+    // var → const
+    "\\bvar\\s+": {
+        type: "replace",
+        replacement: (line) => line.replace(/\bvar\s+/, "const ")
+    },
+    // == → ===
+    "[^!=]==[^=]": {
+        type: "replace",
+        replacement: (line) => line.replace(/([^!=])==([^=])/g, "$1===$2")
+    },
+    // debugger → remove
+    "\\bdebugger\\b": {
+        type: "remove",
+        replacement: () => ""
+    }
+};
+
+// ============================================================================
+// 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/packages/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}`);