@skillsmanager/cli 0.0.1 → 0.0.4

package/dist/auth.js

@@ -1,26 +1,48 @@
 import fs from "fs";
-import readline from "readline";
+import http from "http";
 import { google } from "googleapis";
 import { TOKEN_PATH, ensureConfigDir, readCredentials, credentialsExist } from "./config.js";
 const SCOPES = ["https://www.googleapis.com/auth/drive"];
+const LOOPBACK_PORT = 3847;
+const REDIRECT_URI = `http://localhost:${LOOPBACK_PORT}`;
 function createOAuth2Client() {
     const { client_id, client_secret } = readCredentials();
-    return new google.auth.OAuth2(client_id, client_secret, "urn:ietf:wg:oauth:2.0:oob");
+    return new google.auth.OAuth2(client_id, client_secret, REDIRECT_URI);
 }
 function saveToken(client) {
     ensureConfigDir();
     fs.writeFileSync(TOKEN_PATH, JSON.stringify(client.credentials, null, 2));
 }
-function prompt(question) {
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
-    return new Promise((resolve) => {
-        rl.question(question, (answer) => {
-            rl.close();
-            resolve(answer.trim());
+/**
+ * Starts a temporary local HTTP server to receive the OAuth redirect,
+ * extracts the authorization code, and resolves the promise.
+ */
+function waitForAuthCode() {
+    return new Promise((resolve, reject) => {
+        const server = http.createServer((req, res) => {
+            const url = new URL(req.url ?? "/", `http://localhost:${LOOPBACK_PORT}`);
+            const code = url.searchParams.get("code");
+            const error = url.searchParams.get("error");
+            if (error) {
+                res.writeHead(200, { "Content-Type": "text/html" });
+                res.end("<h2>Authorization failed.</h2><p>You can close this tab.</p>");
+                server.close();
+                reject(new Error(`OAuth error: ${error}`));
+                return;
+            }
+            if (code) {
+                res.writeHead(200, { "Content-Type": "text/html" });
+                res.end("<h2>Authorization successful!</h2><p>You can close this tab and return to the terminal.</p>");
+                server.close();
+                resolve(code);
+            }
+            else {
+                res.writeHead(400, { "Content-Type": "text/html" });
+                res.end("<h2>Missing authorization code.</h2>");
+            }
         });
+        server.listen(LOOPBACK_PORT, () => { });
+        server.on("error", (err) => reject(new Error(`Could not start auth server on port ${LOOPBACK_PORT}: ${err.message}`)));
     });
 }
 export async function runAuthFlow() {
@@ -32,11 +54,12 @@ export async function runAuthFlow() {
     });
     console.log("\nOpen this URL in your browser to authorize Skills Manager:\n");
     console.log(authUrl);
-    console.log();
-    const code = await prompt("Paste the authorization code here: ");
+    console.log("\nWaiting for authorization...");
+    const code = await waitForAuthCode();
     const { tokens } = await client.getToken(code);
     client.setCredentials(tokens);
     saveToken(client);
+    console.log("Authorization successful.");
     return client;
 }
 export function getAuthClient() {

package/dist/backends/gdrive.d.ts

@@ -3,7 +3,6 @@ import type { StorageBackend } from "./interface.js";
 import type { CollectionFile, CollectionInfo, RegistryCollectionRef, RegistryFile, RegistryInfo } from "../types.js";
 export declare class GDriveBackend implements StorageBackend {
     private drive;
-    private oauth2;
     constructor(auth: OAuth2Client);
     getOwner(): Promise<string>;
     getOwnerEmail(): Promise<string>;
@@ -13,6 +12,7 @@ export declare class GDriveBackend implements StorageBackend {
     downloadSkill(collection: CollectionInfo, skillName: string, destDir: string): Promise<void>;
     private downloadFolder;
     createCollection(folderName: string): Promise<CollectionInfo>;
+    deleteCollection(collection: CollectionInfo): Promise<void>;
     uploadSkill(collection: CollectionInfo, localPath: string, skillName: string): Promise<void>;
     discoverRegistries(): Promise<Omit<RegistryInfo, "id">[]>;
     readRegistry(registry: RegistryInfo): Promise<RegistryFile>;

package/dist/backends/gdrive.js

@@ -7,14 +7,12 @@ import { randomUUID } from "crypto";
 const FOLDER_MIME = "application/vnd.google-apps.folder";
 export class GDriveBackend {
     drive;
-    oauth2;
     constructor(auth) {
         this.drive = google.drive({ version: "v3", auth });
-        this.oauth2 = google.oauth2({ version: "v2", auth });
     }
     async getOwner() {
-        const res = await this.oauth2.userinfo.get();
-        return res.data.email ?? "";
+        const res = await this.drive.about.get({ fields: "user(emailAddress)" });
+        return res.data.user?.emailAddress ?? "";
     }
     // Alias for backwards compat
     async getOwnerEmail() {
@@ -180,6 +178,13 @@ export class GDriveBackend {
             registryFileId: fileRes.data.id ?? undefined,
         };
     }
+    async deleteCollection(collection) {
+        // Trash the collection folder on Drive (moves to trash, not permanent delete)
+        await this.drive.files.update({
+            fileId: collection.folderId,
+            requestBody: { trashed: true },
+        });
+    }
     async uploadSkill(collection, localPath, skillName) {
         let folderId = await this.findFolder(skillName, collection.folderId);
         if (!folderId) {

package/dist/backends/github.d.ts

@@ -0,0 +1,26 @@
+import type { StorageBackend } from "./interface.js";
+import type { CollectionFile, CollectionInfo, RegistryCollectionRef, RegistryFile, RegistryInfo } from "../types.js";
+export declare class GithubBackend implements StorageBackend {
+    getOwner(): Promise<string>;
+    ensureRepo(repo: string): Promise<void>;
+    private ensureWorkdir;
+    private gitPushOrPR;
+    private commitAndPush;
+    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>;
+    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(name?: string, repoRef?: string): Promise<RegistryInfo>;
+    createCollection(collectionName: string, repoRef?: string): Promise<CollectionInfo>;
+    static detectRepoContext(absPath: string): {
+        repo: string;
+        repoRoot: string;
+        relPath: string;
+    } | null;
+}

package/dist/backends/github.js

@@ -0,0 +1,378 @@
+import fs from "fs";
+import path from "path";
+import { randomUUID } from "crypto";
+import { spawnSync } from "child_process";
+import chalk from "chalk";
+import { parseCollection, serializeCollection, parseRegistryFile, serializeRegistryFile, COLLECTION_FILENAME, REGISTRY_FILENAME, } from "../registry.js";
+import { CONFIG_DIR } from "../config.js";
+const GITHUB_WORKDIR = path.join(CONFIG_DIR, "github-workdir");
+const SKILLSMANAGER_DIR = ".skillsmanager";
+// ── folderId format: "owner/repo:.skillsmanager/collection-name" ──────────────
+function parseRef(folderId) {
+    const colonIdx = folderId.indexOf(":");
+    if (colonIdx === -1)
+        return { repo: folderId, metaDir: SKILLSMANAGER_DIR };
+    return {
+        repo: folderId.slice(0, colonIdx),
+        metaDir: folderId.slice(colonIdx + 1) || SKILLSMANAGER_DIR,
+    };
+}
+function workdirFor(repo) {
+    return path.join(GITHUB_WORKDIR, repo.replace("/", "_"));
+}
+// ── CLI helpers ───────────────────────────────────────────────────────────────
+function ghExec(args, opts) {
+    const r = spawnSync("gh", args, {
+        cwd: opts?.cwd,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    return {
+        ok: r.status === 0,
+        stdout: (r.stdout ?? "").trim(),
+        stderr: (r.stderr ?? "").trim(),
+    };
+}
+function gitExec(args, cwd) {
+    const r = spawnSync("git", args, { cwd, encoding: "utf-8", stdio: "pipe" });
+    return {
+        ok: r.status === 0,
+        stdout: (r.stdout ?? "").trim(),
+        stderr: (r.stderr ?? "").trim(),
+    };
+}
+function copyDirSync(src, dest) {
+    fs.mkdirSync(dest, { recursive: true });
+    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            copyDirSync(srcPath, destPath);
+        }
+        else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+// ── GithubBackend ─────────────────────────────────────────────────────────────
+export class GithubBackend {
+    // ── Identity ─────────────────────────────────────────────────────────────────
+    async getOwner() {
+        const r = ghExec(["api", "user", "--jq", ".login"]);
+        if (!r.ok || !r.stdout) {
+            throw new Error("GitHub auth failed. Run: skillsmanager setup github");
+        }
+        return r.stdout;
+    }
+    // ── Ensure repo exists (create private if not) ───────────────────────────────
+    async ensureRepo(repo) {
+        const check = ghExec(["api", `repos/${repo}`]);
+        if (!check.ok) {
+            console.log(chalk.dim(`  Repo ${repo} not found — creating private repo...`));
+            const name = repo.split("/")[1];
+            const create = ghExec(["repo", "create", name, "--private", "--confirm"]);
+            if (!create.ok)
+                throw new Error(`Failed to create repo ${repo}: ${create.stderr}`);
+            console.log(chalk.green(`  Created private repo: ${repo}`));
+        }
+    }
+    // ── Private: workdir management ───────────────────────────────────────────────
+    ensureWorkdir(repo) {
+        const dir = workdirFor(repo);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(path.dirname(dir), { recursive: true });
+            const r = spawnSync("gh", ["repo", "clone", repo, dir], { stdio: "inherit" });
+            if (r.status !== 0)
+                throw new Error(`Failed to clone ${repo}`);
+        }
+        else {
+            gitExec(["pull", "--ff-only"], dir);
+        }
+        return dir;
+    }
+    // ── Private: push with PR fallback ───────────────────────────────────────────
+    async gitPushOrPR(workdir, title) {
+        const pushResult = gitExec(["push", "origin", "HEAD"], workdir);
+        if (pushResult.ok)
+            return;
+        // Direct push blocked — create a PR
+        console.log(chalk.yellow("\n  Direct push blocked (branch protection). Creating a PR..."));
+        const branch = `skillsmanager-update-${Date.now()}`;
+        const checkout = gitExec(["checkout", "-b", branch], workdir);
+        if (!checkout.ok)
+            throw new Error(`Failed to create branch: ${checkout.stderr}`);
+        const pushBranch = gitExec(["push", "-u", "origin", branch], workdir);
+        if (!pushBranch.ok)
+            throw new Error(`Failed to push branch: ${pushBranch.stderr}`);
+        const prResult = ghExec(["pr", "create", "--title", title, "--body", "Created by skillsmanager", "--fill"], { cwd: workdir });
+        if (!prResult.ok)
+            throw new Error(`Failed to create PR: ${prResult.stderr}`);
+        const prUrl = prResult.stdout.split("\n").find((l) => l.startsWith("https://")) ?? prResult.stdout;
+        console.log(chalk.cyan(`\n  PR created: ${prUrl}`));
+        console.log(chalk.dim("  Waiting for merge (up to 5 minutes)..."));
+        const timeout = Date.now() + 5 * 60 * 1000;
+        let merged = false;
+        while (Date.now() < timeout) {
+            await new Promise((r) => setTimeout(r, 10_000));
+            const stateResult = ghExec(["pr", "view", prUrl, "--json", "state", "--jq", ".state"], { cwd: workdir });
+            if (stateResult.ok && stateResult.stdout.trim() === "MERGED") {
+                merged = true;
+                break;
+            }
+        }
+        if (!merged) {
+            console.log(chalk.yellow(`\n  PR not merged within timeout. Branch "${branch}" is still open.`));
+            console.log(chalk.dim("  Merge it manually, then run: skillsmanager refresh"));
+            return;
+        }
+        // Back to default branch, pull
+        const headRef = gitExec(["rev-parse", "--abbrev-ref", "origin/HEAD"], workdir);
+        const base = headRef.stdout.replace("origin/", "") || "main";
+        gitExec(["checkout", base], workdir);
+        gitExec(["pull", "--ff-only"], workdir);
+        console.log(chalk.green("  ✓ PR merged and changes pulled."));
+    }
+    async commitAndPush(workdir, message) {
+        const commit = gitExec(["commit", "-m", message], workdir);
+        const nothingToCommit = commit.stdout.includes("nothing to commit") ||
+            commit.stderr.includes("nothing to commit");
+        if (!commit.ok && nothingToCommit)
+            return;
+        if (!commit.ok)
+            throw new Error(`Git commit failed: ${commit.stderr || commit.stdout}`);
+        await this.gitPushOrPR(workdir, message);
+    }
+    // ── Collection operations ─────────────────────────────────────────────────────
+    async discoverCollections() {
+        const r = ghExec(["repo", "list", "--json", "nameWithOwner", "--limit", "100"]);
+        if (!r.ok)
+            return [];
+        let repos = [];
+        try {
+            repos = JSON.parse(r.stdout);
+        }
+        catch {
+            return [];
+        }
+        const collections = [];
+        for (const { nameWithOwner } of repos) {
+            const dirCheck = ghExec([
+                "api", `repos/${nameWithOwner}/contents/${SKILLSMANAGER_DIR}`,
+            ]);
+            if (!dirCheck.ok)
+                continue;
+            let entries = [];
+            try {
+                entries = JSON.parse(dirCheck.stdout);
+            }
+            catch {
+                continue;
+            }
+            for (const entry of entries) {
+                if (entry.type !== "dir")
+                    continue;
+                const fileCheck = ghExec([
+                    "api",
+                    `repos/${nameWithOwner}/contents/${SKILLSMANAGER_DIR}/${entry.name}/${COLLECTION_FILENAME}`,
+                ]);
+                if (!fileCheck.ok)
+                    continue;
+                collections.push({
+                    name: entry.name,
+                    backend: "github",
+                    folderId: `${nameWithOwner}:${SKILLSMANAGER_DIR}/${entry.name}`,
+                });
+            }
+        }
+        return collections;
+    }
+    async readCollection(collection) {
+        const { repo, metaDir } = parseRef(collection.folderId);
+        const r = ghExec([
+            "api", `repos/${repo}/contents/${metaDir}/${COLLECTION_FILENAME}`, "--jq", ".content",
+        ]);
+        if (!r.ok)
+            throw new Error(`Collection file not found in "${collection.name}"`);
+        const content = Buffer.from(r.stdout.replace(/\s/g, ""), "base64").toString("utf-8");
+        return parseCollection(content);
+    }
+    async writeCollection(collection, data) {
+        const { repo, metaDir } = parseRef(collection.folderId);
+        const workdir = this.ensureWorkdir(repo);
+        const filePath = path.join(workdir, metaDir, COLLECTION_FILENAME);
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, serializeCollection(data));
+        gitExec(["add", path.join(metaDir, COLLECTION_FILENAME)], workdir);
+        await this.commitAndPush(workdir, `chore: update ${COLLECTION_FILENAME} for ${collection.name}`);
+    }
+    async downloadSkill(collection, skillName, destDir) {
+        const { repo } = parseRef(collection.folderId);
+        const workdir = this.ensureWorkdir(repo);
+        // Refresh to get latest
+        gitExec(["pull", "--ff-only"], workdir);
+        const col = await this.readCollection(collection);
+        const entry = col.skills.find((s) => s.name === skillName);
+        if (!entry) {
+            throw new Error(`Skill "${skillName}" not found in collection "${collection.name}"`);
+        }
+        const skillPath = path.join(workdir, entry.path);
+        if (!fs.existsSync(skillPath)) {
+            throw new Error(`Skill directory not found at "${entry.path}" in repo "${repo}"`);
+        }
+        if (path.resolve(skillPath) !== path.resolve(destDir)) {
+            copyDirSync(skillPath, destDir);
+        }
+    }
+    async uploadSkill(collection, localPath, skillName) {
+        const { repo } = parseRef(collection.folderId);
+        const workdir = this.ensureWorkdir(repo);
+        const resolvedLocal = path.resolve(localPath);
+        const resolvedWorkdir = path.resolve(workdir);
+        if (resolvedLocal.startsWith(resolvedWorkdir + path.sep) ||
+            resolvedLocal === resolvedWorkdir) {
+            // Already in the repo — no copy needed
+            return;
+        }
+        // External skill: copy into .agentskills/<skillName>/ in the repo
+        const dest = path.join(workdir, ".agentskills", skillName);
+        copyDirSync(localPath, dest);
+        gitExec(["add", path.join(".agentskills", skillName)], workdir);
+        await this.commitAndPush(workdir, `chore: add skill ${skillName}`);
+    }
+    async deleteCollection(collection) {
+        const { repo, metaDir } = parseRef(collection.folderId);
+        const workdir = this.ensureWorkdir(repo);
+        const metaDirPath = path.join(workdir, metaDir);
+        if (!fs.existsSync(metaDirPath))
+            return;
+        fs.rmSync(metaDirPath, { recursive: true, force: true });
+        gitExec(["add", "-A"], workdir);
+        await this.commitAndPush(workdir, `chore: remove collection ${collection.name}`);
+    }
+    // ── Registry operations ───────────────────────────────────────────────────────
+    async discoverRegistries() {
+        const r = ghExec(["repo", "list", "--json", "nameWithOwner", "--limit", "100"]);
+        if (!r.ok)
+            return [];
+        let repos = [];
+        try {
+            repos = JSON.parse(r.stdout);
+        }
+        catch {
+            return [];
+        }
+        const registries = [];
+        for (const { nameWithOwner } of repos) {
+            const check = ghExec([
+                "api", `repos/${nameWithOwner}/contents/${SKILLSMANAGER_DIR}/${REGISTRY_FILENAME}`,
+            ]);
+            if (!check.ok)
+                continue;
+            registries.push({
+                name: nameWithOwner.split("/")[1] ?? nameWithOwner,
+                backend: "github",
+                folderId: `${nameWithOwner}:${SKILLSMANAGER_DIR}`,
+                fileId: `${nameWithOwner}:${SKILLSMANAGER_DIR}/${REGISTRY_FILENAME}`,
+            });
+        }
+        return registries;
+    }
+    async readRegistry(registry) {
+        const { repo, metaDir } = parseRef(registry.folderId);
+        const r = ghExec([
+            "api", `repos/${repo}/contents/${metaDir}/${REGISTRY_FILENAME}`, "--jq", ".content",
+        ]);
+        if (!r.ok)
+            throw new Error(`Registry file not found for "${registry.name}"`);
+        const content = Buffer.from(r.stdout.replace(/\s/g, ""), "base64").toString("utf-8");
+        return parseRegistryFile(content);
+    }
+    async writeRegistry(registry, data) {
+        const { repo, metaDir } = parseRef(registry.folderId);
+        const workdir = this.ensureWorkdir(repo);
+        const filePath = path.join(workdir, metaDir, REGISTRY_FILENAME);
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, serializeRegistryFile(data));
+        gitExec(["add", path.join(metaDir, REGISTRY_FILENAME)], workdir);
+        await this.commitAndPush(workdir, `chore: update ${REGISTRY_FILENAME}`);
+    }
+    async resolveCollectionRef(ref) {
+        if (ref.backend !== "github")
+            return null;
+        const { repo, metaDir } = parseRef(ref.ref);
+        const check = ghExec(["api", `repos/${repo}/contents/${metaDir}/${COLLECTION_FILENAME}`]);
+        if (!check.ok)
+            return null;
+        return { name: ref.name, backend: "github", folderId: ref.ref };
+    }
+    async createRegistry(name, repoRef) {
+        if (!repoRef)
+            throw new Error("GitHub backend requires --repo <owner/repo>");
+        await this.ensureRepo(repoRef);
+        const workdir = this.ensureWorkdir(repoRef);
+        const metaDir = SKILLSMANAGER_DIR;
+        const filePath = path.join(workdir, metaDir, REGISTRY_FILENAME);
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        const owner = await this.getOwner();
+        const registryData = {
+            name: name ?? (repoRef.split("/")[1] ?? "default"),
+            owner,
+            source: "github",
+            collections: [],
+        };
+        fs.writeFileSync(filePath, serializeRegistryFile(registryData));
+        gitExec(["add", path.join(metaDir, REGISTRY_FILENAME)], workdir);
+        await this.commitAndPush(workdir, "chore: init SKILLS_REGISTRY");
+        return {
+            id: randomUUID(),
+            name: registryData.name,
+            backend: "github",
+            folderId: `${repoRef}:${metaDir}`,
+            fileId: `${repoRef}:${metaDir}/${REGISTRY_FILENAME}`,
+        };
+    }
+    // ── createCollection ─────────────────────────────────────────────────────────
+    async createCollection(collectionName, repoRef) {
+        if (!repoRef)
+            throw new Error("GitHub backend requires --repo <owner/repo>");
+        const repo = repoRef;
+        await this.ensureRepo(repo);
+        const workdir = this.ensureWorkdir(repo);
+        const metaDir = `${SKILLSMANAGER_DIR}/${collectionName}`;
+        const filePath = path.join(workdir, metaDir, COLLECTION_FILENAME);
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        const owner = await this.getOwner();
+        const colData = { name: collectionName, owner, skills: [] };
+        fs.writeFileSync(filePath, serializeCollection(colData));
+        gitExec(["add", path.join(metaDir, COLLECTION_FILENAME)], workdir);
+        await this.commitAndPush(workdir, `chore: init collection ${collectionName}`);
+        return {
+            id: randomUUID(),
+            name: collectionName,
+            backend: "github",
+            folderId: `${repo}:${metaDir}`,
+        };
+    }
+    // ── Static: detect if a path is inside a GitHub-tracked git repo ──────────────
+    static detectRepoContext(absPath) {
+        const rootResult = spawnSync("git", ["-C", absPath, "rev-parse", "--show-toplevel"], {
+            encoding: "utf-8", stdio: "pipe",
+        });
+        if (rootResult.status !== 0)
+            return null;
+        const repoRoot = rootResult.stdout.trim();
+        const remoteResult = spawnSync("git", ["-C", repoRoot, "remote", "get-url", "origin"], {
+            encoding: "utf-8", stdio: "pipe",
+        });
+        if (remoteResult.status !== 0)
+            return null;
+        const remoteUrl = remoteResult.stdout.trim();
+        const match = remoteUrl.match(/github\.com[/:]([^/]+\/[^/]+?)(?:\.git)?$/) ??
+            remoteUrl.match(/github\.com\/([^/]+\/[^/]+)/);
+        if (!match)
+            return null;
+        const repo = match[1].replace(/\.git$/, "");
+        const relPath = path.relative(repoRoot, absPath).replace(/\\/g, "/");
+        return { repo, repoRoot, relPath };
+    }
+}

package/dist/backends/interface.d.ts

@@ -6,6 +6,7 @@ export interface StorageBackend {
     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>;
+    deleteCollection(collection: CollectionInfo): Promise<void>;
     discoverRegistries(): Promise<Omit<RegistryInfo, "id">[]>;
     readRegistry(registry: RegistryInfo): Promise<RegistryFile>;
     writeRegistry(registry: RegistryInfo, data: RegistryFile): Promise<void>;

package/dist/backends/local.d.ts

@@ -11,6 +11,7 @@ export declare class LocalBackend implements StorageBackend {
     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>;
+    deleteCollection(collection: CollectionInfo): Promise<void>;
     discoverRegistries(): Promise<Omit<RegistryInfo, "id">[]>;
     readRegistry(registry: RegistryInfo): Promise<RegistryFile>;
     writeRegistry(registry: RegistryInfo, data: RegistryFile): Promise<void>;

package/dist/backends/local.js

@@ -73,6 +73,11 @@ export class LocalBackend {
             return;
         copyDirSync(localPath, dest);
     }
+    async deleteCollection(collection) {
+        if (fs.existsSync(collection.folderId)) {
+            fs.rmSync(collection.folderId, { recursive: true, force: true });
+        }
+    }
     // ── Registry operations ──────────────────────────────────────────────────
     async discoverRegistries() {
         if (!fs.existsSync(LOCAL_REGISTRY_PATH))

package/dist/backends/resolve.d.ts

@@ -0,0 +1,2 @@
+import type { StorageBackend } from "./interface.js";
+export declare function resolveBackend(backendName: string): Promise<StorageBackend>;

package/dist/backends/resolve.js

@@ -0,0 +1,11 @@
+import { ensureAuth } from "../auth.js";
+import { GDriveBackend } from "./gdrive.js";
+import { GithubBackend } from "./github.js";
+import { LocalBackend } from "./local.js";
+export async function resolveBackend(backendName) {
+    if (backendName === "gdrive")
+        return new GDriveBackend(await ensureAuth());
+    if (backendName === "github")
+        return new GithubBackend();
+    return new LocalBackend();
+}