@skillsmanager/cli 0.0.1

package/dist/commands/setup/google.js

@@ -0,0 +1,281 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+import readline from "readline";
+import { execSync, spawnSync } from "child_process";
+import chalk from "chalk";
+import { CREDENTIALS_PATH, ensureConfigDir } from "../../config.js";
+import { runAuthFlow, hasToken } from "../../auth.js";
+import { credentialsExist } from "../../config.js";
+// ─── Prompt helpers ──────────────────────────────────────────────────────────
+function ask(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (ans) => { rl.close(); resolve(ans.trim()); });
+    });
+}
+async function confirm(question) {
+    const ans = await ask(`${question} ${chalk.dim("[y/n]")} `);
+    return ans.toLowerCase().startsWith("y");
+}
+// ─── gcloud helpers ──────────────────────────────────────────────────────────
+function gcloudInstalled() {
+    const r = spawnSync("gcloud", ["version"], { stdio: "pipe" });
+    return r.status === 0;
+}
+function gcloudExec(args, opts) {
+    const r = spawnSync("gcloud", args, {
+        stdio: opts?.input ? ["pipe", "pipe", "pipe"] : ["inherit", "pipe", "pipe"],
+        input: opts?.input,
+        encoding: "utf-8",
+    });
+    return { ok: r.status === 0, stdout: (r.stdout ?? "").trim(), stderr: (r.stderr ?? "").trim() };
+}
+function getActiveGcloudAccount() {
+    const r = gcloudExec(["auth", "list", "--filter=status:ACTIVE", "--format=value(account)"]);
+    return r.ok && r.stdout ? r.stdout.split("\n")[0].trim() : null;
+}
+function listProjects() {
+    const r = gcloudExec(["projects", "list", "--format=value(projectId,name)"]);
+    if (!r.ok || !r.stdout)
+        return [];
+    return r.stdout
+        .split("\n")
+        .filter(Boolean)
+        .map((line) => {
+        const [projectId, ...nameParts] = line.split(/\s+/);
+        return { projectId, name: nameParts.join(" ") || projectId };
+    });
+}
+function apiEnabled(projectId, api) {
+    const r = gcloudExec([
+        "services", "list",
+        `--project=${projectId}`,
+        "--enabled",
+        `--filter=config.name:${api}`,
+        "--format=value(config.name)",
+    ]);
+    return r.ok && r.stdout.includes(api);
+}
+function enableApi(projectId, api) {
+    console.log(chalk.dim(`  Enabling ${api}...`));
+    const r = gcloudExec(["services", "enable", api, `--project=${projectId}`]);
+    return r.ok;
+}
+// ─── Install gcloud ───────────────────────────────────────────────────────────
+async function installGcloud() {
+    const isMac = process.platform === "darwin";
+    if (!isMac) {
+        console.log(chalk.yellow("  Auto-install is only supported on macOS."));
+        console.log(chalk.dim("  Install gcloud manually: https://cloud.google.com/sdk/docs/install"));
+        return false;
+    }
+    // Check homebrew
+    const brewCheck = spawnSync("brew", ["--version"], { stdio: "pipe" });
+    if (brewCheck.status !== 0) {
+        console.log(chalk.yellow("  Homebrew not found. Install it from https://brew.sh then re-run."));
+        return false;
+    }
+    console.log(chalk.dim("  Installing google-cloud-sdk via Homebrew (this may take a minute)..."));
+    const r = spawnSync("brew", ["install", "--cask", "google-cloud-sdk"], { stdio: "inherit" });
+    if (r.status !== 0) {
+        console.log(chalk.red("  Install failed. Try manually: brew install --cask google-cloud-sdk"));
+        return false;
+    }
+    // After cask install, gcloud lives in /usr/local/Caskroom path; add to PATH hint
+    console.log(chalk.dim("  You may need to open a new terminal or source your shell profile for gcloud to be in PATH."));
+    console.log(chalk.dim("  Trying to continue..."));
+    return gcloudInstalled();
+}
+// ─── Project selection ────────────────────────────────────────────────────────
+async function selectOrCreateProject() {
+    const projects = listProjects();
+    if (projects.length > 0) {
+        console.log(chalk.bold("\nExisting projects:"));
+        projects.forEach((p, i) => console.log(`  ${chalk.cyan(i + 1)}. ${p.name} ${chalk.dim(`(${p.projectId})`)}`));
+        console.log(`  ${chalk.cyan(projects.length + 1)}. Create a new project`);
+        const ans = await ask(`\nSelect a project [1-${projects.length + 1}]: `);
+        const idx = parseInt(ans, 10);
+        if (idx >= 1 && idx <= projects.length) {
+            return projects[idx - 1].projectId;
+        }
+    }
+    // Create new
+    const rawName = await ask(`\nProject name ${chalk.dim('(leave blank for "Skills Manager")')}: `);
+    const name = rawName || "Skills Manager";
+    const projectId = name.toLowerCase().replace(/[^a-z0-9]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "")
+        + "-" + Date.now().toString().slice(-6);
+    console.log(chalk.dim(`\n  Creating project ${projectId}...`));
+    const r = gcloudExec(["projects", "create", projectId, `--name=${name}`]);
+    if (!r.ok) {
+        console.log(chalk.red(`  Failed to create project: ${r.stderr}`));
+        return null;
+    }
+    console.log(chalk.green(`  ✓ Project "${name}" created (${projectId})`));
+    return projectId;
+}
+// ─── Open browser helper ──────────────────────────────────────────────────────
+function openUrl(url) {
+    const cmd = process.platform === "darwin" ? "open" :
+        process.platform === "win32" ? "start" : "xdg-open";
+    try {
+        execSync(`${cmd} "${url}"`, { stdio: "ignore" });
+    }
+    catch { /* ignore */ }
+}
+// ─── Main command ─────────────────────────────────────────────────────────────
+export async function setupGoogleCommand() {
+    console.log(chalk.bold("\nSkills Manager — Google Drive Setup\n"));
+    // ── Case 1: credentials.json already present ──────────────────────────────
+    if (credentialsExist()) {
+        console.log(chalk.green("  ✓ credentials.json found"));
+        if (hasToken()) {
+            console.log(chalk.green("  ✓ Already authenticated — nothing to do."));
+            console.log(`\nRun ${chalk.bold("skillsmanager init")} to discover registries.\n`);
+            return;
+        }
+        console.log(chalk.yellow("  ✗ Not yet authenticated — starting OAuth flow...\n"));
+        await runAuthFlow();
+        console.log(chalk.green("\n  ✓ Authenticated successfully."));
+        console.log(`\nRun ${chalk.bold("skillsmanager init")} to discover registries.\n`);
+        return;
+    }
+    // ── Case 2: No credentials.json ───────────────────────────────────────────
+    console.log(chalk.yellow("  ✗ No credentials.json found at ~/.skillsmanager/credentials.json\n"));
+    const wantHelp = await confirm("Would you like Skills Manager to help you set up a Google Cloud project?");
+    if (!wantHelp) {
+        printManualInstructions();
+        return;
+    }
+    // ── Automated setup ───────────────────────────────────────────────────────
+    console.log(chalk.bold("\nStep 1 — gcloud CLI\n"));
+    if (!gcloudInstalled()) {
+        console.log(chalk.yellow("  gcloud CLI is not installed."));
+        const install = await confirm("  Install it now via Homebrew?");
+        if (!install) {
+            console.log(chalk.dim("  Install manually: https://cloud.google.com/sdk/docs/install"));
+            console.log(chalk.dim("  Then re-run: skillsmanager setup google"));
+            return;
+        }
+        const ok = await installGcloud();
+        if (!ok)
+            return;
+    }
+    else {
+        console.log(chalk.green("  ✓ gcloud is installed"));
+    }
+    // ── gcloud auth ───────────────────────────────────────────────────────────
+    console.log(chalk.bold("\nStep 2 — Google Account\n"));
+    let account = getActiveGcloudAccount();
+    if (account) {
+        console.log(chalk.green(`  ✓ Signed in as ${account}`));
+    }
+    else {
+        console.log(chalk.dim("  Opening browser for gcloud login..."));
+        const r = spawnSync("gcloud", ["auth", "login"], { stdio: "inherit" });
+        if (r.status !== 0) {
+            console.log(chalk.red("  gcloud auth login failed. Please try manually."));
+            return;
+        }
+        account = getActiveGcloudAccount();
+        if (!account) {
+            console.log(chalk.red("  Could not determine active account after login."));
+            return;
+        }
+        console.log(chalk.green(`  ✓ Signed in as ${account}`));
+    }
+    // ── Project ───────────────────────────────────────────────────────────────
+    console.log(chalk.bold("\nStep 3 — Google Cloud Project\n"));
+    const projectId = await selectOrCreateProject();
+    if (!projectId)
+        return;
+    // ── Enable Drive API ──────────────────────────────────────────────────────
+    console.log(chalk.bold("\nStep 4 — Enable Google Drive API\n"));
+    const DRIVE_API = "drive.googleapis.com";
+    if (apiEnabled(projectId, DRIVE_API)) {
+        console.log(chalk.green("  ✓ Google Drive API already enabled"));
+    }
+    else {
+        const ok = enableApi(projectId, DRIVE_API);
+        if (ok) {
+            console.log(chalk.green("  ✓ Google Drive API enabled"));
+        }
+        else {
+            console.log(chalk.red("  Failed to enable Google Drive API. Check that billing is set up for the project."));
+            return;
+        }
+    }
+    // ── OAuth credentials (browser) ───────────────────────────────────────────
+    console.log(chalk.bold("\nStep 5 — Create OAuth 2.0 Credentials\n"));
+    console.log("  Google does not allow creating OAuth client credentials from the CLI.");
+    console.log("  Opening the Google Cloud Console to create them...\n");
+    const credentialsUrl = `https://console.cloud.google.com/apis/credentials/oauthclient?project=${projectId}`;
+    console.log(`  URL: ${chalk.cyan(credentialsUrl)}\n`);
+    console.log(chalk.dim("  Instructions:"));
+    console.log(chalk.dim("    1. Application type → Desktop app"));
+    console.log(chalk.dim('    2. Name → "Skills Manager" (or anything)'));
+    console.log(chalk.dim('    3. Click "Create" → then "Download JSON"'));
+    console.log(chalk.dim("    4. Note where the file is saved\n"));
+    openUrl(credentialsUrl);
+    await ask("Press Enter once you have downloaded the credentials JSON file...");
+    // ── Locate and copy the file ──────────────────────────────────────────────
+    console.log();
+    const defaultDownload = path.join(os.homedir(), "Downloads");
+    const downloadsFiles = fs.existsSync(defaultDownload)
+        ? fs.readdirSync(defaultDownload).filter((f) => f.startsWith("client_secret") && f.endsWith(".json"))
+        : [];
+    let credSrc = null;
+    if (downloadsFiles.length > 0) {
+        // Most recently modified one
+        const sorted = downloadsFiles
+            .map((f) => ({ f, mtime: fs.statSync(path.join(defaultDownload, f)).mtimeMs }))
+            .sort((a, b) => b.mtime - a.mtime);
+        const candidate = path.join(defaultDownload, sorted[0].f);
+        console.log(chalk.dim(`  Found: ${candidate}`));
+        const use = await confirm("  Use this file?");
+        if (use)
+            credSrc = candidate;
+    }
+    if (!credSrc) {
+        const entered = await ask("  Enter full path to the downloaded credentials JSON: ");
+        credSrc = entered.replace(/^~/, os.homedir());
+    }
+    if (!credSrc || !fs.existsSync(credSrc)) {
+        console.log(chalk.red(`  File not found: ${credSrc}`));
+        console.log(chalk.dim(`  Copy it manually: cp <path> ~/.skillsmanager/credentials.json`));
+        return;
+    }
+    ensureConfigDir();
+    fs.copyFileSync(credSrc, CREDENTIALS_PATH);
+    console.log(chalk.green(`\n  ✓ Credentials saved to ~/.skillsmanager/credentials.json`));
+    // ── Add test user ─────────────────────────────────────────────────────────
+    console.log(chalk.bold("\nStep 6 — Add Test User\n"));
+    console.log("  Your app is in Testing mode. You must add your Google account as a test user.");
+    console.log("  Opening the OAuth consent screen...\n");
+    console.log(chalk.dim("  Instructions:"));
+    console.log(chalk.dim("    1. Scroll down to \"Test users\""));
+    console.log(chalk.dim(`    2. Click \"Add users\" → enter ${chalk.white(account)}`));
+    console.log(chalk.dim("    3. Click \"Save\"\n"));
+    const consentUrl = `https://console.cloud.google.com/apis/credentials/consent?project=${projectId}`;
+    console.log(`  URL: ${chalk.cyan(consentUrl)}\n`);
+    openUrl(consentUrl);
+    await ask("Press Enter once you have added your email as a test user...");
+    // ── OAuth flow ────────────────────────────────────────────────────────────
+    console.log(chalk.bold("\nStep 7 — Authorize Skills Manager\n"));
+    await runAuthFlow();
+    console.log(chalk.green("\n  ✓ Setup complete!"));
+    console.log(`\nRun ${chalk.bold("skillsmanager init")} to discover your registries.\n`);
+}
+function printManualInstructions() {
+    console.log(chalk.bold("\nManual Setup Instructions\n"));
+    console.log("  1. Go to https://console.cloud.google.com/");
+    console.log("  2. Create a project (or select an existing one)");
+    console.log("  3. Enable the Google Drive API:");
+    console.log("       APIs & Services → Library → search \"Google Drive API\" → Enable");
+    console.log("  4. Create OAuth credentials:");
+    console.log("       APIs & Services → Credentials → Create Credentials → OAuth 2.0 Client ID");
+    console.log("       Application type: Desktop app");
+    console.log("  5. Download the JSON and save it:");
+    console.log(chalk.cyan(`       ~/.skillsmanager/credentials.json`));
+    console.log(`\n  Then run: ${chalk.bold("skillsmanager setup google")}\n`);
+}

package/dist/commands/update.d.ts

@@ -0,0 +1,3 @@
+export declare function updateCommand(skillPath: string, options: {
+    collection?: string;
+}): Promise<void>;

package/dist/commands/update.js

@@ -0,0 +1,83 @@
+import chalk from "chalk";
+import ora from "ora";
+import fs from "fs";
+import YAML from "yaml";
+import path from "path";
+import { ensureReady } from "../ready.js";
+import { getCachePath, ensureCachePath } from "../cache.js";
+export async function updateCommand(skillPath, options) {
+    const absPath = path.resolve(skillPath);
+    if (!fs.existsSync(absPath) || !fs.statSync(absPath).isDirectory()) {
+        console.log(chalk.red(`"${skillPath}" is not a valid directory.`));
+        return;
+    }
+    const skillMdPath = path.join(absPath, "SKILL.md");
+    if (!fs.existsSync(skillMdPath)) {
+        console.log(chalk.red(`No SKILL.md found in "${skillPath}".`));
+        return;
+    }
+    const content = fs.readFileSync(skillMdPath, "utf-8");
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!frontmatterMatch) {
+        console.log(chalk.red("SKILL.md is missing YAML frontmatter."));
+        return;
+    }
+    const frontmatter = YAML.parse(frontmatterMatch[1]);
+    const skillName = frontmatter.name;
+    if (!skillName) {
+        console.log(chalk.red("SKILL.md frontmatter is missing 'name' field."));
+        return;
+    }
+    const { config, backend } = await ensureReady();
+    // Find the collection — --collection override, or look up by installedAt path, or by name
+    let collection = config.collections.find((c) => c.name === options.collection) ?? null;
+    if (!collection) {
+        const entries = config.skills?.[skillName] ?? [];
+        // Prefer the entry whose installedAt includes this exact path
+        const byPath = entries.find((e) => e.installedAt.includes(absPath));
+        // Fall back to the only entry if unambiguous
+        const byName = entries.length === 1 ? entries[0] : null;
+        const entry = byPath ?? byName;
+        if (!entry) {
+            if (entries.length > 1) {
+                const names = entries.map((e) => {
+                    const col = config.collections.find((c) => c.id === e.collectionId);
+                    return col?.name ?? e.collectionId;
+                }).join(", ");
+                console.log(chalk.red(`"${skillName}" exists in multiple collections: ${names}`));
+                console.log(chalk.dim(`  Use: skillsmanager update ${skillPath} --collection <name>`));
+            }
+            else {
+                console.log(chalk.red(`Skill "${skillName}" is not tracked in the skills index.`));
+                console.log(chalk.dim(`  Run: skillsmanager fetch ${skillName} --agent <agent> first.`));
+            }
+            return;
+        }
+        collection = config.collections.find((c) => c.id === entry.collectionId) ?? null;
+        if (!collection) {
+            console.log(chalk.red(`Collection not found. Run: skillsmanager refresh`));
+            return;
+        }
+    }
+    const spinner = ora(`Updating ${chalk.bold(skillName)} in gdrive:${collection.name}...`).start();
+    try {
+        await backend.uploadSkill(collection, absPath, skillName);
+        // Sync updated files into the local cache so symlinks reflect the change immediately
+        ensureCachePath(collection);
+        const cachePath = getCachePath(collection, skillName);
+        await backend.downloadSkill(collection, skillName, cachePath);
+        // Update description in SKILLS_SYNC.yaml if it changed
+        if (frontmatter.description) {
+            const col = await backend.readCollection(collection);
+            const entry = col.skills.find((s) => s.name === skillName);
+            if (entry && entry.description !== frontmatter.description) {
+                entry.description = frontmatter.description;
+                await backend.writeCollection(collection, col);
+            }
+        }
+        spinner.succeed(`${chalk.bold(skillName)} updated in gdrive:${collection.name}`);
+    }
+    catch (err) {
+        spinner.fail(`Failed: ${err.message}`);
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,28 @@
+import type { Config, CollectionInfo, RegistryInfo } from "./types.js";
+export declare const CONFIG_DIR: string;
+export declare const CREDENTIALS_PATH: string;
+export declare const TOKEN_PATH: string;
+export declare const CONFIG_PATH: string;
+export declare const CACHE_DIR: string;
+export declare function ensureConfigDir(): void;
+export declare function ensureCacheDir(): void;
+export declare function readConfig(): Config;
+/**
+ * Merges freshly discovered collections with existing ones, preserving UUIDs
+ * for collections already known (matched by folderId). New collections get a
+ * fresh UUID. This keeps cache paths stable across refreshes.
+ */
+export declare function mergeCollections(fresh: Omit<CollectionInfo, "id">[], existing: CollectionInfo[]): CollectionInfo[];
+/**
+ * Merges freshly discovered registries with existing ones, preserving UUIDs
+ * for registries already known (matched by folderId).
+ */
+export declare function mergeRegistries(fresh: Omit<RegistryInfo, "id">[], existing: RegistryInfo[]): RegistryInfo[];
+export declare function trackSkill(skillName: string, collectionId: string, installedPath?: string): void;
+export declare function writeConfig(config: Config): void;
+export declare function credentialsExist(): boolean;
+export declare function readCredentials(): {
+    client_id: string;
+    client_secret: string;
+    redirect_uris: string[];
+};

package/dist/config.js

@@ -0,0 +1,136 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { randomUUID } from "crypto";
+export const CONFIG_DIR = path.join(os.homedir(), ".skillsmanager");
+export const CREDENTIALS_PATH = path.join(CONFIG_DIR, "credentials.json");
+export const TOKEN_PATH = path.join(CONFIG_DIR, "token.json");
+export const CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+export const CACHE_DIR = path.join(CONFIG_DIR, "cache");
+export function ensureConfigDir() {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+}
+export function ensureCacheDir() {
+    fs.mkdirSync(CACHE_DIR, { recursive: true });
+}
+export function readConfig() {
+    if (!fs.existsSync(CONFIG_PATH)) {
+        throw new Error(`No config found. Run "skillsmanager init" first.`);
+    }
+    const raw = JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8"));
+    // Backwards compat: very old configs used "registries" key for collections
+    if (raw.registries && !raw.collections && Array.isArray(raw.registries) && raw.registries.length > 0 && raw.registries[0].folderId) {
+        // Old format: registries was actually collections
+        raw.collections = raw.registries;
+        raw.registries = [];
+    }
+    let needsWrite = false;
+    // Backwards compat: ensure registries array exists
+    if (!raw.registries || !Array.isArray(raw.registries)) {
+        raw.registries = [];
+        needsWrite = true;
+    }
+    // Backfill UUIDs on registries
+    const registries = raw.registries;
+    registries.forEach((r) => { if (!r.id) {
+        r.id = randomUUID();
+        needsWrite = true;
+    } });
+    // Backwards compat: assign stable UUIDs to collections missing an id
+    const collections = raw.collections;
+    if (Array.isArray(collections)) {
+        collections.forEach((c) => { if (!c.id) {
+            c.id = randomUUID();
+            needsWrite = true;
+        } });
+    }
+    // Backwards compat: old configs have no skills index
+    if (!raw.skills) {
+        raw.skills = {};
+        needsWrite = true;
+    }
+    // Backwards compat: old skills index used flat { collectionId } instead of array
+    const skills = raw.skills;
+    for (const key of Object.keys(skills)) {
+        const val = skills[key];
+        if (!Array.isArray(val)) {
+            skills[key] = [{ collectionId: val.collectionId, installedAt: [] }];
+            needsWrite = true;
+        }
+    }
+    const config = raw;
+    // Persist any backfilled values so they are stable on subsequent reads
+    if (needsWrite)
+        fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+    return config;
+}
+/**
+ * Merges freshly discovered collections with existing ones, preserving UUIDs
+ * for collections already known (matched by folderId). New collections get a
+ * fresh UUID. This keeps cache paths stable across refreshes.
+ */
+export function mergeCollections(fresh, existing) {
+    return fresh.map((c) => {
+        const prev = existing.find((e) => e.folderId === c.folderId);
+        return { ...c, id: prev?.id ?? randomUUID() };
+    });
+}
+/**
+ * Merges freshly discovered registries with existing ones, preserving UUIDs
+ * for registries already known (matched by folderId).
+ */
+export function mergeRegistries(fresh, existing) {
+    return fresh.map((r) => {
+        const prev = existing.find((e) => e.folderId === r.folderId);
+        return { ...r, id: prev?.id ?? randomUUID() };
+    });
+}
+export function trackSkill(skillName, collectionId, installedPath) {
+    let config;
+    try {
+        config = readConfig();
+    }
+    catch {
+        config = { registries: [], collections: [], skills: {}, discoveredAt: new Date().toISOString() };
+    }
+    if (!config.skills)
+        config.skills = {};
+    const entries = config.skills[skillName] ?? [];
+    // Find existing entry for this collection
+    const existing = entries.find((e) => e.collectionId === collectionId);
+    if (existing) {
+        if (installedPath && !existing.installedAt.includes(installedPath)) {
+            existing.installedAt.push(installedPath);
+        }
+    }
+    else {
+        entries.push({ collectionId, installedAt: installedPath ? [installedPath] : [] });
+    }
+    config.skills[skillName] = entries;
+    writeConfig(config);
+}
+export function writeConfig(config) {
+    ensureConfigDir();
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+export function credentialsExist() {
+    return fs.existsSync(CREDENTIALS_PATH);
+}
+export function readCredentials() {
+    if (!credentialsExist()) {
+        throw new Error(`No credentials file found at ${CREDENTIALS_PATH}.\n\n` +
+            `To set up Google Drive:\n` +
+            `  1. Go to https://console.cloud.google.com/\n` +
+            `  2. Create a project and enable the Google Drive API\n` +
+            `  3. Create OAuth 2.0 credentials (Desktop app type)\n` +
+            `  4. Download the JSON and save as ${CREDENTIALS_PATH}\n` +
+            `  5. Run "skillsmanager init" again`);
+    }
+    const raw = JSON.parse(fs.readFileSync(CREDENTIALS_PATH, "utf-8"));
+    const creds = raw.installed ?? raw.web ?? raw;
+    return {
+        client_id: creds.client_id,
+        client_secret: creds.client_secret,
+        redirect_uris: creds.redirect_uris ?? ["urn:ietf:wg:oauth:2.0:oob"],
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+import chalk from "chalk";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { program } from "commander";
+import { AGENT_PATHS } from "./types.js";
+import { initCommand } from "./commands/init.js";
+import { listCommand } from "./commands/list.js";
+import { searchCommand } from "./commands/search.js";
+import { fetchCommand } from "./commands/fetch.js";
+import { addCommand } from "./commands/add.js";
+import { updateCommand } from "./commands/update.js";
+import { refreshCommand } from "./commands/refresh.js";
+import { setupGoogleCommand } from "./commands/setup/google.js";
+import { collectionCreateCommand } from "./commands/collection.js";
+import { installCommand, uninstallCommand } from "./commands/install.js";
+import { registryCreateCommand, registryListCommand, registryDiscoverCommand, registryAddCollectionCommand, 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
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const skillMdPath = path.resolve(__dirname, "..", "skills", "skillsmanager", "SKILL.md");
+let helpText = "Discover, fetch, and manage agent skills from local or remote storage.";
+try {
+    const raw = fs.readFileSync(skillMdPath, "utf-8");
+    // Strip YAML frontmatter
+    helpText = raw.replace(/^---\n[\s\S]*?\n---\n*/, "").trim();
+}
+catch { /* use fallback */ }
+program
+    .name("skillsmanager")
+    .description(helpText)
+    .version("0.0.1");
+// ── Setup ────────────────────────────────────────────────────────────────────
+const setup = program
+    .command("setup")
+    .description("Set up storage backends");
+setup
+    .command("google")
+    .description("One-time Google Drive setup (human-facing, not for agents)")
+    .action(setupGoogleCommand);
+// ── Core commands ────────────────────────────────────────────────────────────
+program
+    .command("init")
+    .description("Authenticate and discover collections (runs automatically when needed)")
+    .action(initCommand);
+program
+    .command("list")
+    .description("List all available skills across all collections")
+    .action(listCommand);
+program
+    .command("search <query>")
+    .description("Search skills by name or description (BM25 ranked)")
+    .action(searchCommand);
+program
+    .command("fetch <names...>")
+    .description("Download and install a skill via symlink")
+    .requiredOption("--agent <agent>", `Agent to install for (${supportedAgents})`)
+    .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")
+    .option("--collection <name>", "Target collection (default: first available)")
+    .action((skillPath, options) => addCommand(skillPath, options));
+program
+    .command("update <path>")
+    .description("Push local edits to a skill back to storage and refresh cache")
+    .option("--collection <name>", "Override target collection")
+    .action((skillPath, options) => updateCommand(skillPath, options));
+program
+    .command("refresh")
+    .description("Re-discover collections from storage")
+    .action(refreshCommand);
+// ── Collection ───────────────────────────────────────────────────────────────
+const collection = program
+    .command("collection")
+    .description("Manage collections");
+collection
+    .command("create [name]")
+    .description("Create a new collection (defaults to SKILLS_MY_SKILLS)")
+    .action(collectionCreateCommand);
+// ── Registry ─────────────────────────────────────────────────────────────────
+const registry = program
+    .command("registry")
+    .description("Manage registries (root indexes pointing to collections)");
+registry
+    .command("create")
+    .description("Create a new registry (default: local, --backend gdrive for Drive)")
+    .option("--backend <backend>", "local (default) or gdrive", "local")
+    .action((options) => registryCreateCommand(options));
+registry
+    .command("list")
+    .description("Show all registries and their collection references")
+    .action(registryListCommand);
+registry
+    .command("discover")
+    .description("Search a backend for registries owned by the current user")
+    .option("--backend <backend>", "local (default) or gdrive", "local")
+    .action((options) => registryDiscoverCommand(options));
+registry
+    .command("add-collection <name>")
+    .description("Add a collection reference to the registry")
+    .option("--backend <backend>", "Backend where the collection lives")
+    .option("--ref <ref>", "Backend-specific reference (folder name, repo path)")
+    .action((name, options) => registryAddCollectionCommand(name, options));
+registry
+    .command("push")
+    .description("Push local registry and collections to a remote backend")
+    .option("--backend <backend>", "Target backend (default: gdrive)", "gdrive")
+    .action((options) => registryPushCommand(options));
+// ── Install/Uninstall ────────────────────────────────────────────────────────
+program
+    .command("install")
+    .description("Install the skillsmanager skill to agent directories")
+    .option("--agent <agents>", "Comma-separated agents (default: all)")
+    .option("--path <dir>", "Custom directory to install to")
+    .action((options) => installCommand(options));
+program
+    .command("uninstall")
+    .description("Remove the skillsmanager skill from agent directories")
+    .option("--agent <agents>", "Comma-separated agents (default: all)")
+    .option("--path <dir>", "Custom directory to remove from")
+    .action((options) => uninstallCommand(options));
+program.parseAsync(process.argv).catch((err) => {
+    console.error(chalk.red("Error:"), err.message);
+    process.exit(1);
+});