@actiondock/builder 2.15.0 → 2.17.0

package/dist/export-source.js

@@ -1,15 +1,13 @@
 import { copyFileSync, existsSync, readFileSync, writeFileSync, } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { mkdirSync } from "node:fs";
-import { generateNodeHostEntrySource, generateNodeSupervisorEntrySource } from "./entry-generators.js";
-import { appendLocalExecutionContract } from "./skill-md.js";
 import { generateSourceSkillMd } from "./skill/index.js";
 import { RUNTIME_REFERENCE_REL_PATH, renderRuntimeReferenceContent, } from "./skill/templates.js";
-import { loadManifest } from "@actiondock/core/project";
 import { BuilderError } from "./errors.js";
 import { getInternalDependencyVersion } from "./fs-utils.js";
 import { assertValidManifestActionIds, sanitizeExportDependencies, serializePlanManifest, } from "./manifest.js";
 import { copyPlanEntries } from "./stage-sources.js";
+import { isOwnAction } from "./types.js";
 import { buildConfigForTemplates, writeSkillMd, } from "./skill-md.js";
 /**
  * 源码型 Skill 导出装配层。
@@ -24,24 +22,18 @@ export function stageSourceSkill(root, skillDir, plan, options, pkgSlug) {
     const actionsDir = plan.actionsDir || "actions";
     const playbooksDir = plan.playbooksDir || "playbooks";
     const configForTemplates = buildConfigForTemplates(plan, actionsDir, playbooksDir);
-    const usedExistingSkillMd = writeSkillMd(root, skillDir, { skipSkillMd: options.skipSkillMd, skillMdPath: options.skillMdPath, pkgSlug }, () => generateSourceSkillMd(configForTemplates, plan.actions.filter((a) => !a.isExternal), plan.playbooks));
+    const usedExistingSkillMd = writeSkillMd(root, skillDir, { skipSkillMd: options.skipSkillMd, skillMdPath: options.skillMdPath, pkgSlug }, () => generateSourceSkillMd(configForTemplates, plan.actions.filter((a) => isOwnAction(a)), plan.playbooks));
     // 导出精简后的 actiondock.json 项目配置（项目元数据与清单的单一事实源）
     const exportedConfig = serializePlanManifest(plan, {
         omitEmptyConfig: true,
         includeDirs: { actionsDir, playbooksDir },
     });
-    const originalManifest = options.manifest || loadManifest(root);
-    if (originalManifest?.dependencies)
-        exportedConfig.dependencies = originalManifest.dependencies;
-    const packageUses = originalManifest?.uses;
-    if (packageUses)
-        exportedConfig.uses = packageUses;
     if (exportedConfig.actions && typeof exportedConfig.actions === "object") {
         assertValidManifestActionIds(exportedConfig.actions);
     }
     writeFileSync(join(skillDir, "actiondock.json"), JSON.stringify(exportedConfig, null, 2) + "\n", "utf-8");
     // 导出 package.json
-    writeSourceSkillPkgJson(root, skillDir, plan, pkgSlug, options);
+    writeSourceSkillPkgJson(root, skillDir, plan, pkgSlug);
     // 拷贝 tsconfig.json（若存在）
     const tsconfigPath = join(root, "tsconfig.json");
     if (existsSync(tsconfigPath)) {
@@ -51,27 +43,13 @@ export function stageSourceSkill(root, skillDir, plan, options, pkgSlug) {
     copyPlanEntries(skillDir, plan, {
         playbookRelPath: (pb) => join(playbooksDir, basename(pb.filePath)),
     });
-    if (!options._isSubpackage) {
-        for (const name of ["entry.mjs", "entry-host.js"]) {
-            if (existsSync(join(skillDir, name))) {
-                throw new BuilderError(`Source Skill entry conflict: '${name}' is reserved for the local runtime entry; refusing to overwrite a declared file.`, "SOURCE_ENTRY_CONFLICT");
-            }
-        }
-        writeFileSync(join(skillDir, "entry.mjs"), generateNodeSupervisorEntrySource(plan), "utf-8");
-        writeFileSync(join(skillDir, "entry-host.js"), generateNodeHostEntrySource(undefined, {
-            localPackages: [{ packageId: plan.packageId, relativeRoot: "." }],
-        }), "utf-8");
-        if (usedExistingSkillMd)
-            appendLocalExecutionContract(join(skillDir, "SKILL.md"), [plan]);
-    }
     // 声明资产拷贝完成后再物化默认运行参考文件：仅在使用自动模板时生成；
     // 与项目声明资产同路径冲突时报错不覆盖（拷贝在前，冲突检测能真实命中）
     if (usedExistingSkillMd === undefined && !options.skipSkillMd) {
         writeRuntimeReferenceFile(skillDir, {
             dependencyStepLabel: "安装技能源码依赖",
             relinkStepLabel: "完成安装后重新链接本技能",
-            invocationStyle: "source-ad",
-            entryRelPath: 'node "<skill_root>/entry.mjs"',
+            invocationStyle: "global-ad",
         });
     }
     return usedExistingSkillMd;
@@ -88,16 +66,15 @@ export function writeRuntimeReferenceFile(destDir, options) {
     mkdirSync(dirname(referencePath), { recursive: true });
     writeFileSync(referencePath, renderRuntimeReferenceContent(options), "utf-8");
 }
-function writeSourceSkillPkgJson(root, skillDir, plan, pkgSlug, options) {
+function writeSourceSkillPkgJson(root, skillDir, plan, pkgSlug) {
     let exportedPkg;
-    const fallbackName = options?.defaultPackageName || pkgSlug;
     const projectPkgPath = join(root, "package.json");
     if (existsSync(projectPkgPath)) {
         try {
             const raw = readFileSync(projectPkgPath, "utf-8");
             const parsed = JSON.parse(raw);
             exportedPkg = {
-                name: parsed.name || fallbackName,
+                name: parsed.name || pkgSlug,
                 version: plan.version || parsed.version || "0.1.0",
                 description: plan.description || parsed.description,
                 type: "module",
@@ -108,13 +85,12 @@ function writeSourceSkillPkgJson(root, skillDir, plan, pkgSlug, options) {
             if (err instanceof BuilderError) {
                 throw err;
             }
-            exportedPkg = fallbackSkillPkg(plan, fallbackName);
+            exportedPkg = fallbackSkillPkg(plan, pkgSlug);
         }
     }
     else {
-        exportedPkg = fallbackSkillPkg(plan, fallbackName);
+        exportedPkg = fallbackSkillPkg(plan, pkgSlug);
     }
-    exportedPkg.dependencies["@actiondock/core"] ??= getInternalDependencyVersion();
     writeFileSync(join(skillDir, "package.json"), JSON.stringify(exportedPkg, null, 2) + "\n", "utf-8");
 }
 /** 无 package.json 或解析失败时的兜底导出描述 */

package/dist/exporter.js

@@ -1,11 +1,9 @@
 import { existsSync, mkdirSync, rmSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
-import { getPackageSlug, loadManifest } from "@actiondock/core/project";
+import { getPackageSlug } from "@actiondock/core/project";
 import { BuilderError } from "./errors.js";
 import { replaceDirAtomic } from "./fs-utils.js";
 import { collectRelativeFiles } from "./fs-utils.js";
-import { createSourcePackageGraph } from "./source-graph.js";
-import { deriveEffectivePackageGraph } from "./derived-graph.js";
 import { SelectionPlanner } from "./planner.js";
 import { isOwnAction } from "./types.js";
 import { createArchive, resolveArchiveFormat } from "./export-archive.js";
@@ -27,36 +25,9 @@ export class SkillExporter {
      */
     async export(options) {
         const root = resolve(options.projectRoot);
-        const mode = options.mode === "node" ? "node" : "source";
-        // 共享图、规划与源码清单使用同一有效声明；显式 manifest 不从磁盘继承依赖。
-        if (mode === "source" && (options.config || options.manifest)) {
-            const graphNode = options.packageGraph && Array.from(options.packageGraph.packages.values()).find((p) => resolve(p.root) === root);
-            const baseManifest = options.manifest || graphNode?.manifest || loadManifest(root) || {};
-            const manifest = {
-                ...baseManifest,
-                ...options.config,
-                ...options.manifest,
-                // 保持既有 config 元数据优先级；动作、dependencies、uses 使用有效清单声明。
-                ...Object.fromEntries([
-                    "id", "name", "version", "description", "config", "actionsDir", "playbooksDir",
-                ].map((key) => [key, options.config?.[key]]).filter(([, value]) => value !== undefined)),
-            };
-            options = {
-                ...options,
-                manifest,
-                config: { ...manifest, name: manifest.name || manifest.id, version: manifest.version || "0.1.0" },
-            };
-        }
+        const mode = options.standalone === true || options.mode === "node" ? "node" : "source";
         // 调用 SelectionPlanner 执行声明式构建规划
-        const packageGraph = mode === "source" && options.packageGraph
-            ? deriveEffectivePackageGraph(options.packageGraph, root, options.manifest)
-            : options.packageGraph ?? (mode === "source" ? createSourcePackageGraph([root], options.manifest) : undefined);
-        options = {
-            ...options,
-            packageGraph,
-        };
         const plan = SelectionPlanner.plan({
-            packageGraph,
             projectRoot: root,
             config: options.config,
             manifest: options.manifest,
@@ -68,20 +39,19 @@ export class SkillExporter {
         const defaultFolderName = `${pkgSlug}-skill`;
         const defaultSkillDir = join(root, "dist", defaultFolderName);
         const targetSkillDir = resolve(options.outDir || defaultSkillDir);
-        const hasExternalDeps = Boolean((packageGraph && packageGraph.packages.size > 1) || (plan.externalProjectRoots && plan.externalProjectRoots.length > 0));
-        // 单包源码导出若依赖闭包含外部包，导成 mini-workspace 形态（packages/ 下带齐依赖包），和 bundle 统一成一个交付形状
+        const hasExternalDeps = Boolean(plan.externalProjectRoots && plan.externalProjectRoots.length > 0);
+        // 单包源码导出若开启 bundleDeps 且依赖闭包含外部包，导成 mini-workspace 形态（packages/ 下带齐依赖包），和 bundle 统一成一个交付形状
         // 该复合分支会展开全部依赖包，无法保留调用方传入的 actions/playbooks 过滤选项；
         // 静默丢弃过滤会导致产物全量导出，必须显式拒绝并给出调整指引（CLI 侧已有 roots>1 守卫，此处补齐 composite 分支守卫）
         const hasFilters = Boolean((options.actions && options.actions.length > 0) ||
             (options.playbooks && options.playbooks.length > 0));
-        const willUseComposite = mode === "source" && !options._isSubpackage && hasExternalDeps;
+        const willUseComposite = mode === "source" && !options._isSubpackage && hasExternalDeps && options.bundleDeps === true;
         if (hasFilters && willUseComposite) {
             throw new BuilderError("Filtering options (--actions, --playbook) cannot be combined with a source export whose dependency closure spans external linked packages (composite mini-workspace output). Remove the filtering options to export the full closure, or adjust the 'uses' declarations so the closure stays within a single package.", "FILTERS_UNSUPPORTED_FOR_COMPOSITE");
         }
         if (willUseComposite) {
-            const allProjectRoots = Array.from(new Set([root, ...Array.from(packageGraph.packages.values(), (p) => p.root)]));
+            const allProjectRoots = Array.from(new Set([root, ...plan.externalProjectRoots]));
             const compositeRes = await this.exportComposite({
-                packageGraph,
                 bundleName: plan.packageName || plan.packageId,
                 projectRoots: allProjectRoots,
                 outDir: targetSkillDir,
@@ -90,6 +60,7 @@ export class SkillExporter {
                 workspaceRoot: options.workspaceRoot,
                 skillMdPath: options.skillMdPath,
                 customMdPath: options.customMdPath,
+                bundleDeps: options.bundleDeps,
             });
             return {
                 packageId: plan.packageId,

package/dist/planner.js

@@ -1,6 +1,6 @@
 import { existsSync, statSync } from "node:fs";
 import { basename, join, relative, resolve } from "node:path";
-import { ActionDockError, ACTION_NOT_FOUND, loadProjectConfig, } from "@actiondock/core";
+import { ActionDockError, ACTION_NOT_FOUND, UNDECLARED_ACTION_DEPENDENCY, loadProjectConfig, } from "@actiondock/core";
 import { assertPathWithinRoot, traverseDirectory, loadManifest, loadPlaybooks, validateManifest, } from "@actiondock/core/project";
 import { DefaultActionCatalog, PackageGraphBuilder, resolveAction, } from "@actiondock/core/graph";
 import { PlannerError } from "./errors.js";
@@ -150,16 +150,13 @@ export class SelectionPlanner {
             selectedPlaybooks = Array.from(playbooksMap.values());
         }
         const manifestActions = manifest.actions || {};
-        // 若显式指定了 Action 列表，加入集合（保持本包短名与完全限定名解析契约）
+        // 若显式指定了 Action 列表，加入集合
         if (options?.actions && options.actions.length > 0) {
             for (const actId of options.actions) {
-                const localId = actId.startsWith(`${config.id}/`)
-                    ? actId.slice(config.id.length + 1)
-                    : actId;
-                if (!manifestActions[localId] && !manifestActions[actId]) {
+                if (!manifestActions[actId]) {
                     throw new PlannerError(`Action '${actId}' specified in build options was not found in manifest`, "ACTION_NOT_FOUND");
                 }
-                initialActionIds.add(manifestActions[localId] ? localId : actId);
+                initialActionIds.add(actId);
             }
         }
         // 若均未显式指定，默认包含清单中的全部 Action
@@ -168,87 +165,94 @@ export class SelectionPlanner {
                 initialActionIds.add(actId);
             }
         }
+        // 当前包在 actiondock.json 中声明的顶层 uses 直接依赖
+        const currentPkgUses = config?.uses;
+        if (Array.isArray(currentPkgUses)) {
+            for (const depId of currentPkgUses) {
+                if (typeof depId === "string" && depId.trim()) {
+                    initialActionIds.add(depId.trim());
+                }
+            }
+        }
         return { initialActionIds, selectedPlaybooks };
     }
     /**
      * 进行依赖闭包（uses）解析计算，自动处理环形依赖与传递依赖（支持当前清单与已链接外部包）。
      */
-    resolveClosure(root, manifest, config, initialActionIds, packageGraph) {
+    resolveClosure(root, manifest, config, initialActionIds) {
         const resolvedActionIds = new Set();
+        // queued 与 resolvedActionIds 联合判重，避免高入度节点在 uses 图中被重复入队导致 O(边数) 重复解析
+        const queued = new Set(initialActionIds);
+        const queue = Array.from(initialActionIds);
         const externalActionRoots = new Map();
         const externalActionEntries = new Map();
-        const graph = packageGraph ?? new PackageGraphBuilder({ root, manifest, allowDevLinks: true }).buildSync();
+        const manifestActions = manifest.actions || {};
+        const graph = new PackageGraphBuilder({ root, allowDevLinks: true }).buildSync();
         const catalog = new DefaultActionCatalog(graph);
-        const queue = [];
-        const visitedPackages = new Set();
-        const expandedPackages = new Set();
-        for (const id of initialActionIds) {
-            queue.push({ id, caller: config.id, isInitialAction: true });
-        }
-        const rawRootUses = manifest.uses ?? config.uses ?? [];
-        visitedPackages.add(config.id);
-        for (const use of rawRootUses) {
-            if (typeof use === "string" && use.trim()) {
-                queue.push({ id: use.trim(), caller: config.id, isInitialAction: false });
-            }
-        }
         while (queue.length > 0) {
-            const { id, caller, isInitialAction } = queue.shift();
-            // uses 支持包名与包级通配符；将其展开为该包的完整动作集合。
-            // 明确选中的初始动作不按包名展开；uses 中的裸包名和通配符仍按包级引用处理。
-            const isWildcard = id.endsWith("/*");
-            const packageId = isWildcard
-                ? id.slice(0, -2)
-                : !isInitialAction && graph.hasPackage(id)
-                    ? id
-                    : undefined;
-            if (packageId) {
-                const node = graph.getPackage(packageId);
-                if (!node)
-                    throw new PlannerError(`Package '${packageId}' referenced by uses was not found`, "PACKAGE_NOT_FOUND");
-                if (expandedPackages.has(packageId))
-                    continue;
-                expandedPackages.add(packageId);
-                if (!visitedPackages.has(packageId)) {
-                    visitedPackages.add(packageId);
-                    for (const use of node.manifest.uses || []) {
-                        queue.push({ id: use, caller: packageId, isInitialAction: false });
+            const currentId = queue.shift();
+            queued.delete(currentId);
+            if (resolvedActionIds.has(currentId)) {
+                continue;
+            }
+            let entry = manifestActions[currentId] || config?.actions?.[currentId];
+            let entryRoot = root;
+            if (!entry) {
+                const resolved = resolveAction(currentId, { graph, catalog, caller: config?.id });
+                const resolvedPkgId = resolved.package.id;
+                const resolvedActionId = resolved.ref.actionId;
+                const extNode = graph.packages.get(resolvedPkgId);
+                if (extNode && existsSync(extNode.root)) {
+                    const extRoot = extNode.root;
+                    let extConfig;
+                    try {
+                        extConfig = loadProjectConfig(extRoot);
+                    }
+                    catch {
+                        extConfig = {
+                            id: resolvedPkgId,
+                            name: resolvedPkgId,
+                            version: "0.1.0",
+                        };
+                    }
+                    const externalManifest = loadManifest(extRoot);
+                    const externalEntry = externalManifest?.actions?.[resolvedActionId] ||
+                        extConfig?.actions?.[resolvedActionId];
+                    if (!externalEntry) {
+                        throw new ActionDockError(UNDECLARED_ACTION_DEPENDENCY, `UNDECLARED_ACTION_DEPENDENCY: Action '${resolvedActionId}' is not declared in package '${resolvedPkgId}' manifest`);
+                    }
+                    entry = externalEntry;
+                    entryRoot = extRoot;
+                    // 依赖包 actiondock.json 中声明的传递依赖闭包（入队前查重，避免重复膨胀）
+                    const extPkgUses = extConfig?.uses;
+                    if (Array.isArray(extPkgUses)) {
+                        for (const u of extPkgUses) {
+                            const trimmedUse = typeof u === "string" ? u.trim() : "";
+                            if (trimmedUse &&
+                                !resolvedActionIds.has(trimmedUse) &&
+                                !queued.has(trimmedUse)) {
+                                queued.add(trimmedUse);
+                                queue.push(trimmedUse);
+                            }
+                        }
                     }
                 }
-                for (const actionId of Object.keys(node.manifest.actions || {})) {
-                    queue.push({ id: `${packageId}/${actionId}`, caller: packageId, isInitialAction: false });
-                }
-                continue;
             }
-            // 保持显式 config/manifest 的单包规划语义，不让磁盘图覆盖调用方清单。
-            const localId = id.startsWith(`${config.id}/`) ? id.slice(config.id.length + 1) : id;
-            const isLocal = (caller === config.id || id.startsWith(`${config.id}/`)) &&
-                Boolean(manifest.actions?.[localId] || config.actions?.[localId]);
-            const resolved = isLocal ? undefined : resolveAction(id, { graph, catalog, caller });
-            const pkgId = resolved?.package.id || config.id;
-            const actionId = resolved?.ref.actionId || localId;
-            const node = graph.getPackage(pkgId);
-            const canonicalId = pkgId === config.id ? actionId : `${pkgId}/${actionId}`;
-            if (resolvedActionIds.has(canonicalId))
-                continue;
-            const entry = pkgId === config.id
-                ? manifest.actions?.[actionId] || config.actions?.[actionId]
-                : node.manifest.actions?.[actionId];
-            if (!entry)
-                throw new ActionDockError(ACTION_NOT_FOUND, `Action '${id}' is not declared in manifest`);
-            resolvedActionIds.add(canonicalId);
-            if (pkgId !== config.id) {
-                externalActionRoots.set(canonicalId, node.root);
-                externalActionEntries.set(canonicalId, entry);
+            if (!entry) {
+                throw new ActionDockError(ACTION_NOT_FOUND, `Action '${currentId}' referenced in dependency closure (uses) was not found in manifest or linked packages`);
             }
-            if (!visitedPackages.has(pkgId)) {
-                visitedPackages.add(pkgId);
-                for (const use of node?.manifest.uses || []) {
-                    queue.push({ id: use, caller: pkgId, isInitialAction: false });
-                }
+            if (entryRoot !== root) {
+                externalActionRoots.set(currentId, entryRoot);
+                externalActionEntries.set(currentId, entry);
             }
-            for (const use of entry.uses || []) {
-                queue.push({ id: use, caller: pkgId, isInitialAction: false });
+            resolvedActionIds.add(currentId);
+            if (entry.uses && Array.isArray(entry.uses)) {
+                for (const depId of entry.uses) {
+                    if (!resolvedActionIds.has(depId) && !queued.has(depId)) {
+                        queued.add(depId);
+                        queue.push(depId);
+                    }
+                }
             }
         }
         return { resolvedActionIds, externalActionRoots, externalActionEntries };
@@ -447,7 +451,7 @@ export class SelectionPlanner {
         const playbooksMap = this.collectPlaybooks(root, config, manifest);
         const { initialActionIds, selectedPlaybooks } = this.resolveInitialSelection(options, manifest, config, playbooksMap);
         // 依赖闭包解析与 Action 依赖结构物化
-        const closure = this.resolveClosure(root, manifest, config, initialActionIds, options?.packageGraph);
+        const closure = this.resolveClosure(root, manifest, config, initialActionIds);
         let finalPlaybooks = selectedPlaybooks;
         // 若指定了 Action 但未指定 Playbook，反向裁剪排除无法满足依赖的 Playbook
         if (options?.actions && options.actions.length > 0 && (!options.playbooks || options.playbooks.length === 0)) {

package/dist/skill/templates.d.ts

@@ -1,4 +1,4 @@
-import type { ActionSpec, ProjectConfig, RuntimeProjectConfig } from "@actiondock/core";
+import type { ActionSpec, ProjectConfig } from "@actiondock/core";
 import type { PlaybookDefinition } from "@actiondock/core/project";
 import type { CompositeCustomSection } from "./custom-parser.js";
 export type SkillActionItem = ActionSpec | {
@@ -26,9 +26,9 @@ export declare function renderRuntimeReferenceContent(options: {
     relinkStepLabel: string;
     /** 是否在重新链接步骤末尾附加复合链接语义说明 */
     compositeLinkNote?: boolean;
-    /** 调用方式说明：源码型（source-ad）、Node 目录型（node-entry）与开发全局模式（global-ad） */
-    invocationStyle: "global-ad" | "source-ad" | "node-entry";
-    /** Node 目录型的入口相对路径（invocationStyle 为 node-entry 或 source-ad 时使用） */
+    /** 调用方式说明：源码型与 Node 目录型分化（如是否需要全局 ad） */
+    invocationStyle: "global-ad" | "node-entry";
+    /** Node 目录型的入口相对路径（invocationStyle 为 node-entry 时使用） */
     entryRelPath?: string;
 }): string;
 /** 运行时参考文件的导出目录内相对路径（单一事实源） */
@@ -36,7 +36,7 @@ export declare const RUNTIME_REFERENCE_REL_PATH = "references/actiondock-runtime
 export declare function generateSourceSkillMd(config: ProjectConfig, actions: SkillActionItem[], playbooks: SkillPlaybookItem[]): string;
 export declare function generateStandaloneSkillMd(config: ProjectConfig, actions: SkillActionItem[], playbooks: SkillPlaybookItem[], binaryRelPath?: string): string;
 export interface CompositeSkillPackageInfo {
-    config: ProjectConfig | RuntimeProjectConfig;
+    config: ProjectConfig;
     actions: Array<{
         id: string;
         description?: string;
@@ -54,8 +54,6 @@ export interface CompositeSkillPackageInfo {
  */
 export declare function generateCompositeSkillMd(bundleName: string, description: string, packages: CompositeSkillPackageInfo[], options?: {
     customSections?: CompositeCustomSection[];
-    /** 调用方式：开发全局模式（global-ad）、源码 Skill（source-ad）与独立 Node 目录型（node-entry） */
-    invocationStyle?: "global-ad" | "source-ad" | "node-entry";
     /** 规程链接的子包目录前缀：导出布局为 "packages"（默认）；就地生成时传 "." 使用工作区实际目录 */
     packagesBaseDir?: string;
 }): string;