@skillsmanager/cli 0.0.4 → 0.0.6

package/dist/commands/skill.js

@@ -0,0 +1,76 @@
+import chalk from "chalk";
+import ora from "ora";
+import fs from "fs";
+import path from "path";
+import { readConfig, writeConfig, CACHE_DIR } from "../config.js";
+import { resolveBackend } from "../backends/resolve.js";
+export async function skillDeleteCommand(skillName, options) {
+    let config;
+    try {
+        config = readConfig();
+    }
+    catch {
+        console.log(chalk.red("No config found. Run `skillsmanager refresh` first."));
+        return;
+    }
+    // Resolve which collection to target
+    let collection = config.collections.find((c) => c.name === options.collection);
+    if (options.collection && !collection) {
+        console.log(chalk.red(`Collection "${options.collection}" not found.`));
+        return;
+    }
+    if (!collection) {
+        const locations = config.skills[skillName] ?? [];
+        if (locations.length === 0) {
+            console.log(chalk.red(`Skill "${skillName}" not found in any collection.`));
+            return;
+        }
+        if (locations.length > 1) {
+            const names = locations
+                .map((l) => config.collections.find((c) => c.id === l.collectionId)?.name ?? l.collectionId)
+                .join(", ");
+            console.log(chalk.red(`Skill "${skillName}" exists in multiple collections: ${names}`));
+            console.log(chalk.dim(`  Use --collection <name> to specify which one.`));
+            return;
+        }
+        collection = config.collections.find((c) => c.id === locations[0].collectionId);
+        if (!collection) {
+            console.log(chalk.red(`Collection for skill "${skillName}" not found in config.`));
+            return;
+        }
+    }
+    const backend = await resolveBackend(collection.backend);
+    // Delete from backend storage
+    const spinner = ora(`Deleting skill "${skillName}" from ${collection.backend}...`).start();
+    try {
+        await backend.deleteSkill(collection, skillName);
+        spinner.succeed(`Deleted "${skillName}" from ${collection.backend}`);
+    }
+    catch (err) {
+        spinner.fail(`Failed to delete from backend: ${err.message}`);
+        return;
+    }
+    // Remove from collection YAML
+    try {
+        const col = await backend.readCollection(collection);
+        col.skills = col.skills.filter((s) => s.name !== skillName);
+        await backend.writeCollection(collection, col);
+    }
+    catch {
+        // Non-fatal: backend data already removed
+    }
+    // Clean up local cache
+    const cachePath = path.join(CACHE_DIR, collection.id, skillName);
+    if (fs.existsSync(cachePath)) {
+        fs.rmSync(cachePath, { recursive: true, force: true });
+    }
+    // Update config skills index
+    if (config.skills[skillName]) {
+        config.skills[skillName] = config.skills[skillName].filter((l) => l.collectionId !== collection.id);
+        if (config.skills[skillName].length === 0) {
+            delete config.skills[skillName];
+        }
+    }
+    writeConfig(config);
+    console.log(chalk.green(`\n  ✓ Skill "${skillName}" removed from collection "${collection.name}".\n`));
+}

package/dist/commands/status.d.ts

@@ -0,0 +1 @@
+export declare function statusCommand(): Promise<void>;

package/dist/commands/status.js

@@ -0,0 +1,35 @@
+import chalk from "chalk";
+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 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)) + "  " +
+        chalk.bold("Status".padEnd(col2)) + "  " +
+        chalk.bold("Identity");
+    const divider = "─".repeat(col1) + "  " + "─".repeat(col2) + "  " + "─".repeat(30);
+    console.log();
+    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(statusLabel)
+            : chalk.red(statusLabel);
+        const identity = row.loggedIn
+            ? chalk.white(row.identity)
+            : chalk.dim(row.hint ?? "");
+        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

package/dist/index.js

@@ -14,8 +14,11 @@ import { updateCommand } from "./commands/update.js";
 import { refreshCommand } from "./commands/refresh.js";
 import { setupGoogleCommand } from "./commands/setup/google.js";
 import { setupGithubCommand } from "./commands/setup/github.js";
+import { logoutGoogleCommand, logoutGithubCommand } from "./commands/logout.js";
 import { collectionCreateCommand } from "./commands/collection.js";
+import { skillDeleteCommand } from "./commands/skill.js";
 import { installCommand, uninstallCommand } from "./commands/install.js";
+import { statusCommand } from "./commands/status.js";
 import { registryCreateCommand, registryListCommand, registryDiscoverCommand, registryAddCollectionCommand, registryRemoveCollectionCommand, registryPushCommand, } from "./commands/registry.js";
 const supportedAgents = Object.keys(AGENT_PATHS).join(", ");
 // Read the bundled SKILL.md as the CLI help — single source of truth
@@ -44,7 +47,24 @@ setup
     .command("github")
     .description("One-time GitHub setup — checks gh CLI and runs gh auth login")
     .action(setupGithubCommand);
+// ── Logout ───────────────────────────────────────────────────────────────────
+const logout = program
+    .command("logout")
+    .description("Log out of a storage backend");
+logout
+    .command("google")
+    .description("Clear Google OAuth session (and optionally credentials)")
+    .option("--all", "Also remove credentials.json to start setup from scratch")
+    .action((options) => logoutGoogleCommand(options));
+logout
+    .command("github")
+    .description("Log out of GitHub (runs gh auth logout)")
+    .action(logoutGithubCommand);
 // ── Core commands ────────────────────────────────────────────────────────────
+program
+    .command("status")
+    .description("Show login status and identity for each backend")
+    .action(statusCommand);
 program
     .command("init")
     .description("Authenticate and discover collections (runs automatically when needed)")
@@ -64,10 +84,13 @@ program
     .option("--scope <scope>", "global (~/.agent/skills/) or project (./.agent/skills/)", "global")
     .action((names, options) => fetchCommand(names, options));
 program
-    .command("add <path>")
-    .description("Upload a local skill directory to a collection")
+    .command("add [path]")
+    .description("Upload a local skill directory to a collection, or register a remote path")
     .option("--collection <name>", "Target collection (default: first available)")
-    .action((skillPath, options) => addCommand(skillPath, options));
+    .option("--remote-path <rel/path>", "Register a skill path from the collection's skills-source repo (no local files needed)")
+    .option("--name <name>", "Skill name (required with --remote-path)")
+    .option("--description <desc>", "Skill description (used with --remote-path)")
+    .action((skillPath, options) => addCommand(skillPath ?? "", options));
 program
     .command("update <path>")
     .description("Push local edits to a skill back to storage and refresh cache")
@@ -77,6 +100,15 @@ program
     .command("refresh")
     .description("Re-discover collections from storage")
     .action(refreshCommand);
+// ── Skill ────────────────────────────────────────────────────────────────────
+const skill = program
+    .command("skill")
+    .description("Manage individual skills");
+skill
+    .command("delete <name>")
+    .description("Delete a single skill from a collection")
+    .option("--collection <name>", "Collection to delete from (required if skill is in multiple)")
+    .action((name, options) => skillDeleteCommand(name, options));
 // ── Collection ───────────────────────────────────────────────────────────────
 const collection = program
     .command("collection")
@@ -86,6 +118,7 @@ collection
     .description("Create a new collection (defaults to SKILLS_MY_SKILLS)")
     .option("--backend <backend>", "gdrive (default) or github", "gdrive")
     .option("--repo <owner/repo>", "GitHub repo to use (required for --backend github)")
+    .option("--skills-repo <owner/repo>", "GitHub repo where skills live; collection YAML stays in the declared backend")
     .action((name, options) => collectionCreateCommand(name, options));
 // ── Registry ─────────────────────────────────────────────────────────────────
 const registry = program
@@ -116,6 +149,7 @@ registry
     .command("remove-collection <name>")
     .description("Remove a collection reference from the registry")
     .option("--delete", "Also delete the collection and all its skills from the backend")
+    .option("--backend <backend>", "Backend the collection lives on (local, gdrive, github)")
     .action((name, options) => registryRemoveCollectionCommand(name, options));
 registry
     .command("push")

package/dist/registry.js

@@ -6,7 +6,7 @@ export const LEGACY_COLLECTION_FILENAME = "SKILLS_SYNC.yaml";
 // ── Collection (formerly "registry") parsing ─────────────────────────────────
 export function parseCollection(content) {
     const data = YAML.parse(content);
-    return {
+    const col = {
         name: data.name ?? "",
         owner: data.owner ?? "",
         skills: (data.skills ?? []).map((s) => ({
@@ -15,17 +15,29 @@ export function parseCollection(content) {
             description: s.description ?? "",
         })),
     };
+    if (data.type)
+        col.type = data.type;
+    if (data.metadata && typeof data.metadata === "object") {
+        col.metadata = data.metadata;
+    }
+    return col;
 }
 export function serializeCollection(collection) {
-    return YAML.stringify({
+    const obj = {
         name: collection.name,
         owner: collection.owner,
-        skills: collection.skills.map((s) => ({
-            name: s.name,
-            path: s.path,
-            description: s.description,
-        })),
-    });
+    };
+    if (collection.type)
+        obj.type = collection.type;
+    obj.skills = collection.skills.map((s) => ({
+        name: s.name,
+        path: s.path,
+        description: s.description,
+    }));
+    if (collection.metadata && Object.keys(collection.metadata).length > 0) {
+        obj.metadata = collection.metadata;
+    }
+    return YAML.stringify(obj);
 }
 // Backwards-compat aliases
 export const parseRegistry = parseCollection;

package/dist/types.d.ts

@@ -6,7 +6,9 @@ export interface SkillEntry {
 export interface CollectionFile {
     name: string;
     owner: string;
+    type?: string;
     skills: SkillEntry[];
+    metadata?: Record<string, unknown>;
 }
 export interface CollectionInfo {
     id: string;

package/dist/utils/git.d.ts

@@ -0,0 +1,10 @@
+export interface GitRepoContext {
+    repo: string;
+    repoRoot: string;
+    relPath: string;
+}
+/**
+ * Returns git repo context for a path if it belongs to a GitHub-tracked repo,
+ * or null otherwise.
+ */
+export declare function detectRepoContext(absPath: string): GitRepoContext | null;

package/dist/utils/git.js

@@ -0,0 +1,27 @@
+import { spawnSync } from "child_process";
+import path from "path";
+/**
+ * Returns git repo context for a path if it belongs to a GitHub-tracked repo,
+ * or null otherwise.
+ */
+export function 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skillsmanager/cli",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Discover, fetch, and manage agent skills from local or remote storage",
   "type": "module",
   "bin": {
@@ -35,7 +35,7 @@
     "url": "git+https://github.com/talktoajayprakash/skillsmanager.git"
   },
   "author": "Ajay Prakash",
-  "license": "MIT",
+  "license": "Apache-2.0",
   "homepage": "https://github.com/talktoajayprakash/skillsmanager#readme",
   "dependencies": {
     "chalk": "^4.1.2",

package/skills/skillsmanager/SKILL.md

@@ -5,12 +5,13 @@ description: Discover, fetch, add, and update agent skills from local or remote
 
 # Skills Manager
 
-Skills Manager is a CLI tool for managing agent skills stored locally or in remote storage (Google Drive). Use it to find, install, share, and update skills. Works offline by default — no setup needed for local use.
+Skills Manager is a CLI tool for managing agent skills stored locally or in remote storage (Google Drive, GitHub). Use it to find, install, share, and update skills. Works offline by default — no setup needed for local use.
 
 ## Prerequisites
 
 - Local storage works out of the box — no setup needed.
 - For Google Drive: a human must run `skillsmanager setup google` once to configure credentials.
+- For GitHub: requires the `gh` CLI to be installed and authenticated (`gh auth login`). No additional skillsmanager setup needed.
 - All commands except `setup google` are non-interactive and designed for agent use.
 
 ## Commands
@@ -33,7 +34,7 @@ skillsmanager list
 
 Supported agents: `claude`, `codex`, `agents`, `cursor`, `windsurf`, `copilot`, `gemini`, `roo`, `openclaw`, `antigravity`
 
-### Share a skill
+### Share a skill you own
 
 ```bash
 # Upload a local skill directory to a collection
@@ -44,6 +45,18 @@ skillsmanager add <path>
 skillsmanager add <path> --collection <name>
 ```
 
+### Register a skill path without uploading files (cross-repo / curated collections)
+
+Use `--remote-path` when the skill files already exist in a remote backend and you just want to register a pointer to them. You cannot `add` local files to a cross-backend collection — you must use this flag instead.
+
+```bash
+# Register a skill entry by path — no file upload
+skillsmanager add --remote-path <backend-path> --name <skill-name> --description "<description>" --collection <name>
+
+# Example: register a skill that lives in a GitHub repo
+skillsmanager add --remote-path skills/write-tests/ --name write-tests --description "Generate unit tests" --collection my-col
+```
+
 ### Update a skill
 
 ```bash
@@ -57,6 +70,16 @@ skillsmanager update <path> --collection <name>
 
 After updating, the local cache is refreshed so all symlinks on this machine reflect the change immediately.
 
+### Delete a skill
+
+```bash
+# Delete a skill from its collection (removes from backend, cache, and index)
+skillsmanager skill delete <name>
+
+# If the skill exists in multiple collections, specify which one
+skillsmanager skill delete <name> --collection <collection-name>
+```
+
 ### Registry and collection management
 
 ```bash
@@ -66,27 +89,44 @@ skillsmanager registry create
 # Create a registry in Google Drive
 skillsmanager registry create --backend gdrive
 
+# Create a registry in a GitHub repo (creates repo if it doesn't exist)
+skillsmanager registry create --backend github --repo <owner/repo>
+
 # Show all registries and their collection references
 skillsmanager registry list
 
 # Search a backend for registries owned by the current user
 skillsmanager registry discover --backend gdrive
+skillsmanager registry discover --backend github
 
 # Add a collection reference to the registry
 skillsmanager registry add-collection <name>
 
-# Push local registry and collections to Google Drive
+# Push local registry and collections to Google Drive (safe to re-run — skips already-synced collections)
 skillsmanager registry push --backend gdrive
 
+# Push local registry and collections to GitHub (safe to re-run — skips already-synced collections)
+skillsmanager registry push --backend github --repo <owner/repo>
+
 # Remove a collection reference from the registry (keeps data)
 skillsmanager registry remove-collection <name>
 
 # Remove and permanently delete the collection and all its skills
 skillsmanager registry remove-collection <name> --delete
 
-# Create a new collection
+# Create a new collection (local by default)
 skillsmanager collection create [name]
 
+# Create a collection in a GitHub repo (skills stored in that repo)
+skillsmanager collection create [name] --backend github --repo <owner/repo>
+
+# Create a collection in Google Drive
+skillsmanager collection create [name] --backend gdrive
+
+# Create a collection whose skills live in a specific GitHub repo (cross-backend)
+skillsmanager collection create [name] --backend gdrive --skills-repo <owner/repo>
+skillsmanager collection create [name] --backend github --repo <owner/registry-repo> --skills-repo <owner/skills-repo>
+
 # Re-discover collections from storage
 skillsmanager refresh
 ```
@@ -107,15 +147,37 @@ skillsmanager install --path <dir>
 skillsmanager uninstall
 ```
 
+## Cross-backend collections (curated skill libraries)
+
+A collection can declare that its skill files live in a different GitHub repo than the collection YAML. This is indicated by `type: github` in `SKILLS_COLLECTION.yaml`.
+
+**When you encounter a cross-backend collection:**
+- `skillsmanager add <local-path> --collection <name>` → **will fail** with an error like `skills source type is "github"`. This is expected — you cannot upload local files to a foreign repo.
+- **Do this instead:** `skillsmanager add --remote-path <path-in-repo> --name <n> --description "<d>" --collection <name>`
+- `skillsmanager fetch <skill> --agent claude` → **works normally** — files are automatically pulled from the declared GitHub repo
+
+**How to identify a cross-backend collection:**
+- `skillsmanager registry list` — collections with a `--skills-repo` are shown with their skills repo
+- Reading the `SKILLS_COLLECTION.yaml` directly — look for `type: github` + `metadata.repo`
+
+**Quick rule:**
+- Own the skill files? → `skillsmanager add <path>`
+- Files already in a GitHub repo? → `skillsmanager add --remote-path <path> --name <n> --description "<d>"`
+
+---
+
 ## Common Workflows
 
 **User asks to find a skill:**
 1. `skillsmanager search <relevant terms>`
 2. `skillsmanager fetch <skill-name> --agent claude`
 
-**User asks to share a skill they created:**
+**User asks to share a skill they created locally:**
 1. Ensure the skill directory has a `SKILL.md` with `name` and `description` in YAML frontmatter
 2. `skillsmanager add <path-to-skill-directory>`
+3. Fetch the skill to make it immediately available to the agent:
+   - For all projects: `skillsmanager fetch <skill-name> --agent claude`
+   - For current project only: `skillsmanager fetch <skill-name> --agent claude --scope project`
 
 **User asks to update a skill:**
 1. Edit the skill files locally
@@ -128,20 +190,61 @@ skillsmanager uninstall
 1. `skillsmanager setup google` (one-time, human-only)
 2. `skillsmanager registry push --backend gdrive`
 
+**User wants to store skills in a GitHub repo:**
+1. `skillsmanager collection create <name> --backend github --repo <owner/repo>` — creates the GitHub repo if needed, and auto-registers the collection
+2. `skillsmanager add <path> --collection <name>` — upload the skill into that collection
+
+**User wants to create a curated collection of skills from a public GitHub repo (cross-backend):**
+
+Use this when you want to expose skills from an external GitHub repo (e.g. `anthropics/skills`) via a collection the user can fetch from, without copying the files.
+
+1. `skillsmanager collection create <name> --backend gdrive --skills-repo <owner/skills-repo>`
+   - This creates the collection YAML in the user's Google Drive with `type: github` + `metadata.repo` pointing to the skills repo
+2. Register each skill by its path in the skills repo (no file upload needed):
+   ```bash
+   skillsmanager add --remote-path skills/write-tests/ --name write-tests --description "Generate unit tests" --collection <name>
+   ```
+3. Users fetch skills normally — `skillsmanager fetch write-tests --agent claude` — and the files are pulled from the skills repo
+
+**User wants to add a skill from a public GitHub repo without uploading files:**
+1. Create or identify a collection with `--skills-repo <owner/repo>`
+2. `skillsmanager add --remote-path <path-in-repo> --name <skill-name> --description "<desc>" --collection <name>`
+
+**User wants to discover GitHub-hosted collections:**
+1. `skillsmanager registry discover --backend github`
+
 **User wants to see what registries and collections exist:**
 1. `skillsmanager registry list`
 
+**User asks to delete/remove a single skill:**
+1. `skillsmanager skill delete <skill-name>`
+2. If the skill lives in multiple collections, add `--collection <name>` to target the right one
+
 **User wants to remove a collection:**
 1. `skillsmanager registry remove-collection <name>` (removes reference only, data is kept)
 2. `skillsmanager registry remove-collection <name> --delete` (permanently deletes collection and skills)
 
+## Collection types
+
+Most collections store skill files directly in their backend. But a collection can also declare that skill files live in a different GitHub repo — this is useful for curating public skills or pointing to a shared library repo.
+
+| Collection backend | Skills repo | What `add` does | What `fetch` does |
+|---|---|---|---|
+| `gdrive` or `local` | (none) | Uploads files to Drive/local | Downloads from Drive/local |
+| `github` | (same repo as collection) | Commits files to the repo | Clones/pulls from repo |
+| `gdrive` or `local` | `--skills-repo owner/repo` | **Requires `--remote-path`** — registers a path pointer only | Downloads files from the GitHub repo |
+| `github` (registry repo) | `--skills-repo owner/skills-repo` | **Requires `--remote-path`** — registers a path pointer only | Downloads files from the skills repo |
+
+When you try to `skillsmanager add <local-path>` to a collection with a cross-backend skills repo, the command will fail with a clear error pointing you to `--remote-path`.
+
 ## Architecture
 
 - **Registry** (`SKILLS_REGISTRY.yaml`): root index pointing to all collections across backends
 - **Collection** (`SKILLS_COLLECTION.yaml`): folder of skills with an index file
-- **Backends**: `local` (default, `~/.skillsmanager/`) and `gdrive` (Google Drive)
+- **Backends**: `local` (default, `~/.skillsmanager/`), `gdrive` (Google Drive), and `github` (GitHub repo via `gh` CLI)
 - **Cache**: skills are cached at `~/.skillsmanager/cache/<uuid>/` and symlinked to agent directories
 - **Symlinks**: all agents share one cached copy — updating the cache updates all agents
+- **RoutingBackend**: transparent middleware that intercepts skill-file operations and dispatches to the right backend based on the collection's declared `type` field
 
 ## Scope