@actiondock/cli 2.0.12 → 2.2.0

package/dist/commands/index.js

@@ -0,0 +1,111 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { Command } from "commander";
+import { registerActionCommands } from "./action/create.js";
+import { registerAddCommand } from "./add.js";
+import { registerBuildCommand } from "./build.js";
+import { registerConfigCommands } from "./config/index.js";
+import { registerDescribeCommand } from "./describe.js";
+import { registerDoctorCommand } from "./doctor.js";
+import { registerExportCommand } from "./export.js";
+import { registerGenerateCommands } from "./generate.js";
+import { registerInfoCommand } from "./info.js";
+import { registerInitCommand } from "./init.js";
+import { registerLinkCommands } from "./link.js";
+import { registerListCommand } from "./list.js";
+import { registerMcpCommands } from "./mcp.js";
+import { registerNewCommands } from "./new.js";
+import { registerPackCommand } from "./pack.js";
+import { registerPlaybookCommands } from "./playbook.js";
+import { registerProfileCommands } from "./profile.js";
+import { registerRemoveCommand } from "./remove.js";
+import { registerRunCommand } from "./run.js";
+import { registerRunsCommands } from "./runs.js";
+import { registerServeCommand } from "./serve.js";
+import { registerStateCommands } from "./state.js";
+import { registerTestCommand } from "./test.js";
+import { registerValidateCommand } from "./validate.js";
+/**
+ * 读取 CLI 自身 package.json 的版本号（单一事实源）。
+ * 兼容源码运行（src/commands）与构建产物运行（dist/commands）两种目录层级。
+ */
+function readCliVersion() {
+    try {
+        const pkgJson = JSON.parse(readFileSync(join(import.meta.dirname, "../../package.json"), "utf-8"));
+        return (pkgJson && pkgJson.version) || "0.0.0";
+    }
+    catch {
+        // package.json 缺失或损坏时回退占位版本，避免阻断启动
+        return "0.0.0";
+    }
+}
+/**
+ * CLI 版本号（来自 package.json 单一事实源）。
+ */
+export const CLI_VERSION = readCliVersion();
+/**
+ * 递归注入全局通用选项。
+ *
+ * 输出纪律契约：--json/--envelope 对所有命令统一注入；已实现 renderResult
+ * 数据输出的命令会消费它们，未实现机器输出的命令（init、link、test、new、
+ * serve、mcp 等）将其作为无操作标志忽略，不影响人类输出行为。
+ * 错误信封由顶层 main 的 renderError 统一兜底，与命令实现解耦。
+ */
+function applyCommonOptions(cmd) {
+    const hasOpt = (flagName) => 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(context) {
+    const program = new Command();
+    program
+        .name("ad")
+        .description("ActionDock (ad) 2.0 - Toolchain for building and shipping standalone AI Agent Actions & Skills")
+        .version(CLI_VERSION, "-v, --version");
+    program.option("-V", "output the version number");
+    program.on("option:V", () => {
+        program._outputConfiguration.writeOut(`${program.version()}\n`);
+        program._exit(0, "commander.version", program.version());
+    });
+    // 禁用 Commander 内部直接 process.exit，统一由顶层调度器管控退出码
+    program.exitOverride((err) => {
+        throw err;
+    });
+    registerInitCommand(program);
+    registerAddCommand(program, context);
+    registerRemoveCommand(program, context);
+    registerNewCommands(program, context);
+    registerActionCommands(program, context);
+    registerInfoCommand(program, context);
+    registerDoctorCommand(program, context);
+    registerListCommand(program, context);
+    registerDescribeCommand(program, context);
+    registerRunCommand(program, context);
+    registerValidateCommand(program, context);
+    registerGenerateCommands(program, context);
+    registerPlaybookCommands(program, context);
+    registerConfigCommands(program, context);
+    registerStateCommands(program, context);
+    registerRunsCommands(program, context);
+    registerTestCommand(program);
+    registerBuildCommand(program, context);
+    registerPackCommand(program, context);
+    registerExportCommand(program, context);
+    registerLinkCommands(program);
+    registerProfileCommands(program);
+    registerServeCommand(program, context);
+    registerMcpCommands(program, context);
+    applyCommonOptions(program);
+    return program;
+}
+export { registerActionCommands, registerAddCommand, registerBuildCommand, registerConfigCommands, registerDescribeCommand, registerDoctorCommand, registerExportCommand, registerGenerateCommands, registerInfoCommand, registerInitCommand, registerLinkCommands, registerListCommand, registerMcpCommands, registerNewCommands, registerPackCommand, registerPlaybookCommands, registerProfileCommands, registerRemoveCommand, registerRunCommand, registerRunsCommands, registerServeCommand, registerStateCommands, registerTestCommand, registerValidateCommand, };

package/dist/commands/info.d.ts

@@ -1,2 +1,9 @@
-import type { Command } from "commander";
-export declare function registerInfoCommand(program: Command): void;
+import { Command } from "commander";
+import type { CliContext } from "../types.js";
+/**
+ * 注册 info 命令。
+ *
+ * @param program Commander 实例
+ * @param context 命令行上下文
+ */
+export declare function registerInfoCommand(program: Command, context?: CliContext): void;

package/dist/commands/info.js

@@ -0,0 +1,210 @@
+import { fetchRemoteInfo, filterWithFallbackInfo, getRegistryStatus, resolvePackageRoot, resolveTarget, } from "@actiondock/core";
+import { ArgumentError, ExecutionError } from "../errors.js";
+import { projectDetailToJson, renderAggregatedPackages, renderProjectDetail, renderRegistryTree, renderResult, } from "../renderer.js";
+import { getProjectDetailInfo, scanLocalAggregatedPackages } from "../services/index.js";
+import { getEffectiveOptions, resolveFallbackStrategy, resolveIntent } from "../utils/index.js";
+/**
+ * 将远端信息响应归一为本地工程详情视图。
+ */
+function remoteInfoToDetail(remoteInfo) {
+    return {
+        id: remoteInfo.id,
+        name: remoteInfo.name || remoteInfo.id,
+        version: remoteInfo.version || "unknown",
+        description: remoteInfo.description,
+        projectRoot: remoteInfo.path || remoteInfo.projectRoot || "",
+        actionsDir: "remote",
+        playbooksDir: "remote",
+        actionsCount: remoteInfo.actionsCount || (remoteInfo.actions ? remoteInfo.actions.length : 0),
+        playbooksCount: remoteInfo.playbooksCount || (remoteInfo.playbooks ? remoteInfo.playbooks.length : 0),
+        actions: (remoteInfo.actionsDetail || remoteInfo.actions || []).map((a) => typeof a === "string" ? a : a.id),
+        playbooks: (remoteInfo.playbooksDetail || remoteInfo.playbooks || []).map((pb) => typeof pb === "string" ? pb : pb.id),
+        configDeclared: Object.keys(remoteInfo.configDeclared || {}),
+        configDef: remoteInfo.configDeclared,
+    };
+}
+/**
+ * 渲染工程详情输出（机器模式输出视图转换结果，人类模式渲染详情）。
+ */
+function renderProjectDetailOutput(detail, options) {
+    renderResult(projectDetailToJson(detail), {
+        json: options.json,
+        envelope: options.envelope,
+        humanFormatter: () => renderProjectDetail(detail),
+        context: options.context,
+    });
+}
+/**
+ * 注册 info 命令。
+ *
+ * @param program Commander 实例
+ * @param context 命令行上下文
+ */
+export function registerInfoCommand(program, context) {
+    program
+        .command("info [patterns...]")
+        .description("Display information about current project, linked package, or remote target")
+        .option("-i, --intent <pattern>", "Regex or fuzzy intent filter; falls back to full list when no match")
+        .option("-P, --package <id>", "Target package ID or path")
+        .option("--tree", "Display packages in hierarchical tree view grouped by workspace")
+        .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")
+        .option("--envelope", "Wrap JSON output in standard envelope")
+        .option("--data-dir <path>", "Custom database storage directory")
+        .action(async (patterns = [], rawOptions, cmd) => {
+        const options = getEffectiveOptions(rawOptions, cmd);
+        const effectiveIntent = resolveIntent(options.intent, patterns);
+        const { isMachine, shouldFallback } = resolveFallbackStrategy(options);
+        const outOpts = { json: options.json, envelope: options.envelope, context };
+        // 远端服务目标分支
+        const target = resolveTarget({
+            profile: options.profile,
+            server: options.server,
+            token: options.token,
+        }, context?.customHome);
+        if (target.type === "remote") {
+            const remoteInfo = await fetchRemoteInfo(target.serverUrl, target.token, {
+                intent: effectiveIntent,
+                package: options.package,
+                tree: Boolean(options.tree),
+            });
+            if (isMachine) {
+                renderResult(remoteInfo, outOpts);
+                return;
+            }
+            if (remoteInfo.type === "tree" || (options.tree && remoteInfo.workspaces)) {
+                renderResult(remoteInfo, {
+                    humanFormatter: () => renderRegistryTree(remoteInfo),
+                    context,
+                });
+                return;
+            }
+            if (remoteInfo.type === "package_detail" || (remoteInfo.id && !remoteInfo.packages)) {
+                const detail = remoteInfoToDetail(remoteInfo);
+                renderResult(detail, {
+                    humanFormatter: () => renderProjectDetail(detail),
+                    context,
+                });
+                return;
+            }
+            const packages = remoteInfo.packages || remoteInfo.linkedPackages || [];
+            renderResult(packages, {
+                humanFormatter: () => renderAggregatedPackages(packages),
+                context,
+            });
+            return;
+        }
+        // 本地注册表树状图分支
+        if (options.tree) {
+            const status = getRegistryStatus(context?.customHome);
+            renderResult(status, {
+                json: options.json,
+                envelope: options.envelope,
+                humanFormatter: () => renderRegistryTree(status),
+                context,
+            });
+            return;
+        }
+        // 显式指定 Package 参数分支
+        if (options.package) {
+            const directRoot = resolvePackageRoot(options.package);
+            if (directRoot) {
+                const detail = await getProjectDetailInfo(directRoot);
+                renderProjectDetailOutput(detail, outOpts);
+                return;
+            }
+            throw new ArgumentError(`Package '${options.package}' not found in linked packages or path`);
+        }
+        // 扫描本地候选包（当前工程根目录 + 全局已链接包）
+        const { currentRoot, aggregated } = scanLocalAggregatedPackages(context);
+        // 无关键字过滤场景
+        if (!effectiveIntent) {
+            if (currentRoot) {
+                const detail = await getProjectDetailInfo(currentRoot);
+                renderProjectDetailOutput(detail, outOpts);
+                return;
+            }
+            if (aggregated.length === 0) {
+                renderResult({ linkedPackages: [] }, {
+                    ...outOpts,
+                    humanFormatter: () => "No ActionDock project in current directory, and no packages linked.\nRun 'ad link' inside an Action package to register it.",
+                });
+                return;
+            }
+            renderResult({ linkedPackages: aggregated }, {
+                ...outOpts,
+                humanFormatter: () => renderAggregatedPackages(aggregated),
+            });
+            return;
+        }
+        // 有关键字过滤场景：单一位置参数且非显式 --intent 时优先尝试包寻址
+        if (patterns.length === 1 && !options.intent) {
+            const directRoot = resolvePackageRoot(patterns[0]);
+            if (directRoot) {
+                const detail = await getProjectDetailInfo(directRoot);
+                renderProjectDetailOutput(detail, outOpts);
+                return;
+            }
+        }
+        if (aggregated.length === 0) {
+            if (isMachine) {
+                renderResult({ linkedPackages: [], matchedCount: 0, isFallback: false }, outOpts);
+                return;
+            }
+            throw new ExecutionError(`No ActionDock project or linked packages available to match '${effectiveIntent}'`);
+        }
+        const filterRes = filterWithFallbackInfo(aggregated, effectiveIntent, [
+            (p) => p.id,
+            (p) => p.name,
+            (p) => p.description,
+            (p) => p.path,
+            (p) => p.actions,
+            (p) => p.playbooks,
+        ], shouldFallback);
+        // 无匹配项
+        if (filterRes.matchedCount === 0) {
+            if (!filterRes.isFallback) {
+                if (isMachine) {
+                    renderResult({ linkedPackages: [], matchedCount: 0, isFallback: false }, outOpts);
+                    return;
+                }
+                throw new ExecutionError(`No packages matched intent '${effectiveIntent}'`);
+            }
+            // 回退模式：展示全部包并附带提示
+            if (isMachine) {
+                renderResult({ linkedPackages: filterRes.items, isFallback: true, matchedCount: 0 }, outOpts);
+                return;
+            }
+            renderResult({ linkedPackages: filterRes.items, isFallback: true, matchedCount: 0 }, {
+                ...outOpts,
+                humanFormatter: () => `(No linked packages matched intent '${effectiveIntent}', showing all packages)\n\n` +
+                    renderAggregatedPackages(filterRes.items),
+            });
+            return;
+        }
+        // 机器模式下搜索：稳定返回列表结构，不因为 matchedCount === 1 突变为详情
+        if (isMachine) {
+            renderResult({ linkedPackages: filterRes.items, matchedCount: filterRes.matchedCount, isFallback: false }, outOpts);
+            return;
+        }
+        // 人类终端交互：精确匹配单个包展开详情
+        if (filterRes.matchedCount === 1) {
+            const matchedPkg = filterRes.items[0];
+            const detail = await getProjectDetailInfo(matchedPkg.path);
+            renderProjectDetailOutput(detail, outOpts);
+            return;
+        }
+        // 匹配多个包：输出摘要列表
+        renderResult({ linkedPackages: filterRes.items }, {
+            ...outOpts,
+            humanFormatter: () => renderAggregatedPackages(filterRes.items, {
+                header: `ActionDock Linked Packages (${filterRes.matchedCount} matches for '${effectiveIntent}'):\n`,
+                showTip: true,
+            }),
+        });
+    });
+}

package/dist/commands/init.js

@@ -0,0 +1,24 @@
+import { initProject } from "@actiondock/core";
+import { writeStdout } from "../renderer.js";
+import { ExecutionError } from "../errors.js";
+export function registerInitCommand(program) {
+    program
+        .command("init [directory]")
+        .description("Initialize a new ActionDock project")
+        .option("-i, --id <id>", "Project identifier")
+        .option("-n, --name <name>", "Project display name")
+        .option("-d, --desc <description>", "Project description")
+        .action((dir = ".", options) => {
+        try {
+            initProject(dir, {
+                id: options.id,
+                name: options.name,
+                description: options.desc,
+            });
+            writeStdout(`Successfully initialized ActionDock project in ${dir}`);
+        }
+        catch (err) {
+            throw new ExecutionError(err.message);
+        }
+    });
+}

package/dist/commands/link.js

@@ -0,0 +1,71 @@
+import { linkPackage, pruneRegistry, unlinkPackage, } from "@actiondock/core";
+import { ExecutionError } from "../errors.js";
+import { writeStdout } from "../renderer.js";
+export function registerLinkCommands(program) {
+    // ad link [path]
+    program
+        .command("link [path]")
+        .option("-r, --recursive", "Recursively discover and link packages in subdirectories")
+        .description("Link local Action package(s) or workspace directory into global registry for instant cross-directory execution")
+        .action(async (targetPath, options) => {
+        try {
+            const result = await linkPackage(targetPath || process.cwd(), undefined, {
+                recursive: options.recursive,
+            });
+            if (result.isWorkspace) {
+                writeStdout(`[OK] Linked workspace '${result.path}' (${result.entries.length} package${result.entries.length > 1 ? "s" : ""}):`);
+                for (const e of result.entries) {
+                    writeStdout(`  - ${e.id} (v${e.version}) -> ${e.path}`);
+                }
+                writeStdout("[INFO] Sub-packages added to this workspace will be automatically discovered.");
+            }
+            else {
+                writeStdout(`[OK] Linked package '${result.id}' (v${result.version}) from ${result.path}`);
+            }
+        }
+        catch (err) {
+            throw new ExecutionError(err.message);
+        }
+    });
+    // ad unlink [id|path]
+    program
+        .command("unlink [identifier]")
+        .option("-p, --prune", "Automatically scan and prune any stale/missing paths from registry")
+        .description("Unlink a package, workspace, or prune stale entries from global developer registry")
+        .action(async (identifier, options) => {
+        try {
+            if (options.prune || identifier === "--prune") {
+                const result = await pruneRegistry();
+                const totalPruned = result.prunedPackages.length + result.prunedWorkspaces.length;
+                if (totalPruned === 0) {
+                    writeStdout("[OK] No stale registry entries found.");
+                }
+                else {
+                    writeStdout(`[OK] Pruned ${result.prunedWorkspaces.length} workspace(s) and ${result.prunedPackages.length} package(s) from registry.`);
+                    for (const ws of result.prunedWorkspaces) {
+                        writeStdout(`  - [workspace] ${ws.path}`);
+                    }
+                    for (const pkg of result.prunedPackages) {
+                        writeStdout(`  - [package] ${pkg.id} (${pkg.path})`);
+                    }
+                }
+                return;
+            }
+            const removed = await unlinkPackage(identifier || process.cwd());
+            if (removed) {
+                if (removed.type === "workspace") {
+                    writeStdout(`[OK] Unlinked workspace '${removed.path}' (${removed.packagesCount || 0} package${(removed.packagesCount || 0) > 1 ? "s" : ""} unlinked)`);
+                }
+                else {
+                    writeStdout(`[OK] Unlinked package '${removed.id}' (${removed.path})`);
+                }
+            }
+            else {
+                writeStdout(`Package or workspace '${identifier || process.cwd()}' was not linked in registry`);
+            }
+        }
+        catch (err) {
+            throw new ExecutionError(err.message);
+        }
+    });
+}

package/dist/commands/list.d.ts

@@ -0,0 +1,9 @@
+import { Command } from "commander";
+import type { CliContext } from "../types.js";
+/**
+ * 注册顶层统一 list 命令：列出当前工程、已链接包或远端服务中的可用 Action。
+ *
+ * @param program Commander 根程序对象
+ * @param context 命令行上下文
+ */
+export declare function registerListCommand(program: Command, context?: CliContext): void;

package/dist/commands/list.js

@@ -0,0 +1,77 @@
+import { filterWithFallbackInfo } from "@actiondock/core";
+import { ArgumentError } from "../errors.js";
+import { renderActionList, renderResult } from "../renderer.js";
+import { getEffectiveOptions, resolveFallbackStrategy, resolveIntent, resolveLocalPackageRoot, withTarget } from "../utils/index.js";
+/**
+ * 注册顶层统一 list 命令：列出当前工程、已链接包或远端服务中的可用 Action。
+ *
+ * @param program Commander 根程序对象
+ * @param context 命令行上下文
+ */
+export function registerListCommand(program, context) {
+    program
+        .command("list [patterns...]")
+        .description("List actions in current project, linked packages, or remote profile")
+        .option("-i, --intent <pattern>", "Regex or fuzzy intent filter; falls back to full list when no match")
+        .option("-P, --package <id>", "Target package ID or path")
+        .option("-p, --profile <name>", "Query against a specific execution 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 as JSON")
+        .option("--envelope", "Wrap JSON output in standard envelope")
+        .option("--data-dir <path>", "Custom database storage directory")
+        .action(async (patterns = [], rawOptions, cmd) => {
+        const options = getEffectiveOptions(rawOptions, cmd);
+        const effectiveIntent = resolveIntent(options.intent, patterns);
+        const { isMachine, shouldFallback } = resolveFallbackStrategy(options);
+        // 目标拓扑解析（仅 local 分支需要包寻址）
+        const targetPackageRoot = resolveLocalPackageRoot(options.package);
+        if (options.package && !targetPackageRoot) {
+            throw new ArgumentError(`Package '${options.package}' not found in linked packages or path`);
+        }
+        // 通过 Target 门面统一获取 Action 列表
+        await withTarget(options, context, async (target, resolved) => {
+            let rawSummaries = await target.listActions();
+            // 若指定了目标包但本地未过滤，则精确匹配包标识
+            if (options.package && !options.profile && !options.server) {
+                rawSummaries = rawSummaries.filter((s) => s.id.startsWith(`${options.package}/`) ||
+                    s.packageId === options.package ||
+                    !s.id.includes("/"));
+            }
+            const rawList = rawSummaries.map((s) => {
+                let id = s.id;
+                if (targetPackageRoot || options.package) {
+                    const pkgId = s.packageId || options.package;
+                    if (pkgId && id.startsWith(`${pkgId}/`)) {
+                        id = id.slice(pkgId.length + 1);
+                    }
+                    else if (targetPackageRoot && id.includes("/")) {
+                        id = id.slice(id.indexOf("/") + 1);
+                    }
+                }
+                return {
+                    id,
+                    description: s.description || "",
+                };
+            });
+            const filterRes = filterWithFallbackInfo(rawList, effectiveIntent, [(a) => a.id, (a) => a.description], shouldFallback);
+            if (filterRes.isFallback && isMachine) {
+                renderResult({ items: filterRes.items, isFallback: true, matchedCount: 0 }, { json: options.json, envelope: options.envelope, context });
+                return;
+            }
+            const title = resolved.type === "remote"
+                ? `Actions on remote server ${resolved.serverUrl}${resolved.profileName ? ` (Profile: ${resolved.profileName})` : ""}`
+                : targetPackageRoot
+                    ? `Actions in ${options.package || "current project"}`
+                    : "Available Actions";
+            renderResult(filterRes.items, {
+                json: options.json,
+                envelope: options.envelope,
+                humanFormatter: () => renderActionList(filterRes.items, title, filterRes.isFallback, effectiveIntent),
+                context,
+            });
+        }, { localRoot: targetPackageRoot || undefined, scanLinkedPackages: true });
+    });
+}

package/dist/commands/mcp.d.ts

@@ -1,2 +1,9 @@
-import type { Command } from "commander";
-export declare function registerMcpCommands(program: Command): void;
+import { Command } from "commander";
+import type { CliContext } from "../types.js";
+/**
+ * 注册 mcp 命令（STDIO 与 HTTP 传输服务模式）。
+ *
+ * @param program Commander 实例
+ * @param context 命令行上下文
+ */
+export declare function registerMcpCommands(program: Command, context?: CliContext): void;