@skillsmanager/cli 0.0.1 → 0.0.4

package/dist/commands/add.js

@@ -3,8 +3,9 @@ import path from "path";
 import chalk from "chalk";
 import ora from "ora";
 import YAML from "yaml";
-import { ensureReady } from "../ready.js";
-import { trackSkill } from "../config.js";
+import { readConfig, trackSkill } from "../config.js";
+import { GithubBackend } from "../backends/github.js";
+import { resolveBackend } from "../backends/resolve.js";
 export async function addCommand(skillPath, options) {
     const absPath = path.resolve(skillPath);
     if (!fs.existsSync(absPath) || !fs.statSync(absPath).isDirectory()) {
@@ -29,8 +30,37 @@ export async function addCommand(skillPath, options) {
         console.log(chalk.red("SKILL.md frontmatter is missing 'name' field."));
         return;
     }
-    const { config, backend } = await ensureReady();
-    // Pick collection — first one by default, or by name
+    // ── Auto-detect if skill lives inside a GitHub-tracked repo ─────────────────
+    // If no --collection specified and a matching GitHub collection exists in config,
+    // use it automatically (no prompt — agent-friendly).
+    if (!options.collection) {
+        const ctx = GithubBackend.detectRepoContext(absPath);
+        if (ctx) {
+            let config;
+            try {
+                config = readConfig();
+            }
+            catch {
+                config = null;
+            }
+            const githubCollection = config?.collections.find((c) => c.backend === "github" && c.folderId.startsWith(`${ctx.repo}:`));
+            if (githubCollection) {
+                await addToGithub(absPath, ctx, skillName, description, githubCollection);
+                return;
+            }
+            // No matching GitHub collection — fall through to standard flow
+            // (user can run `skillsmanager collection create --backend github --repo <repo>` first)
+        }
+    }
+    // ── Standard flow ─────────────────────────────────────────────────────────────
+    let config;
+    try {
+        config = readConfig();
+    }
+    catch {
+        console.log(chalk.red("No config found. Run: skillsmanager collection create"));
+        return;
+    }
     let collection = config.collections[0];
     if (options.collection) {
         const found = config.collections.find((c) => c.name === options.collection);
@@ -41,20 +71,72 @@ export async function addCommand(skillPath, options) {
         }
         collection = found;
     }
+    if (!collection) {
+        console.log(chalk.red("No collections configured. Run: skillsmanager collection create"));
+        return;
+    }
+    const backend = await resolveBackend(collection.backend);
+    await uploadToCollection(backend, collection, absPath, skillName, description);
+}
+// ── GitHub path: register in-repo skill or copy external skill ────────────────
+async function addToGithub(absPath, ctx, skillName, description, collection) {
+    const github = new GithubBackend();
+    const spinner = ora(`Adding ${chalk.bold(skillName)} to github:${collection.folderId}...`).start();
+    try {
+        // uploadSkill is a no-op for in-repo skills; copies if external
+        await github.uploadSkill(collection, absPath, skillName);
+        // Determine effective skill path in the repo
+        const skillEntry = absPath.startsWith(ctx.repoRoot)
+            ? ctx.relPath // in-repo: use relative path
+            : `.agentskills/${skillName}`; // external: was copied here by uploadSkill
+        const col = await github.readCollection(collection);
+        const existing = col.skills.findIndex((s) => s.name === skillName);
+        if (existing >= 0) {
+            col.skills[existing] = { name: skillName, path: skillEntry, description };
+        }
+        else {
+            col.skills.push({ name: skillName, path: skillEntry, description });
+        }
+        await github.writeCollection(collection, col);
+        trackSkill(skillName, collection.id, absPath);
+        spinner.succeed(`${chalk.bold(skillName)} registered in github:${collection.folderId} at ${chalk.dim(skillEntry)}`);
+    }
+    catch (err) {
+        spinner.fail(`Failed: ${err.message}`);
+    }
+}
+// ── Shared: upload to any collection backend ──────────────────────────────────
+async function uploadToCollection(backend, collection, absPath, skillName, description) {
     const spinner = ora(`Adding ${chalk.bold(skillName)} to ${collection.name}...`).start();
     try {
         await backend.uploadSkill(collection, absPath, skillName);
+        // For GitHub collections, determine the effective in-repo path
+        let skillPath;
+        if (collection.backend === "github") {
+            // If the skill is already inside the repo workdir, use its relative path
+            const ctx = GithubBackend.detectRepoContext(absPath);
+            const repoFromCollection = collection.folderId.split(":")[0];
+            if (ctx && ctx.repo === repoFromCollection) {
+                skillPath = ctx.relPath; // e.g. "src/my-inrepo-skill"
+            }
+            else {
+                skillPath = `.agentskills/${skillName}`; // external → copied here by uploadSkill
+            }
+        }
+        else {
+            skillPath = `${skillName}/`;
+        }
         const col = await backend.readCollection(collection);
         const existing = col.skills.findIndex((s) => s.name === skillName);
         if (existing >= 0) {
-            col.skills[existing] = { name: skillName, path: `${skillName}/`, description };
+            col.skills[existing] = { name: skillName, path: skillPath, description };
         }
         else {
-            col.skills.push({ name: skillName, path: `${skillName}/`, description });
+            col.skills.push({ name: skillName, path: skillPath, description });
         }
         await backend.writeCollection(collection, col);
         trackSkill(skillName, collection.id, absPath);
-        spinner.succeed(`${chalk.bold(skillName)} added to gdrive:${collection.name}`);
+        spinner.succeed(`${chalk.bold(skillName)} added to ${collection.backend}:${collection.name}`);
     }
     catch (err) {
         spinner.fail(`Failed: ${err.message}`);

package/dist/commands/collection.d.ts

@@ -1 +1,4 @@
-export declare function collectionCreateCommand(name?: string): Promise<void>;
+export declare function collectionCreateCommand(name?: string, options?: {
+    backend?: string;
+    repo?: string;
+}): Promise<void>;

package/dist/commands/collection.js

@@ -1,42 +1,76 @@
 import chalk from "chalk";
 import ora from "ora";
-import { writeConfig, CONFIG_PATH } from "../config.js";
+import fs from "fs";
+import { writeConfig, CONFIG_PATH, readConfig } from "../config.js";
 import { ensureAuth } from "../auth.js";
 import { GDriveBackend } from "../backends/gdrive.js";
-import fs from "fs";
-export async function collectionCreateCommand(name) {
-    const auth = await ensureAuth();
-    const backend = new GDriveBackend(auth);
-    const PREFIX = "SKILLS_";
-    let folderName;
-    if (!name) {
-        folderName = `${PREFIX}MY_SKILLS`;
+import { GithubBackend } from "../backends/github.js";
+export async function collectionCreateCommand(name, options = {}) {
+    const backendName = options.backend ?? "gdrive";
+    if (backendName === "github") {
+        await createGithubCollection(name, options.repo);
     }
     else {
-        folderName = name.startsWith(PREFIX) ? name : `${PREFIX}${name}`;
+        await createGdriveCollection(name);
+    }
+}
+async function createGithubCollection(name, repo) {
+    if (!repo) {
+        console.log(chalk.red("GitHub backend requires --repo <owner/repo>"));
+        console.log(chalk.dim("  Example: skillsmanager collection create my-skills --backend github --repo owner/my-repo"));
+        return;
     }
+    const collectionName = name ?? "default";
+    const backend = new GithubBackend();
+    console.log(chalk.bold(`\nCreating GitHub collection "${collectionName}" in ${repo}...\n`));
+    try {
+        const collection = await backend.createCollection(collectionName, repo);
+        console.log(chalk.green(`\n  ✓ Collection "${collectionName}" created in github:${collection.folderId}`));
+        const config = loadOrDefaultConfig();
+        upsertCollection(config, collection);
+        writeConfig(config);
+        console.log(`\nRun ${chalk.bold("skillsmanager add <path>")} to add skills to it.\n`);
+    }
+    catch (err) {
+        console.log(chalk.red(`Failed: ${err.message}`));
+    }
+}
+async function createGdriveCollection(name) {
+    const auth = await ensureAuth();
+    const backend = new GDriveBackend(auth);
+    const PREFIX = "SKILLS_";
+    const folderName = !name
+        ? `${PREFIX}MY_SKILLS`
+        : name.startsWith(PREFIX) ? name : `${PREFIX}${name}`;
     const spinner = ora(`Creating collection "${folderName}" in Google Drive...`).start();
     try {
         const collection = await backend.createCollection(folderName);
         spinner.succeed(`Collection "${folderName}" created in Google Drive`);
-        let config = { registries: [], collections: [], skills: {}, discoveredAt: new Date().toISOString() };
-        if (fs.existsSync(CONFIG_PATH)) {
-            try {
-                config = JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8"));
-            }
-            catch { /* use default */ }
-        }
-        const already = config.collections.findIndex((c) => c.name === collection.name);
-        if (already >= 0) {
-            config.collections[already] = collection;
-        }
-        else {
-            config.collections.push(collection);
-        }
+        const config = loadOrDefaultConfig();
+        upsertCollection(config, collection);
         writeConfig(config);
-        console.log(`\nRun ${chalk.bold(`skillsmanager add <path>`)} to add skills to it.\n`);
+        console.log(`\nRun ${chalk.bold("skillsmanager add <path>")} to add skills to it.\n`);
     }
     catch (err) {
         spinner.fail(`Failed: ${err.message}`);
     }
 }
+// ── helpers ───────────────────────────────────────────────────────────────────
+function loadOrDefaultConfig() {
+    if (fs.existsSync(CONFIG_PATH)) {
+        try {
+            return readConfig();
+        }
+        catch { /* fall through */ }
+    }
+    return { registries: [], collections: [], skills: {}, discoveredAt: new Date().toISOString() };
+}
+function upsertCollection(config, collection) {
+    const idx = config.collections.findIndex((c) => c.name === collection.name);
+    if (idx >= 0) {
+        config.collections[idx] = collection;
+    }
+    else {
+        config.collections.push(collection);
+    }
+}

package/dist/commands/fetch.js

@@ -2,21 +2,22 @@ import chalk from "chalk";
 import ora from "ora";
 import path from "path";
 import { getCachePath, ensureCachePath, createSymlink } from "../cache.js";
-import { ensureReady } from "../ready.js";
-import { trackSkill } from "../config.js";
+import { readConfig, trackSkill } from "../config.js";
+import { resolveBackend } from "../backends/resolve.js";
 export async function fetchCommand(names, options) {
     if (names.length === 0) {
         console.log(chalk.red("Please specify at least one skill name."));
         console.log(chalk.dim("  Example: skillsmanager fetch pdf-skill --agent claude"));
         return;
     }
-    const { config, backend } = await ensureReady();
-    // Gather all skills across collections
+    const config = readConfig();
+    // Gather all skills across collections (resolve backend per collection)
     const allSkills = [];
     for (const collection of config.collections) {
+        const backend = await resolveBackend(collection.backend);
         const col = await backend.readCollection(collection);
         for (const entry of col.skills) {
-            allSkills.push({ entry, collection });
+            allSkills.push({ entry, collection, backend });
         }
     }
     const scope = options.scope ?? "global";
@@ -31,7 +32,7 @@ export async function fetchCommand(names, options) {
         try {
             ensureCachePath(match.collection);
             const cachePath = getCachePath(match.collection, name);
-            await backend.downloadSkill(match.collection, name, cachePath);
+            await match.backend.downloadSkill(match.collection, name, cachePath);
             const { skillsDir, created } = createSymlink(name, cachePath, options.agent, scope, cwd);
             trackSkill(name, match.collection.id, path.join(skillsDir, name));
             spinner.succeed(`${chalk.bold(name)} → ${scope === "project" ? "project" : "global"} ${options.agent} skills`);

package/dist/commands/list.js

@@ -1,10 +1,12 @@
 import chalk from "chalk";
 import ora from "ora";
-import { ensureReady } from "../ready.js";
+import { readConfig } from "../config.js";
+import { resolveBackend } from "../backends/resolve.js";
 export async function getAllSkills() {
-    const { config, backend } = await ensureReady();
+    const config = readConfig();
     const allSkills = [];
     for (const collection of config.collections) {
+        const backend = await resolveBackend(collection.backend);
         const col = await backend.readCollection(collection);
         for (const entry of col.skills) {
             allSkills.push({ entry, collection });
@@ -27,7 +29,7 @@ export async function listCommand() {
         console.log(`\n  ${chalk.dim("NAME".padEnd(maxName + 2))}${chalk.dim("DESCRIPTION".padEnd(maxDesc + 2))}${chalk.dim("SOURCE")}`);
         console.log(`  ${chalk.dim("-".repeat(maxName + maxDesc + 30))}`);
         for (const s of skills.sort((a, b) => a.entry.name.localeCompare(b.entry.name))) {
-            console.log(`  ${chalk.cyan(s.entry.name.padEnd(maxName + 2))}${s.entry.description.padEnd(maxDesc + 2)}${chalk.dim(`gdrive:${s.collection.name}`)}`);
+            console.log(`  ${chalk.cyan(s.entry.name.padEnd(maxName + 2))}${s.entry.description.padEnd(maxDesc + 2)}${chalk.dim(`${s.collection.backend}:${s.collection.name}`)}`);
         }
         console.log();
     }

package/dist/commands/refresh.js

@@ -1,40 +1,93 @@
 import chalk from "chalk";
 import ora from "ora";
-import { writeConfig, mergeCollections, readConfig } from "../config.js";
-import { ensureAuth } from "../auth.js";
-import { GDriveBackend } from "../backends/gdrive.js";
+import { writeConfig, mergeCollections, mergeRegistries, readConfig } from "../config.js";
+import { resolveBackend } from "../backends/resolve.js";
 export async function refreshCommand() {
-    const spinner = ora("Discovering collections...").start();
+    const spinner = ora("Discovering registries...").start();
     try {
-        const auth = await ensureAuth();
-        const backend = new GDriveBackend(auth);
-        const fresh = await backend.discoverCollections();
-        let existing = [];
+        let existingCollections = [];
+        let existingSkills = {};
+        let existingRegistries = [];
         try {
-            existing = readConfig().collections;
+            const cfg = readConfig();
+            existingCollections = cfg.collections;
+            existingSkills = cfg.skills ?? {};
+            existingRegistries = cfg.registries ?? [];
         }
         catch { /* no existing config */ }
-        const collections = mergeCollections(fresh, existing);
-        let existingSkills = {};
-        try {
-            existingSkills = readConfig().skills ?? {};
+        // Step 1: Discover registries across all backends
+        const backendsToScan = ["gdrive", "github", "local"];
+        const freshRegistries = [];
+        const skippedBackends = [];
+        for (const backendName of backendsToScan) {
+            try {
+                const backend = await resolveBackend(backendName);
+                const found = await backend.discoverRegistries();
+                freshRegistries.push(...found);
+            }
+            catch {
+                skippedBackends.push(backendName);
+            }
         }
-        catch { /* ok */ }
-        let existingRegistries = [];
-        try {
-            existingRegistries = readConfig().registries ?? [];
+        if (skippedBackends.length > 0) {
+            console.log(chalk.dim(`  Skipped (not configured): ${skippedBackends.join(", ")}`));
+            console.log(chalk.dim(`  Run: skillsmanager setup ${skippedBackends[0]} to enable`));
+        }
+        const mergedRegistries = mergeRegistries(freshRegistries, existingRegistries);
+        spinner.text = `Found ${mergedRegistries.length} registry(ies). Resolving collections...`;
+        // Step 2: Resolve collections from each registry's refs
+        const freshCollections = [];
+        for (const registry of mergedRegistries) {
+            try {
+                const backend = await resolveBackend(registry.backend);
+                const registryFile = await backend.readRegistry(registry);
+                for (const ref of registryFile.collections) {
+                    try {
+                        const refBackend = await resolveBackend(ref.backend);
+                        const colInfo = await refBackend.resolveCollectionRef(ref);
+                        if (colInfo) {
+                            freshCollections.push(colInfo);
+                        }
+                        else {
+                            console.log(chalk.dim(`\n  Warning: collection "${ref.name}" listed in registry "${registry.name}" could not be resolved`));
+                        }
+                    }
+                    catch {
+                        // Skip unresolvable refs silently
+                    }
+                }
+            }
+            catch {
+                // Skip registries that can't be read
+            }
         }
-        catch { /* ok */ }
-        writeConfig({ registries: existingRegistries, collections, skills: existingSkills, discoveredAt: new Date().toISOString() });
+        // Deduplicate by folderId before merging (same collection may appear in multiple registries)
+        const seenFolderIds = new Set();
+        const dedupedCollections = freshCollections.filter((c) => {
+            if (seenFolderIds.has(c.folderId))
+                return false;
+            seenFolderIds.add(c.folderId);
+            return true;
+        });
+        const mergedCollections = mergeCollections(dedupedCollections, existingCollections);
+        writeConfig({
+            registries: mergedRegistries,
+            collections: mergedCollections,
+            skills: existingSkills,
+            discoveredAt: new Date().toISOString(),
+        });
         spinner.stop();
-        if (collections.length === 0) {
-            console.log(chalk.yellow("No collections found."));
-            console.log(chalk.dim("  Run: skillsmanager collection create <name>"));
+        if (mergedRegistries.length === 0) {
+            console.log(chalk.yellow("No registries found."));
+            console.log(chalk.dim("  Run: skillsmanager registry create"));
         }
         else {
-            console.log(chalk.green(`Found ${collections.length} collection(s):`));
-            for (const c of collections) {
-                console.log(`  gdrive:${c.name}`);
+            console.log(chalk.green(`Found ${mergedRegistries.length} registry(ies), ${mergedCollections.length} collection(s):`));
+            for (const r of mergedRegistries) {
+                console.log(`  registry: ${r.backend}:${r.name}`);
+            }
+            for (const c of mergedCollections) {
+                console.log(`  collection: ${c.backend}:${c.name}`);
             }
         }
         console.log();

package/dist/commands/registry.d.ts

@@ -1,5 +1,6 @@
 export declare function registryCreateCommand(options: {
     backend?: string;
+    repo?: string;
 }): Promise<void>;
 export declare function registryListCommand(): Promise<void>;
 export declare function registryDiscoverCommand(options: {
@@ -9,6 +10,10 @@ export declare function registryAddCollectionCommand(collectionName: string, opt
     backend?: string;
     ref?: string;
 }): Promise<void>;
+export declare function registryRemoveCollectionCommand(collectionName: string, options: {
+    delete?: boolean;
+}): Promise<void>;
 export declare function registryPushCommand(options: {
     backend?: string;
+    repo?: string;
 }): Promise<void>;