Merge pull request #216 from modelstudioai/fix/skill-dry-run

Fix skill commands ignoring --dry-run

Author: XXPermanentXX

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

@@ -12,6 +12,7 @@ import {
   writeSkillLock,
 } from "bailian-cli-core";
 import { emitBare, emitResult, formatTable } from "bailian-cli-runtime";
+import { planFanoutLinks, summarizeAgents } from "./dry-run-plan.ts";
 
 interface AddOutcome {
   name: string;
@@ -61,9 +62,48 @@ export default defineCommand({
     const remoteNames = Object.keys(index.skills);
     const parsed = ctx.flags.all ? "all" : parseSkillNames(ctx.flags.name, false);
     const names = parsed === "all" ? remoteNames : parsed;
+    const agents = detectInstalledAgents();
+
+    if (ctx.settings.dryRun) {
+      const skills = names.map((name) => {
+        const entry = index.skills[name];
+        if (!entry) {
+          return {
+            name,
+            status: "failed" as const,
+            reason: "skill not found in registry",
+          };
+        }
+        return {
+          name,
+          status: "install" as const,
+          publishedAt: entry.publishedAt,
+          links: planFanoutLinks(name, agents),
+        };
+      });
+
+      emitResult(
+        {
+          action: "skill.add",
+          registry: getSkillRegistryBaseUrl(),
+          agents: summarizeAgents(agents),
+          skills,
+        },
+        format,
+      );
+
+      const failed = skills.filter((skill) => skill.status === "failed");
+      if (failed.length > 0) {
+        throw new BailianError(
+          `${failed.length}/${skills.length} skill(s) failed to install`,
+          ExitCode.GENERAL,
+          "Check the reason for failed skills in the output; network failures can be retried with bl skill add",
+        );
+      }
+      return;
+    }
 
     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/dry-run-plan.ts

@@ -0,0 +1,54 @@
+import { existsSync, lstatSync } from "node:fs";
+import { join } from "node:path";
+import { getSkillsDir, type AgentTarget } from "bailian-cli-core";
+
+/** dry-run 用的 agent 摘要（含目标目录） */
+export function summarizeAgents(agents: AgentTarget[]): Array<{ id: string; skillsDir: string }> {
+  return agents.map((agent) => ({
+    id: agent.id,
+    skillsDir: agent.skillsDir,
+  }));
+}
+
+export type PathKind = "absent" | "symlink" | "directory" | "file";
+
+/** 预计 fan-out 路径及当前存在性（只读 lstat，不预测 replace/skip） */
+export interface PlannedLink {
+  agent: string;
+  path: string;
+  exists: boolean;
+  kind: PathKind;
+  hasSkillMd: boolean;
+}
+
+function inspectPath(path: string): Pick<PlannedLink, "exists" | "kind" | "hasSkillMd"> {
+  try {
+    const stat = lstatSync(path);
+    if (stat.isSymbolicLink()) {
+      return { exists: true, kind: "symlink", hasSkillMd: false };
+    }
+    if (stat.isDirectory()) {
+      return {
+        exists: true,
+        kind: "directory",
+        hasSkillMd: existsSync(join(path, "SKILL.md")),
+      };
+    }
+    return { exists: true, kind: "file", hasSkillMd: false };
+  } catch {
+    return { exists: false, kind: "absent", hasSkillMd: false };
+  }
+}
+
+/** 按 agent skillsDir 拼出预计链接路径，并标注是否已存在 */
+export function planFanoutLinks(skillName: string, agents: AgentTarget[]): PlannedLink[] {
+  return agents.map((agent) => {
+    const path = join(agent.skillsDir, skillName);
+    return { agent: agent.id, path, ...inspectPath(path) };
+  });
+}
+
+/** Canonical skill 目录路径 */
+export function canonicalSkillPath(skillName: string): string {
+  return join(getSkillsDir(), skillName);
+}

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

@@ -10,6 +10,7 @@ import {
   writeSkillLock,
 } from "bailian-cli-core";
 import { emitBare, emitResult } from "bailian-cli-runtime";
+import { planFanoutLinks, summarizeAgents } from "./dry-run-plan.ts";
 
 /** Prefix used to identify first-party Bailian skills in the registry. */
 const BAILIAN_PREFIX = "bailian-";
@@ -58,9 +59,24 @@ export default defineCommand({
 
     // Discover all bailian-* skills from the live registry index
     const names = Object.keys(index.skills).filter((name) => name.startsWith(BAILIAN_PREFIX));
+    const agents = detectInstalledAgents();
+
+    if (ctx.settings.dryRun) {
+      emitResult(
+        {
+          action: "skill.init",
+          skills: names.map((name) => ({
+            name,
+            links: planFanoutLinks(name, agents),
+          })),
+          agents: summarizeAgents(agents),
+        },
+        format,
+      );
+      return;
+    }
 
     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

@@ -2,14 +2,17 @@ import {
   BailianError,
   ExitCode,
   defineCommand,
+  getSkillsDir,
   listSkillDirsOnDisk,
   parseSkillNames,
+  planUnlinkSkillFromAgents,
   readSkillLock,
   removeSkillDir,
   unlinkSkillFromAgents,
   writeSkillLock,
 } from "bailian-cli-core";
 import { emitBare, emitResult, formatTable } from "bailian-cli-runtime";
+import { join } from "node:path";
 
 interface RemoveOutcome {
   name: string;
@@ -18,6 +21,14 @@ interface RemoveOutcome {
   reason?: string;
 }
 
+interface RemovePlanItem {
+  name: string;
+  status: "remove" | "failed";
+  canonical?: string;
+  links?: string[];
+  reason?: string;
+}
+
 export default defineCommand({
   description: {
     "en-US": "Remove locally installed skills (registry is untouched)",
@@ -51,6 +62,42 @@ export default defineCommand({
     }
 
     const diskDirs = new Set(listSkillDirsOnDisk());
+    const skillsDir = getSkillsDir();
+
+    if (ctx.settings.dryRun) {
+      const results: RemovePlanItem[] = names.map((name) => {
+        const locked = lock.skills[name];
+        if (!locked) {
+          return {
+            name,
+            status: "failed",
+            reason: diskDirs.has(name)
+              ? "directory not managed by bl skill (untracked); remove manually if needed"
+              : "not installed",
+          };
+        }
+        return {
+          name,
+          status: "remove",
+          canonical: join(skillsDir, name),
+          // 与真实 unlink 同一候选集：含 lock 外的历史托管 symlink
+          links: planUnlinkSkillFromAgents(name, locked.links ?? []),
+        };
+      });
+
+      emitResult({ action: "skill.remove", skills: results }, format);
+
+      const failed = results.filter((result) => result.status === "failed");
+      if (failed.length > 0) {
+        throw new BailianError(
+          `${failed.length}/${results.length} skill(s) failed to remove`,
+          ExitCode.GENERAL,
+          "Check the reason for failed skills in the output; use bl skill list to verify local install status",
+        );
+      }
+      return;
+    }
+
     const results: RemoveOutcome[] = [];
     for (const name of names) {
       const locked = lock.skills[name];
@@ -83,17 +130,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

@@ -14,6 +14,7 @@ import {
   writeSkillLock,
 } from "bailian-cli-core";
 import { emitBare, emitResult, formatTable } from "bailian-cli-runtime";
+import { planFanoutLinks, summarizeAgents } from "./dry-run-plan.ts";
 
 interface UpdateOutcome {
   name: string;
@@ -22,6 +23,14 @@ interface UpdateOutcome {
   reason?: string;
 }
 
+interface UpdatePlanItem {
+  name: string;
+  status: "update" | "up-to-date" | "skipped" | "failed";
+  publishedAt?: string;
+  reason?: string;
+  links?: ReturnType<typeof planFanoutLinks>;
+}
+
 /** Max number of skills downloading/installing at the same time. */
 const UPDATE_CONCURRENCY = 3;
 
@@ -61,10 +70,11 @@ export default defineCommand({
     const index = await fetchSkillsIndex();
     const lock = readSkillLock();
     const disk = new Set(listSkillDirsOnDisk());
-
     const agents = detectInstalledAgents();
+
     const results: UpdateOutcome[] = [];
     const targets: string[] = [];
+
     if (requested === "all") {
       // Default: only process skills already installed in lock; reinstall only if version changed or local dir is missing
       for (const [name, locked] of Object.entries(lock.skills)) {
@@ -78,6 +88,11 @@ export default defineCommand({
           continue;
         }
         if (entry.contentHash === locked.contentHash && disk.has(name)) {
+          if (ctx.settings.dryRun) {
+            // 真实路径仍会 fan-out 自愈；dry-run 只展示目标路径与存在性，不写盘
+            results.push({ name, status: "up-to-date", publishedAt: locked.publishedAt });
+            continue;
+          }
           // Self-healing: content unchanged, but still fill fan-out links for agents
           // detected since the last install (and refresh recorded copies); the merged
           // ledger keeps paths of unvisited agents reclaimable by bl skill remove
@@ -103,6 +118,67 @@ export default defineCommand({
       }
     }
 
+    if (ctx.settings.dryRun) {
+      const plan: UpdatePlanItem[] = results.map((result) => {
+        if (result.status === "up-to-date") {
+          return {
+            name: result.name,
+            status: "up-to-date" as const,
+            publishedAt: result.publishedAt,
+            links: planFanoutLinks(result.name, agents),
+          };
+        }
+        if (result.status === "skipped") {
+          return {
+            name: result.name,
+            status: "skipped" as const,
+            publishedAt: result.publishedAt,
+            reason: result.reason,
+          };
+        }
+        return {
+          name: result.name,
+          status: "failed" as const,
+          publishedAt: result.publishedAt,
+          reason: result.reason,
+        };
+      });
+
+      for (const name of targets) {
+        const entry = index.skills[name];
+        if (!entry) {
+          plan.push({ name, status: "failed", reason: "skill not found in registry" });
+          continue;
+        }
+        plan.push({
+          name,
+          status: "update",
+          publishedAt: entry.publishedAt,
+          links: planFanoutLinks(name, agents),
+        });
+      }
+
+      emitResult(
+        {
+          action: "skill.update",
+          registry: getSkillRegistryBaseUrl(),
+          agents: summarizeAgents(agents),
+          skills: plan,
+        },
+        format,
+      );
+
+      const failed = plan.filter((item) => item.status === "failed");
+      if (failed.length > 0) {
+        throw new BailianError(
+          `${failed.length} skill(s) failed to update`,
+          ExitCode.GENERAL,
+          "Check the reason for failed skills in the output; network failures can be retried with bl skill update",
+        );
+      }
+      return;
+    }
+
     const tasks = targets.map((name) => async (): Promise<UpdateOutcome> => {
       const entry = index.skills[name];
       if (!entry) {