skillbox 0.1.1

package/dist/commands/project.js

@@ -0,0 +1,174 @@
+import path from "node:path";
+import { isJsonEnabled, printInfo, printJson } from "../lib/output.js";
+import { loadProjects, saveProjects, upsertProject } from "../lib/projects.js";
+import { loadIndex } from "../lib/index.js";
+import { copySkillToInstallPaths } from "../lib/sync.js";
+import { collectProjectSkills, getProjectInstallPaths, getProjectSkills } from "../lib/installs.js";
+import { handleCommandError } from "../lib/command.js";
+const collect = (value, previous = []) => {
+    return [...previous, value];
+};
+const parseAgentPaths = (entries) => {
+    const overrides = {};
+    for (const entry of entries) {
+        const [agent, pathValue] = entry.split("=");
+        if (!agent || !pathValue) {
+            continue;
+        }
+        const existing = overrides[agent] ?? [];
+        overrides[agent] = [...existing, pathValue];
+    }
+    return overrides;
+};
+export const registerProject = (program) => {
+    const project = program.command("project").description("Manage projects");
+    project
+        .command("add")
+        .argument("<path>", "Project path")
+        .option("--agent-path <agentPath>", "Agent path override (agent=path)", collect)
+        .option("--json", "JSON output")
+        .action(async (inputPath, options) => {
+        try {
+            const resolved = path.resolve(inputPath);
+            const index = await loadProjects();
+            const updated = upsertProject(index, resolved);
+            const overrides = parseAgentPaths(options.agentPath ?? []);
+            const merged = {
+                ...updated,
+                projects: updated.projects.map((project) => {
+                    if (project.root !== resolved) {
+                        return project;
+                    }
+                    const nextPaths = project.agentPaths ? { ...project.agentPaths } : {};
+                    for (const [agent, paths] of Object.entries(overrides)) {
+                        nextPaths[agent] = paths;
+                    }
+                    return { ...project, agentPaths: nextPaths };
+                }),
+            };
+            await saveProjects(merged);
+            if (isJsonEnabled(options)) {
+                printJson({
+                    ok: true,
+                    command: "project add",
+                    data: {
+                        path: resolved,
+                        agentPaths: merged.projects.find((project) => project.root === resolved)?.agentPaths ?? {},
+                    },
+                });
+                return;
+            }
+            printInfo(`Project registered: ${resolved}`);
+        }
+        catch (error) {
+            handleCommandError(options, "project add", error);
+        }
+    });
+    project
+        .command("list")
+        .option("--json", "JSON output")
+        .action(async (options) => {
+        const projectsIndex = await loadProjects();
+        const skillIndex = await loadIndex();
+        const projectSkills = collectProjectSkills(skillIndex.skills);
+        const projects = projectsIndex.projects.map((project) => ({
+            ...project,
+            skills: projectSkills.get(project.root) ?? [],
+        }));
+        if (isJsonEnabled(options)) {
+            printJson({
+                ok: true,
+                command: "project list",
+                data: {
+                    projects,
+                },
+            });
+            return;
+        }
+        printInfo(`Projects: ${projects.length}`);
+        for (const entry of projects) {
+            const skills = entry.skills ?? [];
+            const label = skills.length > 0 ? ` (${skills.length} skills)` : "";
+            printInfo(`- ${entry.root}${label}`);
+            for (const skillName of skills) {
+                printInfo(`  - ${skillName}`);
+            }
+        }
+    });
+    project
+        .command("inspect")
+        .argument("<path>", "Project path")
+        .option("--json", "JSON output")
+        .action(async (inputPath, options) => {
+        const projectsIndex = await loadProjects();
+        const skillIndex = await loadIndex();
+        const resolved = path.resolve(inputPath);
+        const project = projectsIndex.projects.find((entry) => entry.root === resolved);
+        if (!project) {
+            handleCommandError(options, "project inspect", new Error(`Project not registered: ${resolved}`));
+            return;
+        }
+        const skills = getProjectSkills(skillIndex.skills, resolved);
+        const data = {
+            root: project.root,
+            agentPaths: project.agentPaths ?? {},
+            skills,
+        };
+        if (isJsonEnabled(options)) {
+            printJson({
+                ok: true,
+                command: "project inspect",
+                data,
+            });
+            return;
+        }
+        printInfo(`Project: ${data.root}`);
+        const agentEntries = Object.entries(data.agentPaths);
+        if (agentEntries.length === 0) {
+            printInfo("Agent paths: default");
+        }
+        else {
+            printInfo("Agent paths:");
+            for (const [agent, paths] of agentEntries) {
+                printInfo(`- ${agent}: ${paths.join(", ")}`);
+            }
+        }
+        if (data.skills.length === 0) {
+            printInfo("Skills: none");
+        }
+        else {
+            printInfo("Skills:");
+            for (const skillName of data.skills) {
+                printInfo(`- ${skillName}`);
+            }
+        }
+    });
+    project
+        .command("sync")
+        .argument("<path>", "Project path")
+        .option("--json", "JSON output")
+        .action(async (inputPath, options) => {
+        const skillIndex = await loadIndex();
+        const resolved = path.resolve(inputPath);
+        const installPaths = getProjectInstallPaths(skillIndex.skills, resolved);
+        if (installPaths.size === 0) {
+            handleCommandError(options, "project sync", new Error(`No skills recorded for project: ${resolved}`));
+            return;
+        }
+        for (const [skillName, paths] of installPaths.entries()) {
+            await copySkillToInstallPaths(skillName, paths);
+        }
+        if (isJsonEnabled(options)) {
+            printJson({
+                ok: true,
+                command: "project sync",
+                data: {
+                    root: resolved,
+                    skills: Array.from(installPaths.keys()).sort(),
+                },
+            });
+            return;
+        }
+        printInfo(`Synced ${installPaths.size} skill(s) for ${resolved}`);
+    });
+};

package/dist/commands/status.js

@@ -0,0 +1,129 @@
+import { isJsonEnabled, printInfo, printJson, printList } from "../lib/output.js";
+import { loadIndex, saveIndex } from "../lib/index.js";
+import { fetchText } from "../lib/fetcher.js";
+import { hashContent } from "../lib/skill-store.js";
+import { groupStatusByKey } from "../lib/grouping.js";
+import { loadConfig } from "../lib/config.js";
+import { handleCommandError } from "../lib/command.js";
+export const registerStatus = (program) => {
+    program
+        .command("status")
+        .option("--group <group>", "Group by project or source")
+        .option("--json", "JSON output")
+        .action(async (options) => {
+        try {
+            const index = await loadIndex();
+            const config = await loadConfig();
+            const results = [];
+            for (const skill of index.skills) {
+                const projects = (skill.installs ?? [])
+                    .filter((install) => install.scope === "project" && install.projectRoot)
+                    .map((install) => install.projectRoot);
+                const allowSystem = config.manageSystem;
+                const isSystem = (skill.installs ?? []).some((install) => install.scope === "system");
+                if (isSystem && !allowSystem) {
+                    results.push({
+                        name: skill.name,
+                        source: skill.source.type,
+                        outdated: false,
+                        localChecksum: skill.checksum,
+                        projects,
+                        system: true,
+                    });
+                    continue;
+                }
+                if (skill.source.type !== "url" || !skill.source.url) {
+                    results.push({
+                        name: skill.name,
+                        source: skill.source.type,
+                        outdated: false,
+                        localChecksum: skill.checksum,
+                        projects,
+                        system: isSystem,
+                    });
+                    continue;
+                }
+                const remoteText = await fetchText(skill.source.url);
+                const remoteChecksum = hashContent(remoteText);
+                const outdated = remoteChecksum !== skill.checksum;
+                skill.lastChecked = new Date().toISOString();
+                results.push({
+                    name: skill.name,
+                    source: skill.source.type,
+                    outdated,
+                    localChecksum: skill.checksum,
+                    remoteChecksum,
+                    projects,
+                    system: false,
+                });
+            }
+            await saveIndex(index);
+            const outdated = results.filter((entry) => entry.outdated).map((entry) => entry.name);
+            const upToDate = results.filter((entry) => !entry.outdated).map((entry) => entry.name);
+            const groupedProjects = groupByProject(results);
+            const groupedSources = groupBySource(results);
+            if (isJsonEnabled(options)) {
+                printJson({
+                    ok: true,
+                    command: "status",
+                    data: {
+                        group: options.group ?? null,
+                        outdated,
+                        upToDate,
+                        results,
+                        projects: options.group === "project" ? groupedProjects : undefined,
+                        sources: options.group === "source" ? groupedSources : undefined,
+                    },
+                });
+                return;
+            }
+            if (options.group === "project") {
+                printInfo(`Projects: ${groupedProjects.length}`);
+                for (const project of groupedProjects) {
+                    printInfo(`- ${project.root}`);
+                    if (project.outdated.length > 0) {
+                        printList("  Outdated", project.outdated, "    - ");
+                    }
+                    if (project.upToDate.length > 0) {
+                        printList("  Up to date", project.upToDate, "    - ");
+                    }
+                }
+                return;
+            }
+            if (options.group === "source") {
+                printInfo(`Sources: ${groupedSources.length}`);
+                for (const source of groupedSources) {
+                    printInfo(`- ${source.source}`);
+                    if (source.outdated.length > 0) {
+                        printList("  Outdated", source.outdated, "    - ");
+                    }
+                    if (source.upToDate.length > 0) {
+                        printList("  Up to date", source.upToDate, "    - ");
+                    }
+                }
+                return;
+            }
+            printList("Outdated", outdated);
+            printList("Up to date", upToDate);
+        }
+        catch (error) {
+            handleCommandError(options, "status", error);
+        }
+    });
+};
+const groupByProject = (results) => {
+    const grouped = groupStatusByKey(results, (result) => result.name, (result) => result.outdated, (result) => result.projects);
+    return grouped.map((group) => ({
+        root: group.key,
+        outdated: group.outdated,
+        upToDate: group.upToDate,
+    }));
+};
+const groupBySource = (results) => {
+    const grouped = groupStatusByKey(results, (result) => result.name, (result) => result.outdated, (result) => [result.source]);
+    return grouped.map((group) => ({
+        source: group.key,
+        outdated: group.outdated,
+        upToDate: group.upToDate,
+    }));
+};

package/dist/commands/update.js

@@ -0,0 +1,84 @@
+import { isJsonEnabled, printInfo, printJson } from "../lib/output.js";
+import { loadIndex, saveIndex, sortIndex, upsertSkill } from "../lib/index.js";
+import { fetchText } from "../lib/fetcher.js";
+import { parseSkillMarkdown, buildMetadata } from "../lib/skill-parser.js";
+import { ensureSkillsDir, writeSkillFiles } from "../lib/skill-store.js";
+import { copySkillToInstallPaths } from "../lib/sync.js";
+import path from "node:path";
+import { loadConfig } from "../lib/config.js";
+import { handleCommandError } from "../lib/command.js";
+export const registerUpdate = (program) => {
+    program
+        .command("update")
+        .argument("[name]", "Skill name")
+        .option("--system", "Allow system-scope updates")
+        .option("--project <path>", "Only update installs for a project")
+        .option("--json", "JSON output")
+        .action(async (name, options) => {
+        try {
+            const index = await loadIndex();
+            const config = await loadConfig();
+            const targets = name ? index.skills.filter((skill) => skill.name === name) : index.skills;
+            if (name && targets.length === 0) {
+                throw new Error(`Skill not found: ${name}`);
+            }
+            const updated = [];
+            await ensureSkillsDir();
+            const projectRoot = options.project ? path.resolve(options.project) : null;
+            for (const skill of targets) {
+                if (skill.source.type !== "url" || !skill.source.url) {
+                    continue;
+                }
+                const markdown = await fetchText(skill.source.url);
+                const parsed = parseSkillMarkdown(markdown);
+                if (!parsed.description) {
+                    throw new Error(`Skill ${skill.name} is missing a description after update.`);
+                }
+                const metadata = buildMetadata(parsed, { type: "url", url: skill.source.url }, skill.name);
+                await writeSkillFiles(skill.name, markdown, metadata);
+                const allowSystem = options.system || config.manageSystem;
+                const installPaths = (skill.installs ?? [])
+                    .filter((install) => allowSystem || install.scope !== "system")
+                    .filter((install) => !projectRoot || install.projectRoot === projectRoot)
+                    .map((install) => install.path);
+                if (installPaths.length > 0) {
+                    await copySkillToInstallPaths(skill.name, installPaths);
+                }
+                const nextIndex = upsertSkill(index, {
+                    name: skill.name,
+                    source: { type: "url", url: skill.source.url },
+                    checksum: parsed.checksum,
+                    updatedAt: metadata.updatedAt,
+                    lastSync: new Date().toISOString(),
+                });
+                index.skills = nextIndex.skills;
+                updated.push(skill.name);
+            }
+            await saveIndex(sortIndex(index));
+            if (isJsonEnabled(options)) {
+                printJson({
+                    ok: true,
+                    command: "update",
+                    data: {
+                        name: name ?? null,
+                        system: Boolean(options.system),
+                        project: projectRoot,
+                        updated,
+                    },
+                });
+                return;
+            }
+            if (updated.length === 0) {
+                printInfo("No skills updated.");
+                return;
+            }
+            printInfo(`Updated ${updated.length} skill(s):`);
+            for (const skillName of updated) {
+                printInfo(`- ${skillName}`);
+            }
+        }
+        catch (error) {
+            handleCommandError(options, "update", error);
+        }
+    });
+};

package/dist/lib/agents.js

@@ -0,0 +1,44 @@
+import path from "node:path";
+import os from "node:os";
+const home = os.homedir();
+export const agentPaths = (projectRoot) => ({
+    opencode: {
+        project: [
+            path.join(projectRoot, ".opencode", "skills"),
+            path.join(projectRoot, ".claude", "skills"),
+        ],
+        user: [path.join(home, ".config", "opencode", "skills"), path.join(home, ".claude", "skills")],
+    },
+    claude: {
+        project: [path.join(projectRoot, ".claude", "skills")],
+        user: [path.join(home, ".claude", "skills")],
+    },
+    cursor: {
+        project: [
+            path.join(projectRoot, ".cursor", "skills"),
+            path.join(projectRoot, ".claude", "skills"),
+        ],
+        user: [path.join(home, ".cursor", "skills"), path.join(home, ".claude", "skills")],
+    },
+    codex: {
+        project: [path.join(projectRoot, ".codex", "skills")],
+        user: [path.join(home, ".codex", "skills")],
+        system: [path.join(path.sep, "etc", "codex", "skills")],
+    },
+    amp: {
+        project: [
+            path.join(projectRoot, ".agents", "skills"),
+            path.join(projectRoot, ".claude", "skills"),
+        ],
+        user: [path.join(home, ".config", "agents", "skills"), path.join(home, ".claude", "skills")],
+    },
+    antigravity: {
+        project: [path.join(projectRoot, ".agent", "skills")],
+        user: [path.join(home, ".gemini", "antigravity", "skills")],
+    },
+});
+export const allAgents = ["opencode", "claude", "cursor", "codex", "amp", "antigravity"];
+const agentSet = new Set(allAgents);
+export const isAgentId = (value) => {
+    return agentSet.has(value);
+};

package/dist/lib/command.js

@@ -0,0 +1,9 @@
+import { isJsonEnabled, printError, printJson } from "./output.js";
+export const handleCommandError = (options, command, error) => {
+    const message = error instanceof Error ? error.message : "Unexpected error";
+    if (isJsonEnabled(options)) {
+        printJson({ ok: false, command, error: { message } });
+        return;
+    }
+    printError(message);
+};

package/dist/lib/config.js

@@ -0,0 +1,27 @@
+import fs from "node:fs/promises";
+import { skillboxRoot } from "./paths.js";
+import path from "node:path";
+const defaultConfig = () => ({
+    version: 1,
+    defaultAgents: [],
+    defaultScope: "project",
+    manageSystem: false,
+});
+export const configPath = () => path.join(skillboxRoot(), "config.json");
+export const loadConfig = async () => {
+    try {
+        const content = await fs.readFile(configPath(), "utf8");
+        return JSON.parse(content);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return defaultConfig();
+        }
+        throw error;
+    }
+};
+export const saveConfig = async (config) => {
+    await fs.mkdir(skillboxRoot(), { recursive: true });
+    const json = JSON.stringify(config, null, 2);
+    await fs.writeFile(configPath(), `${json}\n`, "utf8");
+};

package/dist/lib/fetcher.js

@@ -0,0 +1,8 @@
+import fetch from "node-fetch";
+export const fetchText = async (url) => {
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+    }
+    return await response.text();
+};

package/dist/lib/grouping.js

@@ -0,0 +1,34 @@
+export const groupNamesByKey = (items, nameOf, keysOf) => {
+    const map = new Map();
+    for (const item of items) {
+        const name = nameOf(item);
+        for (const key of keysOf(item)) {
+            const existing = map.get(key) ?? [];
+            if (!existing.includes(name)) {
+                existing.push(name);
+                map.set(key, existing);
+            }
+        }
+    }
+    return Array.from(map.entries())
+        .map(([key, skills]) => ({ key, skills: skills.sort() }))
+        .sort((a, b) => a.key.localeCompare(b.key));
+};
+export const groupStatusByKey = (items, nameOf, outdatedOf, keysOf) => {
+    const map = new Map();
+    for (const item of items) {
+        const name = nameOf(item);
+        const outdated = outdatedOf(item);
+        for (const key of keysOf(item)) {
+            const entry = map.get(key) ?? { key, outdated: [], upToDate: [] };
+            if (outdated) {
+                entry.outdated.push(name);
+            }
+            else {
+                entry.upToDate.push(name);
+            }
+            map.set(key, entry);
+        }
+    }
+    return Array.from(map.values()).sort((a, b) => a.key.localeCompare(b.key));
+};

package/dist/lib/index.js

@@ -0,0 +1,42 @@
+import fs from "node:fs/promises";
+import { skillboxIndexPath, skillboxRoot } from "./paths.js";
+const emptyIndex = () => ({ version: 1, skills: [] });
+export const loadIndex = async () => {
+    const filePath = skillboxIndexPath();
+    try {
+        const content = await fs.readFile(filePath, "utf8");
+        return JSON.parse(content);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return emptyIndex();
+        }
+        throw error;
+    }
+};
+export const saveIndex = async (index) => {
+    await fs.mkdir(skillboxRoot(), { recursive: true });
+    const filePath = skillboxIndexPath();
+    const json = JSON.stringify(index, null, 2);
+    await fs.writeFile(filePath, `${json}\n`, "utf8");
+};
+export const upsertSkill = (index, skill) => {
+    const next = { ...index, skills: [...index.skills] };
+    const existingIndex = next.skills.findIndex((item) => item.name === skill.name);
+    if (existingIndex === -1) {
+        next.skills.push(skill);
+        return next;
+    }
+    next.skills[existingIndex] = { ...next.skills[existingIndex], ...skill };
+    return next;
+};
+export const sortIndex = (index) => {
+    const skills = [...index.skills].sort((a, b) => a.name.localeCompare(b.name));
+    return { ...index, skills };
+};
+export const ensureIndexSchema = (index) => {
+    if (!index.version) {
+        return { version: 1, skills: index.skills ?? [] };
+    }
+    return index;
+};

package/dist/lib/installs.js

@@ -0,0 +1,36 @@
+const projectInstalls = (install) => {
+    return install.scope === "project" && Boolean(install.projectRoot);
+};
+export const collectProjectSkills = (skills) => {
+    const map = new Map();
+    for (const skill of skills) {
+        for (const install of skill.installs ?? []) {
+            if (!projectInstalls(install)) {
+                continue;
+            }
+            const existing = map.get(install.projectRoot) ?? [];
+            if (!existing.includes(skill.name)) {
+                existing.push(skill.name);
+                map.set(install.projectRoot, existing);
+            }
+        }
+    }
+    return map;
+};
+export const getProjectSkills = (skills, projectRoot) => {
+    const map = collectProjectSkills(skills);
+    return (map.get(projectRoot) ?? []).sort();
+};
+export const getProjectInstallPaths = (skills, projectRoot) => {
+    const map = new Map();
+    for (const skill of skills) {
+        const paths = (skill.installs ?? [])
+            .filter(projectInstalls)
+            .filter((install) => install.projectRoot === projectRoot)
+            .map((install) => install.path);
+        if (paths.length > 0) {
+            map.set(skill.name, paths);
+        }
+    }
+    return map;
+};

package/dist/lib/options.js

@@ -0,0 +1,21 @@
+import { allAgents, isAgentId } from "./agents.js";
+export const parseAgentList = (value) => {
+    if (!value) {
+        return [];
+    }
+    return value
+        .split(",")
+        .map((agent) => agent.trim())
+        .filter((agent) => agent.length > 0)
+        .filter(isAgentId);
+};
+export const resolveAgentList = (override, config) => {
+    const parsed = parseAgentList(override);
+    if (parsed.length > 0) {
+        return parsed;
+    }
+    if (config.defaultAgents.length > 0) {
+        return config.defaultAgents.filter(isAgentId);
+    }
+    return allAgents;
+};

package/dist/lib/output.js

@@ -0,0 +1,26 @@
+import chalk from "chalk";
+export const isJsonEnabled = (options) => Boolean(options.json);
+export const printJson = (result) => {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+};
+export const printInfo = (message) => {
+    process.stdout.write(`${message}\n`);
+};
+export const printError = (message) => {
+    process.stderr.write(`${chalk.red(message)}\n`);
+};
+export const printList = (label, items, indent = "- ") => {
+    printInfo(`${label}: ${items.length}`);
+    for (const item of items) {
+        printInfo(`${indent}${item}`);
+    }
+};
+export const printGroupList = (label, groups, itemPrefix = "  - ") => {
+    printInfo(`${label}: ${groups.length}`);
+    for (const group of groups) {
+        printInfo(`- ${group.key}`);
+        for (const item of group.items) {
+            printInfo(`${itemPrefix}${item}`);
+        }
+    }
+};

package/dist/lib/paths.js

@@ -0,0 +1,6 @@
+import os from "node:os";
+import path from "node:path";
+export const skillboxRoot = () => path.join(os.homedir(), ".config", "skillbox");
+export const skillboxSkillsDir = () => path.join(skillboxRoot(), "skills");
+export const skillboxIndexPath = () => path.join(skillboxRoot(), "index.json");
+export const skillboxProjectsPath = () => path.join(skillboxRoot(), "projects.json");

package/dist/lib/project-paths.js

@@ -0,0 +1,18 @@
+import { agentPaths } from "./agents.js";
+export const buildProjectAgentPaths = (projectRoot, project) => {
+    const defaults = agentPaths(projectRoot);
+    if (!project?.agentPaths) {
+        return defaults;
+    }
+    const merged = { ...defaults };
+    for (const [agent, paths] of Object.entries(project.agentPaths)) {
+        if (!paths) {
+            continue;
+        }
+        merged[agent] = {
+            ...defaults[agent],
+            project: paths,
+        };
+    }
+    return merged;
+};