skillbox 0.3.0 → 0.3.2

package/dist/cli.js

@@ -12,7 +12,7 @@ import { registerRemove } from "./commands/remove.js";
 import { registerStatus } from "./commands/status.js";
 import { registerUpdate } from "./commands/update.js";
 const program = new Command();
-program.name("skillbox").description("Local-first, agent-agnostic skills manager").version("0.3.0");
+program.name("skillbox").description("Local-first, agent-agnostic skills manager").version("0.3.2");
 registerAdd(program);
 registerAgent(program);
 registerConfig(program);

package/dist/commands/add-repo.js

@@ -2,6 +2,7 @@ import { getErrorMessage } from "../lib/command.js";
 import { loadConfig } from "../lib/config.js";
 import { parseRepoRef } from "../lib/github.js";
 import { loadIndex, saveIndex, sortIndex, upsertSkill } from "../lib/index.js";
+import { recordInstallPaths } from "../lib/installs.js";
 import { printInfo, printJson } from "../lib/output.js";
 import { buildProjectAgentPaths } from "../lib/project-paths.js";
 import { fetchRepoFile, listRepoSkills, normalizeRepoRef, writeRepoSkillDirectory, } from "../lib/repo-skills.js";
@@ -31,6 +32,7 @@ async function installSkillTargets(skillName, options, installs) {
     const projectEntry = await ensureProjectRegistered(projectRoot, scope);
     const paths = buildProjectAgentPaths(projectRoot, projectEntry);
     const config = await loadConfig();
+    const recordedPaths = new Set();
     for (const agent of agentList) {
         const map = paths[agent];
         if (!map) {
@@ -41,17 +43,20 @@ async function installSkillTargets(skillName, options, installs) {
         const written = results
             .filter((result) => result.mode !== "skipped")
             .map((result) => result.path);
-        const warning = buildSymlinkWarning(agent, results);
-        if (warning) {
+        const warnings = buildSymlinkWarning(agent, results);
+        for (const warning of warnings) {
             printInfo(warning);
         }
-        for (const target of written) {
-            installs.push({
-                scope,
-                agent,
-                path: target,
-                projectRoot: scope === "project" ? projectRoot : undefined,
-            });
+        const deduped = recordInstallPaths(written, recordedPaths);
+        if (deduped.length > 0) {
+            for (const target of deduped) {
+                installs.push({
+                    scope,
+                    agent,
+                    path: target,
+                    projectRoot: scope === "project" ? projectRoot : undefined,
+                });
+            }
         }
     }
 }

package/dist/commands/add.js

@@ -3,6 +3,7 @@ import { loadConfig } from "../lib/config.js";
 import { fetchText } from "../lib/fetcher.js";
 import { collect } from "../lib/fs-utils.js";
 import { loadIndex, saveIndex, sortIndex, upsertSkill } from "../lib/index.js";
+import { recordInstallPaths } from "../lib/installs.js";
 import { isJsonEnabled, printInfo, printJson } from "../lib/output.js";
 import { buildProjectAgentPaths } from "../lib/project-paths.js";
 import { ensureProjectRegistered, resolveRuntime } from "../lib/runtime.js";
@@ -64,6 +65,7 @@ export function registerAdd(program) {
             const config = await loadConfig();
             const installed = [];
             const installs = [];
+            const recordedPaths = new Set();
             for (const agent of agentList) {
                 const map = paths[agent];
                 if (!map) {
@@ -74,13 +76,14 @@ export function registerAdd(program) {
                 const written = results
                     .filter((result) => result.mode !== "skipped")
                     .map((result) => result.path);
-                const warning = buildSymlinkWarning(agent, results);
-                if (warning) {
+                const warnings = buildSymlinkWarning(agent, results);
+                for (const warning of warnings) {
                     printInfo(warning);
                 }
-                if (written.length > 0) {
-                    installed.push({ agent, scope, targets: written });
-                    for (const target of written) {
+                const deduped = recordInstallPaths(written, recordedPaths);
+                if (deduped.length > 0) {
+                    installed.push({ agent, scope, targets: deduped });
+                    for (const target of deduped) {
                         installs.push({
                             scope,
                             agent,

package/dist/commands/list.js

@@ -58,9 +58,28 @@ function groupByScope(skills) {
         });
     }
     if (projectSkills.length > 0) {
+        const projectRoots = new Map();
+        for (const skill of projectSkills) {
+            const roots = getProjectRoots(skill);
+            if (roots.length === 0) {
+                continue;
+            }
+            for (const root of roots) {
+                const existing = projectRoots.get(root) ?? [];
+                existing.push(skill);
+                projectRoots.set(root, existing);
+            }
+        }
+        const projectGroups = Array.from(projectRoots.entries())
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([projectRoot, skillsForProject]) => ({
+            projectRoot,
+            sourceGroups: groupBySourceType(skillsForProject),
+        }));
         result.push({
             scope: "project",
             sourceGroups: groupBySourceType(projectSkills),
+            projectGroups,
         });
     }
     return result;
@@ -71,10 +90,33 @@ function groupBySourceType(skills) {
     const grouped = groupAndSort(skills, (skill) => skill.source.type, LIST_SOURCE_ORDER, sortByName);
     return grouped.map(({ key, items }) => ({ source: key, skills: items }));
 }
+function getProjectRoots(skill) {
+    const roots = (skill.installs ?? [])
+        .filter((install) => install.scope === "project")
+        .map((install) => install.projectRoot)
+        .filter((root) => Boolean(root));
+    return Array.from(new Set(roots));
+}
 function printScopeGroup(group) {
     const label = group.scope === "global" ? "Global Skills" : "Project Skills";
     const totalCount = group.sourceGroups.reduce((sum, g) => sum + g.skills.length, 0);
     printInfo(`${label} (${totalCount})`);
+    if (group.scope === "project" && group.projectGroups) {
+        for (const projectGroup of group.projectGroups) {
+            printInfo("");
+            printInfo(projectGroup.projectRoot);
+            for (const sourceGroup of projectGroup.sourceGroups) {
+                printInfo(`  ${sourceGroup.source}`);
+                for (const skill of sourceGroup.skills) {
+                    printInfo(`    ${skill.name}`);
+                    if (skill.subcommands.length > 0) {
+                        printInfo(`      → ${skill.subcommands.join(", ")}`);
+                    }
+                }
+            }
+        }
+        return;
+    }
     for (const sourceGroup of group.sourceGroups) {
         printInfo("");
         printInfo(`${sourceGroup.source}`);

package/dist/lib/installs.js

@@ -31,6 +31,17 @@ export function getInstallPaths(skill, projectRoot) {
         .filter((install) => install.projectRoot === projectRoot)
         .map((install) => install.path);
 }
+export function recordInstallPaths(paths, recorded) {
+    const deduped = [];
+    for (const path of paths) {
+        if (recorded.has(path)) {
+            continue;
+        }
+        recorded.add(path);
+        deduped.push(path);
+    }
+    return deduped;
+}
 export function getProjectInstallPaths(skills, projectRoot) {
     const map = new Map();
     for (const skill of skills) {

package/dist/lib/sync.js

@@ -17,29 +17,53 @@ async function copyFiles(sourceDir, targetDir) {
         await fs.copyFile(sourcePath, destPath);
     }
 }
+async function isSymlinkTo(targetDir, expectedSource) {
+    try {
+        const stat = await fs.lstat(targetDir);
+        if (!stat.isSymbolicLink()) {
+            return false;
+        }
+        const linkTarget = await fs.readlink(targetDir);
+        return linkTarget === expectedSource;
+    }
+    catch {
+        return false;
+    }
+}
 async function createSymlink(sourceDir, targetDir) {
+    if (await isSymlinkTo(targetDir, sourceDir)) {
+        return "exists";
+    }
     await fs.symlink(sourceDir, targetDir, "dir");
+    return "created";
 }
 export function buildSymlinkWarning(agent, results) {
     const skipped = results.filter((result) => result.mode === "skipped");
     if (skipped.length === 0) {
-        return null;
+        return [];
+    }
+    const warnings = [];
+    for (const result of skipped) {
+        const skillName = path.basename(result.path);
+        const isExists = result.error?.includes("EEXIST");
+        if (isExists) {
+            warnings.push(`  ⚠ ${skillName} (${agent}): already exists at target, remove manually or use --install-mode copy`);
+        }
+        else {
+            warnings.push(`  ⚠ ${skillName} (${agent}): ${result.error ?? "unknown error"}`);
+        }
     }
-    const details = skipped
-        .map((result) => `${result.path}: ${result.error ?? "unknown error"}`)
-        .join("; ");
-    return `Warning: symlink failed for ${agent}. ${details}. Remove the existing target or run "skillbox config set --install-mode copy" to use file copies.`;
+    return warnings;
 }
 export async function installSkillToTargets(skillName, targets, config) {
     const sourceDir = skillDir(skillName);
     const results = [];
-    for (const targetRoot of targets) {
-        const targetDir = path.join(targetRoot, skillName);
-        await ensureDir(targetRoot);
+    for (const targetDir of targets) {
+        await ensureDir(path.dirname(targetDir));
         if (config.installMode === "symlink") {
             try {
-                await createSymlink(sourceDir, targetDir);
-                results.push({ path: targetDir, mode: "symlink" });
+                const status = await createSymlink(sourceDir, targetDir);
+                results.push({ path: targetDir, mode: status === "exists" ? "symlink" : "symlink" });
             }
             catch (error) {
                 const message = getErrorMessage(error, "unknown error");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skillbox",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Local-first, agent-agnostic skills manager",
   "license": "MIT",
   "author": "Christian Anagnostou",