@skillsmanager/cli 0.0.2 → 0.0.5

package/dist/commands/registry.js

@@ -1,55 +1,64 @@
 import chalk from "chalk";
 import ora from "ora";
 import fs from "fs";
-import { readConfig, writeConfig, mergeRegistries, CONFIG_PATH } from "../config.js";
-import { ensureAuth } from "../auth.js";
-import { GDriveBackend } from "../backends/gdrive.js";
+import { readConfig, writeConfig, mergeRegistries, CONFIG_PATH, CACHE_DIR } from "../config.js";
+import { GithubBackend } from "../backends/github.js";
 import { LocalBackend } from "../backends/local.js";
+import { resolveBackend } from "../backends/resolve.js";
 export async function registryCreateCommand(options) {
     const backend = options.backend ?? "local";
-    if (backend === "local") {
-        const local = new LocalBackend();
-        const spinner = ora("Creating local registry...").start();
-        try {
-            const registry = await local.createRegistry();
-            spinner.succeed(`Local registry created`);
-            let config = { registries: [], collections: [], skills: {}, discoveredAt: new Date().toISOString() };
-            if (fs.existsSync(CONFIG_PATH)) {
-                try {
-                    config = readConfig();
-                }
-                catch { /* use default */ }
-            }
-            config.registries.push(registry);
-            writeConfig(config);
+    const supported = ["local", "gdrive", "github"];
+    if (!supported.includes(backend)) {
+        console.log(chalk.red(`Unknown backend "${backend}". Supported: ${supported.join(", ")}`));
+        return;
+    }
+    if (backend === "github" && !options.repo) {
+        console.log(chalk.red("GitHub backend requires --repo <owner/repo>"));
+        console.log(chalk.dim("  Example: skillsmanager registry create --backend github --repo owner/my-repo"));
+        return;
+    }
+    const label = backend === "local" ? "locally" : `in ${backend}`;
+    const spinner = ora(`Creating registry ${label}...`).start();
+    try {
+        let registry;
+        if (backend === "github") {
+            registry = await new GithubBackend().createRegistry(undefined, options.repo);
         }
-        catch (err) {
-            spinner.fail(`Failed: ${err.message}`);
+        else {
+            registry = await (await resolveBackend(backend)).createRegistry();
         }
-    }
-    else if (backend === "gdrive") {
-        const auth = await ensureAuth();
-        const gdrive = new GDriveBackend(auth);
-        const spinner = ora("Creating registry in Google Drive...").start();
-        try {
-            const registry = await gdrive.createRegistry();
-            spinner.succeed(`Registry created in Google Drive`);
-            let config = { registries: [], collections: [], skills: {}, discoveredAt: new Date().toISOString() };
-            if (fs.existsSync(CONFIG_PATH)) {
+        spinner.succeed(`Registry created ${label}`);
+        let config = { registries: [], collections: [], skills: {}, discoveredAt: new Date().toISOString() };
+        if (fs.existsSync(CONFIG_PATH)) {
+            try {
+                config = readConfig();
+            }
+            catch { /* use default */ }
+        }
+        config.registries.push(registry);
+        writeConfig(config);
+        if (backend !== "local") {
+            const localReg = config.registries.find((r) => r.backend === "local");
+            if (localReg) {
+                const local = new LocalBackend();
                 try {
-                    config = readConfig();
+                    const localData = await local.readRegistry(localReg);
+                    const localCollections = localData.collections.filter((c) => c.backend === "local");
+                    if (localCollections.length > 0) {
+                        const names = localCollections.map((c) => chalk.cyan(c.name)).join(", ");
+                        console.log(chalk.yellow(`\n  Found local registry with ${localCollections.length} collection(s): ${names}`));
+                        const pushCmd = backend === "github"
+                            ? `skillsmanager registry push --backend github --repo ${options.repo}`
+                            : `skillsmanager registry push --backend ${backend}`;
+                        console.log(chalk.dim(`  Run ${chalk.white(pushCmd)} to back them up to ${backend}.\n`));
+                    }
                 }
-                catch { /* use default */ }
+                catch { /* local registry unreadable, skip hint */ }
             }
-            config.registries.push(registry);
-            writeConfig(config);
-        }
-        catch (err) {
-            spinner.fail(`Failed: ${err.message}`);
         }
     }
-    else {
-        console.log(chalk.red(`Unknown backend "${backend}". Supported: local, gdrive`));
+    catch (err) {
+        spinner.fail(`Failed: ${err.message}`);
     }
 }
 export async function registryListCommand() {
@@ -69,9 +78,7 @@ export async function registryListCommand() {
     for (const reg of config.registries) {
         console.log(`\n${chalk.bold(reg.name)} ${chalk.dim(`(${reg.backend})`)}`);
         try {
-            const backend = reg.backend === "gdrive"
-                ? new GDriveBackend(await ensureAuth())
-                : new LocalBackend();
+            const backend = await resolveBackend(reg.backend);
             const data = await backend.readRegistry(reg);
             if (data.collections.length === 0) {
                 console.log(chalk.dim("  No collections"));
@@ -92,9 +99,7 @@ export async function registryDiscoverCommand(options) {
     const backendName = options.backend ?? "local";
     const spinner = ora(`Discovering registries in ${backendName}...`).start();
     try {
-        const backend = backendName === "gdrive"
-            ? new GDriveBackend(await ensureAuth())
-            : new LocalBackend();
+        const backend = await resolveBackend(backendName);
         const fresh = await backend.discoverRegistries();
         let config = { registries: [], collections: [], skills: {}, discoveredAt: new Date().toISOString() };
         if (fs.existsSync(CONFIG_PATH)) {
@@ -135,9 +140,7 @@ export async function registryAddCollectionCommand(collectionName, options) {
     }
     // Use first registry
     const reg = config.registries[0];
-    const backend = reg.backend === "gdrive"
-        ? new GDriveBackend(await ensureAuth())
-        : new LocalBackend();
+    const backend = await resolveBackend(reg.backend);
     const data = await backend.readRegistry(reg);
     const existing = data.collections.find((c) => c.name === collectionName);
     if (existing) {
@@ -152,10 +155,106 @@ export async function registryAddCollectionCommand(collectionName, options) {
     await backend.writeRegistry(reg, data);
     console.log(chalk.green(`Added "${collectionName}" to registry "${reg.name}".`));
 }
+export async function registryRemoveCollectionCommand(collectionName, options) {
+    let config;
+    try {
+        config = readConfig();
+    }
+    catch {
+        console.log(chalk.red("No config found."));
+        return;
+    }
+    if (config.registries.length === 0) {
+        console.log(chalk.red("No registries configured."));
+        return;
+    }
+    // Search all registries for the collection; prefer one matching --backend if given
+    let reg = config.registries[0];
+    let data = null;
+    let backend = await resolveBackend(reg.backend);
+    for (const r of config.registries) {
+        if (options.backend && r.backend !== options.backend)
+            continue;
+        try {
+            const b = await resolveBackend(r.backend);
+            const d = await b.readRegistry(r);
+            if (d.collections.find((c) => c.name === collectionName)) {
+                reg = r;
+                backend = b;
+                data = d;
+                break;
+            }
+        }
+        catch { /* skip unreadable registries */ }
+    }
+    if (!data) {
+        // Fall back to reading the first (or backend-matched) registry for the error message
+        try {
+            data = await backend.readRegistry(reg);
+        }
+        catch { /**/ }
+    }
+    const ref = data?.collections.find((c) => c.name === collectionName);
+    if (!ref) {
+        console.log(chalk.yellow(`Collection "${collectionName}" not found in any registry.`));
+        return;
+    }
+    // If --delete, delete the actual collection and skills from the backend
+    if (options.delete) {
+        const collectionInConfig = config.collections.find((c) => c.name === collectionName);
+        if (collectionInConfig) {
+            const collBackend = await resolveBackend(collectionInConfig.backend);
+            const spinner = ora(`Deleting collection "${collectionName}" from ${collectionInConfig.backend}...`).start();
+            try {
+                await collBackend.deleteCollection(collectionInConfig);
+                spinner.succeed(`Deleted collection "${collectionName}" from ${collectionInConfig.backend}`);
+            }
+            catch (err) {
+                spinner.fail(`Failed to delete: ${err.message}`);
+                return;
+            }
+        }
+        // Clean up local cache
+        if (collectionInConfig) {
+            const cachePath = path.join(CACHE_DIR, collectionInConfig.id);
+            if (fs.existsSync(cachePath)) {
+                fs.rmSync(cachePath, { recursive: true, force: true });
+            }
+        }
+    }
+    // Remove ref from registry
+    data.collections = data.collections.filter((c) => c.name !== collectionName);
+    await backend.writeRegistry(reg, data);
+    // Remove from local config — capture ID before removal for skills cleanup
+    const removedColId = config.collections.find((c) => c.name === collectionName)?.id;
+    config.collections = config.collections.filter((c) => c.name !== collectionName);
+    // Remove skills index entries for this collection
+    if (removedColId) {
+        for (const [skillName, locations] of Object.entries(config.skills)) {
+            config.skills[skillName] = locations.filter((l) => l.collectionId !== removedColId);
+            if (config.skills[skillName].length === 0)
+                delete config.skills[skillName];
+        }
+    }
+    writeConfig(config);
+    if (options.delete) {
+        console.log(chalk.green(`Removed and deleted "${collectionName}" from registry "${reg.name}".`));
+    }
+    else {
+        console.log(chalk.green(`Removed "${collectionName}" from registry "${reg.name}".`));
+        console.log(chalk.dim(`  Collection data was kept. Use --delete to permanently remove it.`));
+    }
+}
 export async function registryPushCommand(options) {
     const targetBackend = options.backend ?? "gdrive";
-    if (targetBackend !== "gdrive") {
-        console.log(chalk.red(`Push to "${targetBackend}" not yet supported. Use: --backend gdrive`));
+    const supportedPush = ["gdrive", "github"];
+    if (!supportedPush.includes(targetBackend)) {
+        console.log(chalk.red(`Push to "${targetBackend}" not yet supported. Use: --backend gdrive or --backend github`));
+        return;
+    }
+    if (targetBackend === "github" && !options.repo) {
+        console.log(chalk.red("GitHub backend requires --repo <owner/repo>"));
+        console.log(chalk.dim("  Example: skillsmanager registry push --backend github --repo owner/my-repo"));
         return;
     }
     let config;
@@ -166,7 +265,6 @@ export async function registryPushCommand(options) {
         console.log(chalk.red("No config found."));
         return;
     }
-    // Find local registry
     const localReg = config.registries.find((r) => r.backend === "local");
     if (!localReg) {
         console.log(chalk.yellow("No local registry to push."));
@@ -179,39 +277,57 @@ export async function registryPushCommand(options) {
         console.log(chalk.yellow("No local collections to push."));
         return;
     }
-    const auth = await ensureAuth();
-    const gdrive = new GDriveBackend(auth);
-    // ── Phase 1: Upload all collections (no state changes yet) ─────────────
-    // If any collection fails, we abort and nothing is committed.
-    const spinner = ora("Pushing collections to Google Drive...").start();
-    // Discover or create gdrive registry (this is safe — an empty registry is harmless)
-    let gdriveReg = config.registries.find((r) => r.backend === "gdrive");
-    if (!gdriveReg) {
-        spinner.text = "Creating registry in Google Drive...";
-        gdriveReg = await gdrive.createRegistry();
-    }
-    // Accumulate results — only commit if ALL succeed
+    const remote = await resolveBackend(targetBackend);
+    const spinner = ora(`Pushing collections to ${targetBackend}...`).start();
+    // Find or create target registry
+    let targetReg = config.registries.find((r) => r.backend === targetBackend);
+    if (!targetReg) {
+        spinner.text = `Creating registry in ${targetBackend}...`;
+        targetReg = await remote.createRegistry();
+    }
+    // Read remote registry upfront to know what's already synced
+    let remoteData;
+    try {
+        remoteData = await remote.readRegistry(targetReg);
+    }
+    catch {
+        remoteData = { name: targetReg.name, owner: await remote.getOwner(), source: targetBackend, collections: [] };
+    }
+    const alreadySynced = new Set(remoteData.collections.map((c) => c.name));
+    // Skip collections already present in the remote registry
+    const toUpload = localCollectionRefs.filter((ref) => !alreadySynced.has(ref.name));
+    if (toUpload.length === 0) {
+        spinner.succeed("Remote registry is already up to date.");
+        return;
+    }
+    // Phase 1: Upload new collections — abort on any failure
     const pushed = [];
     try {
-        for (const ref of localCollectionRefs) {
+        for (const ref of toUpload) {
             spinner.text = `Uploading collection "${ref.name}"...`;
             const collInfo = await local.resolveCollectionRef(ref);
-            if (!collInfo) {
+            if (!collInfo)
                 throw new Error(`Collection "${ref.name}" not found locally`);
+            let remoteCol;
+            if (targetBackend === "gdrive") {
+                const gdrive = remote;
+                const folderName = `SKILLS_${ref.name.toUpperCase()}`;
+                remoteCol = await gdrive.createCollection(folderName);
+            }
+            else {
+                const github = remote;
+                remoteCol = await github.createCollection(ref.name, options.repo);
             }
-            const PREFIX = "SKILLS_";
-            const folderName = `${PREFIX}${ref.name.toUpperCase()}`;
-            const driveCol = await gdrive.createCollection(folderName);
             const colData = await local.readCollection({ ...collInfo, id: "temp" });
             for (const skill of colData.skills) {
                 const localSkillPath = path.join(collInfo.folderId, skill.name);
                 if (fs.existsSync(localSkillPath)) {
                     spinner.text = `Uploading ${ref.name}/${skill.name}...`;
-                    await gdrive.uploadSkill(driveCol, localSkillPath, skill.name);
+                    await remote.uploadSkill(remoteCol, localSkillPath, skill.name);
                 }
             }
-            await gdrive.writeCollection(driveCol, colData);
-            pushed.push({ ref, driveCol, folderName });
+            await remote.writeCollection(remoteCol, colData);
+            pushed.push({ ref, remoteCol });
         }
     }
     catch (err) {
@@ -219,39 +335,31 @@ export async function registryPushCommand(options) {
         console.log(chalk.dim("  No changes were committed. Local state is unchanged."));
         return;
     }
-    // ── Phase 2: Commit — update registry and config atomically ────────────
+    // Phase 2: Commit — update registry and config atomically
     spinner.text = "Updating registry...";
     try {
-        // Read current gdrive registry (may already have entries)
-        let gdriveData;
-        try {
-            gdriveData = await gdrive.readRegistry(gdriveReg);
-        }
-        catch {
-            gdriveData = { name: gdriveReg.name, owner: await gdrive.getOwner(), source: "gdrive", collections: [] };
-        }
-        // Add all pushed collections at once
-        for (const { ref, folderName } of pushed) {
-            gdriveData.collections.push({ name: ref.name, backend: "gdrive", ref: folderName });
+        for (const { ref, remoteCol } of pushed) {
+            if (!remoteData.collections.find((c) => c.name === ref.name)) {
+                remoteData.collections.push({ name: ref.name, backend: targetBackend, ref: remoteCol.folderId });
+            }
         }
-        await gdrive.writeRegistry(gdriveReg, gdriveData);
-        // Update local config
-        if (!config.registries.find((r) => r.id === gdriveReg.id)) {
-            config.registries.push(gdriveReg);
+        await remote.writeRegistry(targetReg, remoteData);
+        if (!config.registries.find((r) => r.id === targetReg.id)) {
+            config.registries.push(targetReg);
         }
-        for (const { driveCol } of pushed) {
-            config.collections.push(driveCol);
+        for (const { remoteCol } of pushed) {
+            config.collections.push(remoteCol);
         }
         writeConfig(config);
-        spinner.succeed(`Pushed ${pushed.length} collection(s) to Google Drive`);
+        spinner.succeed(`Pushed ${pushed.length} collection(s) to ${targetBackend}`);
         for (const { ref } of pushed) {
-            console.log(chalk.dim(`  ${ref.name} → gdrive`));
+            console.log(chalk.dim(`  ${ref.name} → ${targetBackend}`));
         }
     }
     catch (err) {
         spinner.fail(`Failed to update registry: ${err.message}`);
         console.log(chalk.dim("  Collections were uploaded but the registry was not updated."));
-        console.log(chalk.dim("  Run 'skillsmanager registry push' again to retry."));
+        console.log(chalk.dim(`  Run 'skillsmanager registry push --backend ${targetBackend}' again to retry.`));
     }
 }
 // Need path import for push command

package/dist/commands/setup/github.d.ts

@@ -0,0 +1,4 @@
+export declare function ghInstalled(): boolean;
+export declare function ghAuthed(): boolean;
+export declare function ghGetLogin(): string;
+export declare function setupGithubCommand(): Promise<void>;

package/dist/commands/setup/github.js

@@ -0,0 +1,91 @@
+import { spawnSync } from "child_process";
+import chalk from "chalk";
+// ── helpers ───────────────────────────────────────────────────────────────────
+export function ghInstalled() {
+    return spawnSync("gh", ["--version"], { stdio: "pipe" }).status === 0;
+}
+export function ghAuthed() {
+    return spawnSync("gh", ["auth", "status"], { stdio: "pipe" }).status === 0;
+}
+export function ghGetLogin() {
+    const r = spawnSync("gh", ["api", "user", "--jq", ".login"], {
+        encoding: "utf-8", stdio: "pipe",
+    });
+    return r.status === 0 ? (r.stdout?.trim() ?? "") : "";
+}
+async function installGh() {
+    if (process.platform !== "darwin") {
+        console.log(chalk.yellow("  Auto-install is only supported on macOS."));
+        console.log(chalk.dim("  Install manually: https://cli.github.com/manual/installation"));
+        return false;
+    }
+    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 gh via Homebrew..."));
+    const r = spawnSync("brew", ["install", "gh"], { stdio: "inherit" });
+    if (r.status !== 0) {
+        console.log(chalk.red("  Install failed. Try manually: brew install gh"));
+        return false;
+    }
+    return ghInstalled();
+}
+// ── main command ──────────────────────────────────────────────────────────────
+export async function setupGithubCommand() {
+    console.log(chalk.bold("\nSkills Manager — GitHub Setup\n"));
+    // Step 1: Check gh CLI
+    console.log(chalk.bold("Step 1 — gh CLI\n"));
+    if (!ghInstalled()) {
+        console.log(chalk.yellow("  gh CLI is not installed."));
+        const readline = await import("readline");
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        const ans = await new Promise((resolve) => {
+            rl.question(`  Install it now via Homebrew? ${chalk.dim("[y/n]")} `, (a) => {
+                rl.close();
+                resolve(a.trim().toLowerCase());
+            });
+        });
+        if (!ans.startsWith("y")) {
+            console.log(chalk.dim("  Install manually: https://cli.github.com/manual/installation"));
+            console.log(chalk.dim("  Then re-run: skillsmanager setup github"));
+            return;
+        }
+        const ok = await installGh();
+        if (!ok)
+            return;
+        console.log(chalk.green("  ✓ gh installed"));
+    }
+    else {
+        console.log(chalk.green("  ✓ gh is installed"));
+    }
+    // Step 2: Check auth
+    console.log(chalk.bold("\nStep 2 — GitHub Authentication\n"));
+    if (ghAuthed()) {
+        const r = spawnSync("gh", ["api", "user", "--jq", ".login"], {
+            encoding: "utf-8", stdio: "pipe",
+        });
+        const login = r.stdout?.trim() ?? "";
+        console.log(chalk.green(`  ✓ Already authenticated${login ? ` as ${chalk.white(login)}` : ""}`));
+    }
+    else {
+        console.log(chalk.dim("  Running gh auth login..."));
+        const r = spawnSync("gh", ["auth", "login"], { stdio: "inherit" });
+        if (r.status !== 0) {
+            console.log(chalk.red("  Authentication failed. Please try manually: gh auth login"));
+            return;
+        }
+        const r2 = spawnSync("gh", ["api", "user", "--jq", ".login"], {
+            encoding: "utf-8", stdio: "pipe",
+        });
+        const login = r2.stdout?.trim() ?? "";
+        if (!login) {
+            console.log(chalk.red("  Could not verify authentication."));
+            return;
+        }
+        console.log(chalk.green(`  ✓ Authenticated as ${chalk.white(login)}`));
+    }
+    console.log(chalk.green("\n  ✓ GitHub setup complete!"));
+    console.log(`\nRun ${chalk.bold("skillsmanager collection create --backend github")} to create a collection.\n`);
+}