@skillsmanager/cli 0.0.4 → 0.0.5

package/dist/commands/collection.js

@@ -5,16 +5,18 @@ import { writeConfig, CONFIG_PATH, readConfig } from "../config.js";
 import { ensureAuth } from "../auth.js";
 import { GDriveBackend } from "../backends/gdrive.js";
 import { GithubBackend } from "../backends/github.js";
+import { LocalBackend } from "../backends/local.js";
+import { resolveBackend } from "../backends/resolve.js";
 export async function collectionCreateCommand(name, options = {}) {
     const backendName = options.backend ?? "gdrive";
     if (backendName === "github") {
-        await createGithubCollection(name, options.repo);
+        await createGithubCollection(name, options.repo, options.skillsRepo);
     }
     else {
         await createGdriveCollection(name);
     }
 }
-async function createGithubCollection(name, repo) {
+async function createGithubCollection(name, repo, skillsRepo) {
     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"));
@@ -22,12 +24,19 @@ async function createGithubCollection(name, repo) {
     }
     const collectionName = name ?? "default";
     const backend = new GithubBackend();
-    console.log(chalk.bold(`\nCreating GitHub collection "${collectionName}" in ${repo}...\n`));
+    if (skillsRepo && skillsRepo !== repo) {
+        console.log(chalk.bold(`\nCreating GitHub collection "${collectionName}" in ${repo} (skills source: ${skillsRepo})...\n`));
+    }
+    else {
+        console.log(chalk.bold(`\nCreating GitHub collection "${collectionName}" in ${repo}...\n`));
+    }
     try {
-        const collection = await backend.createCollection(collectionName, repo);
+        const collection = await backend.createCollection(collectionName, repo, skillsRepo);
         console.log(chalk.green(`\n  ✓ Collection "${collectionName}" created in github:${collection.folderId}`));
         const config = loadOrDefaultConfig();
         upsertCollection(config, collection);
+        const registry = await ensureRegistry(config);
+        await registerCollectionInRegistry(registry, collection, config);
         writeConfig(config);
         console.log(`\nRun ${chalk.bold("skillsmanager add <path>")} to add skills to it.\n`);
     }
@@ -48,6 +57,8 @@ async function createGdriveCollection(name) {
         spinner.succeed(`Collection "${folderName}" created in Google Drive`);
         const config = loadOrDefaultConfig();
         upsertCollection(config, collection);
+        const registry = await ensureRegistry(config);
+        await registerCollectionInRegistry(registry, collection, config);
         writeConfig(config);
         console.log(`\nRun ${chalk.bold("skillsmanager add <path>")} to add skills to it.\n`);
     }
@@ -74,3 +85,32 @@ function upsertCollection(config, collection) {
         config.collections.push(collection);
     }
 }
+/** Returns the first registry in config, auto-creating a local one if none exists. */
+async function ensureRegistry(config) {
+    if (config.registries.length > 0)
+        return config.registries[0];
+    console.log(chalk.dim("  No registry found — creating a local registry..."));
+    const local = new LocalBackend();
+    const registry = await local.createRegistry();
+    config.registries.push(registry);
+    console.log(chalk.green("  ✓ Local registry created"));
+    return registry;
+}
+/** Registers the collection ref in the given registry (writes directly to the registry's backend). */
+async function registerCollectionInRegistry(registry, collection, config) {
+    const backend = await resolveBackend(registry.backend);
+    const registryData = await backend.readRegistry(registry);
+    if (registryData.collections.find((c) => c.name === collection.name))
+        return;
+    registryData.collections.push({
+        name: collection.name,
+        backend: collection.backend,
+        ref: collection.folderId,
+    });
+    await backend.writeRegistry(registry, registryData);
+    // Keep local config registry list in sync
+    if (!config.registries.find((r) => r.id === registry.id)) {
+        config.registries.push(registry);
+    }
+    console.log(chalk.dim(`  Registered in registry "${registry.name}" (${registry.backend})`));
+}

package/dist/commands/logout.d.ts

@@ -0,0 +1,4 @@
+export declare function logoutGoogleCommand(options: {
+    all?: boolean;
+}): Promise<void>;
+export declare function logoutGithubCommand(): void;

package/dist/commands/logout.js

@@ -0,0 +1,35 @@
+import fs from "fs";
+import chalk from "chalk";
+import { CREDENTIALS_PATH, TOKEN_PATH } from "../config.js";
+import { spawnSync } from "child_process";
+export async function logoutGoogleCommand(options) {
+    const removeAll = options.all;
+    let removed = false;
+    if (fs.existsSync(TOKEN_PATH)) {
+        fs.unlinkSync(TOKEN_PATH);
+        console.log(chalk.green("  ✓ Removed token.json (OAuth session cleared)"));
+        removed = true;
+    }
+    else {
+        console.log(chalk.dim("  – token.json not found (already logged out)"));
+    }
+    if (removeAll) {
+        if (fs.existsSync(CREDENTIALS_PATH)) {
+            fs.unlinkSync(CREDENTIALS_PATH);
+            console.log(chalk.green("  ✓ Removed credentials.json (OAuth client cleared)"));
+            removed = true;
+        }
+        else {
+            console.log(chalk.dim("  – credentials.json not found"));
+        }
+    }
+    if (removed) {
+        console.log(chalk.dim("\n  Run skillsmanager setup google to set up again."));
+    }
+}
+export function logoutGithubCommand() {
+    const r = spawnSync("gh", ["auth", "logout"], { stdio: "inherit" });
+    if (r.status !== 0) {
+        console.log(chalk.red("  gh auth logout failed. Try manually: gh auth logout"));
+    }
+}

package/dist/commands/registry.d.ts

@@ -12,6 +12,7 @@ export declare function registryAddCollectionCommand(collectionName: string, opt
 }): Promise<void>;
 export declare function registryRemoveCollectionCommand(collectionName: string, options: {
     delete?: boolean;
+    backend?: string;
 }): Promise<void>;
 export declare function registryPushCommand(options: {
     backend?: string;

package/dist/commands/registry.js

@@ -37,6 +37,25 @@ export async function registryCreateCommand(options) {
         }
         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 {
+                    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 { /* local registry unreadable, skip hint */ }
+            }
+        }
     }
     catch (err) {
         spinner.fail(`Failed: ${err.message}`);
@@ -149,12 +168,35 @@ export async function registryRemoveCollectionCommand(collectionName, options) {
         console.log(chalk.red("No registries configured."));
         return;
     }
-    const reg = config.registries[0];
-    const backend = await resolveBackend(reg.backend);
-    const data = await backend.readRegistry(reg);
-    const ref = data.collections.find((c) => c.name === collectionName);
+    // 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 registry.`));
+        console.log(chalk.yellow(`Collection "${collectionName}" not found in any registry.`));
         return;
     }
     // If --delete, delete the actual collection and skills from the backend
@@ -243,10 +285,25 @@ export async function registryPushCommand(options) {
         spinner.text = `Creating registry in ${targetBackend}...`;
         targetReg = await remote.createRegistry();
     }
-    // Phase 1: Upload all collections — abort on any failure
+    // 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)
@@ -281,17 +338,12 @@ export async function registryPushCommand(options) {
     // Phase 2: Commit — update registry and config atomically
     spinner.text = "Updating registry...";
     try {
-        let targetData;
-        try {
-            targetData = await remote.readRegistry(targetReg);
-        }
-        catch {
-            targetData = { name: targetReg.name, owner: await remote.getOwner(), source: targetBackend, collections: [] };
-        }
         for (const { ref, remoteCol } of pushed) {
-            targetData.collections.push({ name: ref.name, backend: targetBackend, ref: remoteCol.folderId });
+            if (!remoteData.collections.find((c) => c.name === ref.name)) {
+                remoteData.collections.push({ name: ref.name, backend: targetBackend, ref: remoteCol.folderId });
+            }
         }
-        await remote.writeRegistry(targetReg, targetData);
+        await remote.writeRegistry(targetReg, remoteData);
         if (!config.registries.find((r) => r.id === targetReg.id)) {
             config.registries.push(targetReg);
         }

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

@@ -1 +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

@@ -1,12 +1,18 @@
 import { spawnSync } from "child_process";
 import chalk from "chalk";
 // ── helpers ───────────────────────────────────────────────────────────────────
-function ghInstalled() {
+export function ghInstalled() {
     return spawnSync("gh", ["--version"], { stdio: "pipe" }).status === 0;
 }
-function ghAuthed() {
+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."));

package/dist/commands/setup/google.js

@@ -4,9 +4,10 @@ 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 { CREDENTIALS_PATH, ensureConfigDir, CONFIG_PATH, readConfig } from "../../config.js";
+import { runAuthFlow, hasToken, getAuthedEmail } from "../../auth.js";
 import { credentialsExist } from "../../config.js";
+import { LocalBackend } from "../../backends/local.js";
 // ─── Prompt helpers ──────────────────────────────────────────────────────────
 function ask(question) {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -123,6 +124,26 @@ function openUrl(url) {
     }
     catch { /* ignore */ }
 }
+// ─── Post-auth nudge ─────────────────────────────────────────────────────────
+async function printPushNudgeIfNeeded() {
+    if (!fs.existsSync(CONFIG_PATH))
+        return;
+    try {
+        const config = readConfig();
+        const localReg = config.registries.find((r) => r.backend === "local");
+        if (!localReg)
+            return;
+        const local = new LocalBackend();
+        const localData = await local.readRegistry(localReg);
+        const localCollections = localData.collections.filter((c) => c.backend === "local");
+        if (localCollections.length === 0)
+            return;
+        const names = localCollections.map((c) => chalk.cyan(c.name)).join(", ");
+        console.log(chalk.yellow(`\n  Found local registry with ${localCollections.length} collection(s): ${names}`));
+        console.log(chalk.dim(`  Run ${chalk.white("skillsmanager registry push --backend gdrive")} to back them up to Google Drive.\n`));
+    }
+    catch { /* unreadable config, skip hint */ }
+}
 // ─── Main command ─────────────────────────────────────────────────────────────
 export async function setupGoogleCommand() {
     console.log(chalk.bold("\nSkills Manager — Google Drive Setup\n"));
@@ -131,13 +152,16 @@ export async function setupGoogleCommand() {
         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`);
+            await printPushNudgeIfNeeded();
+            console.log(`Run ${chalk.bold("skillsmanager refresh")} 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`);
+        const client = await runAuthFlow();
+        const authedEmail = await getAuthedEmail(client);
+        console.log(chalk.green(`\n  ✓ Authenticated successfully${authedEmail ? ` as ${chalk.white(authedEmail)}` : ""}.`));
+        await printPushNudgeIfNeeded();
+        console.log(`Run ${chalk.bold("skillsmanager refresh")} to discover registries.\n`);
         return;
     }
     // ── Case 2: No credentials.json ───────────────────────────────────────────
@@ -189,33 +213,54 @@ export async function setupGoogleCommand() {
     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"));
+    // ── Enable APIs ───────────────────────────────────────────────────────────
+    console.log(chalk.bold("\nStep 4 — Enable Required APIs\n"));
+    const REQUIRED_APIS = [
+        { api: "drive.googleapis.com", label: "Google Drive API" },
+    ];
+    for (const { api, label } of REQUIRED_APIS) {
+        if (apiEnabled(projectId, api)) {
+            console.log(chalk.green(`  ✓ ${label} already enabled`));
         }
         else {
-            console.log(chalk.red("  Failed to enable Google Drive API. Check that billing is set up for the project."));
-            return;
+            const ok = enableApi(projectId, api);
+            if (ok) {
+                console.log(chalk.green(`  ✓ ${label} enabled`));
+            }
+            else {
+                console.log(chalk.red(`  Failed to enable ${label}. Check that billing is set up for the project.`));
+                return;
+            }
         }
     }
+    // ── Configure OAuth Consent Screen ────────────────────────────────────────
+    console.log(chalk.bold("\nStep 5 — Configure OAuth Consent Screen\n"));
+    console.log("  Before creating credentials, Google requires you to configure the");
+    console.log("  OAuth consent screen (the login screen your users will see).\n");
+    console.log(`  ${chalk.yellow("Note:")} Personal Google accounts can only create ${chalk.white("External")} apps.`);
+    console.log(`  External apps start in Testing mode — only test users you add can sign in.\n`);
+    const consentUrl = `https://console.cloud.google.com/apis/credentials/consent?project=${projectId}`;
+    console.log(`  URL: ${chalk.cyan(consentUrl)}\n`);
+    console.log(chalk.dim("  Instructions:"));
+    console.log(chalk.dim(`    1. Audience → select ${chalk.white("External")} (required for personal accounts)`));
+    console.log(chalk.dim(`    2. App name → ${chalk.white("Skills Manager")}`));
+    console.log(chalk.dim(`    3. User support email → ${chalk.white(account)}`));
+    console.log(chalk.dim(`    4. Contact email → ${chalk.white(account)}`));
+    console.log(chalk.dim(`    5. Click "Create"`));
+    console.log(chalk.dim(`    6. Scroll to "Test users" → "Add users" → enter ${chalk.white(account)} → Save\n`));
+    openUrl(consentUrl);
+    await ask("Press Enter once you have configured the consent screen and added yourself as a test user...");
     // ── 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");
+    console.log(chalk.bold("\nStep 6 — Create OAuth 2.0 Credentials\n"));
+    console.log("  Now create the OAuth client ID that Skills Manager will use to authenticate.");
+    console.log("  Opening the Google Cloud Console...\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"));
+    console.log(chalk.dim(`    1. Application type → ${chalk.white("Desktop app")}`));
+    console.log(chalk.dim(`    2. Name → ${chalk.white("Skills Manager")} (or anything)`));
+    console.log(chalk.dim(`    3. Click "Create" → then "Download JSON"`));
+    console.log(chalk.dim(`    4. Save the file (it will land in your Downloads folder)\n`));
     openUrl(credentialsUrl);
     await ask("Press Enter once you have downloaded the credentials JSON file...");
     // ── Locate and copy the file ──────────────────────────────────────────────
@@ -248,23 +293,13 @@ export async function setupGoogleCommand() {
     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`);
+    const client = await runAuthFlow();
+    const authedEmail = await getAuthedEmail(client);
+    console.log(chalk.green(`\n  ✓ Setup complete! Authenticated as ${chalk.white(authedEmail ?? account)}`));
+    await printPushNudgeIfNeeded();
+    console.log(`Run ${chalk.bold("skillsmanager refresh")} to discover your registries.\n`);
 }
 function printManualInstructions() {
     console.log(chalk.bold("\nManual Setup Instructions\n"));
@@ -272,10 +307,15 @@ function printManualInstructions() {
     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("  4. Configure the OAuth consent screen:");
+    console.log("       APIs & Services → OAuth consent screen");
+    console.log("       Audience: External (required for personal Google accounts)");
+    console.log("       Fill in App name, support email, and contact email");
+    console.log("       Under \"Test users\", add your own Google account email");
+    console.log("  5. 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("  6. 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/skill.d.ts

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

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,65 @@
+import os from "os";
+import chalk from "chalk";
+import { credentialsExist } from "../config.js";
+import { hasToken, getAuthClient } from "../auth.js";
+import { GDriveBackend } from "../backends/gdrive.js";
+import { ghInstalled, ghAuthed, ghGetLogin } from "./setup/github.js";
+async function getGdriveStatus() {
+    if (!credentialsExist()) {
+        return { name: "gdrive", loggedIn: false, identity: "", hint: "run: skillsmanager setup google" };
+    }
+    if (!hasToken()) {
+        return { name: "gdrive", loggedIn: false, identity: "", hint: "run: skillsmanager setup google" };
+    }
+    try {
+        const client = getAuthClient();
+        const backend = new GDriveBackend(client);
+        const email = await backend.getOwner();
+        return { name: "gdrive", loggedIn: true, identity: email };
+    }
+    catch {
+        return { name: "gdrive", loggedIn: false, identity: "", hint: "run: skillsmanager setup google" };
+    }
+}
+function getGithubStatus() {
+    if (!ghInstalled()) {
+        return { name: "github", loggedIn: false, identity: "", hint: "install gh CLI first" };
+    }
+    if (!ghAuthed()) {
+        return { name: "github", loggedIn: false, identity: "", hint: "run: skillsmanager setup github" };
+    }
+    const login = ghGetLogin();
+    return { name: "github", loggedIn: true, identity: login };
+}
+export async function statusCommand() {
+    const localStatus = {
+        name: "local",
+        loggedIn: true,
+        identity: os.userInfo().username,
+    };
+    const [gdriveStatus, githubStatus] = await Promise.all([
+        getGdriveStatus(),
+        Promise.resolve(getGithubStatus()),
+    ]);
+    const rows = [localStatus, gdriveStatus, githubStatus];
+    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 status = row.loggedIn
+            ? chalk.green("✓ logged in")
+            : chalk.red("✗ not logged in");
+        const identity = row.loggedIn
+            ? chalk.white(row.identity)
+            : chalk.dim(row.hint ?? "");
+        const statusLabel = row.loggedIn ? "✓ logged in" : "✗ not logged in";
+        console.log(row.name.padEnd(col1) + "  " + status + " ".repeat(Math.max(0, col2 - statusLabel.length)) + "  " + identity);
+    }
+    console.log();
+}