add-skill-kit 3.2.2 → 3.2.4

package/bin/lib/commands/install.js

@@ -131,7 +131,7 @@ export async function run(spec) {
         for (const e of fs.readdirSync(skillsDir)) {
             const sp = path.join(skillsDir, e);
             if (fs.statSync(sp).isDirectory()) {
-                // Check if this directory has SKILL.md (top-level skill)
+                // Check if this directory has SKILL.md (top-level skill only)
                 if (fs.existsSync(path.join(sp, "SKILL.md"))) {
                     const m = parseSkillMdFrontmatter(path.join(sp, "SKILL.md"));
                     skillsInRepo.push({
@@ -142,22 +142,8 @@ export async function run(spec) {
                         _path: sp
                     });
                 }
-
-                // Also scan nested directories (2 levels deep) for sub-skills
-                for (const sub of fs.readdirSync(sp)) {
-                    const subPath = path.join(sp, sub);
-                    if (fs.statSync(subPath).isDirectory() && fs.existsSync(path.join(subPath, "SKILL.md"))) {
-                        const m = parseSkillMdFrontmatter(path.join(subPath, "SKILL.md"));
-                        const skillName = `${e}/${sub}`; // e.g. "game-development/2d-games"
-                        skillsInRepo.push({
-                            title: skillName,
-                            value: skillName,
-                            description: m.description || "",
-                            selected: singleSkill ? skillName === singleSkill : true,
-                            _path: subPath
-                        });
-                    }
-                }
+                // NOTE: Sub-folders are NOT counted as separate skills
+                // They are part of the parent skill (e.g. game-development/2d-games)
             }
         }
     }
@@ -187,31 +173,45 @@ export async function run(spec) {
         stepLine();
         step(`Auto-selected: ${c.cyan(singleSkill)}`);
     } else {
-        // Group skills by category - 5 main categories (all skills covered, no Other)
-        // NOTE: Order matters! Mobile is before Security so mobile-security-coder goes to Mobile
+        // FAANG-Grade Categories (8 balanced categories)
+        // NOTE: Order matters! Specialized categories FIRST, Core is fallback
         const CATEGORY_KEYWORDS = {
-            "⚙️  Backend & API": [
-                // Core backend
-                "backend", "api", "nodejs", "server", "database", "prisma", "mcp", "python", "cache",
-                // Architecture & patterns
-                "architecture", "pattern", "app-builder", "performance", "profiling",
-                // Testing & quality
-                "testing", "test", "tdd", "lint", "validate", "debugging", "systematic", "debug",
-                "code-review", "code-quality", "e2e", "integration", "webapp", "checklist", "reviewer", "clean",
-                // Documentation & tools  
-                "documentation", "plan", "writing", "geo", "seo", "i18n", "localization", "template",
-                // CLI & scripting
-                "bash", "linux", "powershell", "windows", "shell", "script",
-                // AI & automation
-                "agent", "routing", "brainstorm", "behavioral", "intelligent", "parallel", "modes",
-                // Other skills
-                "typescript", "problem", "workflow", "builder", "conventions", "fundamentals",
-                "best-practices", "procedures", "management"
+            // Specialized domains
+            "🎨 Frontend & UI": [
+                "frontend", "nextjs", "tailwind", "css", "ui", "ux", "visual",
+                "studio", "web-core", "design-system", "react-architect", "react"
+            ],
+            "🎮 Game Development": [
+                "game", "development", "engine", "unity", "unreal", "godot", "phaser"
+            ],
+            "📱 Mobile": [
+                "mobile", "first", "developer", "react-native", "flutter",
+                "ios", "android", "swift", "kotlin"
+            ],
+            "🔒 Security & DevOps": [
+                "security", "vulnerability", "offensive", "scanner", "red-team", "governance",
+                "cicd", "pipeline", "gitops", "docker", "deploy", "server-ops"
+            ],
+            // Technical domains
+            "🧪 Testing & Quality": [
+                "test", "testing", "tdd", "e2e", "debug", "quality", "review",
+                "lint", "validate", "automation", "problem", "checker"
+            ],
+            "🤖 AI & Agents": [
+                "agent", "pattern", "auto-learn", "execution", "self-evolution",
+                "lifecycle", "skill-forge", "intelligent", "routing"
             ],
-            "🎨 Frontend & UI": ["frontend", "nextjs", "tailwind", "css", "ui", "ux", "visual", "studio", "web-core", "design-system", "react-architect", "react"],
-            "🎮 Game Development": ["game", "development", "engine", "unity", "unreal", "godot", "phaser", "game-dev"],
-            "📱 Mobile": ["mobile", "first", "developer", "react-native", "flutter", "ios", "android", "swift", "kotlin"],
-            "🔒 Security & DevOps": ["security", "vulnerability", "deploy", "git", "docker", "red-team", "governance", "offensive", "gitops", "cicd", "pipeline", "incident", "chaos", "scanner"]
+            "📚 Docs & Planning": [
+                "doc", "template", "plan", "project", "idea", "brainstorm",
+                "geo", "seo", "i18n", "writing"
+            ],
+            // Fallback (core backend/infra)
+            "⚙️  Backend & Core": [
+                "backend", "api", "nodejs", "python", "server", "database",
+                "prisma", "mcp", "data", "architect", "scaffold", "system",
+                "typescript", "shell", "bash", "powershell", "git", "code-craft",
+                "code-constitution", "observability", "perf", "state", "rollback"
+            ]
         };
 
         function categorizeSkill(skillName) {
@@ -221,12 +221,18 @@ export async function run(spec) {
                     return category;
                 }
             }
-            return "⚙️  Backend & API"; // Default fallback (no "Other" category)
+            return "⚙️  Backend & Core"; // Default fallback (no "Other" category)
         }
 
+        // REQUIRED SKILLS - Always installed, not shown in selection
+        const REQUIRED_SKILLS = ["auto-learner"];
+
+        // Filter out required skills from selection list
+        const selectableSkills = skillsInRepo.filter(s => !REQUIRED_SKILLS.includes(s.value));
+
         // Group skills by category
         const grouped = {};
-        for (const skill of skillsInRepo) {
+        for (const skill of selectableSkills) {
             const cat = categorizeSkill(skill.value);
             if (!grouped[cat]) grouped[cat] = [];
             grouped[cat].push(skill);
@@ -263,13 +269,22 @@ export async function run(spec) {
 
         // Get all skills from selected categories
         selectedSkills = selectedCategories.flatMap(cat => grouped[cat].map(s => s.value));
-    }
 
+        // Add required system skills
+        const requiredInRepo = skillsInRepo.filter(s => REQUIRED_SKILLS.includes(s.value)).map(s => s.value);
+        selectedSkills = [...new Set([...selectedSkills, ...requiredInRepo])];
+    }
 
+    // Check for required skills and show info
+    const CORE_REQUIRED = ["auto-learner"];
+    const installedRequired = selectedSkills.filter(s => CORE_REQUIRED.includes(s));
 
     stepLine();
     step("Select skills to install");
-    console.log(`${c.gray(S.branch)}  ${c.dim(selectedSkills.join(", "))}`);
+    console.log(`${c.gray(S.branch)}  ${c.dim(selectedSkills.filter(s => !CORE_REQUIRED.includes(s)).join(", "))}`);
+    if (installedRequired.length > 0) {
+        console.log(`${c.gray(S.branch)}  ${c.cyan("+ System required:")} ${c.green(installedRequired.join(", "))}`);
+    }
 
     // --- Detect installed agents ---
     stepLine();
@@ -490,7 +505,7 @@ export async function run(spec) {
         archInstalled = true;
     }
 
-    // Install knowledge if it exists
+    // Install knowledge if it exists (required for Agent CLI)
     const knowledgeDir = path.join(baseAgentDir, "knowledge");
     const targetKnowledgeDir = path.join(WORKSPACE, "..", "knowledge");
     let knowledgeInstalled = false;
@@ -499,6 +514,13 @@ export async function run(spec) {
         fs.cpSync(knowledgeDir, targetKnowledgeDir, { recursive: true });
         step("Installed knowledge/");
         knowledgeInstalled = true;
+    } else if (!fs.existsSync(targetKnowledgeDir)) {
+        // Create empty knowledge folder for Agent CLI
+        fs.mkdirSync(targetKnowledgeDir, { recursive: true });
+        // Create minimal structure for Agent CLI
+        fs.writeFileSync(path.join(targetKnowledgeDir, "lessons-learned.yaml"), "# Lessons learned by AI Agent\nlessons: []\n");
+        step("Created knowledge/ (Agent CLI ready)");
+        knowledgeInstalled = true;
     }
 
     // Install rules if they exist

package/lib/agent-cli/README.md

@@ -0,0 +1,21 @@
+# Agent Skill Kit CLI
+
+The intelligent CLI engine for Agent Skill Kit, featuring:
+- **Routing Engine**: Semantic routing validation
+- **Audit System**: Skill usage auditing and metrics
+- **Interactive Mode**: Smart interactive agent interface
+
+## Installation
+
+This package is typically managed by the `add-skill-kit` installer.
+
+```bash
+# Global install (managed by installer)
+npm install -g @agentskillskit/cli
+
+# Usage
+agent
+```
+
+## Documentation
+See the main [Agent Skill Kit](https://github.com/agentskillskit/agent-skills) repository.

package/lib/agent-cli/bin/ag-smart.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+/**
+ * Smart Agent CLI - ESM Version (Production-Ready)
+ * 
+ * The main interface for humans to interact with the Smart Agent Skills system.
+ * 
+ * Commands:
+ *   learn          Add new lessons to memory
+ *   recall         Check files against memory
+ *   audit          Full compliance audit
+ *   watch          Real-time file monitoring
+ *   stats          Knowledge base statistics
+ *   install-hooks  Install git pre-commit hook
+ *   lint-learn     Auto-learn from ESLint output
+ */
+
+import { spawn } from "child_process";
+import path from "path";
+import { fileURLToPath } from "url";
+import { VERSION } from "../lib/config.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ARGS = process.argv.slice(2);
+const COMMAND = ARGS[0];
+const SCRIPTS_DIR = path.join(__dirname, "..", "lib");
+const HOOKS_DIR = path.join(SCRIPTS_DIR, "hooks");
+
+/**
+ * Run a script with given arguments
+ * @param {string} script - Script filename (relative to lib/)
+ * @param {string[]} args - Arguments to pass
+ * @param {string} baseDir - Base directory for script
+ */
+function run(script, args = [], baseDir = SCRIPTS_DIR) {
+    const scriptPath = path.join(baseDir, script);
+    const child = spawn("node", [scriptPath, ...args], {
+        stdio: "inherit",
+        shell: true
+    });
+
+    child.on("close", (code) => {
+        process.exit(code || 0);
+    });
+
+    child.on("error", (err) => {
+        console.error(`❌ Failed to run ${script}:`, err.message);
+        process.exit(1);
+    });
+}
+
+function printHelp() {
+    console.log(`
+🤖 Agent Skill Kit CLI v${VERSION}
+
+Usage: ag-smart <command> [options]
+
+${"─".repeat(50)}
+
+📚 CORE COMMANDS:
+
+  learn          Teach a new lesson to the memory
+                 ag-smart learn --add --pattern "var " --message "Use let/const"
+                 ag-smart learn --list
+                 ag-smart learn --remove LEARN-001
+
+  recall         Check file(s) against learned patterns
+                 ag-smart recall src/app.js
+                 ag-smart recall ./src
+
+  audit          Run full compliance audit
+                 ag-smart audit [directory]
+
+${"─".repeat(50)}
+
+🚀 PRODUCTION FEATURES:
+
+  watch          Real-time file monitoring
+                 ag-smart watch [directory]
+
+  stats          Knowledge base statistics
+                 ag-smart stats
+
+  install-hooks  Install git pre-commit hook
+                 ag-smart install-hooks
+                 ag-smart install-hooks --remove
+
+  lint-learn     Auto-learn from ESLint JSON output
+                 npx eslint . --format json | ag-smart lint-learn
+
+  fix            🆕 Auto-fix violations
+                 ag-smart fix <file|dir> [--mode safe|aggressive]
+
+  sync-skills    🆕 Sync hot patterns to SKILL.md
+                 ag-smart sync-skills
+
+${"─".repeat(50)}
+
+📖 HELP:
+
+  help, --help   Show this help message
+  --version      Show version number
+
+💡 Docs: https://github.com/agentskillkit/agent-skills
+`);
+}
+
+// Command routing
+switch (COMMAND) {
+    // Core commands (v2 versions)
+    case "learn":
+        run("learn.js", ARGS.slice(1));
+        break;
+    case "recall":
+        run("recall.js", ARGS.slice(1));
+        break;
+    case "audit":
+        run("audit.js", ARGS.slice(1));
+        break;
+
+    // Production features
+    case "watch":
+        run("watcher.js", ARGS.slice(1));
+        break;
+    case "stats":
+        run("stats.js", ARGS.slice(1));
+        break;
+    case "install-hooks":
+        run("install-hooks.js", ARGS.slice(1), HOOKS_DIR);
+        break;
+    case "lint-learn":
+        run("lint-learn.js", ARGS.slice(1), HOOKS_DIR);
+        break;
+    case "fix":
+        run("fix.js", ARGS.slice(1));
+        break;
+    case "sync-skills":
+        run("skill-learn.js", ARGS.slice(1));
+        break;
+
+    // Meta
+    case "--version":
+    case "-v":
+        console.log(VERSION);
+        break;
+    case "help":
+    case "--help":
+    case "-h":
+        printHelp();
+        break;
+    case undefined:
+        // No command = show interactive Clack menu
+        import("../lib/ui/index.js").then(m => m.showMainMenu()).catch(console.error);
+        break;
+    default:
+        console.log(`❌ Unknown command: ${COMMAND}`);
+        console.log("   Run 'ag-smart help' for available commands.\n");
+        process.exit(1);
+}

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

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+/**
+ * Smart Audit Script (Production-Ready)
+ * 
+ * The "Judge" - Orchestrates all compliance checks:
+ * 1. Memory Recall (Past Mistakes)
+ * 2. Constitution Checks (Governance)
+ * 3. Real-time Analysis
+ * 
+ * Usage: ag-smart audit [directory]
+ */
+
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { scanDirectory, loadKnowledge, saveKnowledge, printResults } from "./recall.js";
+import { AGENT_DIR, VERSION } from "./config.js";
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// ============================================================================
+// AUDIT CONFIGURATION
+// ============================================================================
+
+const SCAN_EXTENSIONS = [".js", ".ts", ".tsx", ".jsx", ".mjs"];
+
+// ============================================================================
+// GOVERNANCE CHECKS
+// ============================================================================
+
+/**
+ * Check if governance files exist
+ * @param {string} projectRoot 
+ * @returns {{ passed: boolean, details: string[] }}
+ */
+function checkGovernance(projectRoot) {
+    const details = [];
+    let passed = true;
+
+    const governanceFiles = [
+        { path: path.join(projectRoot, ".agent", "GEMINI.md"), name: "GEMINI.md" },
+        { path: path.join(projectRoot, ".agent", "ARCHITECTURE.md"), name: "ARCHITECTURE.md" }
+    ];
+
+    governanceFiles.forEach(file => {
+        if (fs.existsSync(file.path)) {
+            details.push(`${pc.green("✓")} ${file.name} found`);
+        } else {
+            details.push(`${pc.yellow("⚠")} ${file.name} not found (optional)`);
+        }
+    });
+
+    // Check for skills
+    const skillsDir = path.join(projectRoot, ".agent", "skills");
+    if (fs.existsSync(skillsDir)) {
+        const skills = fs.readdirSync(skillsDir).filter(f =>
+            fs.statSync(path.join(skillsDir, f)).isDirectory()
+        );
+        details.push(`${pc.green("✓")} ${skills.length} skill(s) loaded`);
+    }
+
+    return { passed, details };
+}
+
+// ============================================================================
+// MAIN AUDIT
+// ============================================================================
+
+/**
+ * Run full audit on a project
+ * @param {string} projectRoot 
+ */
+async function runAudit(projectRoot) {
+    p.intro(pc.cyan(`⚖️  SMART AUDIT v${VERSION}`));
+
+    let exitCode = 0;
+    const startTime = Date.now();
+
+    // Phase 1: Memory Recall
+    const s1 = p.spinner();
+    s1.start("Phase 1: Memory Recall");
+
+    const db = loadKnowledge();
+
+    if (db.lessons.length === 0) {
+        s1.stop("Phase 1: No lessons learned yet");
+    } else {
+        const { results } = scanDirectory(projectRoot, db, SCAN_EXTENSIONS);
+
+        if (results.length > 0) {
+            const stats = printResults(results);
+            saveKnowledge(db);
+
+            if (stats.errors > 0) {
+                exitCode = 1;
+            }
+            s1.stop(`Phase 1: Found ${stats.total} violation(s)`);
+        } else {
+            s1.stop("Phase 1: No violations found");
+        }
+    }
+
+    // Phase 2: Governance
+    const s2 = p.spinner();
+    s2.start("Phase 2: Governance Check");
+
+    const govResult = checkGovernance(projectRoot);
+    s2.stop("Phase 2: Governance checked");
+
+    p.note(govResult.details.join("\n"), pc.dim("Governance"));
+
+    // Phase 3: Summary
+    const duration = ((Date.now() - startTime) / 1000).toFixed(2);
+    const totalHits = db.lessons.reduce((sum, l) => sum + (l.hitCount || 0), 0);
+
+    const summaryLines = [
+        `⏱️  Completed in ${duration}s`,
+        `📊 Lessons in memory: ${db.lessons.length}`,
+        `🎯 Total pattern hits: ${totalHits}`
+    ];
+    p.note(summaryLines.join("\n"), pc.dim("Summary"));
+
+    if (exitCode === 0) {
+        p.outro(pc.green("✅ AUDIT PASSED: Code is smart and compliant"));
+    } else {
+        p.outro(pc.red("❌ AUDIT FAILED: Please fix ERROR violations"));
+    }
+
+    process.exit(exitCode);
+}
+
+// ============================================================================
+// CLI
+// ============================================================================
+
+const args = process.argv.slice(2);
+const projectRoot = args[0] || process.cwd();
+
+if (args.includes("--help")) {
+    console.log(`
+⚖️  Smart Audit - Compliance Checker
+
+Usage:
+  ag-smart audit [directory]
+
+Options:
+  --help    Show this help
+`);
+    process.exit(0);
+}
+
+runAudit(projectRoot);

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

@@ -0,0 +1,100 @@
+/**
+ * @fileoverview Tests for audit.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-audit-test");
+const AGENT_DIR = path.join(TEST_DIR, ".agent");
+
+describe("Audit - Governance Check", () => {
+    beforeEach(() => {
+        fs.mkdirSync(AGENT_DIR, { recursive: true });
+    });
+
+    afterEach(() => {
+        fs.rmSync(TEST_DIR, { recursive: true, force: true });
+    });
+
+    it("detects GEMINI.md presence", () => {
+        const geminiPath = path.join(AGENT_DIR, "GEMINI.md");
+
+        // Before creation
+        expect(fs.existsSync(geminiPath)).toBe(false);
+
+        // After creation
+        fs.writeFileSync(geminiPath, "# Test", "utf8");
+        expect(fs.existsSync(geminiPath)).toBe(true);
+    });
+
+    it("detects ARCHITECTURE.md presence", () => {
+        const archPath = path.join(AGENT_DIR, "ARCHITECTURE.md");
+        fs.writeFileSync(archPath, "# Architecture", "utf8");
+
+        expect(fs.existsSync(archPath)).toBe(true);
+    });
+
+    it("counts skills in skills directory", () => {
+        const skillsDir = path.join(AGENT_DIR, "skills");
+        fs.mkdirSync(skillsDir, { recursive: true });
+
+        // Create mock skills
+        fs.mkdirSync(path.join(skillsDir, "skill-1"));
+        fs.mkdirSync(path.join(skillsDir, "skill-2"));
+
+        const skills = fs.readdirSync(skillsDir).filter(f =>
+            fs.statSync(path.join(skillsDir, f)).isDirectory()
+        );
+
+        expect(skills.length).toBe(2);
+    });
+});
+
+describe("Audit - Compliance Results", () => {
+    it("calculates pass/fail status correctly", () => {
+        const results = {
+            errors: 0,
+            warnings: 2,
+            total: 2
+        };
+
+        // Errors = 0 means pass
+        expect(results.errors === 0).toBe(true);
+    });
+
+    it("fails when errors exist", () => {
+        const results = {
+            errors: 1,
+            warnings: 0,
+            total: 1
+        };
+
+        expect(results.errors > 0).toBe(true);
+    });
+
+    it("calculates total correctly", () => {
+        const violations = [
+            { lesson: { severity: "ERROR" }, matches: [1, 2] },
+            { lesson: { severity: "WARNING" }, matches: [1] }
+        ];
+
+        let total = 0;
+        let errors = 0;
+        let warnings = 0;
+
+        violations.forEach(v => {
+            total += v.matches.length;
+            if (v.lesson.severity === "ERROR") {
+                errors += v.matches.length;
+            } else {
+                warnings += v.matches.length;
+            }
+        });
+
+        expect(total).toBe(3);
+        expect(errors).toBe(2);
+        expect(warnings).toBe(1);
+    });
+});