skillbox 0.2.1 → 0.3.0

package/dist/commands/remove.js

@@ -0,0 +1,101 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { handleCommandError } from "../lib/command.js";
+import { loadIndex, saveIndex, sortIndex } from "../lib/index.js";
+import { isJsonEnabled, printInfo, printJson } from "../lib/output.js";
+import { skillDir } from "../lib/skill-store.js";
+async function removePaths(paths) {
+    for (const target of paths) {
+        await fs.rm(target, { recursive: true, force: true });
+    }
+}
+function groupInstallsByScope(installs) {
+    const groups = new Map();
+    for (const install of installs) {
+        const key = install.scope === "project" ? `project:${install.projectRoot}` : "user";
+        const existing = groups.get(key) ?? [];
+        existing.push(install);
+        groups.set(key, existing);
+    }
+    return groups;
+}
+function printRemovedInstalls(installs) {
+    const groups = groupInstallsByScope(installs);
+    // Sort: user scope first, then projects
+    const sortedKeys = Array.from(groups.keys()).sort((a, b) => {
+        if (a === "user")
+            return -1;
+        if (b === "user")
+            return 1;
+        return a.localeCompare(b);
+    });
+    for (const key of sortedKeys) {
+        const groupInstalls = groups.get(key) ?? [];
+        const label = key === "user" ? "user" : key.replace("project:", "project: ");
+        for (const install of groupInstalls) {
+            printInfo(`  ✓ ${label}/${install.agent}`);
+        }
+    }
+}
+export function registerRemove(program) {
+    program
+        .command("remove")
+        .argument("<name>", "Skill name")
+        .option("--project <path>", "Only remove installs for a project")
+        .option("--json", "JSON output")
+        .action(async (name, options) => {
+        try {
+            const index = await loadIndex();
+            const skill = index.skills.find((entry) => entry.name === name);
+            if (!skill) {
+                throw new Error(`Skill not found: ${name}`);
+            }
+            const projectRoot = options.project ? path.resolve(options.project) : null;
+            const installs = skill.installs ?? [];
+            const isProjectInstall = (install) => install.scope === "project" &&
+                Boolean(install.projectRoot) &&
+                install.projectRoot === projectRoot;
+            const toRemove = projectRoot ? installs.filter(isProjectInstall) : installs;
+            if (projectRoot && toRemove.length === 0) {
+                throw new Error(`No installs found for ${name} in ${projectRoot}.`);
+            }
+            const removedPaths = toRemove.map((install) => install.path);
+            await removePaths(removedPaths);
+            let removedCanonical = false;
+            if (projectRoot) {
+                const remaining = installs.filter((install) => !isProjectInstall(install));
+                index.skills = index.skills.map((entry) => entry.name === name
+                    ? { ...entry, installs: remaining.length > 0 ? remaining : undefined }
+                    : entry);
+            }
+            else {
+                index.skills = index.skills.filter((entry) => entry.name !== name);
+                await fs.rm(skillDir(name), { recursive: true, force: true });
+                removedCanonical = true;
+            }
+            await saveIndex(sortIndex(index));
+            if (isJsonEnabled(options)) {
+                printJson({
+                    ok: true,
+                    command: "remove",
+                    data: {
+                        name,
+                        project: projectRoot,
+                        removed: toRemove,
+                        removedCanonical,
+                    },
+                });
+                return;
+            }
+            printInfo(`Skill Removal: ${name}`);
+            if (toRemove.length > 0) {
+                printInfo("");
+                printInfo("Removed from:");
+                printRemovedInstalls(toRemove);
+            }
+        }
+        catch (error) {
+            handleCommandError(options, "remove", error);
+        }
+    });
+}

package/dist/commands/status.js

@@ -1,129 +1,138 @@
-import { isJsonEnabled, printInfo, printJson, printList } from "../lib/output.js";
-import { loadIndex, saveIndex } from "../lib/index.js";
+import { handleCommandError } from "../lib/command.js";
 import { fetchText } from "../lib/fetcher.js";
+import { loadIndex, saveIndex } from "../lib/index.js";
+import { isJsonEnabled, printInfo, printJson } from "../lib/output.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) => {
+import { groupAndSort, sortByName } from "../lib/source-grouping.js";
+async function checkSkillStatus(skill) {
+    const isTrackable = skill.source.type === "url" || skill.source.type === "git";
+    if (!isTrackable || skill.source.type !== "url" || !skill.source.url) {
+        return {
+            name: skill.name,
+            source: skill.source.type,
+            trackable: isTrackable,
+            outdated: false,
+            localChecksum: skill.checksum,
+        };
+    }
+    try {
+        const remoteText = await fetchText(skill.source.url);
+        const remoteChecksum = hashContent(remoteText);
+        const outdated = remoteChecksum !== skill.checksum;
+        return {
+            name: skill.name,
+            source: skill.source.type,
+            trackable: true,
+            outdated,
+            localChecksum: skill.checksum,
+            remoteChecksum,
+        };
+    }
+    catch (err) {
+        return {
+            name: skill.name,
+            source: skill.source.type,
+            trackable: true,
+            outdated: false,
+            localChecksum: skill.checksum,
+            error: err instanceof Error ? err.message : "Failed to check",
+        };
+    }
+}
+// Sort sources: url first, then git, then local (for status command - trackable first)
+const STATUS_SOURCE_ORDER = ["url", "git", "local"];
+function groupBySource(statuses) {
+    const grouped = groupAndSort(statuses, (s) => s.source, STATUS_SOURCE_ORDER, sortByName);
+    return grouped.map(({ key, items }) => {
+        const trackable = items.some((s) => s.trackable);
+        const outdatedCount = items.filter((s) => s.outdated).length;
+        const upToDateCount = items.filter((s) => s.trackable && !s.outdated && !s.error).length;
+        return {
+            source: key,
+            skills: items,
+            trackable,
+            outdatedCount,
+            upToDateCount,
+        };
+    });
+}
+function formatSourceHeader(group) {
+    const count = group.skills.length;
+    const skillWord = count === 1 ? "skill" : "skills";
+    if (!group.trackable) {
+        return `${group.source} (${count} ${skillWord} - not tracked)`;
+    }
+    if (group.outdatedCount > 0) {
+        return `${group.source} (${count} ${skillWord}, ${group.outdatedCount} outdated)`;
+    }
+    return `${group.source} (${count} ${skillWord})`;
+}
+function printSourceGroup(group) {
+    printInfo(formatSourceHeader(group));
+    for (const skill of group.skills) {
+        if (!group.trackable) {
+            printInfo(`  ${skill.name}`);
+        }
+        else if (skill.error) {
+            printInfo(`  ? ${skill.name} (${skill.error})`);
+        }
+        else if (skill.outdated) {
+            printInfo(`  ✗ ${skill.name} (outdated)`);
+        }
+        else {
+            printInfo(`  ✓ ${skill.name}`);
+        }
+    }
+}
+export function 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 = [];
+            const statuses = [];
             for (const skill of index.skills) {
-                const projects = Array.from(new Set((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 status = await checkSkillStatus(skill);
+                statuses.push(status);
+                // Update lastChecked for trackable skills
+                if (status.trackable && !status.error) {
+                    skill.lastChecked = new Date().toISOString();
                 }
-                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);
+            const sourceGroups = groupBySource(statuses);
+            const totalOutdated = statuses.filter((s) => s.outdated).length;
+            const totalTrackable = statuses.filter((s) => s.trackable).length;
+            const totalUpToDate = statuses.filter((s) => s.trackable && !s.outdated && !s.error).length;
             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,
+                        total: statuses.length,
+                        outdated: totalOutdated,
+                        upToDate: totalUpToDate,
+                        trackable: totalTrackable,
+                        skills: statuses,
+                        bySource: sourceGroups,
                     },
                 });
                 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;
+            printInfo("Skill Status");
+            for (const group of sourceGroups) {
+                printInfo("");
+                printSourceGroup(group);
             }
-            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;
+            // Summary line if there are outdated skills
+            if (totalOutdated > 0) {
+                printInfo("");
+                printInfo(`Run 'skillbox update' to update ${totalOutdated} outdated skill(s).`);
             }
-            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

@@ -1,84 +1,213 @@
-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) => {
+import { loadConfig } from "../lib/config.js";
+import { fetchText } from "../lib/fetcher.js";
+import { loadIndex, saveIndex, sortIndex, upsertSkill } from "../lib/index.js";
+import { getInstallPaths } from "../lib/installs.js";
+import { isJsonEnabled, printInfo, printJson } from "../lib/output.js";
+import { fetchRepoFile, normalizeRepoRef, writeRepoSkillDirectory } from "../lib/repo-skills.js";
+import { buildMetadata, parseSkillMarkdown } from "../lib/skill-parser.js";
+import { ensureSkillsDir, writeSkillFiles, writeSkillMetadata } from "../lib/skill-store.js";
+import { groupAndSort, sortByName } from "../lib/source-grouping.js";
+import { installSkillToTargets } from "../lib/sync.js";
+// Sort sources: url first, then git (trackable sources first)
+const UPDATE_SOURCE_ORDER = ["url", "git", "local"];
+function groupBySource(results) {
+    const grouped = groupAndSort(results, (r) => r.source, UPDATE_SOURCE_ORDER, sortByName);
+    return grouped.map(({ key, items }) => ({
+        source: key,
+        results: items,
+        updatedCount: items.filter((r) => r.status === "updated").length,
+        failedCount: items.filter((r) => r.status === "failed").length,
+    }));
+}
+function formatSourceHeader(group) {
+    const count = group.results.length;
+    const skillWord = count === 1 ? "skill" : "skills";
+    if (group.source === "local") {
+        return `${group.source} (${count} ${skillWord} - skipped)`;
+    }
+    if (group.failedCount > 0) {
+        return `${group.source} (${count} ${skillWord}, ${group.failedCount} failed)`;
+    }
+    return `${group.source} (${count} ${skillWord})`;
+}
+function printSourceGroup(group) {
+    printInfo(formatSourceHeader(group));
+    for (const result of group.results) {
+        if (result.status === "skipped") {
+            printInfo(`  - ${result.name}`);
+        }
+        else if (result.status === "failed") {
+            printInfo(`  ✗ ${result.name} (${result.error ?? "failed"})`);
+        }
+        else {
+            printInfo(`  ✓ ${result.name}`);
+        }
+    }
+}
+async function updateUrlSkill(skill, index, projectRoot, config) {
+    if (!skill.source.url) {
+        return;
+    }
+    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 installPaths = getInstallPaths(skill, projectRoot);
+    if (installPaths.length > 0) {
+        await installSkillToTargets(skill.name, installPaths, config);
+    }
+    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;
+}
+async function updateGitSkill(skill, index, projectRoot, config) {
+    if (!skill.source.repo) {
+        return;
+    }
+    const [owner, repo] = skill.source.repo.split("/");
+    if (!owner || !repo) {
+        return;
+    }
+    const skillPath = skill.source.path?.replace(/\/$/, "") ?? "";
+    const ref = await normalizeRepoRef({
+        owner,
+        repo,
+        ref: skill.source.ref ?? "main",
+    });
+    const skillFilePath = skillPath ? `${skillPath}/SKILL.md` : "SKILL.md";
+    const markdown = await fetchRepoFile(ref, skillFilePath);
+    const parsed = parseSkillMarkdown(markdown);
+    if (!parsed.description) {
+        throw new Error(`Skill ${skill.name} is missing a description after update.`);
+    }
+    await writeRepoSkillDirectory(ref, skillPath, skill.name);
+    const source = {
+        type: "git",
+        repo: skill.source.repo,
+        path: skillPath || undefined,
+        ref: ref.ref,
+    };
+    const metadata = buildMetadata(parsed, source, skill.name);
+    await writeSkillMetadata(skill.name, metadata);
+    const installPaths = getInstallPaths(skill, projectRoot);
+    if (installPaths.length > 0) {
+        await installSkillToTargets(skill.name, installPaths, config);
+    }
+    const nextIndex = upsertSkill(index, {
+        name: skill.name,
+        source,
+        checksum: parsed.checksum,
+        updatedAt: metadata.updatedAt,
+        lastSync: new Date().toISOString(),
+    });
+    index.skills = nextIndex.skills;
+}
+export function 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 config = await loadConfig();
             const projectRoot = options.project ? path.resolve(options.project) : null;
+            const results = [];
             for (const skill of targets) {
-                if (skill.source.type !== "url" || !skill.source.url) {
-                    continue;
+                if (skill.source.type === "url") {
+                    try {
+                        await updateUrlSkill(skill, index, projectRoot, config);
+                        results.push({ name: skill.name, source: "url", status: "updated" });
+                    }
+                    catch (err) {
+                        results.push({
+                            name: skill.name,
+                            source: "url",
+                            status: "failed",
+                            error: err instanceof Error ? err.message : "unknown error",
+                        });
+                    }
                 }
-                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.`);
+                else if (skill.source.type === "git") {
+                    try {
+                        await updateGitSkill(skill, index, projectRoot, config);
+                        results.push({ name: skill.name, source: "git", status: "updated" });
+                    }
+                    catch (err) {
+                        results.push({
+                            name: skill.name,
+                            source: "git",
+                            status: "failed",
+                            error: err instanceof Error ? err.message : "unknown error",
+                        });
+                    }
                 }
-                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);
+                else {
+                    results.push({ name: skill.name, source: skill.source.type, status: "skipped" });
                 }
-                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));
+            const sourceGroups = groupBySource(results);
+            const totalUpdated = results.filter((r) => r.status === "updated").length;
+            const totalFailed = results.filter((r) => r.status === "failed").length;
+            const totalSkipped = results.filter((r) => r.status === "skipped").length;
+            const totalTrackable = results.filter((r) => r.source !== "local").length;
             if (isJsonEnabled(options)) {
                 printJson({
                     ok: true,
                     command: "update",
                     data: {
                         name: name ?? null,
-                        system: Boolean(options.system),
                         project: projectRoot,
-                        updated,
+                        total: results.length,
+                        updated: totalUpdated,
+                        failed: totalFailed,
+                        skipped: totalSkipped,
+                        results,
+                        bySource: sourceGroups,
                     },
                 });
                 return;
             }
-            if (updated.length === 0) {
-                printInfo("No skills updated.");
+            if (results.length === 0) {
+                printInfo("No skills to update.");
                 return;
             }
-            printInfo(`Updated ${updated.length} skill(s):`);
-            for (const skillName of updated) {
-                printInfo(`- ${skillName}`);
+            printInfo("Skill Update");
+            for (const group of sourceGroups) {
+                printInfo("");
+                printSourceGroup(group);
+            }
+            // Summary line
+            printInfo("");
+            if (totalFailed > 0) {
+                printInfo(`Updated ${totalUpdated} of ${totalTrackable} trackable skills (${totalFailed} failed).`);
+            }
+            else if (totalUpdated > 0) {
+                printInfo(`Updated ${totalUpdated} of ${totalTrackable} trackable skills.`);
+            }
+            else if (totalSkipped > 0 && totalTrackable === 0) {
+                printInfo("No trackable skills to update.");
             }
         }
         catch (error) {
             handleCommandError(options, "update", error);
         }
     });
-};
+}

package/dist/lib/agent-detect.js

@@ -1,6 +1,6 @@
-import fs from "node:fs/promises";
-import path from "node:path";
 import os from "node:os";
+import path from "node:path";
+import { exists } from "./fs-utils.js";
 const home = os.homedir();
 const agentRoots = {
     opencode: [path.join(home, ".config", "opencode")],
@@ -10,16 +10,7 @@ const agentRoots = {
     amp: [path.join(home, ".config", "agents")],
     antigravity: [path.join(home, ".gemini", "antigravity")],
 };
-const exists = async (target) => {
-    try {
-        await fs.access(target);
-        return true;
-    }
-    catch {
-        return false;
-    }
-};
-export const detectAgents = async () => {
+export async function detectAgents() {
     const detected = [];
     for (const [agent, roots] of Object.entries(agentRoots)) {
         const matches = await Promise.all(roots.map((root) => exists(root)));
@@ -28,4 +19,4 @@ export const detectAgents = async () => {
         }
     }
     return detected;
-};
+}