@skillsmanager/cli 0.0.4 → 0.0.6

package/dist/backends/interface.d.ts

@@ -1,15 +1,32 @@
 import type { CollectionFile, CollectionInfo, RegistryCollectionRef, RegistryFile, RegistryInfo } from "../types.js";
+export interface CreateCollectionOptions {
+    name: string;
+    repo?: string;
+    skillsRepo?: string;
+}
+export interface CreateRegistryOptions {
+    name?: string;
+    repo?: string;
+}
+export interface BackendStatus {
+    loggedIn: boolean;
+    identity: string;
+    hint?: string;
+}
 export interface StorageBackend {
     getOwner(): Promise<string>;
+    getStatus(): Promise<BackendStatus>;
     discoverCollections(): Promise<Omit<CollectionInfo, "id">[]>;
     readCollection(collection: CollectionInfo): Promise<CollectionFile>;
     writeCollection(collection: CollectionInfo, data: CollectionFile): Promise<void>;
     downloadSkill(collection: CollectionInfo, skillName: string, destDir: string): Promise<void>;
-    uploadSkill(collection: CollectionInfo, localPath: string, skillName: string): Promise<void>;
+    uploadSkill(collection: CollectionInfo, localPath: string, skillName: string): Promise<string>;
     deleteCollection(collection: CollectionInfo): Promise<void>;
+    deleteSkill(collection: CollectionInfo, skillName: string): Promise<void>;
     discoverRegistries(): Promise<Omit<RegistryInfo, "id">[]>;
     readRegistry(registry: RegistryInfo): Promise<RegistryFile>;
     writeRegistry(registry: RegistryInfo, data: RegistryFile): Promise<void>;
     resolveCollectionRef(ref: RegistryCollectionRef): Promise<Omit<CollectionInfo, "id"> | null>;
-    createRegistry(name?: string): Promise<RegistryInfo>;
+    createRegistry(options?: CreateRegistryOptions): Promise<RegistryInfo>;
+    createCollection(options: CreateCollectionOptions): Promise<CollectionInfo>;
 }

package/dist/backends/local.d.ts

@@ -1,4 +1,4 @@
-import type { StorageBackend } from "./interface.js";
+import type { BackendStatus, CreateRegistryOptions, StorageBackend } from "./interface.js";
 import type { CollectionFile, CollectionInfo, RegistryCollectionRef, RegistryFile, RegistryInfo } from "../types.js";
 /**
  * Local filesystem backend — stores collections and the registry under ~/.skillsmanager/.
@@ -6,16 +6,18 @@ import type { CollectionFile, CollectionInfo, RegistryCollectionRef, RegistryFil
  */
 export declare class LocalBackend implements StorageBackend {
     getOwner(): Promise<string>;
+    getStatus(): Promise<BackendStatus>;
     discoverCollections(): Promise<Omit<CollectionInfo, "id">[]>;
     readCollection(collection: CollectionInfo): Promise<CollectionFile>;
     writeCollection(collection: CollectionInfo, data: CollectionFile): Promise<void>;
     downloadSkill(collection: CollectionInfo, skillName: string, destDir: string): Promise<void>;
-    uploadSkill(collection: CollectionInfo, localPath: string, skillName: string): Promise<void>;
+    uploadSkill(collection: CollectionInfo, localPath: string, skillName: string): Promise<string>;
     deleteCollection(collection: CollectionInfo): Promise<void>;
+    deleteSkill(collection: CollectionInfo, skillName: string): Promise<void>;
     discoverRegistries(): Promise<Omit<RegistryInfo, "id">[]>;
     readRegistry(registry: RegistryInfo): Promise<RegistryFile>;
     writeRegistry(registry: RegistryInfo, data: RegistryFile): Promise<void>;
     resolveCollectionRef(ref: RegistryCollectionRef): Promise<Omit<CollectionInfo, "id"> | null>;
-    createRegistry(name?: string): Promise<RegistryInfo>;
-    createCollection(name: string): Promise<CollectionInfo>;
+    createRegistry(options?: CreateRegistryOptions): Promise<RegistryInfo>;
+    createCollection({ name }: import("./interface.js").CreateCollectionOptions): Promise<CollectionInfo>;
 }

package/dist/backends/local.js

@@ -20,6 +20,9 @@ export class LocalBackend {
         }
         return process.env.USER ?? process.env.USERNAME ?? "unknown";
     }
+    async getStatus() {
+        return { loggedIn: true, identity: await this.getOwner() };
+    }
     // ── Collection operations ────────────────────────────────────────────────
     async discoverCollections() {
         if (!fs.existsSync(COLLECTIONS_DIR))
@@ -68,16 +71,22 @@ export class LocalBackend {
     }
     async uploadSkill(collection, localPath, skillName) {
         const dest = path.join(collection.folderId, skillName);
-        // If source and dest are the same, no-op
-        if (path.resolve(localPath) === path.resolve(dest))
-            return;
-        copyDirSync(localPath, dest);
+        if (path.resolve(localPath) !== path.resolve(dest)) {
+            copyDirSync(localPath, dest);
+        }
+        return `${skillName}/`;
     }
     async deleteCollection(collection) {
         if (fs.existsSync(collection.folderId)) {
             fs.rmSync(collection.folderId, { recursive: true, force: true });
         }
     }
+    async deleteSkill(collection, skillName) {
+        const skillPath = path.join(collection.folderId, skillName);
+        if (fs.existsSync(skillPath)) {
+            fs.rmSync(skillPath, { recursive: true, force: true });
+        }
+    }
     // ── Registry operations ──────────────────────────────────────────────────
     async discoverRegistries() {
         if (!fs.existsSync(LOCAL_REGISTRY_PATH))
@@ -115,26 +124,22 @@ export class LocalBackend {
             folderId: dir,
         };
     }
-    async createRegistry(name) {
+    async createRegistry(options) {
+        const name = options?.name ?? "local";
         fs.mkdirSync(CONFIG_DIR, { recursive: true });
         const owner = await this.getOwner();
-        const data = {
-            name: name ?? "local",
-            owner,
-            source: "local",
-            collections: [],
-        };
+        const data = { name, owner, source: "local", collections: [] };
         fs.writeFileSync(LOCAL_REGISTRY_PATH, serializeRegistryFile(data));
         return {
             id: randomUUID(),
-            name: name ?? "local",
+            name,
             backend: "local",
             folderId: CONFIG_DIR,
             fileId: LOCAL_REGISTRY_PATH,
         };
     }
     // ── Convenience: create a local collection ───────────────────────────────
-    async createCollection(name) {
+    async createCollection({ name }) {
         const dir = path.join(COLLECTIONS_DIR, name);
         fs.mkdirSync(dir, { recursive: true });
         const owner = await this.getOwner();

package/dist/backends/resolve.d.ts

@@ -1,2 +1,4 @@
 import type { StorageBackend } from "./interface.js";
 export declare function resolveBackend(backendName: string): Promise<StorageBackend>;
+/** Like resolveBackend but never triggers auth flows — returns null for unconfigured backends. */
+export declare function tryResolveBackend(backendName: string): Promise<StorageBackend | null>;

package/dist/backends/resolve.js

@@ -1,11 +1,32 @@
-import { ensureAuth } from "../auth.js";
+import { ensureAuth, getAuthClient, hasToken } from "../auth.js";
+import { credentialsExist } from "../config.js";
 import { GDriveBackend } from "./gdrive.js";
 import { GithubBackend } from "./github.js";
 import { LocalBackend } from "./local.js";
+import { RoutingBackend } from "./routing.js";
 export async function resolveBackend(backendName) {
+    let inner;
     if (backendName === "gdrive")
-        return new GDriveBackend(await ensureAuth());
+        inner = new GDriveBackend(await ensureAuth());
+    else if (backendName === "github")
+        inner = new GithubBackend();
+    else
+        inner = new LocalBackend();
+    return new RoutingBackend(inner);
+}
+/** Like resolveBackend but never triggers auth flows — returns null for unconfigured backends. */
+export async function tryResolveBackend(backendName) {
+    if (backendName === "gdrive") {
+        if (!credentialsExist() || !hasToken())
+            return null;
+        try {
+            return new RoutingBackend(new GDriveBackend(getAuthClient()));
+        }
+        catch {
+            return null;
+        }
+    }
     if (backendName === "github")
-        return new GithubBackend();
-    return new LocalBackend();
+        return new RoutingBackend(new GithubBackend());
+    return new RoutingBackend(new LocalBackend());
 }

package/dist/backends/routing.d.ts

@@ -0,0 +1,38 @@
+import type { BackendStatus, CreateCollectionOptions, CreateRegistryOptions, StorageBackend } from "./interface.js";
+import type { CollectionFile, CollectionInfo, RegistryCollectionRef, RegistryFile, RegistryInfo } from "../types.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 declare class RoutingBackend implements StorageBackend {
+    private readonly inner;
+    constructor(inner: StorageBackend);
+    getOwner(): Promise<string>;
+    getStatus(): Promise<BackendStatus>;
+    discoverCollections(): Promise<Omit<CollectionInfo, "id">[]>;
+    readCollection(collection: CollectionInfo): Promise<CollectionFile>;
+    writeCollection(collection: CollectionInfo, data: CollectionFile): Promise<void>;
+    deleteCollection(collection: CollectionInfo): Promise<void>;
+    discoverRegistries(): Promise<Omit<RegistryInfo, "id">[]>;
+    readRegistry(registry: RegistryInfo): Promise<RegistryFile>;
+    writeRegistry(registry: RegistryInfo, data: RegistryFile): Promise<void>;
+    resolveCollectionRef(ref: RegistryCollectionRef): Promise<Omit<CollectionInfo, "id"> | null>;
+    createRegistry(options?: CreateRegistryOptions): Promise<RegistryInfo>;
+    createCollection(options: CreateCollectionOptions): Promise<CollectionInfo>;
+    downloadSkill(collection: CollectionInfo, skillName: string, destDir: string): Promise<void>;
+    uploadSkill(collection: CollectionInfo, localPath: string, skillName: string): Promise<string>;
+    deleteSkill(collection: CollectionInfo, skillName: string): Promise<void>;
+    private requireRepo;
+    private requireEntry;
+}

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.d.ts

@@ -1,3 +1,6 @@
 export declare function addCommand(skillPath: string, options: {
     collection?: string;
+    remotePath?: string;
+    name?: string;
+    description?: string;
 }): Promise<void>;

package/dist/commands/add.js

@@ -4,9 +4,14 @@ 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 ─
+    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.`));
@@ -34,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 {
@@ -75,21 +80,136 @@ export async function addCommand(skillPath, options) {
         console.log(chalk.red("No collections configured. Run: skillsmanager collection create"));
         return;
     }
+    // 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 (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}" (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>`)));
+                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 hostBackend.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;
+    }
+    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 spinner = ora(`Registering ${chalk.bold(skillName)} in ${collection.name} at ${chalk.dim(remotePath)}...`).start();
+    try {
+        const col = colForType;
+        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 hostBackend.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 github = await resolveBackend("github");
     const spinner = ora(`Adding ${chalk.bold(skillName)} to github:${collection.folderId}...`).start();
     try {
-        // 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 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 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 };
@@ -109,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.d.ts

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

package/dist/commands/collection.js

@@ -2,51 +2,28 @@ 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 { resolveBackend } from "../backends/resolve.js";
 export async function collectionCreateCommand(name, options = {}) {
     const backendName = options.backend ?? "gdrive";
-    if (backendName === "github") {
-        await createGithubCollection(name, options.repo);
-    }
-    else {
-        await createGdriveCollection(name);
-    }
-}
-async function createGithubCollection(name, repo) {
-    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();
-    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);
-        console.log(chalk.green(`\n  ✓ Collection "${collectionName}" created in github:${collection.folderId}`));
-        const config = loadOrDefaultConfig();
-        upsertCollection(config, collection);
-        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 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();
+        const registry = await ensureRegistry(config);
+        await registerCollectionInRegistry(registry, collection, config);
+        collection.sourceRegistryId = registry.id;
         upsertCollection(config, collection);
         writeConfig(config);
         console.log(`\nRun ${chalk.bold("skillsmanager add <path>")} to add skills to it.\n`);
@@ -74,3 +51,32 @@ function upsertCollection(config, collection) {
         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 = await resolveBackend("local");
+    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})`));
+}