skillshelf 0.6.1 → 0.6.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skillshelf",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "Agent-first skill registry + manager for Claude Code and compatible agents.",
   "type": "module",
   "license": "MIT",

package/src/commands/rm.test.ts

@@ -166,6 +166,30 @@ describe("skl rm/retire/unretire — removal lifecycle (friction #1)", () => {
     expect(errors.join("\n")).toContain("not in the library");
   });
 
+  test("rm removes MULTIPLE names in one call (regression: batch must not drop names)", async () => {
+    await writeSkill(library, "beta");
+    await writeSkill(library, "gamma");
+    const { ctx } = makeCtx(library);
+    // Live OWNED skills need --force; the WHOLE batch must purge, not just the first
+    // (the old single-name rm silently ignored names 2..N).
+    const code = await rmRun(["alpha", "beta", "gamma", "--force"], ctx);
+    expect(code).toBe(0);
+    for (const n of ["alpha", "beta", "gamma"]) {
+      expect(existsSync(join(library, n))).toBe(false);
+    }
+  });
+
+  test("rm batch is ATOMIC on validation — one missing name deletes nothing", async () => {
+    await writeSkill(library, "beta");
+    const { ctx, errors } = makeCtx(library);
+    const code = await rmRun(["alpha", "ghost", "beta", "--force"], ctx);
+    expect(code).toBe(1);
+    expect(errors.join("\n")).toContain("not in the library");
+    // No partial purge — both valid names survive because one name was invalid.
+    expect(existsSync(join(library, "alpha"))).toBe(true);
+    expect(existsSync(join(library, "beta"))).toBe(true);
+  });
+
   test("rm refuses a path-traversal name (no escape outside the library)", async () => {
     // a sibling dir outside the library that must NOT be deletable via `../`
     const victim = join(tmp, "victim");

package/src/commands/rm.ts

@@ -1,10 +1,14 @@
-// `skl rm <name>` — delete a skill from the library entirely: remove its dir (or, for
-// a LINKED entry, just the symlink — the dev repo it points at is never touched, so
-// this doubles as `unlink`) AND drop its taxonomy + lockfile entries, then re-index.
+// `skl rm <name>...` — delete skill(s) from the library entirely: remove each dir (or,
+// for a LINKED entry, just the symlink — the dev repo it points at is never touched, so
+// this doubles as `unlink`) AND drop its taxonomy + lockfile entries, then re-index ONCE.
 // Before this, the ONLY delete path was an unguarded `rm -rf` against the library —
 // no safety rail for the most destructive lifecycle step.
 //
-//   skl rm <name> [--force] [--dry-run] [--json]
+//   skl rm <name>... [--force] [--dry-run] [--json]
+//
+// Batch: multiple names delete in one call (reindex collapses to one, mirroring
+// `retire`). Validation is ATOMIC — if any name is missing or a live OWNED skill without
+// --force, the whole batch refuses and nothing is deleted (never a partial purge).
 //
 // Safety (mirrors `link --at` refuse-by-default + named escape hatch): a LIVE (active,
 // non-retired) skill is refused without --force — retire it first (reversible) or pass
@@ -12,15 +16,15 @@
 // it purges without --force. --dry-run previews exactly what would be removed.
 
 import type { Ctx } from "../types.ts";
-import { locateEntry, removeSkill, reindexLibrary } from "../core/lifecycle.ts";
+import { locateEntry, removeSkill, reindexLibrary, type RemoveResult } from "../core/lifecycle.ts";
 import { readTaxonomy } from "../core/taxonomy.ts";
 import { readLockfile } from "../core/provenance.ts";
 import { render, type CommandResult } from "../core/report.ts";
 
 export const meta = {
   name: "rm",
-  summary: "Delete a skill from the library (dir/symlink + taxonomy + lock), re-index",
-  usage: "skl rm <name> [--force] [--dry-run] [--json]",
+  summary: "Delete skill(s) from the library (dir/symlink + taxonomy + lock), re-index",
+  usage: "skl rm <name>... [--force] [--dry-run] [--json]",
 } as const;
 
 export async function run(argv: string[], ctx: Ctx): Promise<number> {
@@ -35,64 +39,71 @@ export async function run(argv: string[], ctx: Ctx): Promise<number> {
     ctx.error(`usage: ${meta.usage}`);
     return 1;
   }
-  const name = argv.find((a) => !a.startsWith("--"));
-  if (!name) {
+  const names = argv.filter((a) => !a.startsWith("--"));
+  if (names.length === 0) {
     ctx.error("skl rm: a <name> is required");
     ctx.error(`usage: ${meta.usage}`);
     return 1;
   }
 
   try {
-    const loc = locateEntry(ctx.libraryPath, name);
-    if (!loc.path) {
-      ctx.error(`skl rm: '${name}' is not in the library`);
+    // Locate + guard EVERY name up front. The batch is ATOMIC on validation: if any
+    // name is missing, or is a live OWNED skill without --force (destroys real bytes),
+    // refuse the WHOLE batch and delete nothing — never a partial purge.
+    const located = names.map((name) => ({ name, loc: locateEntry(ctx.libraryPath, name) }));
+
+    const notFound = located.filter((x) => !x.loc.path).map((x) => x.name);
+    if (notFound.length) {
+      // Not-found stays a plain error (no --json body), matching the prior single-name path.
+      for (const n of notFound) ctx.error(`skl rm: '${n}' is not in the library`);
       return 1;
     }
-    // Refuse only a live OWNED skill unless forced — that destroys real bytes. A
-    // LINKED entry is just a symlink: removing it loses nothing (the dev repo stays
-    // canonical), so `skl rm <linked>` is the safe `unlink` and needs no --force. A
-    // purely-retired skill is already in the reversible holding area, so it purges
-    // freely. NOTE: gate on `loc.active` itself (the resolved path IS the active copy
-    // when active), NOT on the absence of a retired twin — a skill present in BOTH
-    // active and _retired still resolves `path` to the active copy, so a `!loc.retired`
-    // term would wrongly drop the guard and delete the live copy without --force.
-    if (loc.active && !loc.isLink && !force) {
-      // Refusal is an ERROR path: the human side prints via ctx.error (not ctx.log),
-      // so it stays in run(); only the --json payload routes through render().
+
+    // Refuse only a live OWNED skill unless forced — that destroys real bytes. A LINKED
+    // entry is just a symlink (removing it loses nothing); a purely-retired skill is
+    // already in the reversible holding area — both purge freely. Gate on `loc.active`
+    // itself (NOT `!loc.retired`) so a skill present in BOTH active and _retired keeps
+    // the guard on its live copy.
+    const refused = located.filter((x) => x.loc.active && !x.loc.isLink && !force).map((x) => x.name);
+    if (refused.length) {
       if (json) {
-        const result: CommandResult = {
-          json: { ok: false, name, refused: true, reason: "live-owned-needs-force" },
-          human: () => {},
-        };
-        render(ctx, json, result);
+        // Preserve the single-name payload shape; use a list form for a batch.
+        const body =
+          names.length === 1
+            ? { ok: false, name: names[0], refused: true, reason: "live-owned-needs-force" }
+            : { ok: false, refused, reason: "live-owned-needs-force" };
+        render(ctx, json, { json: body, human: () => {} });
       } else {
-        ctx.error(`skl rm: '${name}' is a live skill — this destroys real bytes.`);
-        ctx.error("Retire it first (reversible):  skl retire " + name);
-        ctx.error("Or hard-purge now:             skl rm " + name + " --force");
+        for (const n of refused) {
+          ctx.error(`skl rm: '${n}' is a live skill — this destroys real bytes.`);
+          ctx.error("Retire it first (reversible):  skl retire " + n);
+          ctx.error("Or hard-purge now:             skl rm " + n + " --force");
+        }
       }
       return 1;
     }
 
     // Preview what would be dropped (for --dry-run and richer reporting).
-    const tax = await readTaxonomy(ctx.libraryPath);
-    const lock = await readLockfile(ctx.libraryPath);
-    const plan = {
-      name,
-      path: loc.path,
-      mode: loc.isLink ? ("linked" as const) : ("owned" as const),
-      wasRetired: loc.retired && !loc.active,
-      taxonomyEntry: name in tax.skills,
-      lockEntry: name in lock.entries,
-    };
-
     if (dryRun) {
+      const tax = await readTaxonomy(ctx.libraryPath);
+      const lock = await readLockfile(ctx.libraryPath);
+      const plans = located.map(({ name, loc }) => ({
+        name,
+        path: loc.path,
+        mode: loc.isLink ? ("linked" as const) : ("owned" as const),
+        wasRetired: loc.retired && !loc.active,
+        taxonomyEntry: name in tax.skills,
+        lockEntry: name in lock.entries,
+      }));
       const result: CommandResult = {
-        json: { ok: true, dryRun: true, plan },
+        json: names.length === 1 ? { ok: true, dryRun: true, plan: plans[0] } : { ok: true, dryRun: true, plans },
         human: (emit) => {
-          emit(`DRY RUN — would remove '${name}':`);
-          emit(`  path:     ${plan.path}${plan.mode === "linked" ? " (symlink only — dev repo untouched)" : ""}`);
-          emit(`  taxonomy: ${plan.taxonomyEntry ? "drop entry" : "none"}`);
-          emit(`  lockfile: ${plan.lockEntry ? "drop entry" : "none"}`);
+          for (const plan of plans) {
+            emit(`DRY RUN — would remove '${plan.name}':`);
+            emit(`  path:     ${plan.path}${plan.mode === "linked" ? " (symlink only — dev repo untouched)" : ""}`);
+            emit(`  taxonomy: ${plan.taxonomyEntry ? "drop entry" : "none"}`);
+            emit(`  lockfile: ${plan.lockEntry ? "drop entry" : "none"}`);
+          }
           emit("Re-run without --dry-run to apply.");
         },
       };
@@ -100,14 +111,22 @@ export async function run(argv: string[], ctx: Ctx): Promise<number> {
       return 0;
     }
 
-    const removed = await removeSkill(ctx.libraryPath, name);
+    // Apply: remove each, then re-index ONCE at the end (a per-name reindex is the cost
+    // a bulk rm avoids — collapse it to one, mirroring bulkLifecycle).
+    const removed: RemoveResult[] = [];
+    for (const { name } of located) {
+      removed.push(await removeSkill(ctx.libraryPath, name));
+    }
     await reindexLibrary(ctx.libraryPath);
+
     const result: CommandResult = {
-      json: { ok: true, ...removed },
+      json: names.length === 1 ? { ok: true, ...removed[0] } : { ok: true, removed },
       human: (emit) => {
-        emit(`removed ${name}${removed.wasLink ? " (symlink only — dev repo untouched)" : ""}`);
-        if (removed.taxonomyDropped) emit("  dropped taxonomy entry");
-        if (removed.lockDropped) emit("  dropped lockfile entry");
+        for (const r of removed) {
+          emit(`removed ${r.name}${r.wasLink ? " (symlink only — dev repo untouched)" : ""}`);
+          if (r.taxonomyDropped) emit("  dropped taxonomy entry");
+          if (r.lockDropped) emit("  dropped lockfile entry");
+        }
       },
     };
     render(ctx, json, result);