@skillsmanager/cli 0.0.2 → 0.0.4

package/dist/commands/registry.js

@@ -1,55 +1,45 @@
 import chalk from "chalk";
 import ora from "ora";
 import fs from "fs";
-import { readConfig, writeConfig, mergeRegistries, CONFIG_PATH } from "../config.js";
-import { ensureAuth } from "../auth.js";
-import { GDriveBackend } from "../backends/gdrive.js";
+import { readConfig, writeConfig, mergeRegistries, CONFIG_PATH, CACHE_DIR } from "../config.js";
+import { GithubBackend } from "../backends/github.js";
 import { LocalBackend } from "../backends/local.js";
+import { resolveBackend } from "../backends/resolve.js";
 export async function registryCreateCommand(options) {
     const backend = options.backend ?? "local";
-    if (backend === "local") {
-        const local = new LocalBackend();
-        const spinner = ora("Creating local registry...").start();
-        try {
-            const registry = await local.createRegistry();
-            spinner.succeed(`Local registry created`);
-            let config = { registries: [], collections: [], skills: {}, discoveredAt: new Date().toISOString() };
-            if (fs.existsSync(CONFIG_PATH)) {
-                try {
-                    config = readConfig();
-                }
-                catch { /* use default */ }
-            }
-            config.registries.push(registry);
-            writeConfig(config);
+    const supported = ["local", "gdrive", "github"];
+    if (!supported.includes(backend)) {
+        console.log(chalk.red(`Unknown backend "${backend}". Supported: ${supported.join(", ")}`));
+        return;
+    }
+    if (backend === "github" && !options.repo) {
+        console.log(chalk.red("GitHub backend requires --repo <owner/repo>"));
+        console.log(chalk.dim("  Example: skillsmanager registry create --backend github --repo owner/my-repo"));
+        return;
+    }
+    const label = backend === "local" ? "locally" : `in ${backend}`;
+    const spinner = ora(`Creating registry ${label}...`).start();
+    try {
+        let registry;
+        if (backend === "github") {
+            registry = await new GithubBackend().createRegistry(undefined, options.repo);
         }
-        catch (err) {
-            spinner.fail(`Failed: ${err.message}`);
+        else {
+            registry = await (await resolveBackend(backend)).createRegistry();
         }
-    }
-    else if (backend === "gdrive") {
-        const auth = await ensureAuth();
-        const gdrive = new GDriveBackend(auth);
-        const spinner = ora("Creating registry in Google Drive...").start();
-        try {
-            const registry = await gdrive.createRegistry();
-            spinner.succeed(`Registry created in Google Drive`);
-            let config = { registries: [], collections: [], skills: {}, discoveredAt: new Date().toISOString() };
-            if (fs.existsSync(CONFIG_PATH)) {
-                try {
-                    config = readConfig();
-                }
-                catch { /* use default */ }
+        spinner.succeed(`Registry created ${label}`);
+        let config = { registries: [], collections: [], skills: {}, discoveredAt: new Date().toISOString() };
+        if (fs.existsSync(CONFIG_PATH)) {
+            try {
+                config = readConfig();
             }
-            config.registries.push(registry);
-            writeConfig(config);
-        }
-        catch (err) {
-            spinner.fail(`Failed: ${err.message}`);
+            catch { /* use default */ }
         }
+        config.registries.push(registry);
+        writeConfig(config);
     }
-    else {
-        console.log(chalk.red(`Unknown backend "${backend}". Supported: local, gdrive`));
+    catch (err) {
+        spinner.fail(`Failed: ${err.message}`);
     }
 }
 export async function registryListCommand() {
@@ -69,9 +59,7 @@ export async function registryListCommand() {
     for (const reg of config.registries) {
         console.log(`\n${chalk.bold(reg.name)} ${chalk.dim(`(${reg.backend})`)}`);
         try {
-            const backend = reg.backend === "gdrive"
-                ? new GDriveBackend(await ensureAuth())
-                : new LocalBackend();
+            const backend = await resolveBackend(reg.backend);
             const data = await backend.readRegistry(reg);
             if (data.collections.length === 0) {
                 console.log(chalk.dim("  No collections"));
@@ -92,9 +80,7 @@ export async function registryDiscoverCommand(options) {
     const backendName = options.backend ?? "local";
     const spinner = ora(`Discovering registries in ${backendName}...`).start();
     try {
-        const backend = backendName === "gdrive"
-            ? new GDriveBackend(await ensureAuth())
-            : new LocalBackend();
+        const backend = await resolveBackend(backendName);
         const fresh = await backend.discoverRegistries();
         let config = { registries: [], collections: [], skills: {}, discoveredAt: new Date().toISOString() };
         if (fs.existsSync(CONFIG_PATH)) {
@@ -135,9 +121,7 @@ export async function registryAddCollectionCommand(collectionName, options) {
     }
     // Use first registry
     const reg = config.registries[0];
-    const backend = reg.backend === "gdrive"
-        ? new GDriveBackend(await ensureAuth())
-        : new LocalBackend();
+    const backend = await resolveBackend(reg.backend);
     const data = await backend.readRegistry(reg);
     const existing = data.collections.find((c) => c.name === collectionName);
     if (existing) {
@@ -152,10 +136,83 @@ export async function registryAddCollectionCommand(collectionName, options) {
     await backend.writeRegistry(reg, data);
     console.log(chalk.green(`Added "${collectionName}" to registry "${reg.name}".`));
 }
+export async function registryRemoveCollectionCommand(collectionName, options) {
+    let config;
+    try {
+        config = readConfig();
+    }
+    catch {
+        console.log(chalk.red("No config found."));
+        return;
+    }
+    if (config.registries.length === 0) {
+        console.log(chalk.red("No registries configured."));
+        return;
+    }
+    const reg = config.registries[0];
+    const backend = await resolveBackend(reg.backend);
+    const data = await backend.readRegistry(reg);
+    const ref = data.collections.find((c) => c.name === collectionName);
+    if (!ref) {
+        console.log(chalk.yellow(`Collection "${collectionName}" not found in registry.`));
+        return;
+    }
+    // If --delete, delete the actual collection and skills from the backend
+    if (options.delete) {
+        const collectionInConfig = config.collections.find((c) => c.name === collectionName);
+        if (collectionInConfig) {
+            const collBackend = await resolveBackend(collectionInConfig.backend);
+            const spinner = ora(`Deleting collection "${collectionName}" from ${collectionInConfig.backend}...`).start();
+            try {
+                await collBackend.deleteCollection(collectionInConfig);
+                spinner.succeed(`Deleted collection "${collectionName}" from ${collectionInConfig.backend}`);
+            }
+            catch (err) {
+                spinner.fail(`Failed to delete: ${err.message}`);
+                return;
+            }
+        }
+        // Clean up local cache
+        if (collectionInConfig) {
+            const cachePath = path.join(CACHE_DIR, collectionInConfig.id);
+            if (fs.existsSync(cachePath)) {
+                fs.rmSync(cachePath, { recursive: true, force: true });
+            }
+        }
+    }
+    // Remove ref from registry
+    data.collections = data.collections.filter((c) => c.name !== collectionName);
+    await backend.writeRegistry(reg, data);
+    // Remove from local config — capture ID before removal for skills cleanup
+    const removedColId = config.collections.find((c) => c.name === collectionName)?.id;
+    config.collections = config.collections.filter((c) => c.name !== collectionName);
+    // Remove skills index entries for this collection
+    if (removedColId) {
+        for (const [skillName, locations] of Object.entries(config.skills)) {
+            config.skills[skillName] = locations.filter((l) => l.collectionId !== removedColId);
+            if (config.skills[skillName].length === 0)
+                delete config.skills[skillName];
+        }
+    }
+    writeConfig(config);
+    if (options.delete) {
+        console.log(chalk.green(`Removed and deleted "${collectionName}" from registry "${reg.name}".`));
+    }
+    else {
+        console.log(chalk.green(`Removed "${collectionName}" from registry "${reg.name}".`));
+        console.log(chalk.dim(`  Collection data was kept. Use --delete to permanently remove it.`));
+    }
+}
 export async function registryPushCommand(options) {
     const targetBackend = options.backend ?? "gdrive";
-    if (targetBackend !== "gdrive") {
-        console.log(chalk.red(`Push to "${targetBackend}" not yet supported. Use: --backend gdrive`));
+    const supportedPush = ["gdrive", "github"];
+    if (!supportedPush.includes(targetBackend)) {
+        console.log(chalk.red(`Push to "${targetBackend}" not yet supported. Use: --backend gdrive or --backend github`));
+        return;
+    }
+    if (targetBackend === "github" && !options.repo) {
+        console.log(chalk.red("GitHub backend requires --repo <owner/repo>"));
+        console.log(chalk.dim("  Example: skillsmanager registry push --backend github --repo owner/my-repo"));
         return;
     }
     let config;
@@ -166,7 +223,6 @@ export async function registryPushCommand(options) {
         console.log(chalk.red("No config found."));
         return;
     }
-    // Find local registry
     const localReg = config.registries.find((r) => r.backend === "local");
     if (!localReg) {
         console.log(chalk.yellow("No local registry to push."));
@@ -179,39 +235,42 @@ export async function registryPushCommand(options) {
         console.log(chalk.yellow("No local collections to push."));
         return;
     }
-    const auth = await ensureAuth();
-    const gdrive = new GDriveBackend(auth);
-    // ── Phase 1: Upload all collections (no state changes yet) ─────────────
-    // If any collection fails, we abort and nothing is committed.
-    const spinner = ora("Pushing collections to Google Drive...").start();
-    // Discover or create gdrive registry (this is safe — an empty registry is harmless)
-    let gdriveReg = config.registries.find((r) => r.backend === "gdrive");
-    if (!gdriveReg) {
-        spinner.text = "Creating registry in Google Drive...";
-        gdriveReg = await gdrive.createRegistry();
-    }
-    // Accumulate results — only commit if ALL succeed
+    const remote = await resolveBackend(targetBackend);
+    const spinner = ora(`Pushing collections to ${targetBackend}...`).start();
+    // Find or create target registry
+    let targetReg = config.registries.find((r) => r.backend === targetBackend);
+    if (!targetReg) {
+        spinner.text = `Creating registry in ${targetBackend}...`;
+        targetReg = await remote.createRegistry();
+    }
+    // Phase 1: Upload all collections — abort on any failure
     const pushed = [];
     try {
         for (const ref of localCollectionRefs) {
             spinner.text = `Uploading collection "${ref.name}"...`;
             const collInfo = await local.resolveCollectionRef(ref);
-            if (!collInfo) {
+            if (!collInfo)
                 throw new Error(`Collection "${ref.name}" not found locally`);
+            let remoteCol;
+            if (targetBackend === "gdrive") {
+                const gdrive = remote;
+                const folderName = `SKILLS_${ref.name.toUpperCase()}`;
+                remoteCol = await gdrive.createCollection(folderName);
+            }
+            else {
+                const github = remote;
+                remoteCol = await github.createCollection(ref.name, options.repo);
             }
-            const PREFIX = "SKILLS_";
-            const folderName = `${PREFIX}${ref.name.toUpperCase()}`;
-            const driveCol = await gdrive.createCollection(folderName);
             const colData = await local.readCollection({ ...collInfo, id: "temp" });
             for (const skill of colData.skills) {
                 const localSkillPath = path.join(collInfo.folderId, skill.name);
                 if (fs.existsSync(localSkillPath)) {
                     spinner.text = `Uploading ${ref.name}/${skill.name}...`;
-                    await gdrive.uploadSkill(driveCol, localSkillPath, skill.name);
+                    await remote.uploadSkill(remoteCol, localSkillPath, skill.name);
                 }
             }
-            await gdrive.writeCollection(driveCol, colData);
-            pushed.push({ ref, driveCol, folderName });
+            await remote.writeCollection(remoteCol, colData);
+            pushed.push({ ref, remoteCol });
         }
     }
     catch (err) {
@@ -219,39 +278,36 @@ export async function registryPushCommand(options) {
         console.log(chalk.dim("  No changes were committed. Local state is unchanged."));
         return;
     }
-    // ── Phase 2: Commit — update registry and config atomically ────────────
+    // Phase 2: Commit — update registry and config atomically
     spinner.text = "Updating registry...";
     try {
-        // Read current gdrive registry (may already have entries)
-        let gdriveData;
+        let targetData;
         try {
-            gdriveData = await gdrive.readRegistry(gdriveReg);
+            targetData = await remote.readRegistry(targetReg);
         }
         catch {
-            gdriveData = { name: gdriveReg.name, owner: await gdrive.getOwner(), source: "gdrive", collections: [] };
+            targetData = { name: targetReg.name, owner: await remote.getOwner(), source: targetBackend, collections: [] };
         }
-        // Add all pushed collections at once
-        for (const { ref, folderName } of pushed) {
-            gdriveData.collections.push({ name: ref.name, backend: "gdrive", ref: folderName });
+        for (const { ref, remoteCol } of pushed) {
+            targetData.collections.push({ name: ref.name, backend: targetBackend, ref: remoteCol.folderId });
         }
-        await gdrive.writeRegistry(gdriveReg, gdriveData);
-        // Update local config
-        if (!config.registries.find((r) => r.id === gdriveReg.id)) {
-            config.registries.push(gdriveReg);
+        await remote.writeRegistry(targetReg, targetData);
+        if (!config.registries.find((r) => r.id === targetReg.id)) {
+            config.registries.push(targetReg);
         }
-        for (const { driveCol } of pushed) {
-            config.collections.push(driveCol);
+        for (const { remoteCol } of pushed) {
+            config.collections.push(remoteCol);
         }
         writeConfig(config);
-        spinner.succeed(`Pushed ${pushed.length} collection(s) to Google Drive`);
+        spinner.succeed(`Pushed ${pushed.length} collection(s) to ${targetBackend}`);
         for (const { ref } of pushed) {
-            console.log(chalk.dim(`  ${ref.name} → gdrive`));
+            console.log(chalk.dim(`  ${ref.name} → ${targetBackend}`));
         }
     }
     catch (err) {
         spinner.fail(`Failed to update registry: ${err.message}`);
         console.log(chalk.dim("  Collections were uploaded but the registry was not updated."));
-        console.log(chalk.dim("  Run 'skillsmanager registry push' again to retry."));
+        console.log(chalk.dim(`  Run 'skillsmanager registry push --backend ${targetBackend}' again to retry.`));
     }
 }
 // Need path import for push command

package/dist/commands/setup/github.d.ts

@@ -0,0 +1 @@
+export declare function setupGithubCommand(): Promise<void>;

package/dist/commands/setup/github.js

@@ -0,0 +1,85 @@
+import { spawnSync } from "child_process";
+import chalk from "chalk";
+// ── helpers ───────────────────────────────────────────────────────────────────
+function ghInstalled() {
+    return spawnSync("gh", ["--version"], { stdio: "pipe" }).status === 0;
+}
+function ghAuthed() {
+    return spawnSync("gh", ["auth", "status"], { stdio: "pipe" }).status === 0;
+}
+async function installGh() {
+    if (process.platform !== "darwin") {
+        console.log(chalk.yellow("  Auto-install is only supported on macOS."));
+        console.log(chalk.dim("  Install manually: https://cli.github.com/manual/installation"));
+        return false;
+    }
+    const brewCheck = spawnSync("brew", ["--version"], { stdio: "pipe" });
+    if (brewCheck.status !== 0) {
+        console.log(chalk.yellow("  Homebrew not found. Install it from https://brew.sh then re-run."));
+        return false;
+    }
+    console.log(chalk.dim("  Installing gh via Homebrew..."));
+    const r = spawnSync("brew", ["install", "gh"], { stdio: "inherit" });
+    if (r.status !== 0) {
+        console.log(chalk.red("  Install failed. Try manually: brew install gh"));
+        return false;
+    }
+    return ghInstalled();
+}
+// ── main command ──────────────────────────────────────────────────────────────
+export async function setupGithubCommand() {
+    console.log(chalk.bold("\nSkills Manager — GitHub Setup\n"));
+    // Step 1: Check gh CLI
+    console.log(chalk.bold("Step 1 — gh CLI\n"));
+    if (!ghInstalled()) {
+        console.log(chalk.yellow("  gh CLI is not installed."));
+        const readline = await import("readline");
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        const ans = await new Promise((resolve) => {
+            rl.question(`  Install it now via Homebrew? ${chalk.dim("[y/n]")} `, (a) => {
+                rl.close();
+                resolve(a.trim().toLowerCase());
+            });
+        });
+        if (!ans.startsWith("y")) {
+            console.log(chalk.dim("  Install manually: https://cli.github.com/manual/installation"));
+            console.log(chalk.dim("  Then re-run: skillsmanager setup github"));
+            return;
+        }
+        const ok = await installGh();
+        if (!ok)
+            return;
+        console.log(chalk.green("  ✓ gh installed"));
+    }
+    else {
+        console.log(chalk.green("  ✓ gh is installed"));
+    }
+    // Step 2: Check auth
+    console.log(chalk.bold("\nStep 2 — GitHub Authentication\n"));
+    if (ghAuthed()) {
+        const r = spawnSync("gh", ["api", "user", "--jq", ".login"], {
+            encoding: "utf-8", stdio: "pipe",
+        });
+        const login = r.stdout?.trim() ?? "";
+        console.log(chalk.green(`  ✓ Already authenticated${login ? ` as ${chalk.white(login)}` : ""}`));
+    }
+    else {
+        console.log(chalk.dim("  Running gh auth login..."));
+        const r = spawnSync("gh", ["auth", "login"], { stdio: "inherit" });
+        if (r.status !== 0) {
+            console.log(chalk.red("  Authentication failed. Please try manually: gh auth login"));
+            return;
+        }
+        const r2 = spawnSync("gh", ["api", "user", "--jq", ".login"], {
+            encoding: "utf-8", stdio: "pipe",
+        });
+        const login = r2.stdout?.trim() ?? "";
+        if (!login) {
+            console.log(chalk.red("  Could not verify authentication."));
+            return;
+        }
+        console.log(chalk.green(`  ✓ Authenticated as ${chalk.white(login)}`));
+    }
+    console.log(chalk.green("\n  ✓ GitHub setup complete!"));
+    console.log(`\nRun ${chalk.bold("skillsmanager collection create --backend github")} to create a collection.\n`);
+}

package/dist/commands/update.js

@@ -3,7 +3,8 @@ import ora from "ora";
 import fs from "fs";
 import YAML from "yaml";
 import path from "path";
-import { ensureReady } from "../ready.js";
+import { readConfig } from "../config.js";
+import { resolveBackend } from "../backends/resolve.js";
 import { getCachePath, ensureCachePath } from "../cache.js";
 export async function updateCommand(skillPath, options) {
     const absPath = path.resolve(skillPath);
@@ -28,7 +29,7 @@ export async function updateCommand(skillPath, options) {
         console.log(chalk.red("SKILL.md frontmatter is missing 'name' field."));
         return;
     }
-    const { config, backend } = await ensureReady();
+    const config = readConfig();
     // Find the collection — --collection override, or look up by installedAt path, or by name
     let collection = config.collections.find((c) => c.name === options.collection) ?? null;
     if (!collection) {
@@ -59,7 +60,8 @@ export async function updateCommand(skillPath, options) {
             return;
         }
     }
-    const spinner = ora(`Updating ${chalk.bold(skillName)} in gdrive:${collection.name}...`).start();
+    const backend = await resolveBackend(collection.backend);
+    const spinner = ora(`Updating ${chalk.bold(skillName)} in ${collection.backend}:${collection.name}...`).start();
     try {
         await backend.uploadSkill(collection, absPath, skillName);
         // Sync updated files into the local cache so symlinks reflect the change immediately
@@ -75,7 +77,7 @@ export async function updateCommand(skillPath, options) {
                 await backend.writeCollection(collection, col);
             }
         }
-        spinner.succeed(`${chalk.bold(skillName)} updated in gdrive:${collection.name}`);
+        spinner.succeed(`${chalk.bold(skillName)} updated in ${collection.backend}:${collection.name}`);
     }
     catch (err) {
         spinner.fail(`Failed: ${err.message}`);

package/dist/index.js

@@ -13,9 +13,10 @@ import { addCommand } from "./commands/add.js";
 import { updateCommand } from "./commands/update.js";
 import { refreshCommand } from "./commands/refresh.js";
 import { setupGoogleCommand } from "./commands/setup/google.js";
+import { setupGithubCommand } from "./commands/setup/github.js";
 import { collectionCreateCommand } from "./commands/collection.js";
 import { installCommand, uninstallCommand } from "./commands/install.js";
-import { registryCreateCommand, registryListCommand, registryDiscoverCommand, registryAddCollectionCommand, registryPushCommand, } from "./commands/registry.js";
+import { registryCreateCommand, registryListCommand, registryDiscoverCommand, registryAddCollectionCommand, registryRemoveCollectionCommand, registryPushCommand, } from "./commands/registry.js";
 const supportedAgents = Object.keys(AGENT_PATHS).join(", ");
 // Read the bundled SKILL.md as the CLI help — single source of truth
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -39,6 +40,10 @@ setup
     .command("google")
     .description("One-time Google Drive setup (human-facing, not for agents)")
     .action(setupGoogleCommand);
+setup
+    .command("github")
+    .description("One-time GitHub setup — checks gh CLI and runs gh auth login")
+    .action(setupGithubCommand);
 // ── Core commands ────────────────────────────────────────────────────────────
 program
     .command("init")
@@ -79,15 +84,18 @@ const collection = program
 collection
     .command("create [name]")
     .description("Create a new collection (defaults to SKILLS_MY_SKILLS)")
-    .action(collectionCreateCommand);
+    .option("--backend <backend>", "gdrive (default) or github", "gdrive")
+    .option("--repo <owner/repo>", "GitHub repo to use (required for --backend github)")
+    .action((name, options) => collectionCreateCommand(name, options));
 // ── Registry ─────────────────────────────────────────────────────────────────
 const registry = program
     .command("registry")
     .description("Manage registries (root indexes pointing to collections)");
 registry
     .command("create")
-    .description("Create a new registry (default: local, --backend gdrive for Drive)")
-    .option("--backend <backend>", "local (default) or gdrive", "local")
+    .description("Create a new registry (default: local, --backend gdrive or --backend github)")
+    .option("--backend <backend>", "local (default), gdrive, or github", "local")
+    .option("--repo <owner/repo>", "GitHub repo to use (required for --backend github)")
     .action((options) => registryCreateCommand(options));
 registry
     .command("list")
@@ -96,7 +104,7 @@ registry
 registry
     .command("discover")
     .description("Search a backend for registries owned by the current user")
-    .option("--backend <backend>", "local (default) or gdrive", "local")
+    .option("--backend <backend>", "local (default), gdrive, or github", "local")
     .action((options) => registryDiscoverCommand(options));
 registry
     .command("add-collection <name>")
@@ -104,10 +112,16 @@ registry
     .option("--backend <backend>", "Backend where the collection lives")
     .option("--ref <ref>", "Backend-specific reference (folder name, repo path)")
     .action((name, options) => registryAddCollectionCommand(name, options));
+registry
+    .command("remove-collection <name>")
+    .description("Remove a collection reference from the registry")
+    .option("--delete", "Also delete the collection and all its skills from the backend")
+    .action((name, options) => registryRemoveCollectionCommand(name, options));
 registry
     .command("push")
     .description("Push local registry and collections to a remote backend")
-    .option("--backend <backend>", "Target backend (default: gdrive)", "gdrive")
+    .option("--backend <backend>", "Target backend: gdrive (default) or github", "gdrive")
+    .option("--repo <owner/repo>", "GitHub repo to push into (required when --backend github)")
     .action((options) => registryPushCommand(options));
 // ── Install/Uninstall ────────────────────────────────────────────────────────
 program

package/dist/types.js

@@ -10,4 +10,6 @@ export const AGENT_PATHS = {
     copilot: path.join(os.homedir(), ".copilot", "skills"),
     gemini: path.join(os.homedir(), ".gemini", "skills"),
     roo: path.join(os.homedir(), ".roo", "skills"),
+    openclaw: path.join(os.homedir(), ".openclaw", "skills"),
+    antigravity: path.join(os.homedir(), ".gemini", "antigravity", "skills"),
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skillsmanager/cli",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Discover, fetch, and manage agent skills from local or remote storage",
   "type": "module",
   "bin": {

package/skills/skillsmanager/SKILL.md

@@ -31,7 +31,7 @@ skillsmanager fetch <name> --agent <agent> --scope project
 skillsmanager list
 ```
 
-Supported agents: `claude`, `codex`, `agents`, `cursor`, `windsurf`, `copilot`, `gemini`, `roo`
+Supported agents: `claude`, `codex`, `agents`, `cursor`, `windsurf`, `copilot`, `gemini`, `roo`, `openclaw`, `antigravity`
 
 ### Share a skill
 
@@ -78,6 +78,12 @@ skillsmanager registry add-collection <name>
 # Push local registry and collections to Google Drive
 skillsmanager registry push --backend gdrive
 
+# Remove a collection reference from the registry (keeps data)
+skillsmanager registry remove-collection <name>
+
+# Remove and permanently delete the collection and all its skills
+skillsmanager registry remove-collection <name> --delete
+
 # Create a new collection
 skillsmanager collection create [name]
 
@@ -125,6 +131,10 @@ skillsmanager uninstall
 **User wants to see what registries and collections exist:**
 1. `skillsmanager registry list`
 
+**User wants to remove a collection:**
+1. `skillsmanager registry remove-collection <name>` (removes reference only, data is kept)
+2. `skillsmanager registry remove-collection <name> --delete` (permanently deletes collection and skills)
+
 ## Architecture
 
 - **Registry** (`SKILLS_REGISTRY.yaml`): root index pointing to all collections across backends