@skillsmanager/cli 0.0.1

package/dist/backends/local.js

@@ -0,0 +1,159 @@
+import fs from "fs";
+import path from "path";
+import { randomUUID } from "crypto";
+import { parseCollection, serializeCollection, parseRegistryFile, serializeRegistryFile, COLLECTION_FILENAME, LEGACY_COLLECTION_FILENAME, } from "../registry.js";
+import { CONFIG_DIR } from "../config.js";
+const COLLECTIONS_DIR = path.join(CONFIG_DIR, "collections");
+const LOCAL_REGISTRY_PATH = path.join(CONFIG_DIR, "registry.yaml");
+/**
+ * Local filesystem backend — stores collections and the registry under ~/.skillsmanager/.
+ * Works with zero setup, no auth, no internet. This is the default backend.
+ */
+export class LocalBackend {
+    // ── Identity ─────────────────────────────────────────────────────────────
+    async getOwner() {
+        // Try to read from existing registry first
+        if (fs.existsSync(LOCAL_REGISTRY_PATH)) {
+            const data = parseRegistryFile(fs.readFileSync(LOCAL_REGISTRY_PATH, "utf-8"));
+            if (data.owner)
+                return data.owner;
+        }
+        return process.env.USER ?? process.env.USERNAME ?? "unknown";
+    }
+    // ── Collection operations ────────────────────────────────────────────────
+    async discoverCollections() {
+        if (!fs.existsSync(COLLECTIONS_DIR))
+            return [];
+        const collections = [];
+        for (const entry of fs.readdirSync(COLLECTIONS_DIR, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            const dir = path.join(COLLECTIONS_DIR, entry.name);
+            const hasNew = fs.existsSync(path.join(dir, COLLECTION_FILENAME));
+            const hasLegacy = fs.existsSync(path.join(dir, LEGACY_COLLECTION_FILENAME));
+            if (hasNew || hasLegacy) {
+                collections.push({
+                    name: entry.name,
+                    backend: "local",
+                    folderId: dir,
+                });
+            }
+        }
+        return collections;
+    }
+    async readCollection(collection) {
+        const dir = collection.folderId;
+        for (const filename of [COLLECTION_FILENAME, LEGACY_COLLECTION_FILENAME]) {
+            const filePath = path.join(dir, filename);
+            if (fs.existsSync(filePath)) {
+                return parseCollection(fs.readFileSync(filePath, "utf-8"));
+            }
+        }
+        throw new Error(`Collection file not found in "${collection.name}"`);
+    }
+    async writeCollection(collection, data) {
+        const dir = collection.folderId;
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(path.join(dir, COLLECTION_FILENAME), serializeCollection(data));
+    }
+    async downloadSkill(collection, skillName, destDir) {
+        const src = path.join(collection.folderId, skillName);
+        if (!fs.existsSync(src)) {
+            throw new Error(`Skill "${skillName}" not found in local collection "${collection.name}"`);
+        }
+        // If source and dest are the same, no-op
+        if (path.resolve(src) === path.resolve(destDir))
+            return;
+        copyDirSync(src, destDir);
+    }
+    async uploadSkill(collection, localPath, skillName) {
+        const dest = path.join(collection.folderId, skillName);
+        // If source and dest are the same, no-op
+        if (path.resolve(localPath) === path.resolve(dest))
+            return;
+        copyDirSync(localPath, dest);
+    }
+    // ── Registry operations ──────────────────────────────────────────────────
+    async discoverRegistries() {
+        if (!fs.existsSync(LOCAL_REGISTRY_PATH))
+            return [];
+        return [{
+                name: "local",
+                backend: "local",
+                folderId: CONFIG_DIR,
+                fileId: LOCAL_REGISTRY_PATH,
+            }];
+    }
+    async readRegistry(registry) {
+        const filePath = registry.fileId ?? LOCAL_REGISTRY_PATH;
+        if (!fs.existsSync(filePath)) {
+            throw new Error("Local registry not found");
+        }
+        return parseRegistryFile(fs.readFileSync(filePath, "utf-8"));
+    }
+    async writeRegistry(registry, data) {
+        const filePath = registry.fileId ?? LOCAL_REGISTRY_PATH;
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, serializeRegistryFile(data));
+    }
+    async resolveCollectionRef(ref) {
+        if (ref.backend !== "local")
+            return null;
+        const dir = path.join(COLLECTIONS_DIR, ref.ref);
+        const hasNew = fs.existsSync(path.join(dir, COLLECTION_FILENAME));
+        const hasLegacy = fs.existsSync(path.join(dir, LEGACY_COLLECTION_FILENAME));
+        if (!hasNew && !hasLegacy)
+            return null;
+        return {
+            name: ref.name,
+            backend: "local",
+            folderId: dir,
+        };
+    }
+    async createRegistry(name) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+        const owner = await this.getOwner();
+        const data = {
+            name: name ?? "local",
+            owner,
+            source: "local",
+            collections: [],
+        };
+        fs.writeFileSync(LOCAL_REGISTRY_PATH, serializeRegistryFile(data));
+        return {
+            id: randomUUID(),
+            name: name ?? "local",
+            backend: "local",
+            folderId: CONFIG_DIR,
+            fileId: LOCAL_REGISTRY_PATH,
+        };
+    }
+    // ── Convenience: create a local collection ───────────────────────────────
+    async createCollection(name) {
+        const dir = path.join(COLLECTIONS_DIR, name);
+        fs.mkdirSync(dir, { recursive: true });
+        const owner = await this.getOwner();
+        const data = { name, owner, skills: [] };
+        fs.writeFileSync(path.join(dir, COLLECTION_FILENAME), serializeCollection(data));
+        return {
+            id: randomUUID(),
+            name,
+            backend: "local",
+            folderId: dir,
+        };
+    }
+}
+// ── Helpers ────────────────────────────────────────────────────────────────
+function copyDirSync(src, dest) {
+    fs.mkdirSync(dest, { recursive: true });
+    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            copyDirSync(srcPath, destPath);
+        }
+        else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}

package/dist/bm25.d.ts

@@ -0,0 +1,20 @@
+/**
+ * BM25 ranking implementation.
+ *
+ * Scores a set of documents against a query. Higher score = better match.
+ * Documents are ranked by how well query terms appear in them, weighted by
+ * how rare those terms are across the whole corpus.
+ *
+ * Parameters (industry defaults):
+ *   k1 = 1.5  — TF saturation: diminishing returns on repeated terms
+ *   b  = 0.75 — length normalization: penalizes longer documents slightly
+ */
+export interface BM25Document {
+    id: string;
+    text: string;
+}
+export interface BM25Result {
+    id: string;
+    score: number;
+}
+export declare function bm25Search(docs: BM25Document[], query: string, topK?: number): BM25Result[];

package/dist/bm25.js

@@ -0,0 +1,65 @@
+/**
+ * BM25 ranking implementation.
+ *
+ * Scores a set of documents against a query. Higher score = better match.
+ * Documents are ranked by how well query terms appear in them, weighted by
+ * how rare those terms are across the whole corpus.
+ *
+ * Parameters (industry defaults):
+ *   k1 = 1.5  — TF saturation: diminishing returns on repeated terms
+ *   b  = 0.75 — length normalization: penalizes longer documents slightly
+ */
+const K1 = 1.5;
+const B = 0.75;
+function tokenize(text) {
+    return text
+        .toLowerCase()
+        .replace(/[_\-]/g, " ") // treat underscores and hyphens as word separators
+        .replace(/[^a-z0-9 ]/g, "")
+        .split(/\s+/)
+        .filter(Boolean);
+}
+export function bm25Search(docs, query, topK = 10) {
+    if (docs.length === 0 || !query.trim())
+        return [];
+    const queryTokens = tokenize(query);
+    if (queryTokens.length === 0)
+        return [];
+    // Build per-document token frequencies
+    const docTokens = docs.map((d) => tokenize(d.text));
+    const docLengths = docTokens.map((t) => t.length);
+    const avgLength = docLengths.reduce((a, b) => a + b, 0) / docs.length;
+    // Build IDF: count how many documents contain each query term
+    const docFreq = {};
+    for (const token of queryTokens) {
+        docFreq[token] = 0;
+        for (const tokens of docTokens) {
+            if (tokens.includes(token))
+                docFreq[token]++;
+        }
+    }
+    const scores = docs.map((doc, i) => {
+        const tf = {};
+        for (const t of docTokens[i]) {
+            tf[t] = (tf[t] ?? 0) + 1;
+        }
+        let score = 0;
+        for (const token of queryTokens) {
+            const f = tf[token] ?? 0;
+            if (f === 0)
+                continue;
+            const df = docFreq[token];
+            // IDF formula: log((N - df + 0.5) / (df + 0.5) + 1)
+            const idf = Math.log((docs.length - df + 0.5) / (df + 0.5) + 1);
+            // TF normalization with length penalty
+            const tfNorm = (f * (K1 + 1)) /
+                (f + K1 * (1 - B + B * (docLengths[i] / avgLength)));
+            score += idf * tfNorm;
+        }
+        return { id: doc.id, score };
+    });
+    return scores
+        .filter((r) => r.score > 0)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, topK);
+}

package/dist/cache.d.ts

@@ -0,0 +1,21 @@
+import type { CollectionInfo } from "./types.js";
+export declare function getCachePath(collection: CollectionInfo, skillName?: string): string;
+export declare function ensureCachePath(collection: CollectionInfo): string;
+export type Scope = "global" | "project";
+/**
+ * Returns the symlink target directory for the given agent and scope.
+ * - global: ~/.agent/skills/  (from AGENT_PATHS)
+ * - project: <cwd>/.agent/skills/
+ *
+ * Also returns whether the directory had to be created, so the caller
+ * can print a transparent message to the user.
+ */
+export declare function resolveSkillsDir(agentName: string, scope: Scope, cwd: string): {
+    skillsDir: string;
+    created: boolean;
+};
+export declare function createSymlink(skillName: string, cachePath: string, agentName: string, scope?: Scope, cwd?: string): {
+    skillsDir: string;
+    created: boolean;
+};
+export declare function skillExistsInCache(collection: CollectionInfo, skillName: string): boolean;

package/dist/cache.js

@@ -0,0 +1,59 @@
+import fs from "fs";
+import path from "path";
+import { CACHE_DIR } from "./config.js";
+import { AGENT_PATHS } from "./types.js";
+export function getCachePath(collection, skillName) {
+    const base = path.join(CACHE_DIR, collection.id);
+    return skillName ? path.join(base, skillName) : base;
+}
+export function ensureCachePath(collection) {
+    const p = getCachePath(collection);
+    fs.mkdirSync(p, { recursive: true });
+    return p;
+}
+/**
+ * Returns the symlink target directory for the given agent and scope.
+ * - global: ~/.agent/skills/  (from AGENT_PATHS)
+ * - project: <cwd>/.agent/skills/
+ *
+ * Also returns whether the directory had to be created, so the caller
+ * can print a transparent message to the user.
+ */
+export function resolveSkillsDir(agentName, scope, cwd) {
+    if (!AGENT_PATHS[agentName]) {
+        const supported = Object.keys(AGENT_PATHS).join(", ");
+        throw new Error(`Unknown agent "${agentName}". Supported agents: ${supported}`);
+    }
+    let skillsDir;
+    if (scope === "project") {
+        // Derive the agent subfolder name from the global path (e.g. ".claude/skills")
+        const globalDir = AGENT_PATHS[agentName];
+        const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+        const relative = path.relative(home, globalDir); // e.g. ".claude/skills"
+        skillsDir = path.join(cwd, relative);
+    }
+    else {
+        skillsDir = AGENT_PATHS[agentName];
+    }
+    const existed = fs.existsSync(skillsDir);
+    fs.mkdirSync(skillsDir, { recursive: true });
+    return { skillsDir, created: !existed };
+}
+export function createSymlink(skillName, cachePath, agentName, scope = "global", cwd = process.cwd()) {
+    const { skillsDir, created } = resolveSkillsDir(agentName, scope, cwd);
+    const linkPath = path.join(skillsDir, skillName);
+    if (fs.existsSync(linkPath)) {
+        const stat = fs.lstatSync(linkPath);
+        if (stat.isSymbolicLink()) {
+            fs.unlinkSync(linkPath);
+        }
+        else {
+            throw new Error(`${linkPath} already exists and is not a symlink. Remove it manually to proceed.`);
+        }
+    }
+    fs.symlinkSync(cachePath, linkPath);
+    return { skillsDir, created };
+}
+export function skillExistsInCache(collection, skillName) {
+    return fs.existsSync(getCachePath(collection, skillName));
+}

package/dist/commands/add.d.ts

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

package/dist/commands/add.js

@@ -0,0 +1,62 @@
+import fs from "fs";
+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";
+export async function addCommand(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;
+    const description = frontmatter.description ?? "";
+    if (!skillName) {
+        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
+    let collection = config.collections[0];
+    if (options.collection) {
+        const found = config.collections.find((c) => c.name === options.collection);
+        if (!found) {
+            console.log(chalk.red(`Collection "${options.collection}" not found.`));
+            console.log(chalk.dim(`  Available: ${config.collections.map((c) => c.name).join(", ")}`));
+            return;
+        }
+        collection = found;
+    }
+    const spinner = ora(`Adding ${chalk.bold(skillName)} to ${collection.name}...`).start();
+    try {
+        await backend.uploadSkill(collection, absPath, 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 };
+        }
+        else {
+            col.skills.push({ name: skillName, path: `${skillName}/`, description });
+        }
+        await backend.writeCollection(collection, col);
+        trackSkill(skillName, collection.id, absPath);
+        spinner.succeed(`${chalk.bold(skillName)} added to gdrive:${collection.name}`);
+    }
+    catch (err) {
+        spinner.fail(`Failed: ${err.message}`);
+    }
+}

package/dist/commands/collection.d.ts

@@ -0,0 +1 @@
+export declare function collectionCreateCommand(name?: string): Promise<void>;

package/dist/commands/collection.js

@@ -0,0 +1,42 @@
+import chalk from "chalk";
+import ora from "ora";
+import { writeConfig, CONFIG_PATH } 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`;
+    }
+    else {
+        folderName = 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);
+        }
+        writeConfig(config);
+        console.log(`\nRun ${chalk.bold(`skillsmanager add <path>`)} to add skills to it.\n`);
+    }
+    catch (err) {
+        spinner.fail(`Failed: ${err.message}`);
+    }
+}

package/dist/commands/fetch.d.ts

@@ -0,0 +1,5 @@
+import { type Scope } from "../cache.js";
+export declare function fetchCommand(names: string[], options: {
+    agent: string;
+    scope: Scope;
+}): Promise<void>;

package/dist/commands/fetch.js

@@ -0,0 +1,46 @@
+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";
+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 allSkills = [];
+    for (const collection of config.collections) {
+        const col = await backend.readCollection(collection);
+        for (const entry of col.skills) {
+            allSkills.push({ entry, collection });
+        }
+    }
+    const scope = options.scope ?? "global";
+    const cwd = process.cwd();
+    for (const name of names) {
+        const match = allSkills.find((s) => s.entry.name === name);
+        if (!match) {
+            console.log(chalk.red(`Skill "${name}" not found in any collection.`));
+            continue;
+        }
+        const spinner = ora(`Fetching ${chalk.bold(name)}...`).start();
+        try {
+            ensureCachePath(match.collection);
+            const cachePath = getCachePath(match.collection, name);
+            await 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`);
+            if (created) {
+                console.log(chalk.dim(`  Created ${skillsDir}`));
+            }
+        }
+        catch (err) {
+            spinner.fail(`${chalk.bold(name)}: ${err.message}`);
+        }
+    }
+}

package/dist/commands/init.d.ts

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

package/dist/commands/init.js

@@ -0,0 +1,45 @@
+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 initCommand() {
+    console.log(chalk.bold("\nSkills Manager Init\n"));
+    const auth = await ensureAuth();
+    console.log(chalk.green("  ✓ Authenticated"));
+    const spinner = ora("  Discovering collections...").start();
+    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);
+    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) {
+            const col = await backend.readCollection(c);
+            console.log(`    gdrive:${c.name}  (${col.skills.length} skills)`);
+        }
+    }
+    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() });
+    const totalSkills = (await Promise.all(collections.map((c) => backend.readCollection(c)))).reduce((sum, col) => sum + col.skills.length, 0);
+    console.log(`\n${totalSkills} skills across ${collections.length} collection(s).`);
+    console.log(`\nRun ${chalk.bold("skillsmanager list")} to browse all available skills.\n`);
+}

package/dist/commands/install.d.ts

@@ -0,0 +1,8 @@
+export declare function installCommand(options: {
+    agent?: string;
+    path?: string;
+}): void;
+export declare function uninstallCommand(options: {
+    agent?: string;
+    path?: string;
+}): void;

package/dist/commands/install.js

@@ -0,0 +1,89 @@
+import chalk from "chalk";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { AGENT_PATHS } from "../types.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const SKILL_SOURCE = path.resolve(__dirname, "..", "..", "skills", "skillsmanager");
+function installToDir(skillsDir, label) {
+    fs.mkdirSync(skillsDir, { recursive: true });
+    const linkPath = path.join(skillsDir, "skillsmanager");
+    if (fs.existsSync(linkPath)) {
+        const stat = fs.lstatSync(linkPath);
+        if (stat.isSymbolicLink()) {
+            fs.unlinkSync(linkPath);
+        }
+        else {
+            console.log(chalk.yellow(`  Skipped ${label} — ${linkPath} exists and is not a symlink`));
+            return;
+        }
+    }
+    fs.symlinkSync(SKILL_SOURCE, linkPath);
+    console.log(chalk.green(`  Installed for ${label} → ${linkPath}`));
+}
+export function installCommand(options) {
+    if (!fs.existsSync(SKILL_SOURCE)) {
+        console.log(chalk.red("Bundled skillsmanager skill not found. Reinstall the package."));
+        return;
+    }
+    if (options.path) {
+        const absPath = path.resolve(options.path);
+        installToDir(absPath, absPath);
+        return;
+    }
+    if (options.agent) {
+        const agents = options.agent.split(",").map((a) => a.trim());
+        for (const agent of agents) {
+            const skillsDir = AGENT_PATHS[agent];
+            if (!skillsDir) {
+                console.log(chalk.red(`  Unknown agent "${agent}". Supported: ${Object.keys(AGENT_PATHS).join(", ")}`));
+                continue;
+            }
+            installToDir(skillsDir, agent);
+        }
+        return;
+    }
+    // Default: install to all agents
+    console.log(chalk.dim("Installing skillsmanager skill to all agent directories...\n"));
+    for (const [agent, skillsDir] of Object.entries(AGENT_PATHS)) {
+        installToDir(skillsDir, agent);
+    }
+}
+function uninstallFromDir(skillsDir, label) {
+    const linkPath = path.join(skillsDir, "skillsmanager");
+    if (!fs.existsSync(linkPath)) {
+        console.log(chalk.dim(`  ${label} — not installed, skipping`));
+        return;
+    }
+    const stat = fs.lstatSync(linkPath);
+    if (!stat.isSymbolicLink()) {
+        console.log(chalk.yellow(`  ${label} — ${linkPath} is not a symlink, skipping`));
+        return;
+    }
+    fs.unlinkSync(linkPath);
+    console.log(chalk.green(`  Removed from ${label} → ${linkPath}`));
+}
+export function uninstallCommand(options) {
+    if (options.path) {
+        const absPath = path.resolve(options.path);
+        uninstallFromDir(absPath, absPath);
+        return;
+    }
+    if (options.agent) {
+        const agents = options.agent.split(",").map((a) => a.trim());
+        for (const agent of agents) {
+            const skillsDir = AGENT_PATHS[agent];
+            if (!skillsDir) {
+                console.log(chalk.red(`  Unknown agent "${agent}". Supported: ${Object.keys(AGENT_PATHS).join(", ")}`));
+                continue;
+            }
+            uninstallFromDir(skillsDir, agent);
+        }
+        return;
+    }
+    // Default: uninstall from all agents
+    console.log(chalk.dim("Removing skillsmanager skill from all agent directories...\n"));
+    for (const [agent, skillsDir] of Object.entries(AGENT_PATHS)) {
+        uninstallFromDir(skillsDir, agent);
+    }
+}

package/dist/commands/list.d.ts

@@ -0,0 +1,3 @@
+import type { ResolvedSkill } from "../types.js";
+export declare function getAllSkills(): Promise<ResolvedSkill[]>;
+export declare function listCommand(): Promise<void>;