add-skill-kit 3.2.0 → 3.2.2

package/bin/lib/agents.js

@@ -0,0 +1,208 @@
+/**
+ * @fileoverview Agent definitions and detection
+ * Based on Vercel's agent-skills CLI structure
+ */
+
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+const home = homedir();
+
+// Environment-based paths
+const codexHome = process.env.CODEX_HOME?.trim() || join(home, ".codex");
+const claudeHome = process.env.CLAUDE_CONFIG_DIR?.trim() || join(home, ".claude");
+
+/**
+ * @typedef {Object} AgentConfig
+ * @property {string} name - Internal agent ID
+ * @property {string} displayName - Display name for UI
+ * @property {string} skillsDir - Project-level skills directory
+ * @property {string} globalSkillsDir - Global skills directory
+ * @property {() => boolean} detect - Detection function
+ */
+
+/**
+ * All supported agents with detection logic
+ * @type {Record<string, AgentConfig>}
+ */
+export const AGENTS = {
+    antigravity: {
+        name: "antigravity",
+        displayName: "Antigravity",
+        skillsDir: ".agent/skills",
+        globalSkillsDir: join(home, ".gemini/antigravity/global_skills"),
+        detect: () => existsSync(join(process.cwd(), ".agent")) || existsSync(join(home, ".gemini/antigravity"))
+    },
+    "claude-code": {
+        name: "claude-code",
+        displayName: "Claude Code",
+        skillsDir: ".claude/skills",
+        globalSkillsDir: join(claudeHome, "skills"),
+        detect: () => existsSync(claudeHome)
+    },
+    codex: {
+        name: "codex",
+        displayName: "Codex",
+        skillsDir: ".codex/skills",
+        globalSkillsDir: join(codexHome, "skills"),
+        detect: () => existsSync(codexHome) || existsSync("/etc/codex")
+    },
+    "gemini-cli": {
+        name: "gemini-cli",
+        displayName: "Gemini CLI",
+        skillsDir: ".gemini/skills",
+        globalSkillsDir: join(home, ".gemini/skills"),
+        detect: () => existsSync(join(home, ".gemini"))
+    },
+    "github-copilot": {
+        name: "github-copilot",
+        displayName: "GitHub Copilot",
+        skillsDir: ".github/skills",
+        globalSkillsDir: join(home, ".copilot/skills"),
+        detect: () => existsSync(join(process.cwd(), ".github")) || existsSync(join(home, ".copilot"))
+    },
+    windsurf: {
+        name: "windsurf",
+        displayName: "Windsurf",
+        skillsDir: ".windsurf/skills",
+        globalSkillsDir: join(home, ".codeium/windsurf/skills"),
+        detect: () => existsSync(join(home, ".codeium/windsurf"))
+    },
+    cursor: {
+        name: "cursor",
+        displayName: "Cursor",
+        skillsDir: ".cursor/skills",
+        globalSkillsDir: join(home, ".cursor/skills"),
+        detect: () => existsSync(join(home, ".cursor"))
+    },
+    cline: {
+        name: "cline",
+        displayName: "Cline",
+        skillsDir: ".cline/skills",
+        globalSkillsDir: join(home, ".cline/skills"),
+        detect: () => existsSync(join(home, ".cline"))
+    },
+    roo: {
+        name: "roo",
+        displayName: "Roo Code",
+        skillsDir: ".roo/skills",
+        globalSkillsDir: join(home, ".roo/skills"),
+        detect: () => existsSync(join(home, ".roo"))
+    },
+    continue: {
+        name: "continue",
+        displayName: "Continue",
+        skillsDir: ".continue/skills",
+        globalSkillsDir: join(home, ".continue/skills"),
+        detect: () => existsSync(join(process.cwd(), ".continue")) || existsSync(join(home, ".continue"))
+    },
+    goose: {
+        name: "goose",
+        displayName: "Goose",
+        skillsDir: ".goose/skills",
+        globalSkillsDir: join(home, ".config/goose/skills"),
+        detect: () => existsSync(join(home, ".config/goose"))
+    },
+    trae: {
+        name: "trae",
+        displayName: "Trae",
+        skillsDir: ".trae/skills",
+        globalSkillsDir: join(home, ".trae/skills"),
+        detect: () => existsSync(join(home, ".trae"))
+    },
+    kilo: {
+        name: "kilo",
+        displayName: "Kilo Code",
+        skillsDir: ".kilocode/skills",
+        globalSkillsDir: join(home, ".kilocode/skills"),
+        detect: () => existsSync(join(home, ".kilocode"))
+    },
+    opencode: {
+        name: "opencode",
+        displayName: "OpenCode",
+        skillsDir: ".opencode/skills",
+        globalSkillsDir: join(home, ".config/opencode/skills"),
+        detect: () => existsSync(join(home, ".config/opencode"))
+    },
+    amp: {
+        name: "amp",
+        displayName: "Amp",
+        skillsDir: ".agents/skills",
+        globalSkillsDir: join(home, ".config/agents/skills"),
+        detect: () => existsSync(join(home, ".config/amp"))
+    },
+    junie: {
+        name: "junie",
+        displayName: "Junie",
+        skillsDir: ".junie/skills",
+        globalSkillsDir: join(home, ".junie/skills"),
+        detect: () => existsSync(join(home, ".junie"))
+    },
+    "kiro-cli": {
+        name: "kiro-cli",
+        displayName: "Kiro CLI",
+        skillsDir: ".kiro/skills",
+        globalSkillsDir: join(home, ".kiro/skills"),
+        detect: () => existsSync(join(home, ".kiro"))
+    },
+    zencoder: {
+        name: "zencoder",
+        displayName: "Zencoder",
+        skillsDir: ".zencoder/skills",
+        globalSkillsDir: join(home, ".zencoder/skills"),
+        detect: () => existsSync(join(home, ".zencoder"))
+    },
+    openhands: {
+        name: "openhands",
+        displayName: "OpenHands",
+        skillsDir: ".openhands/skills",
+        globalSkillsDir: join(home, ".openhands/skills"),
+        detect: () => existsSync(join(home, ".openhands"))
+    },
+    "qwen-code": {
+        name: "qwen-code",
+        displayName: "Qwen Code",
+        skillsDir: ".qwen/skills",
+        globalSkillsDir: join(home, ".qwen/skills"),
+        detect: () => existsSync(join(home, ".qwen"))
+    }
+};
+
+/**
+ * Detect all installed agents on the system
+ * @returns {Array<{name: string, displayName: string, skillsDir: string, globalSkillsDir: string}>}
+ */
+export function detectInstalledAgents() {
+    const detected = [];
+
+    for (const [key, config] of Object.entries(AGENTS)) {
+        if (config.detect()) {
+            detected.push({
+                name: config.name,
+                displayName: config.displayName,
+                skillsDir: config.skillsDir,
+                globalSkillsDir: config.globalSkillsDir
+            });
+        }
+    }
+
+    return detected;
+}
+
+/**
+ * Get agent config by name
+ * @param {string} name - Agent name
+ * @returns {AgentConfig | undefined}
+ */
+export function getAgentConfig(name) {
+    return AGENTS[name];
+}
+
+/**
+ * Get all agent names
+ * @returns {string[]}
+ */
+export function getAllAgentNames() {
+    return Object.keys(AGENTS);
+}

package/bin/lib/commands/install.js

@@ -130,14 +130,34 @@ export async function run(spec) {
     if (skillsDir) {
         for (const e of fs.readdirSync(skillsDir)) {
             const sp = path.join(skillsDir, e);
-            if (fs.statSync(sp).isDirectory() && fs.existsSync(path.join(sp, "SKILL.md"))) {
-                const m = parseSkillMdFrontmatter(path.join(sp, "SKILL.md"));
-                skillsInRepo.push({
-                    title: e + (m.description ? c.dim(` (${m.description.substring(0, 40)}...)`) : ""),
-                    value: e,
-                    selected: singleSkill ? e === singleSkill : true,
-                    _path: sp  // Store actual path for later use
-                });
+            if (fs.statSync(sp).isDirectory()) {
+                // Check if this directory has SKILL.md (top-level skill)
+                if (fs.existsSync(path.join(sp, "SKILL.md"))) {
+                    const m = parseSkillMdFrontmatter(path.join(sp, "SKILL.md"));
+                    skillsInRepo.push({
+                        title: e,  // Only show folder name
+                        value: e,
+                        description: m.description || "",
+                        selected: singleSkill ? e === singleSkill : true,
+                        _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
+                        });
+                    }
+                }
             }
         }
     }
@@ -167,177 +187,167 @@ export async function run(spec) {
         stepLine();
         step(`Auto-selected: ${c.cyan(singleSkill)}`);
     } else {
-        // Show selection prompt for multiple skills
-        stepLine();
+        // 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
+        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"
+            ],
+            "🎨 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"]
+        };
+
+        function categorizeSkill(skillName) {
+            const lower = skillName.toLowerCase();
+            for (const [category, keywords] of Object.entries(CATEGORY_KEYWORDS)) {
+                if (keywords.some(kw => lower.includes(kw))) {
+                    return category;
+                }
+            }
+            return "⚙️  Backend & API"; // Default fallback (no "Other" category)
+        }
+
+        // Group skills by category
+        const grouped = {};
+        for (const skill of skillsInRepo) {
+            const cat = categorizeSkill(skill.value);
+            if (!grouped[cat]) grouped[cat] = [];
+            grouped[cat].push(skill);
+        }
+
+        // Custom sort: alphabetical but "Other" always last
+        const sortedCategories = Object.keys(grouped).sort((a, b) => {
+            if (a.includes("Other")) return 1;
+            if (b.includes("Other")) return -1;
+            return a.localeCompare(b);
+        });
 
-        // Active Step: Selection
-        // Note: activeStep already prints the icon. Clack prompts typically print their own message.
-        // But we want to enforce the tree style.
-        // Clack's multiselect prints: "? Message"
-        // We want: "◆ Select skills to install"
-        // We can print "activeStep" line, and then let clack print below?
-        // Or we use clack's message but Clack doesn't support custom icons well in the prompt line itself easily without patches.
-        // We will print the active step line manually, and set clack message to something minimal or empty if possible, or just repeat it but we want the "◆".
-        // Let's print activeStep("Select skills to install") and then run multiselect with a simpler message like " " or hidden?
-        // Clack behaves best with a message. Let's try printing the header and then the prompt.
 
-        activeStep("Select skills to install");
+        stepLine();
+        activeStep("Select skill categories to install");
 
-        const skills = await multiselect({
+        // Show only categories, not individual skills
+        const selectedCategories = await multiselect({
             message: `${c.cyan("space")} select · ${c.cyan("enter")} confirm`,
-            options: skillsInRepo.map(s => ({
-                label: s.title,
-                value: s.value
+            options: sortedCategories.map(cat => ({
+                label: `${cat} (${grouped[cat].length} skills)`,
+                value: cat,
+                hint: grouped[cat].slice(0, 3).map(s => s.value).join(", ") + (grouped[cat].length > 3 ? "..." : "")
             })),
-            initialValues: skillsInRepo.map(s => s.value), // Pre-select all
+            initialValues: sortedCategories, // Pre-select all
             required: true
         });
 
-        if (isCancel(skills)) {
+        if (isCancel(selectedCategories)) {
             cancel("Cancelled.");
             fs.rmSync(tmp, { recursive: true, force: true });
             return;
         }
 
-        selectedSkills = skills;
+        // Get all skills from selected categories
+        selectedSkills = selectedCategories.flatMap(cat => grouped[cat].map(s => s.value));
     }
 
-    // Ensure newline after prompt to fix tree alignment
+
+
     stepLine();
     step("Select skills to install");
     console.log(`${c.gray(S.branch)}  ${c.dim(selectedSkills.join(", "))}`);
 
-    // --- NEW: Scope Selection ---
+    // --- Detect installed agents ---
+    stepLine();
+    const { detectInstalledAgents } = await import("../agents.js");
+    const detectedAgents = detectInstalledAgents();
 
-    // Determine installation scope
-    let isGlobal = false;
+    if (detectedAgents.length === 0) {
+        step(c.yellow("No agents detected"), S.diamond, "yellow");
+        step(c.dim("Please install at least one AI agent (Antigravity, Claude Code, etc.)"), S.branch, "gray");
+        fs.rmSync(tmp, { recursive: true, force: true });
+        return;
+    }
 
-    if (GLOBAL) {
-        isGlobal = true;
-    } else {
-        activeStep("Select installation scope");
-
-        const scopeSelection = await select({
-            message: " ",
-            options: [
-                {
-                    label: "Current Project",
-                    value: "local",
-                    hint: "Installs to .agent/ (Best for project-specific skills)"
-                },
-                {
-                    label: "Global System",
-                    value: "global",
-                    hint: "Installs to ~/.gemini/ (Available to all projects via 'agent' command)"
-                }
-            ],
-            initialValue: "local"
-        });
+    step(`Detected ${detectedAgents.length} agents`);
 
-        if (isCancel(scopeSelection)) {
-            cancel("Cancelled.");
-            fs.rmSync(tmp, { recursive: true, force: true });
-            return;
-        }
+    // --- Select agents (Vercel-style) ---
+    const { selectAgentsPrompt, selectScopePrompt, selectMethodPrompt } = await import("../ui.js");
+
+    stepLine();
+    activeStep("Install to");
+    const selectedAgents = await selectAgentsPrompt(detectedAgents);
 
-        isGlobal = scopeSelection === "global";
+    if (!selectedAgents || selectedAgents.length === 0) {
+        fs.rmSync(tmp, { recursive: true, force: true });
+        return;
     }
-    const targetScope = isGlobal ? GLOBAL_DIR : WORKSPACE;
 
     stepLine();
-    step("Installation scope");
-    console.log(`${c.gray(S.branch)}  ${c.dim(isGlobal ? "Global System" : "Current Project")}`);
-
-    // 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 ${availableAgents.length} agents (${activeAgentCount} available)`);
+    step("Install to");
+    console.log(`${c.gray(S.branch)}  ${c.dim(selectedAgents.map(a => a.displayName).join(", "))}`);
 
-    let agents;
-    while (true) {
-        // Active Step
-        activeStep("Select agents to install skills to (Antigravity only)");
+    // --- Select installation scope ---
+    let isGlobal = GLOBAL;
 
-        agents = await multiselect({
-            message: `${c.cyan("space")} select · ${c.cyan("enter")} confirm`,
-            options: availableAgents.map(a => ({
-                label: a.available ? a.label : c.dim(a.label),
-                value: a.value
-            })),
-            initialValues: ["antigravity"],
-            required: true
-        });
+    if (!GLOBAL) {
+        stepLine();
+        activeStep("Installation scope");
+        const scope = await selectScopePrompt();
 
-        if (isCancel(agents)) {
-            cancel("Cancelled.");
+        if (!scope) {
             fs.rmSync(tmp, { recursive: true, force: true });
             return;
         }
 
-        const invalidAgents = agents.filter(a => ["claude", "codex", "gemini", "windsurf"].includes(a));
-        if (invalidAgents.length > 0) {
-            step(`Selection contains coming soon agents. Only Antigravity is currently supported.`, S.cross, "red");
-            stepLine();
-            continue;
-        }
-
-        break;
-    }
-
-    if (!agents || agents.length === 0) {
-        console.log(`\n ${c.yellow("No agents selected.")}`);
-        fs.rmSync(tmp, { recursive: true, force: true });
-        return;
+        isGlobal = scope === "global";
     }
 
-    // Agent summary
     stepLine();
-    step("Select agents to install skills to");
-    console.log(`${c.gray(S.branch)}  ${c.dim(Array.isArray(agents) ? agents.join(", ") : agents)}`);
+    step("Installation scope");
+    console.log(`${c.gray(S.branch)}  ${c.dim(isGlobal ? "Global" : "Project")}`);
 
-    // Installation method
+    // --- Select installation method ---
+    stepLine();
     activeStep("Installation method");
+    const installMethod = await selectMethodPrompt();
 
-    const installMethod = await select({
-        message: " ",
-        options: [
-            { label: "Symlink (Recommended)", value: "symlink", hint: "Single source of truth, easy updates" },
-            { label: "Copy to all agents", value: "copy" }
-        ],
-        initialValue: "symlink"
-    });
-
-    if (isCancel(installMethod)) {
-        cancel("Cancelled.");
+    if (!installMethod) {
         fs.rmSync(tmp, { recursive: true, force: true });
         return;
     }
 
+
     // Installation Summary Box
     stepLine();
-    step("Installation Summary"); // Passive header for box
+    step("Installation method");
+    console.log(`${c.gray(S.branch)}  ${c.dim(installMethod === "symlink" ? "Symlink" : "Copy")}`);
+
+    stepLine();
+    step("Installation Summary");
     stepLine();
 
-    const selectedAgentsList = Array.isArray(agents) ? agents : [agents];
-    const agentsString = selectedAgentsList.map(a =>
-        a === "antigravity" ? "Antigravity" :
-            a.charAt(0).toUpperCase() + a.slice(1)
-    ).join(", ");
+    const agentsString = selectedAgents.map(a => a.displayName).join(", ");
 
     let summaryContent = "";
     const methodVerb = installMethod === "symlink" ? "symlink" : "copy";
 
     for (const sn of selectedSkills) {
-        // Show actual target path
-        const targetPath = path.relative(process.cwd(), path.join(targetScope, sn));
-        summaryContent += `${c.cyan(targetPath)}\n`;
+        summaryContent += `${c.cyan(sn)}\n`;
         summaryContent += `  ${c.dim(methodVerb)} ${c.gray("→")} ${c.dim(agentsString)}\n\n`;
     }
 
@@ -356,7 +366,6 @@ export async function run(spec) {
     stepLine();
 
     // Confirmation
-    // Active Step
     activeStep("Proceed with installation?");
     const shouldProceed = await confirm({ message: " ", initialValue: true });
 
@@ -366,29 +375,51 @@ export async function run(spec) {
         return;
     }
 
-    // Install
+    // Install skills to multiple agents
     stepLine();
-    fs.mkdirSync(targetScope, { recursive: true });
+    const { installSkillForAgents } = await import("../installer.js");
 
     // Create a map for skill paths
     const skillPathMap = Object.fromEntries(skillsInRepo.map(s => [s.value, s._path]));
 
+    const installResults = { success: [], failed: [] };
+
     for (const sn of selectedSkills) {
         const src = skillPathMap[sn] || path.join(skillsDir || tmp, sn);
-        const dest = path.join(targetScope, sn);
 
-        await installSkill(src, dest, installMethod, {
-            repo: `${org}/${repo}`,
-            skill: sn,
-            ref: ref || null
+        const is = spinner();
+        is.start(`Installing ${sn} to ${selectedAgents.length} agents`);
+
+        const result = await installSkillForAgents(src, sn, selectedAgents, {
+            method: installMethod,
+            scope: isGlobal ? "global" : "project",
+            metadata: {
+                repo: `${org}/${repo}`,
+                ref: ref || null
+            }
         });
+
+        installResults.success.push(...result.success);
+        installResults.failed.push(...result.failed);
+
+        if (result.failed.length === 0) {
+            is.stop(`Installed ${sn} (${result.success.length} agents)`);
+        } else {
+            is.stop(`${sn}: ${result.success.length} success, ${result.failed.length} failed`);
+        }
     }
 
+
+    // Derive base .agent directory from skillsDir
+    // If skillsDir is .../skills, then baseAgentDir is parent (.agent)
+    const baseAgentDir = skillsDir ? path.dirname(skillsDir) : path.join(tmp, ".agent");
+
     // Install workflows if they exist
-    const workflowsDir = path.join(tmp, ".agent", "workflows");
+    const workflowsDir = path.join(baseAgentDir, "workflows");
     const targetWorkflowsDir = path.join(WORKSPACE, "..", "workflows");
     let workflowsInstalled = 0;
 
+
     if (fs.existsSync(workflowsDir)) {
         stepLine();
         const ws = spinner();
@@ -411,7 +442,7 @@ export async function run(spec) {
     }
 
     // Install GEMINI.md if it exists
-    const geminiSrc = path.join(tmp, ".agent", "GEMINI.md");
+    const geminiSrc = path.join(baseAgentDir, "GEMINI.md");
     const geminiDest = path.join(WORKSPACE, "..", "GEMINI.md");
     let geminiInstalled = false;
 
@@ -423,7 +454,7 @@ export async function run(spec) {
     }
 
     // Install agents if they exist
-    const agentsDir = path.join(tmp, ".agent", "agents");
+    const agentsDir = path.join(baseAgentDir, "agents");
     const targetAgentsDir = path.join(WORKSPACE, "..", "agents");
     let agentsInstalled = 0;
 
@@ -449,7 +480,7 @@ export async function run(spec) {
     }
 
     // Install ARCHITECTURE.md if it exists
-    const archSrc = path.join(tmp, ".agent", "ARCHITECTURE.md");
+    const archSrc = path.join(baseAgentDir, "ARCHITECTURE.md");
     const archDest = path.join(WORKSPACE, "..", "ARCHITECTURE.md");
     let archInstalled = false;
 
@@ -460,7 +491,7 @@ export async function run(spec) {
     }
 
     // Install knowledge if it exists
-    const knowledgeDir = path.join(tmp, ".agent", "knowledge");
+    const knowledgeDir = path.join(baseAgentDir, "knowledge");
     const targetKnowledgeDir = path.join(WORKSPACE, "..", "knowledge");
     let knowledgeInstalled = false;
 
@@ -471,7 +502,7 @@ export async function run(spec) {
     }
 
     // Install rules if they exist
-    const rulesDir = path.join(tmp, ".agent", "rules");
+    const rulesDir = path.join(baseAgentDir, "rules");
     const targetRulesDir = path.join(WORKSPACE, "..", "rules");
     let rulesInstalled = 0;
 

package/bin/lib/installer.js

@@ -1,7 +1,11 @@
 import fs from "fs";
 import path from "path";
+import { homedir } from "os";
 import { GLOBAL_DIR } from "./config.js";
 import { merkleHash } from "./helpers.js";
+import { AGENTS } from "./agents.js";
+
+const home = homedir();
 
 /**
  * Install a skill to the destination using the specified method.
@@ -47,3 +51,114 @@ export async function installSkill(src, dest, method, metadata) {
         method: method
     }, null, 2));
 }
+
+/**
+ * Install a skill to multiple agents
+ * @param {string} src - Source directory containing the skill
+ * @param {string} skillName - Name of the skill
+ * @param {Array<{name: string, displayName: string, skillsDir: string, globalSkillsDir: string}>} agents - Agents to install to
+ * @param {Object} options - Installation options
+ * @param {string} options.method - 'symlink' or 'copy'
+ * @param {string} options.scope - 'project' or 'global'
+ * @param {Object} options.metadata - Metadata for tracking
+ * @returns {Promise<{success: Array, failed: Array}>}
+ */
+export async function installSkillForAgents(src, skillName, agents, options = {}) {
+    const { method = "symlink", scope = "project", metadata = {} } = options;
+    const results = { success: [], failed: [] };
+
+    // For symlink mode: first copy to canonical location
+    let canonicalPath = null;
+
+    if (method === "symlink") {
+        // Canonical: .agents/skills/<skill-name> or ~/.agents/skills/<skill-name>
+        const baseDir = scope === "global" ? home : process.cwd();
+        canonicalPath = path.join(baseDir, ".agents", "skills", skillName);
+
+        // Ensure fresh copy in canonical
+        if (fs.existsSync(canonicalPath)) {
+            fs.rmSync(canonicalPath, { recursive: true, force: true });
+        }
+        fs.mkdirSync(path.dirname(canonicalPath), { recursive: true });
+
+        try {
+            await fs.promises.cp(src, canonicalPath, { recursive: true });
+
+            // Write metadata to canonical location
+            const hash = merkleHash(canonicalPath);
+            const metaFile = path.join(canonicalPath, ".skill-source.json");
+            fs.writeFileSync(metaFile, JSON.stringify({
+                ...metadata,
+                skillName,
+                checksum: hash,
+                installedAt: new Date().toISOString(),
+                method: method,
+                scope: scope,
+                agents: agents.map(a => a.name)
+            }, null, 2));
+        } catch (err) {
+            // If canonical copy fails, abort
+            return {
+                success: [],
+                failed: agents.map(a => ({ agent: a.displayName, error: `Canonical copy failed: ${err.message}` }))
+            };
+        }
+    }
+
+    // Install to each agent
+    for (const agent of agents) {
+        const agentConfig = AGENTS[agent.name];
+        if (!agentConfig) {
+            results.failed.push({ agent: agent.displayName, error: "Unknown agent" });
+            continue;
+        }
+
+        // Determine destination path
+        const baseDir = scope === "global" ? agentConfig.globalSkillsDir : path.join(process.cwd(), agentConfig.skillsDir);
+        const destPath = path.join(baseDir, skillName);
+
+        try {
+            // Ensure parent directory exists
+            fs.mkdirSync(path.dirname(destPath), { recursive: true });
+
+            // Remove existing if any
+            if (fs.existsSync(destPath)) {
+                fs.rmSync(destPath, { recursive: true, force: true });
+            }
+
+            if (method === "symlink" && canonicalPath) {
+                // Create symlink to canonical location
+                try {
+                    fs.symlinkSync(canonicalPath, destPath, "junction");
+                    results.success.push({ agent: agent.displayName, path: destPath, mode: "symlink" });
+                } catch (symlinkErr) {
+                    // Fallback to copy if symlink fails (Windows permissions)
+                    await fs.promises.cp(canonicalPath, destPath, { recursive: true });
+                    results.success.push({ agent: agent.displayName, path: destPath, mode: "copy (symlink failed)" });
+                }
+            } else {
+                // Direct copy
+                await fs.promises.cp(src, destPath, { recursive: true });
+
+                // Write metadata
+                const hash = merkleHash(destPath);
+                const metaFile = path.join(destPath, ".skill-source.json");
+                fs.writeFileSync(metaFile, JSON.stringify({
+                    ...metadata,
+                    skillName,
+                    checksum: hash,
+                    installedAt: new Date().toISOString(),
+                    method: "copy",
+                    scope: scope
+                }, null, 2));
+
+                results.success.push({ agent: agent.displayName, path: destPath, mode: "copy" });
+            }
+        } catch (err) {
+            results.failed.push({ agent: agent.displayName, error: err.message });
+        }
+    }
+
+    return results;
+}
+

package/bin/lib/ui.js

@@ -6,9 +6,22 @@ import kleur from "kleur";
 import boxen from "boxen";
 import { intro, outro, multiselect, select, confirm, isCancel, cancel, text } from "@clack/prompts";
 import ora from "ora";
+import gradient from "gradient-string";
 
 export { intro, outro, multiselect, select, confirm, isCancel, cancel, text };
 
+// --- ASCII Art Banner ---
+const PIKAKIT_BANNER = `
+ ____  _ _         _  ___ _   
+|  _ \\(_) | ____ _| |/ (_) |_ 
+| |_) | | |/ / _\` | ' /| | __|
+|  __/| |   < (_| | . \\| | |_ 
+|_|   |_|_|\\_\\__,_|_|\\_\\_|\\__|
+`;
+
+// Custom gradient: white → gray (like vercel style)
+const pikaGradient = gradient(['#ffffff', '#bbbbbb', '#888888', '#555555']);
+
 /**
  * Create a spinner
  */
@@ -148,15 +161,169 @@ export function box(message, options = {}) {
 }
 
 /**
- * Show branded intro with version
+ * Show branded intro with version (matches agent CLI style)
  * @param {string} version - Package version
  * @param {string} [status] - Optional status text
  */
 export function brandedIntro(version, status = "") {
-    const statusLine = status ? `\n\n   ${c.dim(status)}` : "";
-    console.log(box(
-        `📦 Add Skill Kit v${version}${statusLine}`,
-        { borderColor: status.includes("✓") ? "green" : "blue" }
-    ));
+    // Split banner and filter to get content lines only
+    const bannerLines = PIKAKIT_BANNER.split('\n').filter(line => line.trim() !== '');
+
+    // Print all lines except the last with gradient
+    for (let i = 0; i < bannerLines.length - 1; i++) {
+        console.log(pikaGradient(bannerLines[i]));
+    }
+
+    // Last line: gradient ASCII + dim version (aligned at bottom)
+    const lastLine = bannerLines[bannerLines.length - 1];
+    console.log(pikaGradient(lastLine) + `  ${c.dim(`v${version}`)}`);
+    console.log(''); // Empty line after banner
+
+    if (status) {
+        console.log(`${c.dim(status)}`);
+    }
+}
+
+// --- Vercel-Style Installation Prompts ---
+
+/**
+ * Prompt user to select which agents to install to
+ * @param {Array<{name: string, displayName: string, skillsDir: string}>} detectedAgents
+ * @returns {Promise<Array<{name: string, displayName: string, skillsDir: string}> | null>}
+ */
+export async function selectAgentsPrompt(detectedAgents) {
+    if (detectedAgents.length === 0) {
+        return null;
+    }
+
+    // First ask: All detected or select specific?
+    const installChoice = await select({
+        message: "Install to",
+        options: [
+            {
+                value: "all",
+                label: `All detected agents (Recommended)`,
+                hint: `Install to all ${detectedAgents.length} detected agents`
+            },
+            {
+                value: "select",
+                label: "Select specific agents",
+                hint: "Choose which agents to install to"
+            }
+        ]
+    });
+
+    if (isCancel(installChoice)) {
+        cancel("Installation cancelled");
+        return null;
+    }
+
+    if (installChoice === "all") {
+        return detectedAgents;
+    }
+
+    // Let user select specific agents
+    const selectedAgents = await multiselect({
+        message: "Select agents to install skills to",
+        options: detectedAgents.map(agent => ({
+            value: agent.name,
+            label: agent.displayName,
+            hint: agent.skillsDir
+        })),
+        required: true
+    });
+
+    if (isCancel(selectedAgents)) {
+        cancel("Installation cancelled");
+        return null;
+    }
+
+    return detectedAgents.filter(a => selectedAgents.includes(a.name));
+}
+
+/**
+ * Prompt user to select installation scope (Project or Global)
+ * @returns {Promise<"project" | "global" | null>}
+ */
+export async function selectScopePrompt() {
+    const scope = await select({
+        message: "Installation scope",
+        options: [
+            {
+                value: "project",
+                label: "Project",
+                hint: "Install in current directory (committed with your project)"
+            },
+            {
+                value: "global",
+                label: "Global",
+                hint: "Install globally (available across all projects)"
+            }
+        ]
+    });
+
+    if (isCancel(scope)) {
+        cancel("Installation cancelled");
+        return null;
+    }
+
+    return scope;
+}
+
+/**
+ * Prompt user to select installation method (Symlink or Copy)
+ * @returns {Promise<"symlink" | "copy" | null>}
+ */
+export async function selectMethodPrompt() {
+    const method = await select({
+        message: "Installation method",
+        options: [
+            {
+                value: "symlink",
+                label: "Symlink (Recommended)",
+                hint: "Single source of truth, easy updates"
+            },
+            {
+                value: "copy",
+                label: "Copy to all agents",
+                hint: "Independent copies for each agent"
+            }
+        ]
+    });
+
+    if (isCancel(method)) {
+        cancel("Installation cancelled");
+        return null;
+    }
+
+    return method;
+}
+
+/**
+ * Prompt user to select skills to install (multiselect with descriptions)
+ * @param {Array<{name: string, description: string, path: string}>} skills
+ * @returns {Promise<Array<{name: string, description: string, path: string}> | null>}
+ */
+export async function selectSkillsPrompt(skills) {
+    if (skills.length === 0) {
+        return null;
+    }
+
+    const selectedNames = await multiselect({
+        message: "Select skills to install",
+        options: skills.map(skill => ({
+            value: skill.name,
+            label: skill.name,
+            hint: skill.description ? skill.description.substring(0, 60) + "..." : ""
+        })),
+        required: true
+    });
+
+    if (isCancel(selectedNames)) {
+        cancel("Installation cancelled");
+        return null;
+    }
+
+    return skills.filter(s => selectedNames.includes(s.name));
 }
 

package/package.json

@@ -1,64 +1,67 @@
-{
-  "name": "add-skill-kit",
-  "version": "3.2.0",
-  "description": "Enterprise-grade Agent Skill Manager with Antigravity Skills support, Progressive Disclosure detection, and semantic routing validation",
-  "license": "MIT",
-  "author": "agentskillkit <agentskillkit@gmail.com>",
-  "homepage": "https://github.com/agentskillkit/add-skill-kit",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/agentskillkit/add-skill-kit.git"
-  },
-  "bugs": {
-    "url": "https://github.com/agentskillkit/add-skill-kit/issues"
-  },
-  "type": "module",
-  "bin": {
-    "kit": "./bin/cli.js"
-  },
-  "files": [
-    "bin/",
-    "specs/",
-    "README.md",
-    "LICENSE"
-  ],
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "keywords": [
-    "agent",
-    "ai",
-    "skills",
-    "cli",
-    "tooling",
-    "registry",
-    "security",
-    "devops",
-    "automation",
-    "antigravity"
-  ],
-  "scripts": {
-    "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"
-  },
-  "dependencies": {
-    "@clack/prompts": "^0.9.1",
-    "boxen": "^8.0.1",
-    "chalk": "^5.4.1",
-    "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"
-  }
-}
+{
+  "name": "add-skill-kit",
+  "version": "3.2.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>",
+  "homepage": "https://github.com/agentskillkit/add-skill-kit",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/agentskillkit/add-skill-kit.git"
+  },
+  "bugs": {
+    "url": "https://github.com/agentskillkit/add-skill-kit/issues"
+  },
+  "type": "module",
+  "bin": {
+    "kit": "./bin/cli.js"
+  },
+  "files": [
+    "bin/",
+    "specs/",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "agent",
+    "ai",
+    "skills",
+    "cli",
+    "tooling",
+    "registry",
+    "security",
+    "devops",
+    "automation",
+    "antigravity"
+  ],
+  "scripts": {
+    "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",
+    "agent": "agent"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.9.1",
+    "boxen": "^8.0.1",
+    "chalk": "^5.4.1",
+    "gradient-string": "^2.0.2",
+    "kleur": "^4.1.5",
+    "ora": "^8.1.0",
+    "prompts": "^2.4.2"
+  },
+  "devDependencies": {
+    "agentskillskit-cli": "^3.2.0",
+    "eslint": "^8.57.0",
+    "prettier": "^3.2.5",
+    "vitest": "^1.6.0"
+  }
+}