@skillsmanager/cli 0.0.2 → 0.0.5

package/dist/commands/add.js

@@ -3,9 +3,15 @@ import path from "path";
 import chalk from "chalk";
 import ora from "ora";
 import YAML from "yaml";
-import { ensureReady } from "../ready.js";
-import { trackSkill } from "../config.js";
+import { readConfig, trackSkill } from "../config.js";
+import { GithubBackend } from "../backends/github.js";
+import { resolveBackend } from "../backends/resolve.js";
 export async function addCommand(skillPath, options) {
+    // ── Remote-path mode: register a skill from a foreign repo without local files ─
+    if (options.remotePath) {
+        await addRemotePath(options);
+        return;
+    }
     const absPath = path.resolve(skillPath);
     if (!fs.existsSync(absPath) || !fs.statSync(absPath).isDirectory()) {
         console.log(chalk.red(`"${skillPath}" is not a valid directory.`));
@@ -29,8 +35,37 @@ export async function addCommand(skillPath, options) {
         console.log(chalk.red("SKILL.md frontmatter is missing 'name' field."));
         return;
     }
-    const { config, backend } = await ensureReady();
-    // Pick collection — first one by default, or by name
+    // ── Auto-detect if skill lives inside a GitHub-tracked repo ─────────────────
+    // If no --collection specified and a matching GitHub collection exists in config,
+    // use it automatically (no prompt — agent-friendly).
+    if (!options.collection) {
+        const ctx = GithubBackend.detectRepoContext(absPath);
+        if (ctx) {
+            let config;
+            try {
+                config = readConfig();
+            }
+            catch {
+                config = null;
+            }
+            const githubCollection = config?.collections.find((c) => c.backend === "github" && c.folderId.startsWith(`${ctx.repo}:`));
+            if (githubCollection) {
+                await addToGithub(absPath, ctx, skillName, description, githubCollection);
+                return;
+            }
+            // No matching GitHub collection — fall through to standard flow
+            // (user can run `skillsmanager collection create --backend github --repo <repo>` first)
+        }
+    }
+    // ── Standard flow ─────────────────────────────────────────────────────────────
+    let config;
+    try {
+        config = readConfig();
+    }
+    catch {
+        console.log(chalk.red("No config found. Run: skillsmanager collection create"));
+        return;
+    }
     let collection = config.collections[0];
     if (options.collection) {
         const found = config.collections.find((c) => c.name === options.collection);
@@ -41,20 +76,187 @@ export async function addCommand(skillPath, options) {
         }
         collection = found;
     }
+    if (!collection) {
+        console.log(chalk.red("No collections configured. Run: skillsmanager collection create"));
+        return;
+    }
+    // If the collection has metadata.repo (foreign skills repo), handle specially
+    if (collection.backend === "github") {
+        const github = new GithubBackend();
+        const col = await github.readCollection(collection);
+        const foreignRepo = col.metadata?.repo;
+        if (foreignRepo) {
+            const ctx = GithubBackend.detectRepoContext(absPath);
+            if (!ctx || ctx.repo !== foreignRepo) {
+                console.log(chalk.red(`This collection's skills source is "${foreignRepo}". ` +
+                    `The provided path does not belong to that repo.\n` +
+                    chalk.dim(`  To register a skill by path without a local clone, use:\n`) +
+                    chalk.dim(`  skillsmanager add --collection ${collection.name} --remote-path <rel/path> --name <name> --description <desc>`)));
+                return;
+            }
+            // Path is from the foreign repo (cloned locally) — register relative path only, no upload
+            const spinner = ora(`Adding ${chalk.bold(skillName)} to ${collection.name}...`).start();
+            try {
+                const existing = col.skills.findIndex((s) => s.name === skillName);
+                const entry = { name: skillName, path: ctx.relPath, description };
+                if (existing >= 0) {
+                    col.skills[existing] = entry;
+                }
+                else {
+                    col.skills.push(entry);
+                }
+                await github.writeCollection(collection, col);
+                trackSkill(skillName, collection.id, absPath);
+                spinner.succeed(`${chalk.bold(skillName)} registered in ${collection.name} at ${chalk.dim(ctx.relPath)}`);
+            }
+            catch (err) {
+                spinner.fail(`Failed: ${err.message}`);
+            }
+            return;
+        }
+    }
+    const backend = await resolveBackend(collection.backend);
+    await uploadToCollection(backend, collection, absPath, skillName, description);
+}
+// ── Remote-path mode: register a skill entry without local files ─────────────
+async function addRemotePath(options) {
+    const { remotePath, name: skillName, description = "", collection: collectionName } = options;
+    if (!remotePath) {
+        console.log(chalk.red("--remote-path requires a relative path (e.g. tools/my-skill/)"));
+        return;
+    }
+    if (!skillName) {
+        console.log(chalk.red("--remote-path requires --name <skill-name>"));
+        return;
+    }
+    let config;
+    try {
+        config = readConfig();
+    }
+    catch {
+        console.log(chalk.red("No config found. Run: skillsmanager collection create"));
+        return;
+    }
+    let collection = config.collections[0];
+    if (collectionName) {
+        const found = config.collections.find((c) => c.name === collectionName);
+        if (!found) {
+            console.log(chalk.red(`Collection "${collectionName}" not found.`));
+            console.log(chalk.dim(`  Available: ${config.collections.map((c) => c.name).join(", ")}`));
+            return;
+        }
+        collection = found;
+    }
+    if (!collection) {
+        console.log(chalk.red("No collections configured. Run: skillsmanager collection create"));
+        return;
+    }
+    if (collection.backend !== "github") {
+        console.log(chalk.red("--remote-path is only supported for GitHub collections."));
+        return;
+    }
+    const github = new GithubBackend();
+    const spinner = ora(`Registering ${chalk.bold(skillName)} in ${collection.name} at ${chalk.dim(remotePath)}...`).start();
+    try {
+        const col = await github.readCollection(collection);
+        const existing = col.skills.findIndex((s) => s.name === skillName);
+        const entry = { name: skillName, path: remotePath, description };
+        if (existing >= 0) {
+            col.skills[existing] = entry;
+        }
+        else {
+            col.skills.push(entry);
+        }
+        await github.writeCollection(collection, col);
+        spinner.succeed(`${chalk.bold(skillName)} registered in ${collection.name} at ${chalk.dim(remotePath)}`);
+    }
+    catch (err) {
+        spinner.fail(`Failed: ${err.message}`);
+    }
+}
+// ── GitHub path: register in-repo skill or copy external skill ────────────────
+async function addToGithub(absPath, ctx, skillName, description, collection) {
+    const github = new GithubBackend();
+    const spinner = ora(`Adding ${chalk.bold(skillName)} to github:${collection.folderId}...`).start();
+    try {
+        const col = await github.readCollection(collection);
+        const foreignRepo = col.metadata?.repo;
+        const hostRepo = collection.folderId.split(":")[0];
+        // If collection has metadata.repo pointing to a foreign repo, validate that
+        // the local skill belongs to that foreign repo (not the collection host repo).
+        if (foreignRepo && foreignRepo !== hostRepo) {
+            if (ctx.repo !== foreignRepo) {
+                spinner.fail(`This collection's skills source is "${foreignRepo}" but the provided path belongs to "${ctx.repo}".`);
+                return;
+            }
+            // Skill is in the foreign repo (cloned locally) — register path only, no upload
+            const entry = { name: skillName, path: ctx.relPath, description };
+            const existing = col.skills.findIndex((s) => s.name === skillName);
+            if (existing >= 0) {
+                col.skills[existing] = entry;
+            }
+            else {
+                col.skills.push(entry);
+            }
+            await github.writeCollection(collection, col);
+            trackSkill(skillName, collection.id, absPath);
+            spinner.succeed(`${chalk.bold(skillName)} registered in github:${collection.folderId} at ${chalk.dim(ctx.relPath)}`);
+            return;
+        }
+        // Standard case: skill is in (or being added to) the collection's host repo
+        // uploadSkill is a no-op for in-repo skills; copies if external
+        await github.uploadSkill(collection, absPath, skillName);
+        // Determine effective skill path in the repo
+        const skillEntry = absPath.startsWith(ctx.repoRoot)
+            ? ctx.relPath // in-repo: use relative path
+            : `.agentskills/${skillName}`; // external: was copied here by uploadSkill
+        const existing = col.skills.findIndex((s) => s.name === skillName);
+        if (existing >= 0) {
+            col.skills[existing] = { name: skillName, path: skillEntry, description };
+        }
+        else {
+            col.skills.push({ name: skillName, path: skillEntry, description });
+        }
+        await github.writeCollection(collection, col);
+        trackSkill(skillName, collection.id, absPath);
+        spinner.succeed(`${chalk.bold(skillName)} registered in github:${collection.folderId} at ${chalk.dim(skillEntry)}`);
+    }
+    catch (err) {
+        spinner.fail(`Failed: ${err.message}`);
+    }
+}
+// ── Shared: upload to any collection backend ──────────────────────────────────
+async function uploadToCollection(backend, collection, absPath, skillName, description) {
     const spinner = ora(`Adding ${chalk.bold(skillName)} to ${collection.name}...`).start();
     try {
         await backend.uploadSkill(collection, absPath, skillName);
+        // For GitHub collections, determine the effective in-repo path
+        let skillPath;
+        if (collection.backend === "github") {
+            // If the skill is already inside the repo workdir, use its relative path
+            const ctx = GithubBackend.detectRepoContext(absPath);
+            const repoFromCollection = collection.folderId.split(":")[0];
+            if (ctx && ctx.repo === repoFromCollection) {
+                skillPath = ctx.relPath; // e.g. "src/my-inrepo-skill"
+            }
+            else {
+                skillPath = `.agentskills/${skillName}`; // external → copied here by uploadSkill
+            }
+        }
+        else {
+            skillPath = `${skillName}/`;
+        }
         const col = await backend.readCollection(collection);
         const existing = col.skills.findIndex((s) => s.name === skillName);
         if (existing >= 0) {
-            col.skills[existing] = { name: skillName, path: `${skillName}/`, description };
+            col.skills[existing] = { name: skillName, path: skillPath, description };
         }
         else {
-            col.skills.push({ name: skillName, path: `${skillName}/`, description });
+            col.skills.push({ name: skillName, path: skillPath, description });
         }
         await backend.writeCollection(collection, col);
         trackSkill(skillName, collection.id, absPath);
-        spinner.succeed(`${chalk.bold(skillName)} added to gdrive:${collection.name}`);
+        spinner.succeed(`${chalk.bold(skillName)} added to ${collection.backend}:${collection.name}`);
     }
     catch (err) {
         spinner.fail(`Failed: ${err.message}`);

package/dist/commands/collection.d.ts

@@ -1 +1,5 @@
-export declare function collectionCreateCommand(name?: string): Promise<void>;
+export declare function collectionCreateCommand(name?: string, options?: {
+    backend?: string;
+    repo?: string;
+    skillsRepo?: string;
+}): Promise<void>;

package/dist/commands/collection.js

@@ -1,42 +1,116 @@
 import chalk from "chalk";
 import ora from "ora";
-import { writeConfig, CONFIG_PATH } from "../config.js";
+import fs from "fs";
+import { writeConfig, CONFIG_PATH, readConfig } from "../config.js";
 import { ensureAuth } from "../auth.js";
 import { GDriveBackend } from "../backends/gdrive.js";
-import fs from "fs";
-export async function collectionCreateCommand(name) {
-    const auth = await ensureAuth();
-    const backend = new GDriveBackend(auth);
-    const PREFIX = "SKILLS_";
-    let folderName;
-    if (!name) {
-        folderName = `${PREFIX}MY_SKILLS`;
+import { GithubBackend } from "../backends/github.js";
+import { LocalBackend } from "../backends/local.js";
+import { resolveBackend } from "../backends/resolve.js";
+export async function collectionCreateCommand(name, options = {}) {
+    const backendName = options.backend ?? "gdrive";
+    if (backendName === "github") {
+        await createGithubCollection(name, options.repo, options.skillsRepo);
+    }
+    else {
+        await createGdriveCollection(name);
+    }
+}
+async function createGithubCollection(name, repo, skillsRepo) {
+    if (!repo) {
+        console.log(chalk.red("GitHub backend requires --repo <owner/repo>"));
+        console.log(chalk.dim("  Example: skillsmanager collection create my-skills --backend github --repo owner/my-repo"));
+        return;
+    }
+    const collectionName = name ?? "default";
+    const backend = new GithubBackend();
+    if (skillsRepo && skillsRepo !== repo) {
+        console.log(chalk.bold(`\nCreating GitHub collection "${collectionName}" in ${repo} (skills source: ${skillsRepo})...\n`));
     }
     else {
-        folderName = name.startsWith(PREFIX) ? name : `${PREFIX}${name}`;
+        console.log(chalk.bold(`\nCreating GitHub collection "${collectionName}" in ${repo}...\n`));
+    }
+    try {
+        const collection = await backend.createCollection(collectionName, repo, skillsRepo);
+        console.log(chalk.green(`\n  ✓ Collection "${collectionName}" created in github:${collection.folderId}`));
+        const config = loadOrDefaultConfig();
+        upsertCollection(config, collection);
+        const registry = await ensureRegistry(config);
+        await registerCollectionInRegistry(registry, collection, config);
+        writeConfig(config);
+        console.log(`\nRun ${chalk.bold("skillsmanager add <path>")} to add skills to it.\n`);
+    }
+    catch (err) {
+        console.log(chalk.red(`Failed: ${err.message}`));
     }
+}
+async function createGdriveCollection(name) {
+    const auth = await ensureAuth();
+    const backend = new GDriveBackend(auth);
+    const PREFIX = "SKILLS_";
+    const folderName = !name
+        ? `${PREFIX}MY_SKILLS`
+        : name.startsWith(PREFIX) ? name : `${PREFIX}${name}`;
     const spinner = ora(`Creating collection "${folderName}" in Google Drive...`).start();
     try {
         const collection = await backend.createCollection(folderName);
         spinner.succeed(`Collection "${folderName}" created in Google Drive`);
-        let config = { registries: [], collections: [], skills: {}, discoveredAt: new Date().toISOString() };
-        if (fs.existsSync(CONFIG_PATH)) {
-            try {
-                config = JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8"));
-            }
-            catch { /* use default */ }
-        }
-        const already = config.collections.findIndex((c) => c.name === collection.name);
-        if (already >= 0) {
-            config.collections[already] = collection;
-        }
-        else {
-            config.collections.push(collection);
-        }
+        const config = loadOrDefaultConfig();
+        upsertCollection(config, collection);
+        const registry = await ensureRegistry(config);
+        await registerCollectionInRegistry(registry, collection, config);
         writeConfig(config);
-        console.log(`\nRun ${chalk.bold(`skillsmanager add <path>`)} to add skills to it.\n`);
+        console.log(`\nRun ${chalk.bold("skillsmanager add <path>")} to add skills to it.\n`);
     }
     catch (err) {
         spinner.fail(`Failed: ${err.message}`);
     }
 }
+// ── helpers ───────────────────────────────────────────────────────────────────
+function loadOrDefaultConfig() {
+    if (fs.existsSync(CONFIG_PATH)) {
+        try {
+            return readConfig();
+        }
+        catch { /* fall through */ }
+    }
+    return { registries: [], collections: [], skills: {}, discoveredAt: new Date().toISOString() };
+}
+function upsertCollection(config, collection) {
+    const idx = config.collections.findIndex((c) => c.name === collection.name);
+    if (idx >= 0) {
+        config.collections[idx] = collection;
+    }
+    else {
+        config.collections.push(collection);
+    }
+}
+/** Returns the first registry in config, auto-creating a local one if none exists. */
+async function ensureRegistry(config) {
+    if (config.registries.length > 0)
+        return config.registries[0];
+    console.log(chalk.dim("  No registry found — creating a local registry..."));
+    const local = new LocalBackend();
+    const registry = await local.createRegistry();
+    config.registries.push(registry);
+    console.log(chalk.green("  ✓ Local registry created"));
+    return registry;
+}
+/** Registers the collection ref in the given registry (writes directly to the registry's backend). */
+async function registerCollectionInRegistry(registry, collection, config) {
+    const backend = await resolveBackend(registry.backend);
+    const registryData = await backend.readRegistry(registry);
+    if (registryData.collections.find((c) => c.name === collection.name))
+        return;
+    registryData.collections.push({
+        name: collection.name,
+        backend: collection.backend,
+        ref: collection.folderId,
+    });
+    await backend.writeRegistry(registry, registryData);
+    // Keep local config registry list in sync
+    if (!config.registries.find((r) => r.id === registry.id)) {
+        config.registries.push(registry);
+    }
+    console.log(chalk.dim(`  Registered in registry "${registry.name}" (${registry.backend})`));
+}

package/dist/commands/fetch.js

@@ -2,21 +2,22 @@ import chalk from "chalk";
 import ora from "ora";
 import path from "path";
 import { getCachePath, ensureCachePath, createSymlink } from "../cache.js";
-import { ensureReady } from "../ready.js";
-import { trackSkill } from "../config.js";
+import { readConfig, trackSkill } from "../config.js";
+import { resolveBackend } from "../backends/resolve.js";
 export async function fetchCommand(names, options) {
     if (names.length === 0) {
         console.log(chalk.red("Please specify at least one skill name."));
         console.log(chalk.dim("  Example: skillsmanager fetch pdf-skill --agent claude"));
         return;
     }
-    const { config, backend } = await ensureReady();
-    // Gather all skills across collections
+    const config = readConfig();
+    // Gather all skills across collections (resolve backend per collection)
     const allSkills = [];
     for (const collection of config.collections) {
+        const backend = await resolveBackend(collection.backend);
         const col = await backend.readCollection(collection);
         for (const entry of col.skills) {
-            allSkills.push({ entry, collection });
+            allSkills.push({ entry, collection, backend });
         }
     }
     const scope = options.scope ?? "global";
@@ -31,7 +32,7 @@ export async function fetchCommand(names, options) {
         try {
             ensureCachePath(match.collection);
             const cachePath = getCachePath(match.collection, name);
-            await backend.downloadSkill(match.collection, name, cachePath);
+            await match.backend.downloadSkill(match.collection, name, cachePath);
             const { skillsDir, created } = createSymlink(name, cachePath, options.agent, scope, cwd);
             trackSkill(name, match.collection.id, path.join(skillsDir, name));
             spinner.succeed(`${chalk.bold(name)} → ${scope === "project" ? "project" : "global"} ${options.agent} skills`);

package/dist/commands/list.js

@@ -1,10 +1,12 @@
 import chalk from "chalk";
 import ora from "ora";
-import { ensureReady } from "../ready.js";
+import { readConfig } from "../config.js";
+import { resolveBackend } from "../backends/resolve.js";
 export async function getAllSkills() {
-    const { config, backend } = await ensureReady();
+    const config = readConfig();
     const allSkills = [];
     for (const collection of config.collections) {
+        const backend = await resolveBackend(collection.backend);
         const col = await backend.readCollection(collection);
         for (const entry of col.skills) {
             allSkills.push({ entry, collection });
@@ -27,7 +29,7 @@ export async function listCommand() {
         console.log(`\n  ${chalk.dim("NAME".padEnd(maxName + 2))}${chalk.dim("DESCRIPTION".padEnd(maxDesc + 2))}${chalk.dim("SOURCE")}`);
         console.log(`  ${chalk.dim("-".repeat(maxName + maxDesc + 30))}`);
         for (const s of skills.sort((a, b) => a.entry.name.localeCompare(b.entry.name))) {
-            console.log(`  ${chalk.cyan(s.entry.name.padEnd(maxName + 2))}${s.entry.description.padEnd(maxDesc + 2)}${chalk.dim(`gdrive:${s.collection.name}`)}`);
+            console.log(`  ${chalk.cyan(s.entry.name.padEnd(maxName + 2))}${s.entry.description.padEnd(maxDesc + 2)}${chalk.dim(`${s.collection.backend}:${s.collection.name}`)}`);
         }
         console.log();
     }

package/dist/commands/logout.d.ts

@@ -0,0 +1,4 @@
+export declare function logoutGoogleCommand(options: {
+    all?: boolean;
+}): Promise<void>;
+export declare function logoutGithubCommand(): void;

package/dist/commands/logout.js

@@ -0,0 +1,35 @@
+import fs from "fs";
+import chalk from "chalk";
+import { CREDENTIALS_PATH, TOKEN_PATH } from "../config.js";
+import { spawnSync } from "child_process";
+export async function logoutGoogleCommand(options) {
+    const removeAll = options.all;
+    let removed = false;
+    if (fs.existsSync(TOKEN_PATH)) {
+        fs.unlinkSync(TOKEN_PATH);
+        console.log(chalk.green("  ✓ Removed token.json (OAuth session cleared)"));
+        removed = true;
+    }
+    else {
+        console.log(chalk.dim("  – token.json not found (already logged out)"));
+    }
+    if (removeAll) {
+        if (fs.existsSync(CREDENTIALS_PATH)) {
+            fs.unlinkSync(CREDENTIALS_PATH);
+            console.log(chalk.green("  ✓ Removed credentials.json (OAuth client cleared)"));
+            removed = true;
+        }
+        else {
+            console.log(chalk.dim("  – credentials.json not found"));
+        }
+    }
+    if (removed) {
+        console.log(chalk.dim("\n  Run skillsmanager setup google to set up again."));
+    }
+}
+export function logoutGithubCommand() {
+    const r = spawnSync("gh", ["auth", "logout"], { stdio: "inherit" });
+    if (r.status !== 0) {
+        console.log(chalk.red("  gh auth logout failed. Try manually: gh auth logout"));
+    }
+}

package/dist/commands/refresh.js

@@ -1,40 +1,93 @@
 import chalk from "chalk";
 import ora from "ora";
-import { writeConfig, mergeCollections, readConfig } from "../config.js";
-import { ensureAuth } from "../auth.js";
-import { GDriveBackend } from "../backends/gdrive.js";
+import { writeConfig, mergeCollections, mergeRegistries, readConfig } from "../config.js";
+import { resolveBackend } from "../backends/resolve.js";
 export async function refreshCommand() {
-    const spinner = ora("Discovering collections...").start();
+    const spinner = ora("Discovering registries...").start();
     try {
-        const auth = await ensureAuth();
-        const backend = new GDriveBackend(auth);
-        const fresh = await backend.discoverCollections();
-        let existing = [];
+        let existingCollections = [];
+        let existingSkills = {};
+        let existingRegistries = [];
         try {
-            existing = readConfig().collections;
+            const cfg = readConfig();
+            existingCollections = cfg.collections;
+            existingSkills = cfg.skills ?? {};
+            existingRegistries = cfg.registries ?? [];
         }
         catch { /* no existing config */ }
-        const collections = mergeCollections(fresh, existing);
-        let existingSkills = {};
-        try {
-            existingSkills = readConfig().skills ?? {};
+        // Step 1: Discover registries across all backends
+        const backendsToScan = ["gdrive", "github", "local"];
+        const freshRegistries = [];
+        const skippedBackends = [];
+        for (const backendName of backendsToScan) {
+            try {
+                const backend = await resolveBackend(backendName);
+                const found = await backend.discoverRegistries();
+                freshRegistries.push(...found);
+            }
+            catch {
+                skippedBackends.push(backendName);
+            }
         }
-        catch { /* ok */ }
-        let existingRegistries = [];
-        try {
-            existingRegistries = readConfig().registries ?? [];
+        if (skippedBackends.length > 0) {
+            console.log(chalk.dim(`  Skipped (not configured): ${skippedBackends.join(", ")}`));
+            console.log(chalk.dim(`  Run: skillsmanager setup ${skippedBackends[0]} to enable`));
+        }
+        const mergedRegistries = mergeRegistries(freshRegistries, existingRegistries);
+        spinner.text = `Found ${mergedRegistries.length} registry(ies). Resolving collections...`;
+        // Step 2: Resolve collections from each registry's refs
+        const freshCollections = [];
+        for (const registry of mergedRegistries) {
+            try {
+                const backend = await resolveBackend(registry.backend);
+                const registryFile = await backend.readRegistry(registry);
+                for (const ref of registryFile.collections) {
+                    try {
+                        const refBackend = await resolveBackend(ref.backend);
+                        const colInfo = await refBackend.resolveCollectionRef(ref);
+                        if (colInfo) {
+                            freshCollections.push(colInfo);
+                        }
+                        else {
+                            console.log(chalk.dim(`\n  Warning: collection "${ref.name}" listed in registry "${registry.name}" could not be resolved`));
+                        }
+                    }
+                    catch {
+                        // Skip unresolvable refs silently
+                    }
+                }
+            }
+            catch {
+                // Skip registries that can't be read
+            }
         }
-        catch { /* ok */ }
-        writeConfig({ registries: existingRegistries, collections, skills: existingSkills, discoveredAt: new Date().toISOString() });
+        // Deduplicate by folderId before merging (same collection may appear in multiple registries)
+        const seenFolderIds = new Set();
+        const dedupedCollections = freshCollections.filter((c) => {
+            if (seenFolderIds.has(c.folderId))
+                return false;
+            seenFolderIds.add(c.folderId);
+            return true;
+        });
+        const mergedCollections = mergeCollections(dedupedCollections, existingCollections);
+        writeConfig({
+            registries: mergedRegistries,
+            collections: mergedCollections,
+            skills: existingSkills,
+            discoveredAt: new Date().toISOString(),
+        });
         spinner.stop();
-        if (collections.length === 0) {
-            console.log(chalk.yellow("No collections found."));
-            console.log(chalk.dim("  Run: skillsmanager collection create <name>"));
+        if (mergedRegistries.length === 0) {
+            console.log(chalk.yellow("No registries found."));
+            console.log(chalk.dim("  Run: skillsmanager registry create"));
         }
         else {
-            console.log(chalk.green(`Found ${collections.length} collection(s):`));
-            for (const c of collections) {
-                console.log(`  gdrive:${c.name}`);
+            console.log(chalk.green(`Found ${mergedRegistries.length} registry(ies), ${mergedCollections.length} collection(s):`));
+            for (const r of mergedRegistries) {
+                console.log(`  registry: ${r.backend}:${r.name}`);
+            }
+            for (const c of mergedCollections) {
+                console.log(`  collection: ${c.backend}:${c.name}`);
             }
         }
         console.log();

package/dist/commands/registry.d.ts

@@ -1,5 +1,6 @@
 export declare function registryCreateCommand(options: {
     backend?: string;
+    repo?: string;
 }): Promise<void>;
 export declare function registryListCommand(): Promise<void>;
 export declare function registryDiscoverCommand(options: {
@@ -9,6 +10,11 @@ export declare function registryAddCollectionCommand(collectionName: string, opt
     backend?: string;
     ref?: string;
 }): Promise<void>;
+export declare function registryRemoveCollectionCommand(collectionName: string, options: {
+    delete?: boolean;
+    backend?: string;
+}): Promise<void>;
 export declare function registryPushCommand(options: {
     backend?: string;
+    repo?: string;
 }): Promise<void>;