@actiondock/cli 2.0.9 → 2.0.11-beta.0

package/src/commands/export.ts

@@ -1,6 +1,15 @@
-import { exportSkill, findProjectRoot, resolvePackageRoot } from "@actiondock/core";
+import { existsSync } from "node:fs";
+import { basename } from "node:path";
+import { exportCompositeSkill, exportSkill, exportSkillBatch } from "@actiondock/builder";
+import { discoverProjects, findProjectRoot, listLinkedPackages, resolvePackageRoot } from "@actiondock/core";
+import { ExecutionError } from "@actiondock/runtime-cli";
 import { Command } from "commander";
 
+function parseListOption(val: string, prev: string[] = []): string[] {
+  const parts = val.split(",").map((s) => s.trim()).filter(Boolean);
+  return [...prev, ...parts];
+}
+
 export function registerExportCommand(program: Command): void {
   const exportCmd = program
     .command("export")
@@ -9,7 +18,18 @@ export function registerExportCommand(program: Command): void {
   exportCmd
     .command("skill")
     .description("Export Skill directory for AI Agents (default: source skill; use -s/--standalone for pre-built standalone binary)")
-    .option("-P, --package <id>", "Target package ID or path")
+    .option(
+      "-P, --package <id...>",
+      "Target package ID(s) or path(s) (can be specified multiple times or comma-separated)",
+      parseListOption,
+      []
+    )
+    .option("--workspace", "Export all packages discovered in current workspace")
+    .option("--all", "Export all linked packages from global registry")
+    .option(
+      "--bundle [name]",
+      "Export multiple packages as a unified composite Skill bundle (defaults to workspace directory name if omitted)"
+    )
     .option("-s, --standalone", "Export pre-compiled standalone binary skill (for environments without ActionDock runtime)")
     .option("-t, --target <target>", "Target compilation platform for standalone mode (e.g. host, linux-x64, darwin-arm64, windows-x64)")
     .option("-o, --out <path>", "Output skill directory")
@@ -20,25 +40,126 @@ export function registerExportCommand(program: Command): void {
     .option("--bytecode", "Compile JavaScript to bytecode in standalone mode (default: true)", true)
     .option("--no-bytecode", "Disable bytecode compilation in standalone mode")
     .option("-z, --archive", "Create a .zip archive of the exported skill")
+    .option("--skill-md <path>", "Use specified existing SKILL.md file instead of auto-generating")
     .action(async (options) => {
-      const root = options.package
-        ? resolvePackageRoot(options.package)
-        : findProjectRoot();
+      const isStandalone = Boolean(options.standalone);
+
+      if (options.bundle && isStandalone) {
+        throw new ExecutionError(
+          "Composite Skill export (--bundle) currently only supports source mode. Please remove --standalone to export as a composite workspace Skill."
+        );
+      }
+
+      const sourceCount =
+        (options.all ? 1 : 0) +
+        (options.workspace ? 1 : 0) +
+        (options.package && options.package.length > 0 ? 1 : 0);
+      if (sourceCount > 1) {
+        throw new ExecutionError(
+          "Options -P/--package, --workspace, and --all are mutually exclusive. Please specify only one package selection mode."
+        );
+      }
+
+      let roots: string[] = [];
 
-      if (!root) {
-        if (options.package) {
-          console.error(`Error: Package '${options.package}' not found in linked packages or path`);
+      if (options.all) {
+        const linked = listLinkedPackages();
+        roots = linked.map((p) => p.path).filter((p) => existsSync(p));
+        if (roots.length === 0) {
+          throw new ExecutionError("No linked packages found in global registry.");
+        }
+      } else if (options.workspace) {
+        const cwd = process.cwd();
+        const discovered = discoverProjects(cwd);
+        roots = discovered.length > 0 ? discovered : (findProjectRoot(cwd) ? [findProjectRoot(cwd)!] : []);
+        if (roots.length === 0) {
+          throw new ExecutionError(
+            `No ActionDock packages found in workspace '${cwd}'.\nMake sure child directories contain actiondock.json.`
+          );
+        }
+      } else if (options.package && options.package.length > 0) {
+        for (const pkgIdOrPath of options.package) {
+          const root = resolvePackageRoot(pkgIdOrPath);
+          if (!root) {
+            throw new ExecutionError(`Package '${pkgIdOrPath}' not found in linked packages or path`);
+          }
+          if (!roots.includes(root)) {
+            roots.push(root);
+          }
+        }
+      } else {
+        const root = findProjectRoot();
+        if (root) {
+          roots.push(root);
         } else {
-          console.error(
-            "Error: Not in an ActionDock project (actiondock.json not found).\nPlease specify -P, --package <id> or cd into a project directory."
+          throw new ExecutionError(
+            "Not in an ActionDock project (actiondock.json not found).\nPlease specify -P, --package <id>, --workspace, --all, or cd into a project directory."
           );
         }
-        process.exit(1);
       }
 
-      const isStandalone = Boolean(options.standalone);
+      if (roots.length > 1 && (options.actions || options.playbook)) {
+        throw new ExecutionError(
+          "Filtering options (--actions, --playbook) can only be used when exporting a single package."
+        );
+      }
 
       try {
+        if (options.bundle !== undefined) {
+          const bundleName =
+            typeof options.bundle === "string" && options.bundle.trim()
+              ? options.bundle.trim()
+              : basename(process.cwd());
+          console.log(`Exporting composite Skill bundle '${bundleName}' (${roots.length} package${roots.length > 1 ? "s" : ""})...`);
+          const result = await exportCompositeSkill({
+            bundleName,
+            projectRoots: roots,
+            outDir: options.out,
+            archive: options.archive,
+            workspaceRoot: options.workspace ? process.cwd() : undefined,
+            skillMdPath: options.skillMd,
+          });
+
+          console.log(`[OK] Successfully exported Composite Skill: ${result.bundleName}`);
+          console.log(`  Packages:   ${result.packagesCount}`);
+          console.log(`  Actions:    ${result.actionsCount}`);
+          console.log(`  Playbooks:  ${result.playbooksCount}`);
+          console.log(`  Skill Dir:  ${result.skillDir}`);
+          if (result.usedExistingSkillMd) {
+            console.log(`  SKILL.md:   Reused existing file from ${result.usedExistingSkillMd}`);
+          }
+          if (result.archivePath) {
+            console.log(`  Archive:    ${result.archivePath}`);
+          }
+          return;
+        }
+
+        if (roots.length > 1) {
+          console.log(`Batch exporting ${roots.length} Skill packages...`);
+          const batchRes = await exportSkillBatch({
+            projectRoots: roots,
+            mode: isStandalone ? "standalone" : "source",
+            standalone: isStandalone,
+            target: options.target,
+            outDir: options.out,
+            archive: options.archive,
+            playbooks: options.playbook,
+            actions: options.actions,
+            minify: options.minify,
+            bytecode: options.bytecode,
+            skillMdPath: options.skillMd,
+          });
+
+          console.log(`[OK] Successfully batch exported ${batchRes.results.length} Skill packages to: ${batchRes.outDir}`);
+          for (const res of batchRes.results) {
+            console.log(`  - ${res.packageId} (v${res.version}): ${res.actionsCount} actions, ${res.playbooksCount} playbooks -> ${res.skillDir}`);
+          }
+          console.log(`  Total Actions:   ${batchRes.totalActions}`);
+          console.log(`  Total Playbooks: ${batchRes.totalPlaybooks}`);
+          return;
+        }
+
+        const root = roots[0];
         console.log(`Exporting ${isStandalone ? "standalone binary" : "source"} Skill artifact...`);
         const result = await exportSkill({
           projectRoot: root,
@@ -51,6 +172,7 @@ export function registerExportCommand(program: Command): void {
           actions: options.actions,
           minify: options.minify,
           bytecode: options.bytecode,
+          skillMdPath: options.skillMd,
         });
 
         console.log(`[OK] Successfully exported ${result.mode === "standalone" ? "Standalone" : "Source"} Skill: ${result.packageId} (v${result.version})`);
@@ -58,13 +180,17 @@ export function registerExportCommand(program: Command): void {
         console.log(`  Actions:    ${result.actionsCount}`);
         console.log(`  Playbooks:  ${result.playbooksCount}`);
         console.log(`  Skill Dir:  ${result.skillDir}`);
+        if (result.usedExistingSkillMd) {
+          console.log(`  SKILL.md:   Reused existing file from ${result.usedExistingSkillMd}`);
+        }
         if (result.archivePath) {
           console.log(`  Archive:    ${result.archivePath}`);
         }
       } catch (err: any) {
-        console.error(`Export failed: ${err.message}`);
-        process.exit(1);
+        throw new ExecutionError(`Export failed: ${err.message}`);
       }
     });
 }
 
+
+

package/src/commands/index.ts

@@ -15,13 +15,43 @@ import { registerServeCommand } from "./serve";
 import { registerStateCommands } from "./state";
 import { registerTestCommand } from "./test";
 
+function applyCommonOptions(cmd: Command): void {
+  const hasOpt = (flagName: string) =>
+    cmd.options.some((o) => o.name() === flagName || o.long === `--${flagName}`);
+
+  if (!hasOpt("json")) {
+    cmd.option("--json", "Output as JSON");
+  }
+  if (!hasOpt("envelope")) {
+    cmd.option("--envelope", "Wrap JSON output in standard envelope");
+  }
+  if (!hasOpt("dataDir") && !hasOpt("data-dir")) {
+    cmd.option("--data-dir <path>", "Custom database storage directory");
+  }
+
+  for (const sub of cmd.commands) {
+    applyCommonOptions(sub);
+  }
+}
+
 export function createCliProgram(): Command {
   const program = new Command();
 
   program
     .name("ad")
     .description("ActionDock (ad) 2.0 - Toolchain for building and shipping standalone AI Agent Actions & Skills")
-    .version("2.0.9");
+    .version("2.0.11-beta.0", "-v, --version");
+
+  program.option("-V", "output the version number");
+  program.on("option:V", () => {
+    (program as any)._outputConfiguration.writeOut(`${program.version()}\n`);
+    (program as any)._exit(0, "commander.version", program.version()!);
+  });
+
+  // 禁用 Commander 内部直接 process.exit，统一由顶层调度器管控退出码
+  program.exitOverride((err) => {
+    throw err;
+  });
 
   registerInitCommand(program);
   registerInfoCommand(program);
@@ -39,5 +69,7 @@ export function createCliProgram(): Command {
   registerServeCommand(program);
   registerMcpCommands(program);
 
+  applyCommonOptions(program);
+
   return program;
 }

package/src/commands/info.ts

@@ -5,13 +5,14 @@ import {
   findProjectRoot,
   getRegistryStatus,
   listLinkedPackages,
-  loadActions,
+  loadManifest,
   loadPlaybooks,
   loadProjectConfig,
   resolvePackageRoot,
   resolveTarget,
 } from "@actiondock/core";
 import { Command } from "commander";
+import { ArgumentError, CliError, ExecutionError, getEffectiveOptions, renderResult } from "@actiondock/runtime-cli";
 import { resolveIntent } from "../utils/filter";
 
 interface AggregatedPackage {
@@ -29,7 +30,16 @@ interface AggregatedPackage {
 
 async function getProjectDetailInfo(root: string) {
   const config = loadProjectConfig(root);
-  const actions = await loadActions(root, config.actionsDir);
+  const manifest = loadManifest(root);
+  const actionsMap = new Map<string, { id: string; description?: string }>();
+  if (manifest?.actions) {
+    for (const [id, item] of Object.entries(manifest.actions)) {
+      actionsMap.set(id, {
+        id,
+        description: item.description,
+      });
+    }
+  }
   const playbooks = loadPlaybooks(root, config.playbooksDir);
 
   return {
@@ -40,13 +50,13 @@ async function getProjectDetailInfo(root: string) {
     projectRoot: root,
     actionsDir: config.actionsDir || "actions",
     playbooksDir: config.playbooksDir || "playbooks",
-    actionsCount: actions.size,
+    actionsCount: actionsMap.size,
     playbooksCount: playbooks.size,
-    actions: Array.from(actions.keys()),
+    actions: Array.from(actionsMap.keys()),
     playbooks: Array.from(playbooks.keys()),
     configDeclared: config.config ? Object.keys(config.config) : [],
     configDef: config.config,
-    actionsMap: actions,
+    actionsMap,
     playbooksMap: playbooks,
   };
 }
@@ -184,15 +194,21 @@ export function registerInfoCommand(program: Command): void {
     .option("-p, --profile <name>", "Query against a specific profile")
     .option("-s, --server <url>", "Remote server URL")
     .option("-t, --token <token>", "Auth token for remote server")
+    .option("--fallback", "Enable fallback to full list when no items match intent")
     .option(
       "--no-fallback",
       "Disable fallback to full list when no items match intent"
     )
     .option("--json", "Output information as JSON")
-    .action(async (patterns: string[] = [], options: any) => {
+    .option("--envelope", "Wrap JSON output in standard envelope")
+    .option("--data-dir <path>", "Custom database storage directory")
+    .action(async (patterns: string[] = [], rawOptions: any, cmd: any) => {
       try {
+        const options = getEffectiveOptions(rawOptions, cmd);
         const effectiveIntent = resolveIntent(options.intent, patterns);
-        const shouldFallback = options.fallback !== false;
+        const isMachine = Boolean(options.json || options.envelope);
+        const fallbackExplicit = options.fallback === true || (Array.isArray(process.argv) && process.argv.includes("--fallback"));
+        const shouldFallback = isMachine ? fallbackExplicit : options.fallback !== false;
 
         const target = resolveTarget({
           profile: options.profile,
@@ -212,8 +228,8 @@ export function registerInfoCommand(program: Command): void {
             }
           );
 
-          if (options.json) {
-            console.log(JSON.stringify(remoteInfo, null, 2));
+          if (isMachine) {
+            renderResult(remoteInfo, { json: options.json, envelope: options.envelope });
             return;
           }
 
@@ -304,8 +320,8 @@ export function registerInfoCommand(program: Command): void {
         // Local Tree
         if (options.tree) {
           const status = getRegistryStatus();
-          if (options.json) {
-            console.log(JSON.stringify(status, null, 2));
+          if (isMachine) {
+            renderResult(status, { json: options.json, envelope: options.envelope });
           } else {
             printRegistryTree(status);
           }
@@ -317,17 +333,16 @@ export function registerInfoCommand(program: Command): void {
           const directRoot = resolvePackageRoot(options.package);
           if (directRoot) {
             const detail = await getProjectDetailInfo(directRoot);
-            if (options.json) {
-              console.log(JSON.stringify(projectDetailToJson(detail), null, 2));
+            if (isMachine) {
+              renderResult(projectDetailToJson(detail), { json: options.json, envelope: options.envelope });
             } else {
               printProjectDetail(detail);
             }
             return;
           }
-          console.error(
-            `Error: Package '${options.package}' not found in linked packages or path`
+          throw new ArgumentError(
+            `Package '${options.package}' not found in linked packages or path`
           );
-          process.exit(1);
         }
 
         // 3. Collect local candidate packages (current project + linked packages)
@@ -339,7 +354,8 @@ export function registerInfoCommand(program: Command): void {
         if (currentRoot) {
           try {
             const config = loadProjectConfig(currentRoot);
-            const actions = await loadActions(currentRoot, config.actionsDir);
+            const manifest = loadManifest(currentRoot);
+            const manifestActionIds = manifest?.actions ? Object.keys(manifest.actions) : [];
             const playbooks = loadPlaybooks(currentRoot, config.playbooksDir);
             aggregated.push({
               id: config.id,
@@ -347,9 +363,9 @@ export function registerInfoCommand(program: Command): void {
               version: config.version,
               description: config.description,
               path: currentRoot,
-              actionsCount: actions.size,
+              actionsCount: manifestActionIds.length,
               playbooksCount: playbooks.size,
-              actions: Array.from(actions.keys()),
+              actions: manifestActionIds,
               playbooks: Array.from(playbooks.keys()),
               configDeclared: config.config ? Object.keys(config.config) : [],
             });
@@ -364,7 +380,8 @@ export function registerInfoCommand(program: Command): void {
           if (seenPaths.has(pkg.path)) continue;
           try {
             const config = loadProjectConfig(pkg.path);
-            const actions = await loadActions(pkg.path, config.actionsDir);
+            const manifest = loadManifest(pkg.path);
+            const manifestActionIds = manifest?.actions ? Object.keys(manifest.actions) : [];
             const playbooks = loadPlaybooks(pkg.path, config.playbooksDir);
 
             aggregated.push({
@@ -373,9 +390,9 @@ export function registerInfoCommand(program: Command): void {
               version: config.version,
               description: config.description,
               path: pkg.path,
-              actionsCount: actions.size,
+              actionsCount: manifestActionIds.length,
               playbooksCount: playbooks.size,
-              actions: Array.from(actions.keys()),
+              actions: manifestActionIds,
               playbooks: Array.from(playbooks.keys()),
               configDeclared: config.config ? Object.keys(config.config) : [],
             });
@@ -389,8 +406,8 @@ export function registerInfoCommand(program: Command): void {
         if (!effectiveIntent) {
           if (currentRoot) {
             const detail = await getProjectDetailInfo(currentRoot);
-            if (options.json) {
-              console.log(JSON.stringify(projectDetailToJson(detail), null, 2));
+            if (isMachine) {
+              renderResult(projectDetailToJson(detail), { json: options.json, envelope: options.envelope });
             } else {
               printProjectDetail(detail);
             }
@@ -398,19 +415,21 @@ export function registerInfoCommand(program: Command): void {
           }
 
           if (aggregated.length === 0) {
+            if (isMachine) {
+              renderResult({ linkedPackages: [] }, { json: options.json, envelope: options.envelope });
+              return;
+            }
             console.log(
               "No ActionDock project in current directory, and no packages linked."
             );
             console.log(
-              "Run 'ad link' inside an Action package to register it."
+              "Run 'ad link' inside an Action package or specify a target package."
             );
             return;
           }
 
-          if (options.json) {
-            console.log(
-              JSON.stringify({ linkedPackages: aggregated }, null, 2)
-            );
+          if (isMachine) {
+            renderResult({ linkedPackages: aggregated }, { json: options.json, envelope: options.envelope });
           } else {
             printAggregatedPackages(aggregated);
           }
@@ -423,8 +442,8 @@ export function registerInfoCommand(program: Command): void {
           const directRoot = resolvePackageRoot(patterns[0]);
           if (directRoot) {
             const detail = await getProjectDetailInfo(directRoot);
-            if (options.json) {
-              console.log(JSON.stringify(projectDetailToJson(detail), null, 2));
+            if (isMachine) {
+              renderResult(projectDetailToJson(detail), { json: options.json, envelope: options.envelope });
             } else {
               printProjectDetail(detail);
             }
@@ -433,10 +452,13 @@ export function registerInfoCommand(program: Command): void {
         }
 
         if (aggregated.length === 0) {
-          console.error(
-            `Error: No ActionDock project or linked packages available to match '${effectiveIntent}'`
+          if (isMachine) {
+            renderResult({ linkedPackages: [], matchedCount: 0, isFallback: false }, { json: options.json, envelope: options.envelope });
+            return;
+          }
+          throw new ExecutionError(
+            `No ActionDock project or linked packages available to match '${effectiveIntent}'`
           );
-          process.exit(1);
         }
 
         // 5.2 Intent filtering across candidate packages
@@ -456,61 +478,58 @@ export function registerInfoCommand(program: Command): void {
 
         // Subcase A: 0 items matched
         if (filterRes.matchedCount === 0) {
-          if (!shouldFallback) {
-            if (options.json) {
-              console.log(JSON.stringify({ linkedPackages: [] }, null, 2));
-            } else {
-              console.error(
-                `Error: No packages matched intent '${effectiveIntent}'`
-              );
+          if (!filterRes.isFallback) {
+            if (isMachine) {
+              renderResult({ linkedPackages: [], matchedCount: 0, isFallback: false }, { json: options.json, envelope: options.envelope });
+              return;
             }
-            process.exit(1);
+            throw new ExecutionError(
+              `No packages matched intent '${effectiveIntent}'`
+            );
           }
 
           // Fallback enabled: display all packages with a notice
-          if (options.json) {
-            console.log(
-              JSON.stringify(
-                { linkedPackages: filterRes.items, isFallback: true },
-                null,
-                2
-              )
+          if (isMachine) {
+            renderResult(
+              { linkedPackages: filterRes.items, isFallback: true, matchedCount: 0 },
+              { json: options.json, envelope: options.envelope }
             );
-          } else {
-            console.log(
-              `(No linked packages matched intent '${effectiveIntent}', showing all packages)\n`
-            );
-            printAggregatedPackages(filterRes.items);
+            return;
           }
+          console.log(
+            `(No linked packages matched intent '${effectiveIntent}', showing all packages)\n`
+          );
+          printAggregatedPackages(filterRes.items);
           return;
         }
 
-        // Subcase B: Exactly 1 item matched -> Display its full project detail
-        if (filterRes.matchedCount === 1 && !filterRes.isFallback) {
+        // Subcase B: Matched items in machine mode
+        if (isMachine) {
+          renderResult(
+            { linkedPackages: filterRes.items, matchedCount: filterRes.matchedCount, isFallback: false },
+            { json: options.json, envelope: options.envelope }
+          );
+          return;
+        }
+
+        // Subcase C: Exactly 1 item matched in human terminal mode -> Display full project detail
+        if (filterRes.matchedCount === 1) {
           const matchedPkg = filterRes.items[0];
           const detail = await getProjectDetailInfo(matchedPkg.path);
-          if (options.json) {
-            console.log(JSON.stringify(projectDetailToJson(detail), null, 2));
-          } else {
-            printProjectDetail(detail);
-          }
+          printProjectDetail(detail);
           return;
         }
 
-        // Subcase C: Multiple items matched -> Display filtered summary list
-        if (options.json) {
-          console.log(
-            JSON.stringify({ linkedPackages: filterRes.items }, null, 2)
-          );
-        } else {
-          printAggregatedPackages(filterRes.items, {
-            header: `ActionDock Linked Packages (${filterRes.matchedCount} matches for '${effectiveIntent}'):\n`,
-            showTip: true,
-          });
-        }
+        // Subcase D: Multiple items matched in human terminal mode -> Display filtered summary list
+        printAggregatedPackages(filterRes.items, {
+          header: `ActionDock Linked Packages (${filterRes.matchedCount} matches for '${effectiveIntent}'):\n`,
+          showTip: true,
+        });
       } catch (err: any) {
-        console.error(`Error: ${err.message}`);
-        process.exit(1);
+        if (err instanceof CliError) {
+          throw err;
+        }
+        throw new ExecutionError(err.message);
       }
     });
 }

package/src/commands/init.ts

@@ -1,4 +1,5 @@
 import { initProject } from "@actiondock/core";
+import { ExecutionError } from "@actiondock/runtime-cli";
 import { Command } from "commander";
 
 export function registerInitCommand(program: Command): void {
@@ -17,8 +18,7 @@ export function registerInitCommand(program: Command): void {
         });
         console.log(`Successfully initialized ActionDock project in ${dir}`);
       } catch (err: any) {
-        console.error(`Error: ${err.message}`);
-        process.exit(1);
+        throw new ExecutionError(err.message);
       }
     });
 }

package/src/commands/link.ts

@@ -3,6 +3,7 @@ import {
   pruneRegistry,
   unlinkPackage,
 } from "@actiondock/core";
+import { ExecutionError } from "@actiondock/runtime-cli";
 import { Command } from "commander";
 
 export function registerLinkCommands(program: Command): void {
@@ -27,8 +28,7 @@ export function registerLinkCommands(program: Command): void {
           console.log(`[OK] Linked package '${result.id}' (v${result.version}) from ${result.path}`);
         }
       } catch (err: any) {
-        console.error(`Error: ${err.message}`);
-        process.exit(1);
+        throw new ExecutionError(err.message);
       }
     });
 
@@ -67,8 +67,7 @@ export function registerLinkCommands(program: Command): void {
           console.log(`Package or workspace '${identifier || process.cwd()}' was not linked in registry`);
         }
       } catch (err: any) {
-        console.error(`Error: ${err.message}`);
-        process.exit(1);
+        throw new ExecutionError(err.message);
       }
     });
 }