add-skill-kit 3.2.3 → 3.2.5

package/lib/agent-cli/lib/hooks/lint-learn.js

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+/**
+ * Lint Learn - Auto-Learn from ESLint Output
+ * 
+ * Parses ESLint JSON output and creates lessons automatically.
+ * 
+ * Usage:
+ *   npx eslint . --format json | agent lint-learn
+ *   npx eslint . --format json > output.json && agent lint-learn output.json
+ */
+
+import fs from "fs";
+import { loadKnowledge, saveKnowledge } from "../recall.js";
+
+// ============================================================================
+// ESLINT PARSER
+// ============================================================================
+
+/**
+ * Parse ESLint JSON output and extract rules
+ * @param {string} jsonContent 
+ * @returns {Array<{ rule: string, count: number, message: string }>}
+ */
+function parseEslintOutput(jsonContent) {
+    const ruleStats = {};
+
+    try {
+        const results = JSON.parse(jsonContent);
+
+        results.forEach(file => {
+            if (!file.messages) return;
+
+            file.messages.forEach(msg => {
+                if (!msg.ruleId) return;
+
+                if (!ruleStats[msg.ruleId]) {
+                    ruleStats[msg.ruleId] = {
+                        rule: msg.ruleId,
+                        count: 0,
+                        message: msg.message,
+                        severity: msg.severity === 2 ? "ERROR" : "WARNING"
+                    };
+                }
+                ruleStats[msg.ruleId].count++;
+            });
+        });
+    } catch (e) {
+        console.error("❌ Failed to parse ESLint JSON output:", e.message);
+        process.exit(1);
+    }
+
+    return Object.values(ruleStats).sort((a, b) => b.count - a.count);
+}
+
+/**
+ * Convert ESLint rule to regex pattern
+ * @param {string} rule - ESLint rule ID
+ * @returns {string}
+ */
+function ruleToPattern(rule) {
+    // Map common ESLint rules to regex patterns
+    const patterns = {
+        "no-console": "console\\.(log|warn|error|info|debug)",
+        "no-debugger": "\\bdebugger\\b",
+        "no-var": "\\bvar\\s+",
+        "no-unused-vars": null, // Can't easily detect with regex
+        "no-undef": null,
+        "eqeqeq": "[^!=]==[^=]",
+        "no-eval": "\\beval\\s*\\(",
+        "no-alert": "\\balert\\s*\\("
+    };
+
+    return patterns[rule] || null;
+}
+
+// ============================================================================
+// MAIN
+// ============================================================================
+
+async function main() {
+    const args = process.argv.slice(2);
+    let jsonContent = "";
+
+    if (args.includes("--help")) {
+        console.log(`
+🔧 Lint Learn - Auto-Learn from ESLint
+
+Usage:
+  npx eslint . --format json | agent lint-learn
+  agent lint-learn eslint-output.json
+
+Creates lessons from ESLint violations automatically.
+`);
+        process.exit(0);
+    }
+
+    // Read from file or stdin
+    if (args[0] && !args[0].startsWith("-")) {
+        if (fs.existsSync(args[0])) {
+            jsonContent = fs.readFileSync(args[0], "utf8");
+        } else {
+            console.error(`❌ File not found: ${args[0]}`);
+            process.exit(1);
+        }
+    } else {
+        // Read from stdin
+        const chunks = [];
+        process.stdin.setEncoding("utf8");
+
+        for await (const chunk of process.stdin) {
+            chunks.push(chunk);
+        }
+        jsonContent = chunks.join("");
+    }
+
+    if (!jsonContent.trim()) {
+        console.log("ℹ️  No input received. Pipe ESLint JSON output or provide a file.");
+        process.exit(0);
+    }
+
+    const rules = parseEslintOutput(jsonContent);
+
+    if (rules.length === 0) {
+        console.log("✅ No ESLint violations found.");
+        process.exit(0);
+    }
+
+    console.log(`\n🔧 Lint Learn - Found ${rules.length} unique ESLint rule(s)\n`);
+
+    const db = loadKnowledge();
+    let added = 0;
+
+    rules.forEach(r => {
+        const pattern = ruleToPattern(r.rule);
+
+        if (!pattern) {
+            console.log(`⏭️  Skipped: ${r.rule} (no regex pattern available)`);
+            return;
+        }
+
+        // Check if already exists
+        const exists = db.lessons.some(l => l.pattern === pattern);
+        if (exists) {
+            console.log(`⏭️  Skipped: ${r.rule} (already in memory)`);
+            return;
+        }
+
+        const id = `LEARN-${String(db.lessons.length + 1).padStart(3, "0")}`;
+
+        db.lessons.push({
+            id,
+            pattern,
+            message: `ESLint: ${r.rule} - ${r.message}`,
+            severity: r.severity,
+            source: "eslint",
+            hitCount: r.count,
+            addedAt: new Date().toISOString()
+        });
+
+        added++;
+        console.log(`✅ Added: [${id}] ${r.rule} (${r.count} occurrences)`);
+    });
+
+    if (added > 0) {
+        saveKnowledge(db);
+        console.log(`\n🎓 Learned ${added} new lesson(s) from ESLint output.\n`);
+    } else {
+        console.log("\nℹ️  No new lessons to add.\n");
+    }
+}
+
+main();

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

@@ -0,0 +1,116 @@
+/**
+ * @fileoverview Ignore patterns parser for Agent Skill Kit
+ * Supports .agentignore file with glob patterns
+ */
+
+import fs from "fs";
+import path from "path";
+import { cwd } from "./config.js";
+
+/** Default patterns always ignored */
+const DEFAULT_IGNORES = [
+    "node_modules/**",
+    ".git/**",
+    "dist/**",
+    "build/**",
+    ".next/**",
+    "coverage/**",
+    "*.log"
+];
+
+/**
+ * Load ignore patterns from .agentignore file
+ * @param {string} basePath - Base directory
+ * @returns {string[]} Array of patterns
+ */
+export function loadIgnorePatterns(basePath = cwd) {
+    const patterns = [...DEFAULT_IGNORES];
+    const ignoreFile = path.join(basePath, ".agentignore");
+
+    try {
+        if (fs.existsSync(ignoreFile)) {
+            const content = fs.readFileSync(ignoreFile, "utf8");
+            const lines = content.split("\n");
+
+            for (const line of lines) {
+                const trimmed = line.trim();
+                // Skip empty lines and comments
+                if (trimmed && !trimmed.startsWith("#")) {
+                    patterns.push(trimmed);
+                }
+            }
+        }
+    } catch (e) {
+        // Silently use defaults
+    }
+
+    return [...new Set(patterns)]; // Remove duplicates
+}
+
+/**
+ * Check if a file path matches any ignore pattern
+ * @param {string} filePath - Relative file path
+ * @param {string[]} patterns - Ignore patterns
+ * @returns {boolean}
+ */
+export function isIgnored(filePath, patterns) {
+    const normalized = filePath.replace(/\\/g, "/");
+
+    for (const pattern of patterns) {
+        // Simple glob matching
+        const regex = patternToRegex(pattern);
+        if (regex.test(normalized)) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+/**
+ * Convert glob pattern to regex
+ * @param {string} pattern - Glob pattern
+ * @returns {RegExp}
+ */
+function patternToRegex(pattern) {
+    let regex = pattern
+        .replace(/\./g, "\\.")      // Escape dots
+        .replace(/\*\*/g, ".*")     // ** matches everything
+        .replace(/\*/g, "[^/]*")    // * matches segment
+        .replace(/\?/g, ".");       // ? matches single char
+
+    // Handle directory patterns (ending with /)
+    if (pattern.endsWith("/")) {
+        regex = regex.slice(0, -1) + "(/.*)?";
+    }
+
+    return new RegExp(`^${regex}$|/${regex}$|^${regex}/`);
+}
+
+/**
+ * Filter files array by ignore patterns
+ * @param {string[]} files - Array of file paths
+ * @param {string[]} patterns - Ignore patterns
+ * @returns {{ included: string[], ignored: number }}
+ */
+export function filterFiles(files, patterns) {
+    const included = [];
+    let ignored = 0;
+
+    for (const file of files) {
+        if (isIgnored(file, patterns)) {
+            ignored++;
+        } else {
+            included.push(file);
+        }
+    }
+
+    return { included, ignored };
+}
+
+export default {
+    loadIgnorePatterns,
+    isIgnored,
+    filterFiles,
+    DEFAULT_IGNORES
+};

package/lib/agent-cli/lib/ignore.test.js

@@ -0,0 +1,58 @@
+/**
+ * @fileoverview Tests for ignore module
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+// Import directly without mocking - test actual behavior
+import { loadIgnorePatterns, isIgnored } from "./ignore.js";
+
+describe("ignore", () => {
+    describe("isIgnored", () => {
+        it("returns false when no patterns", () => {
+            const result = isIgnored("some/path.js", []);
+            expect(result).toBe(false);
+        });
+
+        it("matches exact pattern", () => {
+            const result = isIgnored("node_modules/pkg/file.js", ["node_modules"]);
+            expect(result).toBe(true);
+        });
+
+        it("matches glob pattern", () => {
+            const result = isIgnored("debug.log", ["*.log"]);
+            expect(result).toBe(true);
+        });
+
+        it("returns false for non-matching path", () => {
+            const result = isIgnored("src/app.js", ["*.log", "node_modules"]);
+            expect(result).toBe(false);
+        });
+
+        it("matches directory pattern", () => {
+            const result = isIgnored("dist/bundle.js", ["dist/**"]);
+            expect(result).toBe(true);
+        });
+
+        it("matches nested paths", () => {
+            const result = isIgnored(".git/objects/pack", [".git/**"]);
+            expect(result).toBe(true);
+        });
+    });
+
+    describe("loadIgnorePatterns", () => {
+        it("returns array of patterns", () => {
+            const patterns = loadIgnorePatterns();
+            expect(Array.isArray(patterns)).toBe(true);
+        });
+
+        it("includes default patterns", () => {
+            const patterns = loadIgnorePatterns();
+            // Should have at least some patterns (defaults or from file)
+            expect(patterns.length).toBeGreaterThan(0);
+        });
+    });
+});

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

@@ -0,0 +1,124 @@
+/**
+ * @fileoverview Project initialization wizard
+ * Sets up agent config for new projects
+ */
+
+import fs from "fs";
+import path from "path";
+import { cwd, AGENT_DIR, KNOWLEDGE_DIR, LESSONS_PATH } from "./config.js";
+
+/**
+ * Detect project type based on files
+ * @returns {string} Project type
+ */
+export function detectProjectType() {
+    const files = fs.readdirSync(cwd);
+
+    if (files.includes("package.json")) {
+        const pkg = JSON.parse(fs.readFileSync(path.join(cwd, "package.json"), "utf8"));
+
+        if (pkg.dependencies?.next || pkg.devDependencies?.next) return "nextjs";
+        if (pkg.dependencies?.react || pkg.devDependencies?.react) return "react";
+        if (pkg.dependencies?.vue || pkg.devDependencies?.vue) return "vue";
+        if (pkg.dependencies?.express || pkg.devDependencies?.express) return "node";
+        return "node";
+    }
+
+    if (files.includes("requirements.txt") || files.includes("pyproject.toml")) return "python";
+    if (files.includes("Cargo.toml")) return "rust";
+    if (files.includes("go.mod")) return "go";
+    if (files.includes("pom.xml") || files.includes("build.gradle")) return "java";
+
+    return "generic";
+}
+
+/**
+ * Get default ignore patterns for project type
+ * @param {string} projectType 
+ * @returns {string[]}
+ */
+export function getDefaultIgnorePatterns(projectType) {
+    const common = [
+        "node_modules/**",
+        ".git/**",
+        "dist/**",
+        "build/**",
+        "coverage/**",
+        "*.log",
+        "*.lock",
+        ".env*"
+    ];
+
+    const specific = {
+        node: ["package-lock.json"],
+        nextjs: [".next/**", "out/**"],
+        react: ["build/**"],
+        vue: [".nuxt/**"],
+        python: ["__pycache__/**", "*.pyc", ".venv/**", "venv/**"],
+        rust: ["target/**"],
+        go: ["vendor/**"],
+        java: ["target/**", "*.class"],
+        generic: []
+    };
+
+    return [...common, ...(specific[projectType] || [])];
+}
+
+/**
+ * Initialize agent config
+ * @param {object} options
+ * @param {boolean} options.force - Overwrite existing
+ * @returns {{ success: boolean, message: string }}
+ */
+export function initProject(options = {}) {
+    const { force = false } = options;
+
+    // Check if already initialized
+    if (fs.existsSync(KNOWLEDGE_DIR) && !force) {
+        return {
+            success: false,
+            message: "Already initialized. Use --force to reinitialize."
+        };
+    }
+
+    // Detect project type
+    const projectType = detectProjectType();
+
+    // Create directories
+    fs.mkdirSync(KNOWLEDGE_DIR, { recursive: true });
+
+    // Create lessons-learned.yaml
+    if (!fs.existsSync(LESSONS_PATH)) {
+        const initialLessons = `# Agent Skill Kit - Lessons Learned
+# Project Type: ${projectType}
+# Created: ${new Date().toISOString()}
+
+lessons: []
+`;
+        fs.writeFileSync(LESSONS_PATH, initialLessons);
+    }
+
+    // Create .agentignore if not exists
+    const agentignorePath = path.join(cwd, ".agentignore");
+    if (!fs.existsSync(agentignorePath)) {
+        const patterns = getDefaultIgnorePatterns(projectType);
+        fs.writeFileSync(agentignorePath, patterns.join("\n") + "\n");
+    }
+
+    return {
+        success: true,
+        message: `Initialized for ${projectType} project`,
+        projectType,
+        paths: {
+            knowledge: KNOWLEDGE_DIR,
+            lessons: LESSONS_PATH,
+            agentignore: agentignorePath
+        }
+    };
+}
+
+export default {
+    detectProjectType,
+    getDefaultIgnorePatterns,
+    initProject
+};