add-skill-kit 1.5.6 → 2.3.2

package/README.md

@@ -109,7 +109,7 @@ add-skill-kit doctor
 ### 🎯 Intelligent Installation
 
 - **Interactive selection** - Chọn skills cần cài
-- **Auto-Install CLI** - Tự động cài `@agent-skill-kit/cli`
+- **Auto-Install CLI** - Tự động cài `agentskillskit-cli`
 - **Symlink mode** - Tiết kiệm disk space
 - **Copy mode** - Offline support
 - **Merkle verification** - Đảm bảo integrity

package/bin/lib/commands/help.js

@@ -2,41 +2,158 @@
  * @fileoverview Help command
  */
 
-import { c } from "../ui.js";
+import { step, stepLine, S, c, select, isCancel, cancel } from "../ui.js";
 import { VERSION } from "../config.js";
 
 /**
- * Show help
+ * Show interactive help menu
  */
 export async function run() {
-  console.log(`
-  ${c.bold("add-skill-kit")} ${c.dim("v" + VERSION)}
-
-  ${c.bold("Usage")}
-    $ add-skill-kit <command> [options]
-
-  ${c.bold("Commands")}
-    <org/repo>          Install all skills from repository
-    <org/repo#skill>    Install specific skill
-    list                List installed skills
-    uninstall <skill>   Remove a skill
-    update <skill>      Update a skill
-    verify              Verify checksums
-    doctor              Check health
-    lock                Generate skill-lock.json
-    init                Initialize skills directory
-    validate [skill]    Validate against Antigravity spec
-    analyze <skill>     Analyze skill structure
-    cache [info|clear]  Manage cache
-    info <skill>        Show skill info
-
-  ${c.bold("Options")}
-    --global, -g        Use global scope
-    --force, -f         Force operation
-    --strict            Fail on violations
-    --fix               Auto-fix issues
-    --dry-run           Preview only
-    --verbose, -v       Detailed output
-    --json              JSON output
-`);
+  let running = true;
+
+  while (running) {
+    stepLine();
+    step(c.bold("kit") + c.dim(` v${VERSION}`));
+    step(c.dim("What would you like to know?"));
+    stepLine();
+
+    const choice = await select({
+      message: "Select a topic",
+      options: [
+        { value: "commands", label: "Commands", hint: "View all available commands" },
+        { value: "options", label: "Options", hint: "View all flags and options" },
+        { value: "quickstart", label: "Quick Start", hint: "Get started quickly" },
+        { value: "exit", label: "Exit", hint: "Close help" }
+      ]
+    });
+
+    if (isCancel(choice) || choice === "exit") {
+      stepLine();
+      step("Goodbye!");
+      stepLine();
+      return;
+    }
+
+    stepLine();
+
+    switch (choice) {
+      case "commands":
+        await showCommands();
+        break;
+      case "options":
+        showOptions();
+        break;
+      case "quickstart":
+        showQuickStart();
+        break;
+    }
+
+    stepLine();
+
+    // Ask what to do next
+    const next = await select({
+      message: "What's next?",
+      options: [
+        { value: "back", label: "Back to menu", hint: "See other topics" },
+        { value: "exit", label: "Exit", hint: "Close help" }
+      ]
+    });
+
+    if (isCancel(next) || next === "exit") {
+      stepLine();
+      step("Goodbye!");
+      stepLine();
+      running = false;
+    }
+  }
+}
+
+async function showCommands() {
+  step(c.bold("Available Commands"), S.diamondFilled, "cyan");
+  stepLine();
+
+  step(c.cyan("<org/repo>") + c.dim("          Install all skills from repository"));
+  step(c.dim("Example: kit agentskillkit/agent-skills"));
+  stepLine();
+
+  step(c.cyan("<org/repo#skill>") + c.dim("    Install specific skill"));
+  step(c.dim("Example: kit agentskillkit/agent-skills#react-patterns"));
+  stepLine();
+
+  step(c.cyan("list") + c.dim("                List installed skills"));
+  step(c.cyan("uninstall") + c.dim("          Remove skill(s) (interactive)"));
+  step(c.cyan("uninstall all") + c.dim("       Remove everything (automatic)"));
+  step(c.cyan("update <skill>") + c.dim("      Update a skill"));
+  step(c.cyan("verify") + c.dim("              Verify checksums"));
+  step(c.cyan("doctor") + c.dim("              Check health"));
+  step(c.cyan("lock") + c.dim("                Generate skill-lock.json"));
+  step(c.cyan("init") + c.dim("                Initialize skills directory"));
+  step(c.cyan("validate [skill]") + c.dim("    Validate against Antigravity spec"));
+  step(c.cyan("analyze <skill>") + c.dim("     Analyze skill structure"));
+  step(c.cyan("cache [info|clear]") + c.dim("  Manage cache"));
+  step(c.cyan("info <skill>") + c.dim("        Show skill info"));
+
+  stepLine();
+
+  // Interactive command selection
+  const executeCmd = await select({
+    message: "Execute a command?",
+    options: [
+      { value: "list", label: "list", hint: "List installed skills" },
+      { value: "doctor", label: "doctor", hint: "Check health" },
+      { value: "verify", label: "verify", hint: "Verify checksums" },
+      { value: "uninstall", label: "uninstall", hint: "Interactive removal" },
+      { value: "lock", label: "lock", hint: "Generate lockfile" },
+      { value: "init", label: "init", hint: "Initialize directory" },
+      { value: "none", label: "← Back", hint: "Return to topics" }
+    ]
+  });
+
+  if (!isCancel(executeCmd) && executeCmd !== "none") {
+    stepLine();
+    step(c.cyan(`Running: kit ${executeCmd}`));
+    stepLine();
+
+    // Dynamic import and execute command
+    try {
+      const commandModule = await import(`./${executeCmd}.js`);
+      await commandModule.run();
+    } catch (err) {
+      step(c.red(`Command not yet implemented: ${executeCmd}`));
+    }
+  }
+}
+
+function showOptions() {
+  step(c.bold("Available Options"), S.diamondFilled, "cyan");
+  stepLine();
+
+  step(c.cyan("--global, -g") + c.dim("        Use global scope (~/.gemini)"));
+  step(c.cyan("--force, -f") + c.dim("         Force operation without confirmation"));
+  step(c.cyan("--strict") + c.dim("            Fail on any violations"));
+  step(c.cyan("--fix") + c.dim("               Auto-fix issues (e.g., checksums)"));
+  step(c.cyan("--dry-run") + c.dim("           Preview changes without executing"));
+  step(c.cyan("--verbose, -v") + c.dim("       Show detailed output"));
+  step(c.cyan("--json") + c.dim("              Output in JSON format"));
+}
+
+function showQuickStart() {
+  step(c.bold("Quick Start Guide"), S.diamondFilled, "cyan");
+  stepLine();
+
+  step(c.bold("1. Install skills"));
+  step("   " + c.cyan("kit agentskillkit/agent-skills"));
+  stepLine();
+
+  step(c.bold("2. Choose scope"));
+  step("   " + c.dim("→ Current Project (local .agent/)"));
+  step("   " + c.dim("→ Global System (available everywhere)"));
+  stepLine();
+
+  step(c.bold("3. Check installation"));
+  step("   " + c.cyan("kit doctor"));
+  stepLine();
+
+  step(c.bold("4. Use in your AI"));
+  step("   " + c.dim("Skills are now available in .agent/skills/"));
 }

package/bin/lib/commands/install.js

@@ -597,7 +597,27 @@ export async function run(spec) {
         try {
             await execAsync(`npm install -D ${cliPackage}`, { timeout: 120000 });
             cliSpinner.stop("Agent CLI installed locally");
-            step(c.dim("Run: npx agent"));
+
+            // Add npm scripts to package.json
+            try {
+                const pkgPath = path.join(process.cwd(), "package.json");
+                if (fs.existsSync(pkgPath)) {
+                    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+                    pkg.scripts = pkg.scripts || {};
+
+                    // Add agent script if not exists
+                    if (!pkg.scripts.agent) {
+                        pkg.scripts.agent = "agent";
+                    }
+
+                    fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+                    step(c.green("✓ Added npm script: 'agent'"));
+                }
+            } catch (scriptErr) {
+                step(c.yellow("⚠ Could not add npm scripts automatically"));
+            }
+
+            step(c.dim("Run: npm run agent"));
         } catch (e) {
             cliSpinner.stop(c.yellow("Local CLI installation skipped"));
             step(c.dim(`Run manually: npm i -D ${cliPackage}`));

package/bin/lib/commands/uninstall.js

@@ -4,29 +4,287 @@
 
 import fs from "fs";
 import path from "path";
+import os from "os";
 import prompts from "prompts";
 import { resolveScope, createBackup } from "../helpers.js";
-import { step, stepLine, success, fatal, c } from "../ui.js";
+import { step, stepLine, success, fatal, c, select, isCancel, cancel } from "../ui.js";
 import { DRY } from "../config.js";
 
 /**
- * Remove a skill
- * @param {string} skillName
+ * Remove a skill or all skills
+ * @param {string} skillName - Skill name or "all" to remove everything
  */
 export async function run(skillName) {
-    if (!skillName) fatal("Missing skill name");
-
     const scope = resolveScope();
+
+    // Check if skills directory exists
+    if (!fs.existsSync(scope)) {
+        fatal("No skills directory found");
+    }
+
+    // Get list of installed skills
+    const skills = fs.readdirSync(scope)
+        .filter(item => {
+            const itemPath = path.join(scope, item);
+            return fs.statSync(itemPath).isDirectory() && fs.existsSync(path.join(itemPath, "SKILL.md"));
+        });
+
+    if (skills.length === 0) {
+        step("No skills installed");
+        return;
+    }
+
+    // CASE 1: kit uninstall all → Auto-remove everything
+    if (skillName === "all") {
+        await removeAllAutomatic(scope, skills);
+        return;
+    }
+
+    // CASE 2: kit uninstall (no params) → Interactive menu
+    if (!skillName) {
+        await interactiveRemove(scope, skills);
+        return;
+    }
+
+    // CASE 3: kit uninstall <skill> → Remove specific skill
+    await removeSingleSkill(scope, skillName);
+}
+
+/**
+ * Interactive menu for skill removal
+ */
+async function interactiveRemove(scope, skills) {
+    stepLine();
+    step(`Found ${skills.length} installed skill(s)`);
+    stepLine();
+
+    const choice = await select({
+        message: "What would you like to do?",
+        options: [
+            { value: "select", label: "Select specific skill", hint: "Choose one skill to remove" },
+            { value: "all", label: "Remove all skills", hint: "Remove everything (with confirmations)" },
+            { value: "cancel", label: "Cancel", hint: "Go back" }
+        ]
+    });
+
+    if (isCancel(choice) || choice === "cancel") {
+        cancel("Cancelled");
+        return;
+    }
+
+    if (choice === "all") {
+        await removeAllWithConfirmation(scope, skills);
+        return;
+    }
+
+    // Select specific skill
+    const skillChoice = await select({
+        message: "Select skill to remove",
+        options: skills.map(s => ({ value: s, label: s }))
+    });
+
+    if (isCancel(skillChoice)) {
+        cancel("Cancelled");
+        return;
+    }
+
+    await removeSingleSkill(scope, skillChoice);
+}
+
+/**
+ * Remove all skills automatically (kit uninstall all)
+ */
+async function removeAllAutomatic(scope, skills) {
+    stepLine();
+    step(c.yellow("AUTOMATIC COMPLETE REMOVAL"));
+    step(c.dim(`Removing ${skills.length} skill(s) + .agent folder + npm dependencies`));
+    stepLine();
+
+    if (DRY) {
+        step(`Would remove ${skills.length} skill(s) from: ${scope}`);
+        step("Would remove .agent folder");
+        step("Would remove npm dependencies");
+        return;
+    }
+
+    // 1. Remove all skills with backup
+    for (const skill of skills) {
+        const targetDir = path.join(scope, skill);
+        createBackup(targetDir, skill);
+        fs.rmSync(targetDir, { recursive: true, force: true });
+        step(`✓ Removed: ${skill}`);
+    }
+
+    // 2. Remove .agent folder
+    const agentDir = path.dirname(scope);
+    if (fs.existsSync(agentDir) && path.basename(agentDir) === ".agent") {
+        fs.rmSync(agentDir, { recursive: true, force: true });
+        step("✓ Removed: .agent folder");
+    }
+
+    // 3. Remove npm dependencies
+    const cwd = process.cwd();
+    const nodeModules = path.join(cwd, "node_modules");
+    const packageJson = path.join(cwd, "package.json");
+    const packageLock = path.join(cwd, "package-lock.json");
+
+    if (fs.existsSync(nodeModules)) {
+        fs.rmSync(nodeModules, { recursive: true, force: true });
+        step("✓ Removed: node_modules/");
+    }
+    if (fs.existsSync(packageJson)) {
+        fs.rmSync(packageJson);
+        step("✓ Removed: package.json");
+    }
+    if (fs.existsSync(packageLock)) {
+        fs.rmSync(packageLock);
+        step("✓ Removed: package-lock.json");
+    }
+
+    // 4. For global installs, ask about ~/.gemini/ cleanup
+    if (scope.includes(".gemini")) {
+        stepLine();
+        step(c.yellow("Global Configuration Cleanup"));
+        step(c.dim("The entire ~/.gemini/ folder can be removed:"));
+        step(c.dim("  • GEMINI.md (global rules)"));
+        step(c.dim("  • All Antigravity configs"));
+        step(c.dim("  • Cache and backups"));
+        stepLine();
+
+        const geminiRoot = path.join(require("os").homedir(), ".gemini");
+        if (fs.existsSync(geminiRoot)) {
+            // Just remove it automatically in "all" mode
+            fs.rmSync(geminiRoot, { recursive: true, force: true });
+            step("✓ Removed: ~/.gemini/ (complete cleanup)");
+        }
+    }
+
+    stepLine();
+    success("Complete cleanup done - everything removed");
+}
+
+/**
+ * Remove all skills with step-by-step confirmations (kit uninstall → all)
+ */
+async function removeAllWithConfirmation(scope, skills) {
+    stepLine();
+    step(`Found ${skills.length} skill(s) to remove:`);
+    skills.forEach(s => step(`  • ${s}`, "", "dim"));
+    stepLine();
+
+    const confirmSkills = await prompts({
+        type: "confirm",
+        name: "value",
+        message: `Remove all ${skills.length} skill(s)?`,
+        initial: false
+    });
+
+    if (!confirmSkills.value) {
+        step("Cancelled");
+        return;
+    }
+
+    // Remove each skill with backup
+    for (const skill of skills) {
+        const targetDir = path.join(scope, skill);
+        createBackup(targetDir, skill);
+        fs.rmSync(targetDir, { recursive: true, force: true });
+        step(`Removed: ${skill}`);
+    }
+
+    success(`All ${skills.length} skill(s) removed successfully`);
+    stepLine();
+
+    // Ask about .agent folder
+    const agentDir = path.dirname(scope);
+    if (fs.existsSync(agentDir) && path.basename(agentDir) === ".agent") {
+        stepLine();
+        step(c.yellow("Complete Cleanup"));
+        step(c.dim("The following will also be removed:"));
+        step(c.dim("  • Agents"));
+        step(c.dim("  • Workflows"));
+        step(c.dim("  • Knowledge & Lessons"));
+        step(c.dim("  • All configuration files"));
+        stepLine();
+
+        const confirmAgent = await prompts({
+            type: "confirm",
+            name: "value",
+            message: "Remove entire .agent folder?",
+            initial: false
+        });
+
+        if (confirmAgent.value) {
+            fs.rmSync(agentDir, { recursive: true, force: true });
+            success("Complete cleanup done - .agent folder removed");
+
+            // Ask about npm dependencies
+            stepLine();
+            step(c.yellow("npm Dependencies Cleanup"));
+            step(c.dim("The following npm files will also be removed:"));
+            step(c.dim("  • node_modules/"));
+            step(c.dim("  • package.json"));
+            step(c.dim("  • package-lock.json"));
+            stepLine();
+
+            const confirmNpm = await prompts({
+                type: "confirm",
+                name: "value",
+                message: "Remove npm dependencies?",
+                initial: false
+            });
+
+            if (confirmNpm.value) {
+                const cwd = process.cwd();
+                const nodeModules = path.join(cwd, "node_modules");
+                const packageJson = path.join(cwd, "package.json");
+                const packageLock = path.join(cwd, "package-lock.json");
+
+                if (fs.existsSync(nodeModules)) {
+                    fs.rmSync(nodeModules, { recursive: true, force: true });
+                    step("Removed: node_modules/");
+                }
+                if (fs.existsSync(packageJson)) {
+                    fs.rmSync(packageJson);
+                    step("Removed: package.json");
+                }
+                if (fs.existsSync(packageLock)) {
+                    fs.rmSync(packageLock);
+                    step("Removed: package-lock.json");
+                }
+                success("npm dependencies removed");
+            } else {
+                step(c.dim("Kept npm dependencies"));
+            }
+        } else {
+            step(c.dim("Kept .agent folder (agents, workflows, etc.)"));
+        }
+    }
+
+    stepLine();
+}
+
+/**
+ * Remove a single skill
+ */
+async function removeSingleSkill(scope, skillName) {
     const targetDir = path.join(scope, skillName);
 
-    if (!fs.existsSync(targetDir)) fatal(`Skill not found: ${skillName}`);
+    if (!fs.existsSync(targetDir)) {
+        fatal(`Skill not found: ${skillName}`);
+    }
+
+    if (!fs.existsSync(path.join(targetDir, "SKILL.md"))) {
+        fatal(`Not a valid skill: ${skillName}`);
+    }
 
     stepLine();
+    step(`Removing skill: ${c.cyan(skillName)}`);
 
     const confirm = await prompts({
         type: "confirm",
         name: "value",
-        message: `Remove skill "${skillName}"?`,
+        message: "Confirm removal?",
         initial: false
     });
 
@@ -40,9 +298,10 @@ export async function run(skillName) {
         return;
     }
 
-    createBackup(targetDir, skillName);
-    fs.rmSync(targetDir, { recursive: true, force: true });
+    const backup = createBackup(targetDir, skillName);
+    if (backup) step(`Backup created: ${backup}`);
 
+    fs.rmSync(targetDir, { recursive: true, force: true });
     success(`Removed: ${skillName}`);
     stepLine();
 }

package/bin/lib/config.js

@@ -56,6 +56,9 @@ export const FORCE = flags.has("--force") || flags.has("-f");
 /** @type {boolean} Dry run mode */
 export const DRY = flags.has("--dry-run");
 
+/** @type {boolean} Auto-fix mode */
+export const FIX = flags.has("--fix");
+
 /** @type {boolean} Strict mode */
 export const STRICT = flags.has("--strict");
 

package/bin/lib/helpers.js

@@ -119,11 +119,31 @@ export function resolveScope() {
  */
 export function createBackup(skillDir, skillName) {
     if (DRY) return null;
-    const ts = new Date().toISOString().replace(/[:.]/g, "-");
-    const bp = path.join(BACKUP_DIR, `${skillName}_${ts}`);
-    fs.mkdirSync(BACKUP_DIR, { recursive: true });
-    fs.cpSync(skillDir, bp, { recursive: true });
-    return bp;
+
+    try {
+        const ts = new Date().toISOString().replace(/[:.]/g, "-");
+        const bp = path.join(BACKUP_DIR, `${skillName}_${ts}`);
+        fs.mkdirSync(BACKUP_DIR, { recursive: true });
+
+        // Resolve symlink to real path (Windows compatibility)
+        const realPath = fs.realpathSync(skillDir);
+
+        fs.cpSync(realPath, bp, { recursive: true });
+        return bp;
+    } catch (err) {
+        // Fallback: try direct copy if realpath fails
+        try {
+            const ts = new Date().toISOString().replace(/[:.]/g, "-");
+            const bp = path.join(BACKUP_DIR, `${skillName}_${ts}`);
+            fs.cpSync(skillDir, bp, { recursive: true });
+            return bp;
+        } catch (fallbackErr) {
+            if (process.env.DEBUG) {
+                console.error(`Backup failed for ${skillName}:`, fallbackErr.message);
+            }
+            return null;
+        }
+    }
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "add-skill-kit",
-  "version": "1.5.6",
+  "version": "2.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>",
@@ -14,7 +14,7 @@
   },
   "type": "module",
   "bin": {
-    "add-skill-kit": "./bin/cli.js"
+    "kit": "./bin/cli.js"
   },
   "files": [
     "bin/",