@agentskillkit/agent-skills 3.2.2 → 3.2.5

package/packages/kit/lib/commands/list.js

@@ -0,0 +1,43 @@
+/**
+ * @fileoverview List command
+ */
+
+import { getInstalledSkills } from "../skills.js";
+import { resolveScope, formatBytes } from "../helpers.js";
+import { step, stepLine, S, c, outputJSON } from "../ui.js";
+import { VERBOSE, JSON_OUTPUT } from "../config.js";
+
+/**
+ * List installed skills
+ */
+export async function run() {
+    stepLine();
+    step(c.bold("Installed Skills"), S.diamondFilled, "cyan");
+    console.log(`${c.gray(S.branch)}  ${c.dim("Location: " + resolveScope())}`);
+    stepLine();
+
+    const skills = getInstalledSkills();
+
+    if (skills.length === 0) {
+        step(c.dim("No skills installed."), S.diamond);
+        stepLine();
+        return;
+    }
+
+    if (JSON_OUTPUT) {
+        outputJSON({ skills }, true);
+        return;
+    }
+
+    for (const s of skills) {
+        const icon = s.hasSkillMd ? c.green(S.check) : c.yellow(S.diamond);
+        console.log(`${c.gray(S.branch)}  ${icon}  ${c.bold(s.name)} ${c.dim("v" + s.version)} ${c.dim("(" + formatBytes(s.size) + ")")}`);
+        if (s.description && VERBOSE) {
+            console.log(`${c.gray(S.branch)}      ${c.dim(s.description.substring(0, 60))}`);
+        }
+    }
+
+    stepLine();
+    console.log(`${c.gray(S.branch)}  ${c.dim("Total: " + skills.length + " skill(s)")}`);
+    stepLine();
+}

package/packages/kit/lib/commands/lock.js

@@ -0,0 +1,57 @@
+/**
+ * @fileoverview Lock command - Generate skill-lock.json
+ */
+
+import fs from "fs";
+import path from "path";
+import { step, stepLine, success, fatal, outputJSON } from "../ui.js";
+import { WORKSPACE, DRY, cwd, VERSION } from "../config.js";
+
+/**
+ * Generate skill-lock.json
+ */
+export async function run() {
+    if (!fs.existsSync(WORKSPACE)) {
+        fatal("No .agent/skills directory");
+        return;
+    }
+
+    stepLine();
+
+    const skills = {};
+    for (const name of fs.readdirSync(WORKSPACE)) {
+        const dir = path.join(WORKSPACE, name);
+        if (!fs.statSync(dir).isDirectory()) continue;
+
+        const mf = path.join(dir, ".skill-source.json");
+        if (!fs.existsSync(mf)) continue;
+
+        const m = JSON.parse(fs.readFileSync(mf, "utf-8"));
+        skills[name] = {
+            repo: m.repo,
+            skill: m.skill,
+            ref: m.ref,
+            checksum: `sha256:${m.checksum}`,
+            publisher: m.publisher || null
+        };
+    }
+
+    const lock = {
+        lockVersion: 1,
+        generatedAt: new Date().toISOString(),
+        generator: `@dataguruin/add-skill@${VERSION}`,
+        skills
+    };
+
+    if (DRY) {
+        step("Would generate skill-lock.json");
+        outputJSON(lock, true);
+        return;
+    }
+
+    fs.mkdirSync(path.join(cwd, ".agent"), { recursive: true });
+    fs.writeFileSync(path.join(cwd, ".agent", "skill-lock.json"), JSON.stringify(lock, null, 2));
+
+    success("skill-lock.json generated");
+    stepLine();
+}

package/packages/kit/lib/commands/uninstall.js

@@ -0,0 +1,307 @@
+/**
+ * @fileoverview Uninstall command
+ */
+
+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, select, isCancel, cancel } from "../ui.js";
+import { DRY } from "../config.js";
+
+/**
+ * Remove a skill or all skills
+ * @param {string} skillName - Skill name or "all" to remove everything
+ */
+export async function run(skillName) {
+    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(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: "Confirm removal?",
+        initial: false
+    });
+
+    if (!confirm.value) {
+        step("Cancelled");
+        return;
+    }
+
+    if (DRY) {
+        step(`Would remove: ${targetDir}`);
+        return;
+    }
+
+    const backup = createBackup(targetDir, skillName);
+    if (backup) step(`Backup created: ${backup}`);
+
+    fs.rmSync(targetDir, { recursive: true, force: true });
+    success(`Removed: ${skillName}`);
+    stepLine();
+}

package/packages/kit/lib/commands/update.js

@@ -0,0 +1,55 @@
+/**
+ * @fileoverview Update command
+ */
+
+import fs from "fs";
+import path from "path";
+
+import { resolveScope, createBackup } from "../helpers.js";
+import { step, stepLine, S, c, fatal, spinner } from "../ui.js";
+import { DRY } from "../config.js";
+
+/**
+ * Update a skill
+ * @param {string} skillName
+ */
+export async function run(skillName) {
+    if (!skillName) fatal("Missing skill name");
+
+    const scope = resolveScope();
+    const targetDir = path.join(scope, skillName);
+
+    if (!fs.existsSync(targetDir)) fatal(`Skill not found: ${skillName}`);
+
+    const metaFile = path.join(targetDir, ".skill-source.json");
+    if (!fs.existsSync(metaFile)) fatal("Skill metadata not found");
+
+    const meta = JSON.parse(fs.readFileSync(metaFile, "utf-8"));
+    if (!meta.repo || meta.repo === "local") fatal("Cannot update local skill");
+
+    stepLine();
+
+    const s = spinner();
+    s.start(`Updating ${skillName}`);
+
+    try {
+        if (!DRY) {
+            createBackup(targetDir, skillName);
+            fs.rmSync(targetDir, { recursive: true, force: true });
+        }
+
+        const spec = `${meta.repo}#${meta.skill}${meta.ref ? "@" + meta.ref : ""}`;
+
+        if (DRY) {
+            s.stop("Dry run analysis complete");
+            step(`Would update: ${skillName}`);
+        } else {
+            s.stop("Preparing update...");
+            // Dynamically import install command
+            const { run: install } = await import("./install.js");
+            await install(spec);
+        }
+    } catch (err) {
+        s.fail(`Failed: ${err.message}`);
+    }
+}

package/packages/kit/lib/commands/validate.js

@@ -0,0 +1,69 @@
+/**
+ * @fileoverview Validate command - Antigravity spec validation
+ */
+
+import fs from "fs";
+import path from "path";
+import { getInstalledSkills, parseSkillMdFrontmatter } from "../skills.js";
+import { resolveScope } from "../helpers.js";
+import { step, stepLine, S, c, fatal } from "../ui.js";
+import { VERBOSE, STRICT } from "../config.js";
+
+/**
+ * Validate skills against Antigravity spec
+ * @param {string} [skillName] - Optional specific skill
+ */
+export async function run(skillName) {
+    const scope = resolveScope();
+    let skillsToValidate = [];
+
+    if (skillName) {
+        const sd = path.join(scope, skillName);
+        if (!fs.existsSync(sd)) fatal(`Skill not found: ${skillName}`);
+        skillsToValidate = [{ name: skillName, path: sd }];
+    } else {
+        skillsToValidate = getInstalledSkills();
+    }
+
+    if (skillsToValidate.length === 0) {
+        stepLine();
+        step("No skills to validate", S.diamond);
+        return;
+    }
+
+    stepLine();
+    step(c.bold("Antigravity Validation"), S.diamondFilled, "cyan");
+    stepLine();
+
+    let totalErrors = 0, totalWarnings = 0;
+
+    for (const skill of skillsToValidate) {
+        const errors = [], warnings = [];
+        const smp = path.join(skill.path, "SKILL.md");
+
+        if (!fs.existsSync(smp)) {
+            errors.push("Missing SKILL.md");
+        } else {
+            const m = parseSkillMdFrontmatter(smp);
+            if (!m.description) errors.push("Missing description");
+            else if (m.description.length < 50) warnings.push("Description too short");
+        }
+
+        const status = errors.length > 0 ? c.red("FAIL") : warnings.length > 0 ? c.yellow("WARN") : c.green("PASS");
+        console.log(`${c.gray(S.branch)}  ${status}  ${c.bold(skill.name)}`);
+
+        if (VERBOSE || errors.length || warnings.length) {
+            errors.forEach(e => console.log(`${c.gray(S.branch)}      ${c.red("ERROR: " + e)}`));
+            warnings.forEach(w => console.log(`${c.gray(S.branch)}      ${c.yellow("WARN: " + w)}`));
+        }
+
+        totalErrors += errors.length;
+        totalWarnings += warnings.length;
+    }
+
+    stepLine();
+    console.log(`${c.gray(S.branch)}  Total: ${skillsToValidate.length}, Errors: ${totalErrors}, Warnings: ${totalWarnings}`);
+    stepLine();
+
+    if (STRICT && totalErrors > 0) process.exit(1);
+}

package/packages/kit/lib/commands/verify.js

@@ -0,0 +1,56 @@
+/**
+ * @fileoverview Verify command - Checksum verification
+ */
+
+import fs from "fs";
+import path from "path";
+import { resolveScope, merkleHash } from "../helpers.js";
+import { step, stepLine, S, c } from "../ui.js";
+import { STRICT } from "../config.js";
+
+/**
+ * Verify skill checksums
+ */
+export async function run() {
+    const scope = resolveScope();
+
+    if (!fs.existsSync(scope)) {
+        stepLine();
+        step("No skills directory found", S.diamond);
+        return;
+    }
+
+    stepLine();
+    step(c.bold("Verifying Skills"), S.diamondFilled, "cyan");
+    stepLine();
+
+    let issues = 0;
+
+    for (const name of fs.readdirSync(scope)) {
+        const dir = path.join(scope, name);
+        if (!fs.statSync(dir).isDirectory()) continue;
+
+        const mf = path.join(dir, ".skill-source.json");
+        if (!fs.existsSync(mf)) {
+            step(`${name}: ${c.red("missing metadata")}`, S.cross, "red");
+            issues++;
+            continue;
+        }
+
+        const m = JSON.parse(fs.readFileSync(mf, "utf-8"));
+        const actual = merkleHash(dir);
+
+        if (actual !== m.checksum) {
+            step(`${name}: ${c.red("checksum mismatch")}`, S.cross, "red");
+            issues++;
+        } else {
+            step(`${name}: ${c.green("OK")}`, S.check, "green");
+        }
+    }
+
+    stepLine();
+    console.log(`${c.gray(S.branch)}  ${issues ? c.red(issues + " issue(s)") : c.green("All verified")}`);
+    stepLine();
+
+    if (issues && STRICT) process.exit(1);
+}

package/packages/kit/lib/config.js

@@ -0,0 +1,81 @@
+/**
+ * @fileoverview Configuration and argument parsing
+ */
+
+import path from "path";
+import os from "os";
+
+/** Current working directory */
+export const cwd = process.cwd();
+
+/** Local workspace skills directory (configurable via ADD_SKILL_WORKSPACE) */
+export const WORKSPACE = process.env.ADD_SKILL_WORKSPACE || path.join(cwd, ".agent", "skills");
+
+/** Global skills directory (configurable via ADD_SKILL_GLOBAL_DIR) */
+export const GLOBAL_DIR = process.env.ADD_SKILL_GLOBAL_DIR || path.join(os.homedir(), ".gemini", "antigravity", "skills");
+
+/** Cache root directory */
+export const CACHE_ROOT = process.env.ADD_SKILL_CACHE_DIR || path.join(os.homedir(), ".cache", "agentskillskit");
+
+/** Registry cache directory */
+export const REGISTRY_CACHE = path.join(CACHE_ROOT, "registries");
+
+/** Registries file path */
+export const REGISTRIES_FILE = path.join(CACHE_ROOT, "registries.json");
+
+/** Backup directory */
+export const BACKUP_DIR = path.join(CACHE_ROOT, "backups");
+
+// --- Argument Parsing ---
+
+const args = process.argv.slice(2);
+
+/** Command name (first non-flag argument) */
+export const command = args[0] || "help";
+
+/** All flags (starting with --) */
+export const flags = new Set(args.filter((a) => a.startsWith("--")));
+
+/** Command parameters (non-flag arguments after command) */
+export const params = args.filter((a) => !a.startsWith("--")).slice(1);
+
+// --- Flag Shortcuts ---
+
+/** @type {boolean} Use global scope */
+export const GLOBAL = flags.has("--global") || flags.has("-g");
+
+/** @type {boolean} Verbose output */
+export const VERBOSE = flags.has("--verbose") || flags.has("-v");
+
+/** @type {boolean} JSON output mode */
+export const JSON_OUTPUT = flags.has("--json");
+
+/** @type {boolean} Force operation */
+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");
+
+/** @type {boolean} Locked mode (install from lockfile) */
+export const LOCKED = flags.has("--locked");
+
+/** @type {boolean} Offline mode (skip network operations) */
+export const OFFLINE = flags.has("--offline");
+
+// --- Package Info ---
+
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+
+/** @type {string} Package version */
+export const VERSION = (() => {
+    try { return require("../../package.json").version; }
+    catch { return "1.2.0"; }
+})();
+