fix(skill): honor --dry-run for skill init/add/update/remove

Author: hopelynd

packages/commands/src/commands/skill/add.ts

@@ -57,13 +57,27 @@ export default defineCommand({
   exampleArgs: ["--all", "--name spark-video,bailian-model-recommend"],
   async run(ctx) {
     const format = ctx.settings.outputExplicit ? ctx.settings.output : "json";
+    const agents = detectInstalledAgents();
+    const parsed = ctx.flags.all ? "all" : parseSkillNames(ctx.flags.name, false);
+
+    if (ctx.settings.dryRun) {
+      emitResult(
+        {
+          action: "skill.add",
+          registry: getSkillRegistryBaseUrl(),
+          agents: agents.map((agent) => agent.id),
+          skills: parsed,
+        },
+        format,
+      );
+      return;
+    }
+
     const index = await fetchSkillsIndex();
     const remoteNames = Object.keys(index.skills);
-    const parsed = ctx.flags.all ? "all" : parseSkillNames(ctx.flags.name, false);
     const names = parsed === "all" ? remoteNames : parsed;
 
     const lock = readSkillLock();
-    const agents = detectInstalledAgents();
 
     // collect-then-throw: a single skill failure only affects itself; successful ones are written to disk and lock as usual.
     // Skills install concurrently (bounded by INSTALL_CONCURRENCY) — each writes to a disjoint canonical dir, unique tmpDir, and distinct lock key.

packages/commands/src/commands/skill/init.ts

@@ -4,6 +4,7 @@ import {
   defineCommand,
   detectInstalledAgents,
   fetchSkillsIndex,
+  getSkillRegistryBaseUrl,
   installSkillWithFanout,
   readSkillLock,
   runWithConcurrency,
@@ -54,13 +55,27 @@ export default defineCommand({
   ],
   async run(ctx) {
     const format = ctx.settings.outputExplicit ? ctx.settings.output : DEFAULT_FORMAT;
+    const agents = detectInstalledAgents();
+
+    if (ctx.settings.dryRun) {
+      emitResult(
+        {
+          action: "skill.init",
+          registry: getSkillRegistryBaseUrl(),
+          skills: `${BAILIAN_PREFIX}*`,
+          agents: agents.map((agent) => agent.id),
+        },
+        format,
+      );
+      return;
+    }
+
     const index = await fetchSkillsIndex();
 
     // Discover all bailian-* skills from the live registry index
     const names = Object.keys(index.skills).filter((name) => name.startsWith(BAILIAN_PREFIX));
 
     const lock = readSkillLock();
-    const agents = detectInstalledAgents();
 
     const tasks = names.map((name) => async (): Promise<InitOutcome> => {
       const entry = index.skills[name];

packages/commands/src/commands/skill/remove.ts

@@ -50,6 +50,20 @@ export default defineCommand({
       return;
     }
 
+    if (ctx.settings.dryRun) {
+      emitResult(
+        {
+          action: "skill.remove",
+          skills: names.map((name) => ({
+            name,
+            removedLinks: (lock.skills[name]?.links ?? []).length,
+          })),
+        },
+        format,
+      );
+      return;
+    }
+
     const diskDirs = new Set(listSkillDirsOnDisk());
     const results: RemoveOutcome[] = [];
     for (const name of names) {
@@ -83,17 +97,19 @@ export default defineCommand({
     if (format === "json") {
       emitResult({ skills: results }, format);
     } else {
-      const rows = results.map((r) => [
-        r.name,
-        r.status,
-        r.status === "removed" ? `reclaimed ${r.removedLinks} agent link(s)` : (r.reason ?? "-"),
+      const rows = results.map((result) => [
+        result.name,
+        result.status,
+        result.status === "removed"
+          ? `reclaimed ${result.removedLinks} agent link(s)`
+          : (result.reason ?? "-"),
       ]);
       for (const line of formatTable(["NAME", "STATUS", "DETAIL"], rows)) {
         emitBare(line);
       }
     }
 
-    const failed = results.filter((r) => r.status === "failed");
+    const failed = results.filter((result) => result.status === "failed");
     if (failed.length > 0) {
       throw new BailianError(
         `${failed.length}/${results.length} skill(s) failed to remove`,

packages/commands/src/commands/skill/update.ts

@@ -58,11 +58,43 @@ export default defineCommand({
     const format = ctx.settings.outputExplicit ? ctx.settings.output : "json";
     const updateAll = ctx.flags.all || !ctx.flags.name;
     const requested = updateAll ? "all" : parseSkillNames(ctx.flags.name, false);
-    const index = await fetchSkillsIndex();
     const lock = readSkillLock();
+    const agents = detectInstalledAgents();
+
+    if (ctx.settings.dryRun) {
+      const failed: UpdateOutcome[] = [];
+      let skills: string[];
+      if (requested === "all") {
+        skills = Object.keys(lock.skills);
+      } else {
+        skills = [];
+        for (const name of requested) {
+          if (!lock.skills[name]) {
+            failed.push({
+              name,
+              status: "failed",
+              reason: "not installed; run bl skill add --name " + name + " first",
+            });
+            continue;
+          }
+          skills.push(name);
+        }
+      }
+      emitResult(
+        {
+          action: "skill.update",
+          registry: getSkillRegistryBaseUrl(),
+          skills,
+          ...(failed.length > 0 ? { failed } : {}),
+        },
+        format,
+      );
+      return;
+    }
+
+    const index = await fetchSkillsIndex();
     const disk = new Set(listSkillDirsOnDisk());
 
-    const agents = detectInstalledAgents();
     const results: UpdateOutcome[] = [];
     const targets: string[] = [];
     if (requested === "all") {

packages/commands/tests/e2e/skill.e2e.test.ts

@@ -1,4 +1,4 @@
-import { existsSync, mkdtempSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { describe, expect, test } from "vite-plus/test";
@@ -13,6 +13,31 @@ function makeTempConfigDir(): string {
   return mkdtempSync(join(tmpdir(), "bl-skill-e2e-"));
 }
 
+/** 在隔离 configDir 里种一个假 skill + lock，供 remove/update --dry-run 本地断言 */
+function seedInstalledSkill(configDir: string, skillName: string, links: string[]): void {
+  const skillDir = join(configDir, "skills", skillName);
+  mkdirSync(skillDir, { recursive: true });
+  writeFileSync(join(skillDir, "SKILL.md"), "---\nname: seeded\n---\n");
+  writeFileSync(
+    join(configDir, "skills", "skill-lock.json"),
+    `${JSON.stringify(
+      {
+        version: 1,
+        skills: {
+          [skillName]: {
+            contentHash: "sha256:seeded-for-dry-run",
+            installedAt: new Date().toISOString(),
+            sourceType: "oss",
+            links,
+          },
+        },
+      },
+      null,
+      2,
+    )}\n`,
+  );
+}
+
 describe("e2e: skill", () => {
   test("skill add --help exits successfully", async () => {
     const { stderr, exitCode } = await runCommandHelp(SKILL_ROUTES, ["skill", "add", "--help"]);
@@ -47,7 +72,7 @@ describe("e2e: skill", () => {
   });
 });
 
-// Local-only cases: auth "none" + validation happens before any network access, no gating needed
+// Local-only cases: auth "none" + dry-run / validation happen before any network access
 describe("e2e: skill (local, no credentials)", () => {
   test("skill add without --all or --name errors as usage error (2)", async () => {
     const { stdout, stderr, exitCode } = await runCommandE2e(SKILL_ROUTES, [
@@ -96,6 +121,102 @@ describe("e2e: skill (local, no credentials)", () => {
     expect(data.skills?.[0]?.status).toBe("failed");
     expect(data.skills?.[0]?.reason).toMatch(/not installed/i);
   });
+
+  test("skill remove --dry-run 仅输出计划且不删盘", async () => {
+    const configDir = makeTempConfigDir();
+    const fakeHome = makeTempConfigDir();
+    const linkPath = join(fakeHome, ".claude", "skills", "seeded-skill");
+    seedInstalledSkill(configDir, "seeded-skill", [linkPath]);
+    mkdirSync(join(fakeHome, ".claude", "skills"), { recursive: true });
+    writeFileSync(linkPath, "link-placeholder");
+
+    const { stdout, stderr, exitCode } = await runCommandE2e(
+      SKILL_ROUTES,
+      ["skill", "remove", "--name", "seeded-skill", "--dry-run", "--output", "json"],
+      { BAILIAN_CONFIG_DIR: configDir, HOME: fakeHome, USERPROFILE: fakeHome },
+    );
+    expect(exitCode, stderr).toBe(0);
+    const data = parseStdoutJson<{
+      action?: string;
+      skills?: Array<{ name?: string; removedLinks?: number }>;
+    }>(stdout);
+    expect(data.action).toBe("skill.remove");
+    expect(data.skills?.[0]?.name).toBe("seeded-skill");
+    expect(data.skills?.[0]?.removedLinks).toBe(1);
+    expect(existsSync(join(configDir, "skills", "seeded-skill", "SKILL.md"))).toBe(true);
+    expect(existsSync(join(configDir, "skills", "skill-lock.json"))).toBe(true);
+    expect(existsSync(linkPath)).toBe(true);
+  });
+
+  test("skill add --dry-run 仅输出计划且不写盘、不联网", async () => {
+    const configDir = makeTempConfigDir();
+    const fakeHome = makeTempConfigDir();
+    const { stdout, stderr, exitCode } = await runCommandE2e(
+      SKILL_ROUTES,
+      ["skill", "add", "--name", WIKI_SKILL, "--dry-run", "--output", "json"],
+      { BAILIAN_CONFIG_DIR: configDir, HOME: fakeHome, USERPROFILE: fakeHome },
+    );
+    expect(exitCode, stderr).toBe(0);
+    const data = parseStdoutJson<{
+      action?: string;
+      skills?: string[] | string;
+      registry?: string;
+    }>(stdout);
+    expect(data.action).toBe("skill.add");
+    expect(data.registry).toMatch(/^https?:\/\//);
+    expect(data.skills).toEqual([WIKI_SKILL]);
+    expect(existsSync(join(configDir, "skills", WIKI_SKILL))).toBe(false);
+    expect(existsSync(join(configDir, "skills", "skill-lock.json"))).toBe(false);
+  });
+
+  test("skill init --dry-run 仅输出筛选意图且不写盘、不联网", async () => {
+    const configDir = makeTempConfigDir();
+    const fakeHome = makeTempConfigDir();
+    const { stdout, stderr, exitCode } = await runCommandE2e(
+      SKILL_ROUTES,
+      ["skill", "init", "--dry-run", "--output", "json"],
+      { BAILIAN_CONFIG_DIR: configDir, HOME: fakeHome, USERPROFILE: fakeHome },
+    );
+    expect(exitCode, stderr).toBe(0);
+    const data = parseStdoutJson<{
+      action?: string;
+      skills?: string;
+      registry?: string;
+    }>(stdout);
+    expect(data.action).toBe("skill.init");
+    expect(data.registry).toMatch(/^https?:\/\//);
+    expect(data.skills).toBe("bailian-*");
+    expect(existsSync(join(configDir, "skills"))).toBe(false);
+  });
+
+  test("skill update --dry-run 仅输出计划且不 fan-out、不写 lock", async () => {
+    const configDir = makeTempConfigDir();
+    const fakeHome = makeTempConfigDir();
+    const linkPath = join(fakeHome, ".claude", "skills", "seeded-skill");
+    seedInstalledSkill(configDir, "seeded-skill", [linkPath]);
+    mkdirSync(join(fakeHome, ".claude", "skills"), { recursive: true });
+    writeFileSync(linkPath, "link-placeholder");
+    const lockBefore = readFileSync(join(configDir, "skills", "skill-lock.json"), "utf-8");
+
+    const { stdout, stderr, exitCode } = await runCommandE2e(
+      SKILL_ROUTES,
+      ["skill", "update", "--name", "seeded-skill", "--dry-run", "--output", "json"],
+      { BAILIAN_CONFIG_DIR: configDir, HOME: fakeHome, USERPROFILE: fakeHome },
+    );
+    expect(exitCode, stderr).toBe(0);
+    const data = parseStdoutJson<{
+      action?: string;
+      skills?: string[];
+      registry?: string;
+    }>(stdout);
+    expect(data.action).toBe("skill.update");
+    expect(data.registry).toMatch(/^https?:\/\//);
+    expect(data.skills).toEqual(["seeded-skill"]);
+    expect(readFileSync(join(configDir, "skills", "skill-lock.json"), "utf-8")).toBe(lockBefore);
+    expect(existsSync(join(configDir, "skills", "seeded-skill", "SKILL.md"))).toBe(true);
+    expect(existsSync(linkPath)).toBe(true);
+    expect(readFileSync(linkPath, "utf-8")).toBe("link-placeholder");
+  });
 });
 
 describe.skipIf(!isBailianE2EEnabled())("e2e: skill (real registry)", () => {