@skillsmanager/cli 0.0.4 → 0.0.6

package/LICENSE

@@ -1,21 +1,13 @@
-MIT License
+Copyright 2026 Ajay Prakash
 
-Copyright (c) 2026 Ajay Prakash
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+    http://www.apache.org/licenses/LICENSE-2.0
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -1,58 +1,110 @@
-# Skills Manager
+[![npm](https://img.shields.io/npm/v/%40skillsmanager%2Fcli)](https://www.npmjs.com/package/@skillsmanager/cli)
+[![License: Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)
+[![Node >=18](https://img.shields.io/badge/node-%3E%3D18-brightgreen)](https://nodejs.org)
+[![CI](https://github.com/talktoajayprakash/skillsmanager/actions/workflows/release.yml/badge.svg)](https://github.com/talktoajayprakash/skillsmanager/actions)
+[![Docs](https://img.shields.io/badge/docs-skillsmanager-blue)](https://talktoajayprakash.github.io/skillsmanager)
 
-A CLI for AI agents to discover, fetch, and share agent skills stored in Google Drive.
+# Skills Manager CLI
 
-## What is it?
+**One place to manage, sync, and share all your AI agent skills — across every agent you use.**
 
-Skills Manager lets you maintain a personal library of agent skills in Google Drive and install them into any supported AI agent (Claude, Cursor, Windsurf, Copilot, etc.) with a single command.
+You build skills for your AI agents, but keeping track of them is a mess. They're scattered across GitHub repos, local folders, and machines. Each agent has its own directory. Nothing is searchable. Nothing is shared.
 
-Skills are downloaded to a local cache (`~/.skillsmanager/cache/`) and symlinked into the agent's skills directory. No duplication — one copy, many agents.
+Skills Manager fixes this. It gives every skill a home — in Google Drive, GitHub, or any storage backend you choose — and makes them instantly available to any agent via a single CLI command. Your agents can search, fetch, and use any skill regardless of where it lives.
 
-## Supported agents
+Build skills confidently, store them where you want, and sync them across every device and agent you work with — Claude, Cursor, OpenAI Codex, OpenClaw, and beyond.
 
-`claude`, `codex`, `cursor`, `windsurf`, `copilot`, `gemini`, `roo`, `agents`
+## Why Skills Manager?
 
-## Installation
+- **Unified skill library** — one searchable index across all your skills, wherever they're stored
+- **Cross-agent** — install any skill into Claude, Cursor, Windsurf, Copilot, Gemini, and more
+- **Backend-agnostic** — store in Google Drive, GitHub, Dropbox, AWS S3, or local filesystem
+- **Sync across devices** — skills follow you, not your machine
+- **No duplication** — cached once locally, symlinked into each agent's directory
+- **Git-friendly** — plain Markdown files, easy to version-control and review
+
+## Supported Agents
+
+`claude` · `codex` · `cursor` · `windsurf` · `copilot` · `gemini` · `roo` · `openclaw` · `agents`
+
+> **OpenClaw users:** OpenClaw's skill system uses the same `SKILL.md` format and directory-based loading that Skills Manager is built around. Your OpenClaw skills are first-class citizens — store them in any backend, search them, and sync them across devices just like any other skill.
+>
+> Any agent that reads from a skills directory works with Skills Manager. If your agent can read a file, it can use your skills.
+
+## Quick Start
+
+### 1. Install
 
 ```bash
-npm install -g skillsmanager
+npm install -g @skillsmanager/cli
 ```
 
-## Google Drive setup
+### 2. Install the skillsmanager skill (lets your agent drive Skills Manager)
+
+```bash
+skillsmanager install
+```
+
+This installs the bundled `skillsmanager` skill into all detected agents so your AI assistant can manage skills on your behalf.
+
+### 3. One-time Google Drive setup
+
+Skills Manager uses Google Drive as a remote registry. To connect it:
 
-1. Go to [Google Cloud Console](https://console.cloud.google.com/)
-2. Create a project → enable the **Google Drive API**
-3. Create OAuth 2.0 credentials (Desktop app)
+1. Go to [Google Cloud Console](https://console.cloud.google.com/) and create a project
+2. Enable the **Google Drive API** for that project
+3. Create **OAuth 2.0 credentials** (Desktop app type)
 4. Download `credentials.json` and save it to `~/.skillsmanager/credentials.json`
 
-## Usage
+Then authenticate and discover your registries:
 
 ```bash
-# Authenticate and discover registries
-skillsmanager init
+skillsmanager setup google   # walks you through OAuth
+skillsmanager refresh        # discovers collections in your Drive
+```
 
-# List all available skills
-skillsmanager list
+## Commands
+
+| Command | Description |
+|---|---|
+| `skillsmanager install` | Install the skillsmanager skill to all agents |
+| `skillsmanager list` | List all available skills |
+| `skillsmanager search <query>` | Search skills by name or description |
+| `skillsmanager fetch <name> --agent <agent>` | Download and install a skill for an agent |
+| `skillsmanager add <path>` | Upload a local skill to a collection |
+| `skillsmanager add --remote-path <path> --name <n> --description <d>` | Register a remote skill path (no upload) |
+| `skillsmanager update <path>` | Push local changes back to remote storage |
+| `skillsmanager refresh` | Re-discover collections from remote |
+| `skillsmanager collection create [name] --backend github --repo <owner/repo>` | Create a collection in a GitHub repo |
+| `skillsmanager collection create [name] --skills-repo <owner/repo>` | Create a collection with skills in a separate GitHub repo |
+| `skillsmanager registry push --backend gdrive` | Push local registry to Google Drive |
+| `skillsmanager registry push --backend github --repo <owner/repo>` | Push local registry to GitHub |
+
+## Local Development
 
-# Search skills by name or description
-skillsmanager search <query>
+```bash
+git clone https://github.com/talktoajayprakash/skillsmanager.git
+cd skillsmanager
+npm install
+npm run build       # compiles TypeScript to dist/
+npm link            # makes `skillsmanager` available globally from source
+```
 
-# Download a skill and install it for an agent
-skillsmanager fetch <skill-name> --agent claude
+Run tests:
 
-# Add a local skill to your registry
-skillsmanager add ./my-skill
+```bash
+npm test
+```
 
-# Push local changes to an existing skill back to Drive
-skillsmanager update <skill-name>
+To run without installing globally:
 
-# Re-scan Drive for new registries
-skillsmanager refresh
+```bash
+node dist/index.js <command>
 ```
 
 ## Registry format
 
-Skills are indexed by a `SKILLS_SYNC.yaml` file inside any Google Drive folder you own:
+Skills are indexed by a `SKILLS_REGISTRY.yaml` file inside any Google Drive folder you own:
 
 ```yaml
 name: my-skills
@@ -61,12 +113,9 @@ skills:
   - name: code-review
     path: code-review/
     description: Reviews code for bugs, style, and security issues
-  - name: write-tests
-    path: write-tests/
-    description: Generates unit tests for a given function or module
 ```
 
-Each skill is a directory containing a `SKILL.md` file with YAML frontmatter:
+Each skill is a directory with a `SKILL.md` file:
 
 ```markdown
 ---
@@ -77,8 +126,16 @@ description: Reviews code for bugs, style, and security issues
 ... skill instructions ...
 ```
 
-Skills Manager auto-discovers any `SKILLS_SYNC.yaml` file owned by your Google account, so registries are found automatically on `skillsmanager init` or `skillsmanager refresh`.
+Skills Manager auto-discovers any `SKILLS_REGISTRY.yaml` in your Google account on `refresh`.
+
+## Contributing
+
+See [CONTRIBUTING.md](./CONTRIBUTING.md) — PRs welcome.
+
+## Security
+
+See [SECURITY.md](./SECURITY.md) for how to report vulnerabilities.
 
-## Design doc
+## License
 
-See [WRITEUP.md](./WRITEUP.md) for the full design.
+[Apache 2.0](LICENSE)

package/dist/auth.d.ts

@@ -1,5 +1,6 @@
 import type { OAuth2Client } from "google-auth-library";
 export declare function runAuthFlow(): Promise<OAuth2Client>;
+export declare function getAuthedEmail(client: OAuth2Client): Promise<string | null>;
 export declare function getAuthClient(): OAuth2Client;
 export declare function hasToken(): boolean;
 export declare function ensureAuth(): Promise<OAuth2Client>;

package/dist/auth.js

@@ -2,7 +2,11 @@ import fs from "fs";
 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 SCOPES = [
+    "https://www.googleapis.com/auth/drive",
+    "openid",
+    "https://www.googleapis.com/auth/userinfo.email",
+];
 const LOOPBACK_PORT = 3847;
 const REDIRECT_URI = `http://localhost:${LOOPBACK_PORT}`;
 function createOAuth2Client() {
@@ -26,6 +30,8 @@ function waitForAuthCode() {
             if (error) {
                 res.writeHead(200, { "Content-Type": "text/html" });
                 res.end("<h2>Authorization failed.</h2><p>You can close this tab.</p>");
+                res.socket?.destroy();
+                server.closeAllConnections?.();
                 server.close();
                 reject(new Error(`OAuth error: ${error}`));
                 return;
@@ -33,6 +39,8 @@ function waitForAuthCode() {
             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>");
+                res.socket?.destroy();
+                server.closeAllConnections?.();
                 server.close();
                 resolve(code);
             }
@@ -59,9 +67,18 @@ export async function runAuthFlow() {
     const { tokens } = await client.getToken(code);
     client.setCredentials(tokens);
     saveToken(client);
-    console.log("Authorization successful.");
     return client;
 }
+export async function getAuthedEmail(client) {
+    try {
+        const oauth2 = google.oauth2({ version: "v2", auth: client });
+        const res = await oauth2.userinfo.get();
+        return res.data.email ?? null;
+    }
+    catch {
+        return null;
+    }
+}
 export function getAuthClient() {
     if (!fs.existsSync(TOKEN_PATH)) {
         throw new Error(`Not authenticated. Run "skillsmanager init" first.`);

package/dist/backends/gdrive.d.ts

@@ -1,24 +1,26 @@
 import type { OAuth2Client } from "google-auth-library";
-import type { StorageBackend } from "./interface.js";
+import type { BackendStatus, CreateRegistryOptions, StorageBackend } from "./interface.js";
 import type { CollectionFile, CollectionInfo, RegistryCollectionRef, RegistryFile, RegistryInfo } from "../types.js";
 export declare class GDriveBackend implements StorageBackend {
     private drive;
     constructor(auth: OAuth2Client);
     getOwner(): Promise<string>;
     getOwnerEmail(): 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>;
     private downloadFolder;
-    createCollection(folderName: string): Promise<CollectionInfo>;
+    createCollection({ name, skillsRepo }: import("./interface.js").CreateCollectionOptions): Promise<CollectionInfo>;
     deleteCollection(collection: CollectionInfo): Promise<void>;
-    uploadSkill(collection: CollectionInfo, localPath: string, skillName: string): Promise<void>;
+    deleteSkill(collection: CollectionInfo, skillName: string): Promise<void>;
+    uploadSkill(collection: CollectionInfo, localPath: string, skillName: string): Promise<string>;
     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>;
     private findFolder;
     private uploadFolder;
 }

package/dist/backends/gdrive.js

@@ -18,6 +18,14 @@ export class GDriveBackend {
     async getOwnerEmail() {
         return this.getOwner();
     }
+    async getStatus() {
+        try {
+            return { loggedIn: true, identity: await this.getOwner() };
+        }
+        catch {
+            return { loggedIn: false, identity: "", hint: "run: skillsmanager setup google" };
+        }
+    }
     // ── Collection operations ────────────────────────────────────────────────
     async discoverCollections() {
         const collections = [];
@@ -149,30 +157,28 @@ export class GDriveBackend {
             }
         } while (pageToken);
     }
-    async createCollection(folderName) {
+    async createCollection({ name, skillsRepo }) {
+        const folderName = `SKILLS_${name.toUpperCase()}`;
         const folderRes = await this.drive.files.create({
-            requestBody: {
-                name: folderName,
-                mimeType: FOLDER_MIME,
-            },
+            requestBody: { name: folderName, mimeType: FOLDER_MIME },
             fields: "id, name",
         });
         const folderId = folderRes.data.id;
         const owner = await this.getOwnerEmail();
-        const logicalName = folderName.replace(/^SKILLS_/i, "");
-        const emptyCollection = { name: logicalName, owner, skills: [] };
+        const emptyCollection = { name, owner, skills: [] };
+        if (skillsRepo) {
+            emptyCollection.type = "github";
+            emptyCollection.metadata = { repo: skillsRepo };
+        }
         const content = serializeCollection(emptyCollection);
         const fileRes = await this.drive.files.create({
-            requestBody: {
-                name: COLLECTION_FILENAME,
-                parents: [folderId],
-            },
+            requestBody: { name: COLLECTION_FILENAME, parents: [folderId] },
             media: { mimeType: "text/yaml", body: Readable.from(content) },
             fields: "id",
         });
         return {
             id: randomUUID(),
-            name: logicalName,
+            name,
             backend: "gdrive",
             folderId,
             registryFileId: fileRes.data.id ?? undefined,
@@ -185,6 +191,12 @@ export class GDriveBackend {
             requestBody: { trashed: true },
         });
     }
+    async deleteSkill(collection, skillName) {
+        const folderId = await this.findFolder(skillName, collection.folderId);
+        if (folderId) {
+            await this.drive.files.update({ fileId: folderId, requestBody: { trashed: true } });
+        }
+    }
     async uploadSkill(collection, localPath, skillName) {
         let folderId = await this.findFolder(skillName, collection.folderId);
         if (!folderId) {
@@ -199,6 +211,7 @@ export class GDriveBackend {
             folderId = res.data.id;
         }
         await this.uploadFolder(localPath, folderId);
+        return `${skillName}/`;
     }
     // ── Registry operations ──────────────────────────────────────────────────
     async discoverRegistries() {
@@ -292,7 +305,8 @@ export class GDriveBackend {
         }
         return null;
     }
-    async createRegistry(name) {
+    async createRegistry(options) {
+        const name = options?.name;
         const folderName = name ? `SKILLS_REGISTRY_${name}` : "SKILLS_REGISTRY";
         const folderRes = await this.drive.files.create({
             requestBody: { name: folderName, mimeType: FOLDER_MIME },

package/dist/backends/github.d.ts

@@ -1,7 +1,8 @@
-import type { StorageBackend } from "./interface.js";
+import type { BackendStatus, CreateRegistryOptions, StorageBackend } from "./interface.js";
 import type { CollectionFile, CollectionInfo, RegistryCollectionRef, RegistryFile, RegistryInfo } from "../types.js";
 export declare class GithubBackend implements StorageBackend {
     getOwner(): Promise<string>;
+    getStatus(): Promise<BackendStatus>;
     ensureRepo(repo: string): Promise<void>;
     private ensureWorkdir;
     private gitPushOrPR;
@@ -9,18 +10,18 @@ export declare class GithubBackend implements StorageBackend {
     discoverCollections(): Promise<Omit<CollectionInfo, "id">[]>;
     readCollection(collection: CollectionInfo): Promise<CollectionFile>;
     writeCollection(collection: CollectionInfo, data: CollectionFile): Promise<void>;
+    /** Clone/pull repo and copy relPath to destDir. Usable by other backends for cross-backend routing. */
+    downloadSkillFromRepo(repo: string, relPath: string, destDir: string): Promise<void>;
+    /** Clone/pull repo and delete relPath. Usable by other backends for cross-backend routing. */
+    deleteSkillFromRepo(repo: string, relPath: string): 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, repoRef?: string): Promise<RegistryInfo>;
-    createCollection(collectionName: string, repoRef?: string): Promise<CollectionInfo>;
-    static detectRepoContext(absPath: string): {
-        repo: string;
-        repoRoot: string;
-        relPath: string;
-    } | null;
+    createRegistry(options?: CreateRegistryOptions): Promise<RegistryInfo>;
+    createCollection({ name, repo, skillsRepo }: import("./interface.js").CreateCollectionOptions): Promise<CollectionInfo>;
 }

package/dist/backends/github.js

@@ -3,6 +3,7 @@ import path from "path";
 import { randomUUID } from "crypto";
 import { spawnSync } from "child_process";
 import chalk from "chalk";
+import { ghInstalled, ghAuthed, ghGetLogin } from "../commands/setup/github.js";
 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");
@@ -20,6 +21,13 @@ function parseRef(folderId) {
 function workdirFor(repo) {
     return path.join(GITHUB_WORKDIR, repo.replace("/", "_"));
 }
+/** Returns the repo where skill files live — respects col.type + metadata.repo; defaults to host repo. */
+function skillsRepo(col, hostRepo) {
+    if (col.type === "github" || col.type === undefined) {
+        return col.metadata?.repo ?? hostRepo;
+    }
+    return hostRepo;
+}
 // ── CLI helpers ───────────────────────────────────────────────────────────────
 function ghExec(args, opts) {
     const r = spawnSync("gh", args, {
@@ -64,6 +72,13 @@ export class GithubBackend {
         }
         return r.stdout;
     }
+    async getStatus() {
+        if (!ghInstalled())
+            return { loggedIn: false, identity: "", hint: "install gh CLI first" };
+        if (!ghAuthed())
+            return { loggedIn: false, identity: "", hint: "run: skillsmanager setup github" };
+        return { loggedIn: true, identity: ghGetLogin() };
+    }
     // ── Ensure repo exists (create private if not) ───────────────────────────────
     async ensureRepo(repo) {
         const check = ghExec(["api", `repos/${repo}`]);
@@ -205,39 +220,55 @@ export class GithubBackend {
         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);
+    /** Clone/pull repo and copy relPath to destDir. Usable by other backends for cross-backend routing. */
+    async downloadSkillFromRepo(repo, relPath, destDir) {
         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);
+        const skillPath = path.join(workdir, relPath);
         if (!fs.existsSync(skillPath)) {
-            throw new Error(`Skill directory not found at "${entry.path}" in repo "${repo}"`);
+            throw new Error(`Skill directory not found at "${relPath}" in repo "${repo}"`);
         }
         if (path.resolve(skillPath) !== path.resolve(destDir)) {
             copyDirSync(skillPath, destDir);
         }
     }
-    async uploadSkill(collection, localPath, skillName) {
-        const { repo } = parseRef(collection.folderId);
+    /** Clone/pull repo and delete relPath. Usable by other backends for cross-backend routing. */
+    async deleteSkillFromRepo(repo, relPath) {
         const workdir = this.ensureWorkdir(repo);
+        gitExec(["pull", "--ff-only"], workdir);
+        const skillPath = path.join(workdir, relPath);
+        if (!fs.existsSync(skillPath))
+            return;
+        fs.rmSync(skillPath, { recursive: true, force: true });
+        gitExec(["add", "-A"], workdir);
+        await this.commitAndPush(workdir, `chore: remove skill at ${relPath}`);
+    }
+    async downloadSkill(collection, skillName, destDir) {
+        const { repo: hostRepo } = parseRef(collection.folderId);
+        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 srcRepo = skillsRepo(col, hostRepo);
+        await this.downloadSkillFromRepo(srcRepo, entry.path, destDir);
+    }
+    async uploadSkill(collection, localPath, skillName) {
+        const { repo: hostRepo } = parseRef(collection.folderId);
+        const workdir = this.ensureWorkdir(hostRepo);
         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;
+            // Already in the repo — no copy needed; return relative path from workdir
+            return path.relative(workdir, resolvedLocal).replace(/\\/g, "/");
         }
         // 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}`);
+        return `.agentskills/${skillName}`;
     }
     async deleteCollection(collection) {
         const { repo, metaDir } = parseRef(collection.folderId);
@@ -249,6 +280,15 @@ export class GithubBackend {
         gitExec(["add", "-A"], workdir);
         await this.commitAndPush(workdir, `chore: remove collection ${collection.name}`);
     }
+    async deleteSkill(collection, skillName) {
+        const { repo: hostRepo } = parseRef(collection.folderId);
+        const col = await this.readCollection(collection);
+        const entry = col.skills.find((s) => s.name === skillName);
+        if (!entry)
+            return;
+        const srcRepo = skillsRepo(col, hostRepo);
+        await this.deleteSkillFromRepo(srcRepo, entry.path);
+    }
     // ── Registry operations ───────────────────────────────────────────────────────
     async discoverRegistries() {
         const r = ghExec(["repo", "list", "--json", "nameWithOwner", "--limit", "100"]);
@@ -305,17 +345,18 @@ export class GithubBackend {
             return null;
         return { name: ref.name, backend: "github", folderId: ref.ref };
     }
-    async createRegistry(name, repoRef) {
-        if (!repoRef)
+    async createRegistry(options) {
+        const { name, repo } = options ?? {};
+        if (!repo)
             throw new Error("GitHub backend requires --repo <owner/repo>");
-        await this.ensureRepo(repoRef);
-        const workdir = this.ensureWorkdir(repoRef);
+        await this.ensureRepo(repo);
+        const workdir = this.ensureWorkdir(repo);
         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"),
+            name: name ?? (repo.split("/")[1] ?? "default"),
             owner,
             source: "github",
             collections: [],
@@ -327,52 +368,32 @@ export class GithubBackend {
             id: randomUUID(),
             name: registryData.name,
             backend: "github",
-            folderId: `${repoRef}:${metaDir}`,
-            fileId: `${repoRef}:${metaDir}/${REGISTRY_FILENAME}`,
+            folderId: `${repo}:${metaDir}`,
+            fileId: `${repo}:${metaDir}/${REGISTRY_FILENAME}`,
         };
     }
     // ── createCollection ─────────────────────────────────────────────────────────
-    async createCollection(collectionName, repoRef) {
-        if (!repoRef)
+    async createCollection({ name, repo, skillsRepo }) {
+        if (!repo)
             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 metaDir = `${SKILLSMANAGER_DIR}/${name}`;
         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: [] };
+        const colData = { name, owner, skills: [] };
+        if (skillsRepo && skillsRepo !== repo) {
+            colData.metadata = { repo: skillsRepo };
+        }
         fs.writeFileSync(filePath, serializeCollection(colData));
         gitExec(["add", path.join(metaDir, COLLECTION_FILENAME)], workdir);
-        await this.commitAndPush(workdir, `chore: init collection ${collectionName}`);
+        await this.commitAndPush(workdir, `chore: init collection ${name}`);
         return {
             id: randomUUID(),
-            name: collectionName,
+            name,
             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 };
-    }
 }