add-skill-kit 1.3.0 → 1.3.2

package/bin/cli.js

@@ -1,91 +1,80 @@
 #!/usr/bin/env node
 /**
- * Install Agent Skill v1.0.0
+ * Install Agent Skill CLI
+ * @description Package manager for AI Agent Skills
  */
-import { c, step, fatal, intro, outro } from "./lib/ui.js";
-import { command, params, flags, VERSION } from "./lib/config.js";
+import { c, intro } from "./lib/ui.js";
+import { command, params, VERSION } from "./lib/config.js";
+
+// --- Command Registry ---
+const COMMANDS = {
+    // Installation
+    install: { module: "./lib/commands/install.js", hasParam: true, aliases: ["add", "i"] },
+    uninstall: { module: "./lib/commands/uninstall.js", hasParam: true, aliases: ["remove", "rm"] },
+    update: { module: "./lib/commands/update.js", hasParam: true },
+
+    // Workspace
+    init: { module: "./lib/commands/init.js", aliases: ["list", "ls"] },
+    lock: { module: "./lib/commands/lock.js" },
+    cache: { module: "./lib/commands/cache.js", hasParam: true },
+
+    // Validation
+    verify: { module: "./lib/commands/verify.js" },
+    doctor: { module: "./lib/commands/doctor.js" },
+    validate: { module: "./lib/commands/validate.js", hasParam: true, aliases: ["check"] },
+    analyze: { module: "./lib/commands/analyze.js", hasParam: true },
+
+    // Info
+    info: { module: "./lib/commands/info.js", hasParam: true, aliases: ["show"] },
+    help: { module: "./lib/commands/help.js", aliases: ["--help", "-h"] }
+};
+
+/**
+ * Find command config by name or alias
+ * @param {string} cmd - Command name or alias
+ * @returns {{ name: string, config: object } | null}
+ */
+function findCommand(cmd) {
+    // Direct match
+    if (COMMANDS[cmd]) {
+        return { name: cmd, config: COMMANDS[cmd] };
+    }
+
+    // Alias match
+    for (const [name, config] of Object.entries(COMMANDS)) {
+        if (config.aliases?.includes(cmd)) {
+            return { name, config };
+        }
+    }
+
+    return null;
+}
 
 // --- MAIN ---
 async function main() {
     intro(c.bgBlue(c.white(` Add Skill Kit v${VERSION} `)));
 
-    // Basic command routing
-    let cmdModule;
-
     try {
-        switch (command) {
-            case "list":
-            case "ls":
-            case "init":
-                cmdModule = await import("./lib/commands/init.js");
-                await cmdModule.run();
-                break;
-            case "install":
-            case "add":
-            case "i":
-                cmdModule = await import("./lib/commands/install.js");
-                await cmdModule.run(params[0]);
-                break;
-            case "uninstall":
-            case "remove":
-            case "rm":
-                cmdModule = await import("./lib/commands/uninstall.js");
-                await cmdModule.run(params[0]);
-                break;
-            case "update":
-                cmdModule = await import("./lib/commands/update.js");
-                await cmdModule.run(params[0]);
-                break;
-            case "lock":
-                cmdModule = await import("./lib/commands/lock.js");
-                await cmdModule.run();
-                break;
-            case "verify":
-                cmdModule = await import("./lib/commands/verify.js");
-                await cmdModule.run();
-                break;
-            case "doctor":
-                cmdModule = await import("./lib/commands/doctor.js");
-                await cmdModule.run();
-                break;
-            case "cache":
-                cmdModule = await import("./lib/commands/cache.js");
-                await cmdModule.run(params[0]);
-                break;
-            case "validate":
-            case "check":
-                cmdModule = await import("./lib/commands/validate.js");
-                await cmdModule.run(params[0]);
-                break;
-            case "analyze":
-                cmdModule = await import("./lib/commands/analyze.js");
-                await cmdModule.run(params[0]);
-                break;
-            case "info":
-            case "show":
-                cmdModule = await import("./lib/commands/info.js");
-                await cmdModule.run(params[0]);
-                break;
-            case "help":
-            case "--help":
-            case "-h":
-                cmdModule = await import("./lib/commands/help.js");
-                await cmdModule.run();
-                break;
-            case "--version":
-            case "-V":
-                console.log(VERSION);
-                break;
-            default:
-                // Handle direct install via org/repo syntax
-                if (command.includes("/")) {
-                    cmdModule = await import("./lib/commands/install.js");
-                    await cmdModule.run(command);
-                } else {
-                    console.log(`Unknown command: ${command}`);
-                    cmdModule = await import("./lib/commands/help.js");
-                    await cmdModule.run();
-                }
+        // Handle version flag
+        if (command === "--version" || command === "-V") {
+            console.log(VERSION);
+            return;
+        }
+
+        // Find command
+        const found = findCommand(command);
+
+        if (found) {
+            const cmdModule = await import(found.config.module);
+            await cmdModule.run(found.config.hasParam ? params[0] : undefined);
+        } else if (command.includes("/")) {
+            // Direct install via org/repo syntax
+            const cmdModule = await import("./lib/commands/install.js");
+            await cmdModule.run(command);
+        } else {
+            console.log(`Unknown command: ${command}`);
+            const cmdModule = await import("./lib/commands/help.js");
+            await cmdModule.run();
         }
     } catch (err) {
         console.error(c.red("\nError: " + err.message));

package/bin/lib/commands/install.js

@@ -207,9 +207,17 @@ export async function run(spec) {
     step("Select skills to install");
     console.log(`${c.gray(S.branch)}  ${c.dim(selectedSkills.join(", "))}`);
 
-    // Agent selection
+    // Agent selection - currently only Antigravity supported
+    const availableAgents = [
+        { label: "Antigravity (.agent/skills)", value: "antigravity", available: true },
+        { label: "Claude Code (coming soon)", value: "claude", available: false },
+        { label: "Codex (coming soon)", value: "codex", available: false },
+        { label: "Gemini CLI (coming soon)", value: "gemini", available: false },
+        { label: "Windsurf (coming soon)", value: "windsurf", available: false }
+    ];
+    const activeAgentCount = availableAgents.filter(a => a.available).length;
     stepLine();
-    step("Detected 5 agents"); // Passive info
+    step(`Detected ${availableAgents.length} agents (${activeAgentCount} available)`);
 
     let agents;
     while (true) {
@@ -218,13 +226,10 @@ export async function run(spec) {
 
         agents = await multiselect({
             message: `${c.cyan("space")} select · ${c.cyan("enter")} confirm`,
-            options: [
-                { label: "Antigravity (.agent/skills)", value: "antigravity" },
-                { label: c.dim("Claude Code (coming soon)"), value: "claude" },
-                { label: c.dim("Codex (coming soon)"), value: "codex" },
-                { label: c.dim("Gemini CLI (coming soon)"), value: "gemini" },
-                { label: c.dim("Windsurf (coming soon)"), value: "windsurf" }
-            ],
+            options: availableAgents.map(a => ({
+                label: a.available ? a.label : c.dim(a.label),
+                value: a.value
+            })),
             initialValues: ["antigravity"],
             required: true
         });
@@ -296,9 +301,9 @@ export async function run(spec) {
     const methodVerb = installMethod === "symlink" ? "symlink" : "copy";
 
     for (const sn of selectedSkills) {
-        // Mock path relative to home for visual appeal
-        const mockPath = `~\\Desktop\\New Project\\.agents\\skills\\${sn}`;
-        summaryContent += `${c.cyan(mockPath)}\n`;
+        // Show actual target path
+        const targetPath = path.relative(cwd, path.join(targetScope, sn));
+        summaryContent += `${c.cyan(targetPath)}\n`;
         summaryContent += `  ${c.dim(methodVerb)} ${c.gray("→")} ${c.dim(agentsString)}\n\n`;
     }
 
@@ -383,6 +388,78 @@ export async function run(spec) {
         geminiInstalled = true;
     }
 
+    // Install agents if they exist
+    const agentsDir = path.join(tmp, ".agent", "agents");
+    const targetAgentsDir = path.join(WORKSPACE, "..", "agents");
+    let agentsInstalled = 0;
+
+    if (fs.existsSync(agentsDir)) {
+        stepLine();
+        const as = spinner();
+        as.start("Installing agents");
+
+        fs.mkdirSync(targetAgentsDir, { recursive: true });
+        const agents = fs.readdirSync(agentsDir).filter(f => f.endsWith(".md"));
+
+        for (const agent of agents) {
+            const src = path.join(agentsDir, agent);
+            const dest = path.join(targetAgentsDir, agent);
+
+            if (!fs.existsSync(dest)) {
+                fs.copyFileSync(src, dest);
+                agentsInstalled++;
+            }
+        }
+
+        as.stop(`Installed ${agentsInstalled} agents`);
+    }
+
+    // Install ARCHITECTURE.md if it exists
+    const archSrc = path.join(tmp, ".agent", "ARCHITECTURE.md");
+    const archDest = path.join(WORKSPACE, "..", "ARCHITECTURE.md");
+    let archInstalled = false;
+
+    if (fs.existsSync(archSrc) && !fs.existsSync(archDest)) {
+        fs.copyFileSync(archSrc, archDest);
+        step("Installed ARCHITECTURE.md");
+        archInstalled = true;
+    }
+
+    // Install knowledge if it exists
+    const knowledgeDir = path.join(tmp, ".agent", "knowledge");
+    const targetKnowledgeDir = path.join(WORKSPACE, "..", "knowledge");
+    let knowledgeInstalled = false;
+
+    if (fs.existsSync(knowledgeDir) && !fs.existsSync(targetKnowledgeDir)) {
+        fs.cpSync(knowledgeDir, targetKnowledgeDir, { recursive: true });
+        step("Installed knowledge/");
+        knowledgeInstalled = true;
+    }
+
+    // Install rules if they exist
+    const rulesDir = path.join(tmp, ".agent", "rules");
+    const targetRulesDir = path.join(WORKSPACE, "..", "rules");
+    let rulesInstalled = 0;
+
+    if (fs.existsSync(rulesDir)) {
+        fs.mkdirSync(targetRulesDir, { recursive: true });
+        const rules = fs.readdirSync(rulesDir).filter(f => f.endsWith(".md"));
+
+        for (const rule of rules) {
+            const src = path.join(rulesDir, rule);
+            const dest = path.join(targetRulesDir, rule);
+
+            if (!fs.existsSync(dest)) {
+                fs.copyFileSync(src, dest);
+                rulesInstalled++;
+            }
+        }
+
+        if (rulesInstalled > 0) {
+            step(`Installed ${rulesInstalled} rules`);
+        }
+    }
+
     // Installation complete step
     stepLine();
     step("Installation complete");
@@ -404,14 +481,35 @@ export async function run(spec) {
         successContent += `${c.cyan("✓")} ${c.dim(`.agent/workflows/ (${workflowsInstalled} files)`)}\n`;
     }
 
+    // Agents summary
+    if (agentsInstalled > 0) {
+        successContent += `${c.cyan("✓")} ${c.dim(`.agent/agents/ (${agentsInstalled} files)`)}\n`;
+    }
+
     // GEMINI.md summary
     if (geminiInstalled) {
         successContent += `${c.cyan("✓")} ${c.dim(".agent/GEMINI.md (Agent Rules)")}\n`;
     }
 
+    // ARCHITECTURE.md summary
+    if (archInstalled) {
+        successContent += `${c.cyan("✓")} ${c.dim(".agent/ARCHITECTURE.md")}\n`;
+    }
+
+    // Knowledge summary
+    if (knowledgeInstalled) {
+        successContent += `${c.cyan("✓")} ${c.dim(".agent/knowledge/")}\n`;
+    }
+
+    // Rules summary
+    if (rulesInstalled > 0) {
+        successContent += `${c.cyan("✓")} ${c.dim(`.agent/rules/ (${rulesInstalled} files)`)}\n`;
+    }
+
     // Build title
     const parts = [`${selectedSkills.length} skills`];
     if (workflowsInstalled > 0) parts.push(`${workflowsInstalled} workflows`);
+    if (agentsInstalled > 0) parts.push(`${agentsInstalled} agents`);
     if (geminiInstalled) parts.push("GEMINI.md");
 
     console.log(boxen(successContent.trim(), {

package/bin/lib/helpers.js

@@ -24,7 +24,10 @@ export function getDirSize(dir) {
             }
         };
         walk(dir);
-    } catch { }
+    } catch (err) {
+        // Directory may not exist or be inaccessible
+        if (process.env.DEBUG) console.error(`getDirSize error: ${err.message}`);
+    }
     return size;
 }
 
@@ -78,10 +81,24 @@ export function merkleHash(dir) {
  * @returns {import('./types.js').ParsedSpec}
  */
 export function parseSkillSpec(spec) {
+    if (!spec || typeof spec !== 'string') {
+        throw new Error('Skill spec is required');
+    }
+
     const [repoPart, skillPart] = spec.split("#");
+
+    if (!repoPart.includes('/')) {
+        throw new Error(`Invalid spec format: "${spec}". Expected: org/repo or org/repo#skill`);
+    }
+
     const [org, repo] = repoPart.split("/");
+
+    if (!org || !repo) {
+        throw new Error(`Invalid spec: missing org or repo in "${spec}"`);
+    }
+
     const [skill, ref] = (skillPart || "").split("@");
-    return { org, repo, skill, ref };
+    return { org, repo, skill: skill || undefined, ref: ref || undefined };
 }
 
 /**
@@ -140,8 +157,12 @@ export function loadSkillLock() {
  * @returns {string[]}
  */
 export function loadRegistries() {
-    try { return fs.existsSync(REGISTRIES_FILE) ? JSON.parse(fs.readFileSync(REGISTRIES_FILE, "utf-8")) : []; }
-    catch { return []; }
+    try {
+        return fs.existsSync(REGISTRIES_FILE) ? JSON.parse(fs.readFileSync(REGISTRIES_FILE, "utf-8")) : [];
+    } catch (err) {
+        if (process.env.DEBUG) console.error(`loadRegistries error: ${err.message}`);
+        return [];
+    }
 }
 
 /**

package/bin/lib/helpers.test.js

@@ -0,0 +1,60 @@
+/**
+ * @fileoverview Tests for helpers.js
+ */
+import { describe, it, expect } from "vitest";
+import { formatBytes, formatDate, parseSkillSpec } from "./helpers.js";
+
+describe("formatBytes", () => {
+    it("formats bytes correctly", () => {
+        expect(formatBytes(0)).toBe("0 B");
+        expect(formatBytes(512)).toBe("512 B");
+        expect(formatBytes(1024)).toBe("1.0 KB");
+        expect(formatBytes(1536)).toBe("1.5 KB");
+        expect(formatBytes(1048576)).toBe("1.0 MB");
+        expect(formatBytes(1572864)).toBe("1.5 MB");
+    });
+});
+
+describe("formatDate", () => {
+    it("returns 'unknown' for undefined", () => {
+        expect(formatDate()).toBe("unknown");
+        expect(formatDate(undefined)).toBe("unknown");
+    });
+
+    it("formats ISO date strings", () => {
+        const result = formatDate("2026-01-25T00:00:00.000Z");
+        expect(result).toBeTruthy();
+        expect(typeof result).toBe("string");
+    });
+});
+
+describe("parseSkillSpec", () => {
+    it("parses org/repo format", () => {
+        const result = parseSkillSpec("agentskillkit/agent-skills");
+        expect(result.org).toBe("agentskillkit");
+        expect(result.repo).toBe("agent-skills");
+        expect(result.skill).toBeUndefined();
+        expect(result.ref).toBeUndefined();
+    });
+
+    it("parses org/repo#skill format", () => {
+        const result = parseSkillSpec("agentskillkit/agent-skills#react-patterns");
+        expect(result.org).toBe("agentskillkit");
+        expect(result.repo).toBe("agent-skills");
+        expect(result.skill).toBe("react-patterns");
+    });
+
+    it("parses org/repo#skill@ref format", () => {
+        const result = parseSkillSpec("agentskillkit/agent-skills#react-patterns@v1.0.0");
+        expect(result.org).toBe("agentskillkit");
+        expect(result.repo).toBe("agent-skills");
+        expect(result.skill).toBe("react-patterns");
+        expect(result.ref).toBe("v1.0.0");
+    });
+
+    it("throws error for invalid spec", () => {
+        expect(() => parseSkillSpec("")).toThrow("Skill spec is required");
+        expect(() => parseSkillSpec("invalid")).toThrow("Invalid spec format");
+        expect(() => parseSkillSpec(null)).toThrow("Skill spec is required");
+    });
+});

package/bin/lib/skills.js

@@ -30,7 +30,10 @@ export function parseSkillMdFrontmatter(p) {
             else if (key && val) meta[key] = val;
         }
         return meta;
-    } catch { return {}; }
+    } catch (err) {
+        if (process.env.DEBUG) console.error(`parseSkillMdFrontmatter error: ${err.message}`);
+        return {};
+    }
 }
 
 /**
@@ -69,7 +72,9 @@ export function detectSkillStructure(dir) {
                 s.files.push(item);
             }
         }
-    } catch { }
+    } catch (err) {
+        if (process.env.DEBUG) console.error(`detectSkillStructure error: ${err.message}`);
+    }
     return s;
 }
 

package/bin/lib/skills.test.js

@@ -0,0 +1,109 @@
+/**
+ * @fileoverview Tests for skills.js
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { parseSkillMdFrontmatter, detectSkillStructure } from "./skills.js";
+
+describe("parseSkillMdFrontmatter", () => {
+    let tempDir;
+    let skillMdPath;
+
+    beforeEach(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "skill-test-"));
+        skillMdPath = path.join(tempDir, "SKILL.md");
+    });
+
+    afterEach(() => {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+
+    it("parses valid frontmatter", () => {
+        const content = `---
+name: test-skill
+description: A test skill for testing
+version: 1.0.0
+author: Test Author
+tags: react, testing, patterns
+---
+
+# Test Skill
+
+Some content here.
+`;
+        fs.writeFileSync(skillMdPath, content);
+
+        const result = parseSkillMdFrontmatter(skillMdPath);
+
+        expect(result.name).toBe("test-skill");
+        expect(result.description).toBe("A test skill for testing");
+        expect(result.version).toBe("1.0.0");
+        expect(result.author).toBe("Test Author");
+        expect(result.tags).toEqual(["react", "testing", "patterns"]);
+    });
+
+    it("returns empty object for no frontmatter", () => {
+        fs.writeFileSync(skillMdPath, "# Just a heading\n\nNo frontmatter here.");
+
+        const result = parseSkillMdFrontmatter(skillMdPath);
+
+        expect(result).toEqual({});
+    });
+
+    it("returns empty object for non-existent file", () => {
+        const result = parseSkillMdFrontmatter("/non/existent/path/SKILL.md");
+        expect(result).toEqual({});
+    });
+});
+
+describe("detectSkillStructure", () => {
+    let tempDir;
+
+    beforeEach(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "skill-structure-"));
+    });
+
+    afterEach(() => {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+
+    it("detects standard directories", () => {
+        fs.mkdirSync(path.join(tempDir, "resources"));
+        fs.mkdirSync(path.join(tempDir, "examples"));
+        fs.mkdirSync(path.join(tempDir, "scripts"));
+        fs.writeFileSync(path.join(tempDir, "SKILL.md"), "# Skill");
+
+        const result = detectSkillStructure(tempDir);
+
+        expect(result.hasResources).toBe(true);
+        expect(result.hasExamples).toBe(true);
+        expect(result.hasScripts).toBe(true);
+        expect(result.directories).toContain("resources");
+        expect(result.directories).toContain("examples");
+        expect(result.directories).toContain("scripts");
+        expect(result.files).toContain("SKILL.md");
+    });
+
+    it("detects governance directories", () => {
+        fs.mkdirSync(path.join(tempDir, "constitution"));
+        fs.mkdirSync(path.join(tempDir, "doctrines"));
+        fs.mkdirSync(path.join(tempDir, "enforcement"));
+        fs.mkdirSync(path.join(tempDir, "proposals"));
+
+        const result = detectSkillStructure(tempDir);
+
+        expect(result.hasConstitution).toBe(true);
+        expect(result.hasDoctrines).toBe(true);
+        expect(result.hasEnforcement).toBe(true);
+        expect(result.hasProposals).toBe(true);
+    });
+
+    it("returns empty structure for non-existent dir", () => {
+        const result = detectSkillStructure("/non/existent/path");
+
+        expect(result.directories).toEqual([]);
+        expect(result.files).toEqual([]);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "add-skill-kit",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "Enterprise-grade Agent Skill Manager with Antigravity Skills support, Progressive Disclosure detection, and semantic routing validation",
   "license": "MIT",
   "author": "agentskillkit <agentskillkit@gmail.com>",
@@ -38,9 +38,12 @@
     "antigravity"
   ],
   "scripts": {
-    "lint": "echo \"No lint configured\"",
-    "test": "echo \"No tests yet\"",
-    "ci": "node bin/cli.js verify --strict && node bin/cli.js doctor --strict"
+    "lint": "eslint bin/",
+    "lint:fix": "eslint bin/ --fix",
+    "format": "prettier --write bin/",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "ci": "npm run lint && npm test && node bin/cli.js verify --strict && node bin/cli.js doctor --strict"
   },
   "publishConfig": {
     "access": "public"
@@ -52,5 +55,10 @@
     "kleur": "^4.1.5",
     "ora": "^8.1.0",
     "prompts": "^2.4.2"
+  },
+  "devDependencies": {
+    "eslint": "^8.57.0",
+    "prettier": "^3.2.5",
+    "vitest": "^1.6.0"
   }
 }