@skillsmanager/cli 0.0.5 → 0.0.6

package/dist/backends/routing.js

@@ -0,0 +1,124 @@
+import { GithubBackend } from "./github.js";
+/**
+ * RoutingBackend — a transparent decorator over any StorageBackend.
+ *
+ * Collection-metadata operations (readCollection, writeCollection, registry ops, etc.)
+ * pass straight through to the inner backend — the YAML always lives where the
+ * collection was declared.
+ *
+ * Skill-file operations (downloadSkill, uploadSkill, deleteSkill) inspect col.type
+ * and dispatch to the appropriate handler:
+ *   - col.type === "github"  → GithubBackend helpers (clone/pull the skills repo)
+ *   - col.type absent/same  → inner backend (normal behaviour, no change)
+ *
+ * This means every backend gets cross-backend routing for free without any
+ * per-backend col.type checks.
+ */
+export class RoutingBackend {
+    inner;
+    constructor(inner) {
+        this.inner = inner;
+    }
+    // ── Pass-through: identity + collection metadata ───────────────────────────
+    getOwner() {
+        return this.inner.getOwner();
+    }
+    getStatus() {
+        return this.inner.getStatus();
+    }
+    discoverCollections() {
+        return this.inner.discoverCollections();
+    }
+    readCollection(collection) {
+        return this.inner.readCollection(collection);
+    }
+    writeCollection(collection, data) {
+        return this.inner.writeCollection(collection, data);
+    }
+    deleteCollection(collection) {
+        return this.inner.deleteCollection(collection);
+    }
+    // ── Pass-through: registry operations ─────────────────────────────────────
+    discoverRegistries() {
+        return this.inner.discoverRegistries();
+    }
+    readRegistry(registry) {
+        return this.inner.readRegistry(registry);
+    }
+    writeRegistry(registry, data) {
+        return this.inner.writeRegistry(registry, data);
+    }
+    resolveCollectionRef(ref) {
+        return this.inner.resolveCollectionRef(ref);
+    }
+    createRegistry(options) {
+        return this.inner.createRegistry(options);
+    }
+    createCollection(options) {
+        return this.inner.createCollection(options);
+    }
+    // ── Routed: dispatch on col.type for skill-file operations ─────────────────
+    async downloadSkill(collection, skillName, destDir) {
+        const col = await this.inner.readCollection(collection);
+        const skillType = col.type ?? collection.backend;
+        // Only cross-dispatch when the skill source differs from the collection's own backend.
+        // Same-backend collections (e.g. GitHub-native) handle routing internally.
+        if (skillType === "github" && collection.backend !== "github") {
+            const repo = this.requireRepo(col, collection.name);
+            const entry = this.requireEntry(col, skillName, collection.name);
+            await new GithubBackend().downloadSkillFromRepo(repo, entry.path, destDir);
+            return;
+        }
+        return this.inner.downloadSkill(collection, skillName, destDir);
+    }
+    async uploadSkill(collection, localPath, skillName) {
+        const col = await this.inner.readCollection(collection);
+        const skillType = col.type ?? collection.backend;
+        // Case 1: collection YAML in one backend, skills declared in another (col.type set)
+        if (skillType !== collection.backend) {
+            throw new Error(`Cannot upload skill to collection "${collection.name}": ` +
+                `its skills source type is "${skillType}". ` +
+                `Use --remote-path to register a skill path instead.`);
+        }
+        // Case 2: GitHub-native collection whose metadata.repo points to a foreign repo
+        if (skillType === "github" && col.metadata?.repo) {
+            const hostRepo = collection.folderId.split(":")[0];
+            const foreign = col.metadata.repo;
+            if (foreign !== hostRepo) {
+                throw new Error(`Cannot upload skill to collection "${collection.name}": ` +
+                    `its skills source is "${foreign}" (a repo you may not own). ` +
+                    `Use --remote-path to register a skill path instead.`);
+            }
+        }
+        return this.inner.uploadSkill(collection, localPath, skillName);
+    }
+    async deleteSkill(collection, skillName) {
+        const col = await this.inner.readCollection(collection);
+        const skillType = col.type ?? collection.backend;
+        // Only cross-dispatch when the skill source differs from the collection's own backend.
+        if (skillType === "github" && collection.backend !== "github") {
+            const repo = this.requireRepo(col, collection.name);
+            const entry = col.skills.find((s) => s.name === skillName);
+            if (!entry)
+                return;
+            await new GithubBackend().deleteSkillFromRepo(repo, entry.path);
+            return;
+        }
+        return this.inner.deleteSkill(collection, skillName);
+    }
+    // ── Private helpers ────────────────────────────────────────────────────────
+    requireRepo(col, collectionName) {
+        const repo = col.metadata?.repo;
+        if (!repo) {
+            throw new Error(`Collection "${collectionName}" has type "github" but is missing metadata.repo`);
+        }
+        return repo;
+    }
+    requireEntry(col, skillName, collectionName) {
+        const entry = col.skills.find((s) => s.name === skillName);
+        if (!entry) {
+            throw new Error(`Skill "${skillName}" not found in collection "${collectionName}"`);
+        }
+        return entry;
+    }
+}

package/dist/commands/add.js

@@ -4,7 +4,7 @@ import chalk from "chalk";
 import ora from "ora";
 import YAML from "yaml";
 import { readConfig, trackSkill } from "../config.js";
-import { GithubBackend } from "../backends/github.js";
+import { detectRepoContext } from "../utils/git.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 ─
@@ -39,7 +39,7 @@ export async function addCommand(skillPath, options) {
     // 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);
+        const ctx = detectRepoContext(absPath);
         if (ctx) {
             let config;
             try {
@@ -80,15 +80,17 @@ export async function addCommand(skillPath, options) {
         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);
+    // If the collection's skill type differs from its hosting backend, handle specially.
+    // col.type declares who handles skill files; col.metadata.repo gives the target repo.
+    {
+        const hostBackend = await resolveBackend(collection.backend);
+        const col = await hostBackend.readCollection(collection);
+        const skillType = col.type ?? collection.backend;
         const foreignRepo = col.metadata?.repo;
-        if (foreignRepo) {
-            const ctx = GithubBackend.detectRepoContext(absPath);
+        if (skillType !== collection.backend && skillType === "github" && foreignRepo) {
+            const ctx = detectRepoContext(absPath);
             if (!ctx || ctx.repo !== foreignRepo) {
-                console.log(chalk.red(`This collection's skills source is "${foreignRepo}". ` +
+                console.log(chalk.red(`This collection's skills source is "${foreignRepo}" (type: ${skillType}). ` +
                     `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>`)));
@@ -105,7 +107,7 @@ export async function addCommand(skillPath, options) {
                 else {
                     col.skills.push(entry);
                 }
-                await github.writeCollection(collection, col);
+                await hostBackend.writeCollection(collection, col);
                 trackSkill(skillName, collection.id, absPath);
                 spinner.succeed(`${chalk.bold(skillName)} registered in ${collection.name} at ${chalk.dim(ctx.relPath)}`);
             }
@@ -151,14 +153,16 @@ async function addRemotePath(options) {
         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."));
+    const hostBackend = await resolveBackend(collection.backend);
+    const colForType = await hostBackend.readCollection(collection);
+    const skillType = colForType.type ?? collection.backend;
+    if (skillType !== "github" && collection.backend !== "github") {
+        console.log(chalk.red(`--remote-path is only supported for collections with type "github".`));
         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 col = colForType;
         const existing = col.skills.findIndex((s) => s.name === skillName);
         const entry = { name: skillName, path: remotePath, description };
         if (existing >= 0) {
@@ -167,7 +171,7 @@ async function addRemotePath(options) {
         else {
             col.skills.push(entry);
         }
-        await github.writeCollection(collection, col);
+        await hostBackend.writeCollection(collection, col);
         spinner.succeed(`${chalk.bold(skillName)} registered in ${collection.name} at ${chalk.dim(remotePath)}`);
     }
     catch (err) {
@@ -176,7 +180,7 @@ async function addRemotePath(options) {
 }
 // ── GitHub path: register in-repo skill or copy external skill ────────────────
 async function addToGithub(absPath, ctx, skillName, description, collection) {
-    const github = new GithubBackend();
+    const github = await resolveBackend("github");
     const spinner = ora(`Adding ${chalk.bold(skillName)} to github:${collection.folderId}...`).start();
     try {
         const col = await github.readCollection(collection);
@@ -204,12 +208,8 @@ async function addToGithub(absPath, ctx, skillName, description, collection) {
             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
+        // uploadSkill returns the canonical in-repo path
+        const skillEntry = await github.uploadSkill(collection, absPath, skillName);
         const existing = col.skills.findIndex((s) => s.name === skillName);
         if (existing >= 0) {
             col.skills[existing] = { name: skillName, path: skillEntry, description };
@@ -229,23 +229,7 @@ async function addToGithub(absPath, ctx, skillName, description, collection) {
 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 skillPath = await backend.uploadSkill(collection, absPath, skillName);
         const col = await backend.readCollection(collection);
         const existing = col.skills.findIndex((s) => s.name === skillName);
         if (existing >= 0) {

package/dist/commands/collection.js

@@ -2,63 +2,29 @@ import chalk from "chalk";
 import ora from "ora";
 import fs from "fs";
 import { writeConfig, CONFIG_PATH, readConfig } from "../config.js";
-import { ensureAuth } from "../auth.js";
-import { GDriveBackend } from "../backends/gdrive.js";
-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) {
+    if (backendName === "github" && !options.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 {
-        console.log(chalk.bold(`\nCreating GitHub collection "${collectionName}" in ${repo}...\n`));
-    }
+    const collectionName = name ?? (backendName === "gdrive" ? "MY_SKILLS" : "default");
+    const spinner = ora(`Creating collection "${collectionName}" in ${backendName}...`).start();
     try {
-        const collection = await backend.createCollection(collectionName, repo, skillsRepo);
-        console.log(chalk.green(`\n  ✓ Collection "${collectionName}" created in github:${collection.folderId}`));
+        const backend = await resolveBackend(backendName);
+        const collection = await backend.createCollection({
+            name: collectionName,
+            repo: options.repo,
+            skillsRepo: options.skillsRepo,
+        });
+        spinner.succeed(`Collection "${collection.name}" created (${backendName}:${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`);
-        const config = loadOrDefaultConfig();
+        collection.sourceRegistryId = registry.id;
         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`);
     }
@@ -90,7 +56,7 @@ 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 local = await resolveBackend("local");
     const registry = await local.createRegistry();
     config.registries.push(registry);
     console.log(chalk.green("  ✓ Local registry created"));

package/dist/commands/init.js

@@ -2,13 +2,13 @@ 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 { resolveBackend } from "../backends/resolve.js";
 export async function initCommand() {
     console.log(chalk.bold("\nSkills Manager Init\n"));
     const auth = await ensureAuth();
     console.log(chalk.green("  ✓ Authenticated"));
     const spinner = ora("  Discovering collections...").start();
-    const backend = new GDriveBackend(auth);
+    const backend = await resolveBackend("gdrive");
     const fresh = await backend.discoverCollections();
     let existing = [];
     try {
@@ -25,7 +25,7 @@ export async function initCommand() {
         console.log(chalk.green(`  ✓ Found ${collections.length} collection(s):`));
         for (const c of collections) {
             const col = await backend.readCollection(c);
-            console.log(`    gdrive:${c.name}  (${col.skills.length} skills)`);
+            console.log(`    ${c.backend}:${c.name}  (${col.skills.length} skills)`);
         }
     }
     let existingSkills = {};

package/dist/commands/list.js

@@ -1,3 +1,4 @@
+import os from "os";
 import chalk from "chalk";
 import ora from "ora";
 import { readConfig } from "../config.js";
@@ -14,24 +15,93 @@ export async function getAllSkills() {
     }
     return allSkills;
 }
+function collectionTag(col) {
+    if (col.backend === "github") {
+        const repo = col.folderId.split(":")[0];
+        return `[github: ${repo}]`;
+    }
+    return `[${col.backend}]`;
+}
+const HOME = os.homedir();
+function shortenPath(p) {
+    return p.startsWith(HOME) ? "~" + p.slice(HOME.length) : p;
+}
+function installedPaths(skillName, collectionId, skillIndex) {
+    const entries = skillIndex[skillName] ?? [];
+    const paths = [];
+    for (const entry of entries) {
+        if (entry.collectionId !== collectionId)
+            continue;
+        for (const p of entry.installedAt) {
+            paths.push(shortenPath(p));
+        }
+    }
+    return paths;
+}
+function renderCollections(cols, collectionSkills, skillIndex) {
+    for (let ci = 0; ci < cols.length; ci++) {
+        const col = cols[ci];
+        const isLastCol = ci === cols.length - 1;
+        const colBranch = isLastCol ? "└──" : "├──";
+        const childPad = isLastCol ? "    " : "│   ";
+        console.log(`${colBranch} ${chalk.bold.yellow(col.name)} ${chalk.dim(collectionTag(col))}`);
+        const skills = (collectionSkills.get(col.id) ?? []).sort((a, b) => a.name.localeCompare(b.name));
+        for (let si = 0; si < skills.length; si++) {
+            const skill = skills[si];
+            const isLastSkill = si === skills.length - 1;
+            const skillBranch = isLastSkill ? "└──" : "├──";
+            const paths = installedPaths(skill.name, col.id, skillIndex);
+            console.log(`${childPad}${skillBranch} ${chalk.cyan(skill.name)}  ${chalk.dim(skill.description)}`);
+            if (paths.length > 0) {
+                const installPad = childPad + (isLastSkill ? "    " : "│   ");
+                console.log(`${installPad}${chalk.magenta(`(${paths.join(", ")})`)}`);
+            }
+        }
+    }
+}
 export async function listCommand() {
     const spinner = ora("Fetching skills...").start();
     try {
-        const skills = await getAllSkills();
+        const config = readConfig();
+        // Fetch skills per collection
+        const collectionSkills = new Map();
+        for (const col of config.collections) {
+            const backend = await resolveBackend(col.backend);
+            const colFile = await backend.readCollection(col);
+            collectionSkills.set(col.id, colFile.skills);
+        }
         spinner.stop();
-        if (skills.length === 0) {
+        const totalSkills = [...collectionSkills.values()].reduce((n, s) => n + s.length, 0);
+        if (totalSkills === 0) {
             console.log(chalk.yellow("No skills found across any collections."));
             console.log(chalk.dim('Run "skillsmanager collection create <name>" to create a collection, then "skillsmanager add <path>" to add skills.'));
             return;
         }
-        const maxName = Math.max(...skills.map((s) => s.entry.name.length), 4);
-        const maxDesc = Math.max(...skills.map((s) => s.entry.description.length), 11);
-        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(`${s.collection.backend}:${s.collection.name}`)}`);
+        // Group collections by their source registry
+        const byRegistry = new Map();
+        for (const col of config.collections) {
+            const key = col.sourceRegistryId ?? null;
+            if (!byRegistry.has(key))
+                byRegistry.set(key, []);
+            byRegistry.get(key).push(col);
         }
         console.log();
+        // Render each registry and its collections
+        for (const reg of config.registries) {
+            const cols = byRegistry.get(reg.id);
+            if (!cols || cols.length === 0)
+                continue;
+            console.log(`${chalk.bold.white(reg.name)}  ${chalk.dim(`${reg.backend}`)}`);
+            renderCollections(cols, collectionSkills, config.skills);
+            console.log();
+        }
+        // Collections not associated with any registry
+        const orphans = byRegistry.get(null);
+        if (orphans && orphans.length > 0) {
+            console.log(`${chalk.bold.white("(unregistered)")}  ${chalk.dim("run 'skillsmanager refresh' to link to a registry")}`);
+            renderCollections(orphans, collectionSkills, config.skills);
+            console.log();
+        }
     }
     catch (err) {
         spinner.stop();

package/dist/commands/refresh.js

@@ -46,7 +46,7 @@ export async function refreshCommand() {
                         const refBackend = await resolveBackend(ref.backend);
                         const colInfo = await refBackend.resolveCollectionRef(ref);
                         if (colInfo) {
-                            freshCollections.push(colInfo);
+                            freshCollections.push({ ...colInfo, sourceRegistryId: registry.id });
                         }
                         else {
                             console.log(chalk.dim(`\n  Warning: collection "${ref.name}" listed in registry "${registry.name}" could not be resolved`));

package/dist/commands/registry.js

@@ -2,8 +2,6 @@ import chalk from "chalk";
 import ora from "ora";
 import fs from "fs";
 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";
@@ -20,13 +18,7 @@ export async function registryCreateCommand(options) {
     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);
-        }
-        else {
-            registry = await (await resolveBackend(backend)).createRegistry();
-        }
+        const registry = await (await resolveBackend(backend)).createRegistry({ repo: options.repo });
         spinner.succeed(`Registry created ${label}`);
         let config = { registries: [], collections: [], skills: {}, discoveredAt: new Date().toISOString() };
         if (fs.existsSync(CONFIG_PATH)) {
@@ -40,7 +32,7 @@ export async function registryCreateCommand(options) {
         if (backend !== "local") {
             const localReg = config.registries.find((r) => r.backend === "local");
             if (localReg) {
-                const local = new LocalBackend();
+                const local = await resolveBackend("local");
                 try {
                     const localData = await local.readRegistry(localReg);
                     const localCollections = localData.collections.filter((c) => c.backend === "local");
@@ -270,7 +262,7 @@ export async function registryPushCommand(options) {
         console.log(chalk.yellow("No local registry to push."));
         return;
     }
-    const local = new LocalBackend();
+    const local = await resolveBackend("local");
     const localData = await local.readRegistry(localReg);
     const localCollectionRefs = localData.collections.filter((c) => c.backend === "local");
     if (localCollectionRefs.length === 0) {
@@ -308,16 +300,10 @@ export async function registryPushCommand(options) {
             const collInfo = await local.resolveCollectionRef(ref);
             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 remoteCol = await remote.createCollection({
+                name: ref.name,
+                repo: options.repo,
+            });
             const colData = await local.readCollection({ ...collInfo, id: "temp" });
             for (const skill of colData.skills) {
                 const localSkillPath = path.join(collInfo.folderId, skill.name);

package/dist/commands/search.js

@@ -26,7 +26,7 @@ export async function searchCommand(query) {
         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 ranked) {
-            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/status.js

@@ -1,47 +1,17 @@
-import os from "os";
 import chalk from "chalk";
-import { credentialsExist } from "../config.js";
-import { hasToken, getAuthClient } from "../auth.js";
-import { GDriveBackend } from "../backends/gdrive.js";
-import { ghInstalled, ghAuthed, ghGetLogin } from "./setup/github.js";
-async function getGdriveStatus() {
-    if (!credentialsExist()) {
-        return { name: "gdrive", loggedIn: false, identity: "", hint: "run: skillsmanager setup google" };
-    }
-    if (!hasToken()) {
-        return { name: "gdrive", loggedIn: false, identity: "", hint: "run: skillsmanager setup google" };
-    }
-    try {
-        const client = getAuthClient();
-        const backend = new GDriveBackend(client);
-        const email = await backend.getOwner();
-        return { name: "gdrive", loggedIn: true, identity: email };
-    }
-    catch {
-        return { name: "gdrive", loggedIn: false, identity: "", hint: "run: skillsmanager setup google" };
-    }
-}
-function getGithubStatus() {
-    if (!ghInstalled()) {
-        return { name: "github", loggedIn: false, identity: "", hint: "install gh CLI first" };
-    }
-    if (!ghAuthed()) {
-        return { name: "github", loggedIn: false, identity: "", hint: "run: skillsmanager setup github" };
-    }
-    const login = ghGetLogin();
-    return { name: "github", loggedIn: true, identity: login };
-}
+import { tryResolveBackend } from "../backends/resolve.js";
+const BACKENDS = [
+    { name: "local", hint: "" },
+    { name: "gdrive", hint: "run: skillsmanager setup google" },
+    { name: "github", hint: "run: skillsmanager setup github" },
+];
 export async function statusCommand() {
-    const localStatus = {
-        name: "local",
-        loggedIn: true,
-        identity: os.userInfo().username,
-    };
-    const [gdriveStatus, githubStatus] = await Promise.all([
-        getGdriveStatus(),
-        Promise.resolve(getGithubStatus()),
-    ]);
-    const rows = [localStatus, gdriveStatus, githubStatus];
+    const rows = await Promise.all(BACKENDS.map(async ({ name, hint }) => {
+        const backend = await tryResolveBackend(name);
+        if (!backend)
+            return { name, loggedIn: false, identity: "", hint };
+        return { name, ...(await backend.getStatus()) };
+    }));
     const col1 = 8;
     const col2 = 24;
     const header = chalk.bold("Backend".padEnd(col1)) + "  " +
@@ -52,13 +22,13 @@ export async function statusCommand() {
     console.log(header);
     console.log(chalk.dim(divider));
     for (const row of rows) {
+        const statusLabel = row.loggedIn ? "✓ logged in" : "✗ not logged in";
         const status = row.loggedIn
-            ? chalk.green("✓ logged in")
-            : chalk.red("✗ not logged in");
+            ? chalk.green(statusLabel)
+            : chalk.red(statusLabel);
         const identity = row.loggedIn
             ? chalk.white(row.identity)
             : chalk.dim(row.hint ?? "");
-        const statusLabel = row.loggedIn ? "✓ logged in" : "✗ not logged in";
         console.log(row.name.padEnd(col1) + "  " + status + " ".repeat(Math.max(0, col2 - statusLabel.length)) + "  " + identity);
     }
     console.log();

package/dist/config.js

@@ -70,10 +70,15 @@ export function readConfig() {
  * fresh UUID. This keeps cache paths stable across refreshes.
  */
 export function mergeCollections(fresh, existing) {
-    return fresh.map((c) => {
+    const freshFolderIds = new Set(fresh.map((c) => c.folderId));
+    // Fresh collections, preserving UUIDs for already-known ones
+    const updated = fresh.map((c) => {
         const prev = existing.find((e) => e.folderId === c.folderId);
         return { ...c, id: prev?.id ?? randomUUID() };
     });
+    // Keep existing collections that weren't re-discovered (temporarily unavailable, etc.)
+    const kept = existing.filter((e) => !freshFolderIds.has(e.folderId));
+    return [...updated, ...kept];
 }
 /**
  * Merges freshly discovered registries with existing ones, preserving UUIDs