@skillsmanager/cli 0.0.1

package/dist/ready.d.ts

@@ -0,0 +1,15 @@
+import type { OAuth2Client } from "google-auth-library";
+import { GDriveBackend } from "./backends/gdrive.js";
+import type { Config } from "./types.js";
+export interface ReadyContext {
+    auth: OAuth2Client;
+    config: Config;
+    backend: GDriveBackend;
+}
+/**
+ * Ensures the user is authenticated and has at least one collection configured.
+ * - If not authenticated: launches OAuth flow automatically.
+ * - If no config or empty collections: auto-discovers from Google Drive.
+ * Call this at the start of any command that needs Drive access.
+ */
+export declare function ensureReady(): Promise<ReadyContext>;

package/dist/ready.js

@@ -0,0 +1,39 @@
+import chalk from "chalk";
+import { ensureAuth } from "./auth.js";
+import { readConfig, writeConfig, mergeCollections, CONFIG_PATH } from "./config.js";
+import { GDriveBackend } from "./backends/gdrive.js";
+import fs from "fs";
+/**
+ * Ensures the user is authenticated and has at least one collection configured.
+ * - If not authenticated: launches OAuth flow automatically.
+ * - If no config or empty collections: auto-discovers from Google Drive.
+ * Call this at the start of any command that needs Drive access.
+ */
+export async function ensureReady() {
+    const auth = await ensureAuth();
+    const backend = new GDriveBackend(auth);
+    // Try to load config
+    let config = null;
+    if (fs.existsSync(CONFIG_PATH)) {
+        try {
+            config = readConfig();
+        }
+        catch {
+            config = null;
+        }
+    }
+    // Auto-discover if no config or no collections
+    if (!config || config.collections.length === 0) {
+        process.stdout.write(chalk.dim("Discovering collections... "));
+        const fresh = await backend.discoverCollections();
+        const collections = mergeCollections(fresh, config?.collections ?? []);
+        config = { registries: config?.registries ?? [], collections, skills: config?.skills ?? {}, discoveredAt: new Date().toISOString() };
+        writeConfig(config);
+        if (collections.length === 0) {
+            process.stdout.write("\n");
+            throw new Error("No collections found. Run: skillsmanager collection create <name>");
+        }
+        process.stdout.write(chalk.green(`found ${collections.length}.\n`));
+    }
+    return { auth, config: config, backend };
+}

package/dist/registry.d.ts

@@ -0,0 +1,10 @@
+import type { CollectionFile, RegistryFile } from "./types.js";
+export declare const REGISTRY_FILENAME = "SKILLS_REGISTRY.yaml";
+export declare const COLLECTION_FILENAME = "SKILLS_COLLECTION.yaml";
+export declare const LEGACY_COLLECTION_FILENAME = "SKILLS_SYNC.yaml";
+export declare function parseCollection(content: string): CollectionFile;
+export declare function serializeCollection(collection: CollectionFile): string;
+export declare const parseRegistry: typeof parseCollection;
+export declare const serializeRegistry: typeof serializeCollection;
+export declare function parseRegistryFile(content: string): RegistryFile;
+export declare function serializeRegistryFile(registry: RegistryFile): string;

package/dist/registry.js

@@ -0,0 +1,58 @@
+import YAML from "yaml";
+// ── Filename constants ───────────────────────────────────────────────────────
+export const REGISTRY_FILENAME = "SKILLS_REGISTRY.yaml";
+export const COLLECTION_FILENAME = "SKILLS_COLLECTION.yaml";
+export const LEGACY_COLLECTION_FILENAME = "SKILLS_SYNC.yaml";
+// ── Collection (formerly "registry") parsing ─────────────────────────────────
+export function parseCollection(content) {
+    const data = YAML.parse(content);
+    return {
+        name: data.name ?? "",
+        owner: data.owner ?? "",
+        skills: (data.skills ?? []).map((s) => ({
+            name: s.name,
+            path: s.path ?? `${s.name}/`,
+            description: s.description ?? "",
+        })),
+    };
+}
+export function serializeCollection(collection) {
+    return YAML.stringify({
+        name: collection.name,
+        owner: collection.owner,
+        skills: collection.skills.map((s) => ({
+            name: s.name,
+            path: s.path,
+            description: s.description,
+        })),
+    });
+}
+// Backwards-compat aliases
+export const parseRegistry = parseCollection;
+export const serializeRegistry = serializeCollection;
+// ── Registry file parsing ────────────────────────────────────────────────────
+export function parseRegistryFile(content) {
+    const data = YAML.parse(content);
+    return {
+        name: data.name ?? "",
+        owner: data.owner ?? "",
+        source: data.source ?? "local",
+        collections: (data.collections ?? []).map((c) => ({
+            name: c.name,
+            backend: c.backend ?? "local",
+            ref: c.ref ?? c.name,
+        })),
+    };
+}
+export function serializeRegistryFile(registry) {
+    return YAML.stringify({
+        name: registry.name,
+        owner: registry.owner,
+        source: registry.source,
+        collections: registry.collections.map((c) => ({
+            name: c.name,
+            backend: c.backend,
+            ref: c.ref,
+        })),
+    });
+}

package/dist/types.d.ts

@@ -0,0 +1,54 @@
+export interface SkillEntry {
+    name: string;
+    path: string;
+    description: string;
+}
+export interface CollectionFile {
+    name: string;
+    owner: string;
+    skills: SkillEntry[];
+}
+export interface CollectionInfo {
+    id: string;
+    name: string;
+    backend: string;
+    folderId: string;
+    registryFileId?: string;
+    sourceRegistryId?: string;
+}
+export interface RegistryCollectionRef {
+    name: string;
+    backend: string;
+    ref: string;
+}
+export interface RegistryFile {
+    name: string;
+    owner: string;
+    source: string;
+    collections: RegistryCollectionRef[];
+}
+export interface RegistryInfo {
+    id: string;
+    name: string;
+    backend: string;
+    folderId: string;
+    fileId?: string;
+}
+export interface SkillLocation {
+    collectionId: string;
+    installedAt: string[];
+}
+export interface SkillIndex {
+    [skillName: string]: SkillLocation[];
+}
+export interface Config {
+    registries: RegistryInfo[];
+    collections: CollectionInfo[];
+    skills: SkillIndex;
+    discoveredAt: string;
+}
+export interface ResolvedSkill {
+    entry: SkillEntry;
+    collection: CollectionInfo;
+}
+export declare const AGENT_PATHS: Record<string, string>;

package/dist/types.js

@@ -0,0 +1,13 @@
+import os from "os";
+import path from "path";
+// Agent name → user-level skills directory path
+export const AGENT_PATHS = {
+    claude: path.join(os.homedir(), ".claude", "skills"),
+    codex: path.join(os.homedir(), ".codex", "skills"),
+    agents: path.join(os.homedir(), ".agents", "skills"),
+    cursor: path.join(os.homedir(), ".cursor", "skills"),
+    windsurf: path.join(os.homedir(), ".codeium", "windsurf", "skills"),
+    copilot: path.join(os.homedir(), ".copilot", "skills"),
+    gemini: path.join(os.homedir(), ".gemini", "skills"),
+    roo: path.join(os.homedir(), ".roo", "skills"),
+};

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@skillsmanager/cli",
+  "version": "0.0.1",
+  "description": "Discover, fetch, and manage agent skills from local or remote storage",
+  "type": "module",
+  "bin": {
+    "skillsmanager": "./dist/index.js"
+  },
+  "files": [
+    "dist/",
+    "!dist/tests/",
+    "skills/"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "dev": "node --loader ts-node/esm src/index.ts",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "skills",
+    "claude",
+    "codex",
+    "cursor",
+    "copilot",
+    "gemini",
+    "registry",
+    "sync"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/talktoajayprakash/skillsmanager.git"
+  },
+  "author": "Ajay Prakash",
+  "license": "MIT",
+  "homepage": "https://github.com/talktoajayprakash/skillsmanager#readme",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^12.0.0",
+    "googleapis": "^144.0.0",
+    "ora": "^5.4.1",
+    "yaml": "^2.4.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.4.0",
+    "vitest": "^4.1.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/skills/skillsmanager/SKILL.md

@@ -0,0 +1,139 @@
+---
+name: skillsmanager
+description: Discover, fetch, add, and update agent skills from local or remote storage using the skillsmanager CLI
+---
+
+# 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.
+
+## 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.
+- All commands except `setup google` are non-interactive and designed for agent use.
+
+## Commands
+
+### Find and install a skill
+
+```bash
+# Search by name or description (BM25 ranked — partial/reordered terms work)
+skillsmanager search <query>
+
+# Download and install for this agent
+skillsmanager fetch <name> --agent <agent>
+
+# Install to current project only (instead of global)
+skillsmanager fetch <name> --agent <agent> --scope project
+
+# List all available skills across all collections
+skillsmanager list
+```
+
+Supported agents: `claude`, `codex`, `agents`, `cursor`, `windsurf`, `copilot`, `gemini`, `roo`
+
+### Share a skill
+
+```bash
+# Upload a local skill directory to a collection
+# The directory must contain a SKILL.md with name and description in YAML frontmatter
+skillsmanager add <path>
+
+# Upload to a specific collection
+skillsmanager add <path> --collection <name>
+```
+
+### Update a skill
+
+```bash
+# Push local edits back to storage
+# The skill must have been fetched on this machine first
+skillsmanager update <path>
+
+# If the skill exists in multiple collections, specify which one
+skillsmanager update <path> --collection <name>
+```
+
+After updating, the local cache is refreshed so all symlinks on this machine reflect the change immediately.
+
+### Registry and collection management
+
+```bash
+# Create a local registry (auto-created on first use)
+skillsmanager registry create
+
+# Create a registry in Google Drive
+skillsmanager registry create --backend gdrive
+
+# 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
+
+# Add a collection reference to the registry
+skillsmanager registry add-collection <name>
+
+# Push local registry and collections to Google Drive
+skillsmanager registry push --backend gdrive
+
+# Create a new collection
+skillsmanager collection create [name]
+
+# Re-discover collections from storage
+skillsmanager refresh
+```
+
+### Install the skillsmanager skill for agents
+
+```bash
+# Install to all agent directories
+skillsmanager install
+
+# Install to specific agents
+skillsmanager install --agent claude,codex
+
+# Install to a custom path
+skillsmanager install --path <dir>
+
+# Remove from all agents
+skillsmanager uninstall
+```
+
+## 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:**
+1. Ensure the skill directory has a `SKILL.md` with `name` and `description` in YAML frontmatter
+2. `skillsmanager add <path-to-skill-directory>`
+
+**User asks to update a skill:**
+1. Edit the skill files locally
+2. `skillsmanager update <path-to-skill-directory>`
+
+**User asks to install a skill for this project only:**
+1. `skillsmanager fetch <name> --agent claude --scope project`
+
+**User wants to back up local skills to Google Drive:**
+1. `skillsmanager setup google` (one-time, human-only)
+2. `skillsmanager registry push --backend gdrive`
+
+**User wants to see what registries and collections exist:**
+1. `skillsmanager registry list`
+
+## 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)
+- **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
+
+## Scope
+
+- `--scope global` (default): installs to `~/.agent/skills/` — available across all projects
+- `--scope project`: installs to `./.agent/skills/` in the current working directory — this project only