@skillsmanager/cli 0.0.1

package/dist/commands/list.js

@@ -0,0 +1,38 @@
+import chalk from "chalk";
+import ora from "ora";
+import { ensureReady } from "../ready.js";
+export async function getAllSkills() {
+    const { config, backend } = await ensureReady();
+    const allSkills = [];
+    for (const collection of config.collections) {
+        const col = await backend.readCollection(collection);
+        for (const entry of col.skills) {
+            allSkills.push({ entry, collection });
+        }
+    }
+    return allSkills;
+}
+export async function listCommand() {
+    const spinner = ora("Fetching skills...").start();
+    try {
+        const skills = await getAllSkills();
+        spinner.stop();
+        if (skills.length === 0) {
+            console.log(chalk.yellow("No skills found across any collections."));
+            console.log(chalk.dim('Run "skillsmanager collection create <name>" to create a collection, then "skillsmanager add <path>" to add skills.'));
+            return;
+        }
+        const maxName = Math.max(...skills.map((s) => s.entry.name.length), 4);
+        const maxDesc = Math.max(...skills.map((s) => s.entry.description.length), 11);
+        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();
+    }
+    catch (err) {
+        spinner.stop();
+        throw err;
+    }
+}

package/dist/commands/refresh.d.ts

@@ -0,0 +1 @@
+export declare function refreshCommand(): Promise<void>;

package/dist/commands/refresh.js

@@ -0,0 +1,46 @@
+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";
+export async function refreshCommand() {
+    const spinner = ora("Discovering collections...").start();
+    try {
+        const auth = await ensureAuth();
+        const backend = new GDriveBackend(auth);
+        const fresh = await backend.discoverCollections();
+        let existing = [];
+        try {
+            existing = readConfig().collections;
+        }
+        catch { /* no existing config */ }
+        const collections = mergeCollections(fresh, existing);
+        let existingSkills = {};
+        try {
+            existingSkills = readConfig().skills ?? {};
+        }
+        catch { /* ok */ }
+        let existingRegistries = [];
+        try {
+            existingRegistries = readConfig().registries ?? [];
+        }
+        catch { /* ok */ }
+        writeConfig({ registries: existingRegistries, collections, 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>"));
+        }
+        else {
+            console.log(chalk.green(`Found ${collections.length} collection(s):`));
+            for (const c of collections) {
+                console.log(`  gdrive:${c.name}`);
+            }
+        }
+        console.log();
+    }
+    catch (err) {
+        spinner.stop();
+        throw err;
+    }
+}

package/dist/commands/registry.d.ts

@@ -0,0 +1,14 @@
+export declare function registryCreateCommand(options: {
+    backend?: string;
+}): Promise<void>;
+export declare function registryListCommand(): Promise<void>;
+export declare function registryDiscoverCommand(options: {
+    backend?: string;
+}): Promise<void>;
+export declare function registryAddCollectionCommand(collectionName: string, options: {
+    backend?: string;
+    ref?: string;
+}): Promise<void>;
+export declare function registryPushCommand(options: {
+    backend?: string;
+}): Promise<void>;

package/dist/commands/registry.js

@@ -0,0 +1,258 @@
+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 { LocalBackend } from "../backends/local.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);
+        }
+        catch (err) {
+            spinner.fail(`Failed: ${err.message}`);
+        }
+    }
+    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)) {
+                try {
+                    config = readConfig();
+                }
+                catch { /* use default */ }
+            }
+            config.registries.push(registry);
+            writeConfig(config);
+        }
+        catch (err) {
+            spinner.fail(`Failed: ${err.message}`);
+        }
+    }
+    else {
+        console.log(chalk.red(`Unknown backend "${backend}". Supported: local, gdrive`));
+    }
+}
+export async function registryListCommand() {
+    let config;
+    try {
+        config = readConfig();
+    }
+    catch {
+        console.log(chalk.yellow("No config found. Run: skillsmanager registry create"));
+        return;
+    }
+    if (config.registries.length === 0) {
+        console.log(chalk.yellow("No registries configured."));
+        console.log(chalk.dim("  Run: skillsmanager registry create"));
+        return;
+    }
+    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 data = await backend.readRegistry(reg);
+            if (data.collections.length === 0) {
+                console.log(chalk.dim("  No collections"));
+            }
+            else {
+                for (const ref of data.collections) {
+                    console.log(`  ${chalk.cyan(ref.name)} ${chalk.dim(`${ref.backend}:${ref.ref}`)}`);
+                }
+            }
+        }
+        catch (err) {
+            console.log(chalk.red(`  Error reading: ${err.message}`));
+        }
+    }
+    console.log();
+}
+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 fresh = await backend.discoverRegistries();
+        let config = { registries: [], collections: [], skills: {}, discoveredAt: new Date().toISOString() };
+        if (fs.existsSync(CONFIG_PATH)) {
+            try {
+                config = readConfig();
+            }
+            catch { /* use default */ }
+        }
+        config.registries = mergeRegistries(fresh, config.registries);
+        writeConfig(config);
+        spinner.stop();
+        if (fresh.length === 0) {
+            console.log(chalk.yellow(`No registries found in ${backendName}.`));
+        }
+        else {
+            console.log(chalk.green(`Found ${fresh.length} registry(ies) in ${backendName}:`));
+            for (const r of fresh) {
+                console.log(`  ${chalk.cyan(r.name)}`);
+            }
+        }
+    }
+    catch (err) {
+        spinner.fail(`Failed: ${err.message}`);
+    }
+}
+export async function registryAddCollectionCommand(collectionName, options) {
+    let config;
+    try {
+        config = readConfig();
+    }
+    catch {
+        console.log(chalk.red("No config found. Run: skillsmanager registry create"));
+        return;
+    }
+    if (config.registries.length === 0) {
+        console.log(chalk.red("No registries configured. Run: skillsmanager registry create"));
+        return;
+    }
+    // Use first registry
+    const reg = config.registries[0];
+    const backend = reg.backend === "gdrive"
+        ? new GDriveBackend(await ensureAuth())
+        : new LocalBackend();
+    const data = await backend.readRegistry(reg);
+    const existing = data.collections.find((c) => c.name === collectionName);
+    if (existing) {
+        console.log(chalk.yellow(`Collection "${collectionName}" already in registry.`));
+        return;
+    }
+    data.collections.push({
+        name: collectionName,
+        backend: options.backend ?? reg.backend,
+        ref: options.ref ?? collectionName,
+    });
+    await backend.writeRegistry(reg, data);
+    console.log(chalk.green(`Added "${collectionName}" to registry "${reg.name}".`));
+}
+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`));
+        return;
+    }
+    let config;
+    try {
+        config = readConfig();
+    }
+    catch {
+        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."));
+        return;
+    }
+    const local = new LocalBackend();
+    const localData = await local.readRegistry(localReg);
+    const localCollectionRefs = localData.collections.filter((c) => c.backend === "local");
+    if (localCollectionRefs.length === 0) {
+        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 pushed = [];
+    try {
+        for (const ref of localCollectionRefs) {
+            spinner.text = `Uploading collection "${ref.name}"...`;
+            const collInfo = await local.resolveCollectionRef(ref);
+            if (!collInfo) {
+                throw new Error(`Collection "${ref.name}" not found locally`);
+            }
+            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 gdrive.writeCollection(driveCol, colData);
+            pushed.push({ ref, driveCol, folderName });
+        }
+    }
+    catch (err) {
+        spinner.fail(`Push failed: ${err.message}`);
+        console.log(chalk.dim("  No changes were committed. Local state is unchanged."));
+        return;
+    }
+    // ── 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 });
+        }
+        await gdrive.writeRegistry(gdriveReg, gdriveData);
+        // Update local config
+        if (!config.registries.find((r) => r.id === gdriveReg.id)) {
+            config.registries.push(gdriveReg);
+        }
+        for (const { driveCol } of pushed) {
+            config.collections.push(driveCol);
+        }
+        writeConfig(config);
+        spinner.succeed(`Pushed ${pushed.length} collection(s) to Google Drive`);
+        for (const { ref } of pushed) {
+            console.log(chalk.dim(`  ${ref.name} → gdrive`));
+        }
+    }
+    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."));
+    }
+}
+// Need path import for push command
+import path from "path";

package/dist/commands/search.d.ts

@@ -0,0 +1 @@
+export declare function searchCommand(query: string): Promise<void>;

package/dist/commands/search.js

@@ -0,0 +1,37 @@
+import chalk from "chalk";
+import ora from "ora";
+import { getAllSkills } from "./list.js";
+import { bm25Search } from "../bm25.js";
+export async function searchCommand(query) {
+    const spinner = ora("Searching skills...").start();
+    try {
+        const skills = await getAllSkills();
+        spinner.stop();
+        // Build BM25 documents — name is weighted 3x by repeating it
+        // so a name match outranks a description-only match
+        const docs = skills.map((s) => ({
+            id: s.entry.name,
+            text: `${s.entry.name} ${s.entry.name} ${s.entry.name} ${s.entry.description}`,
+        }));
+        const results = bm25Search(docs, query);
+        if (results.length === 0) {
+            console.log(chalk.yellow(`No skills matching "${query}".`));
+            return;
+        }
+        const ranked = results
+            .map((r) => skills.find((s) => s.entry.name === r.id))
+            .filter(Boolean);
+        const maxName = Math.max(...ranked.map((s) => s.entry.name.length), 4);
+        const maxDesc = Math.max(...ranked.map((s) => s.entry.description.length), 11);
+        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 ranked) {
+            console.log(`  ${chalk.cyan(s.entry.name.padEnd(maxName + 2))}${s.entry.description.padEnd(maxDesc + 2)}${chalk.dim(`gdrive:${s.collection.name}`)}`);
+        }
+        console.log();
+    }
+    catch (err) {
+        spinner.stop();
+        throw err;
+    }
+}

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

@@ -0,0 +1 @@
+export declare function setupGoogleCommand(): Promise<void>;