@actiondock/builder 2.9.1 → 2.11.0

package/dist/archive.js

@@ -4,6 +4,7 @@ import { basename, join } from "node:path";
 import { Transform, Writable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { traverseDirectory } from "@actiondock/core/project";
+import { BuilderError } from "./errors.js";
 /**
  * 递归收集目录内全部条目。
  * 目录遍历统一复用 core 的 traverseDirectory 单一事实源，
@@ -262,7 +263,7 @@ function tarHeader(path, size, mtimeSec, isDir, modeOrExec = false) {
         prefix = cleanPath.slice(0, split);
         name = cleanPath.slice(split + 1) + (trailingSlash ? "/" : "");
         if (split <= 0 || Buffer.byteLength(prefix, "utf8") > 155 || Buffer.byteLength(name, "utf8") > 100) {
-            throw new Error(`归档路径超出 USTAR 字段容量: ${path}`);
+            throw new BuilderError(`Archive path exceeds USTAR field capacity: ${path}`, "ARCHIVE_PATH_TOO_LONG");
         }
     }
     const buf = Buffer.alloc(512);

package/dist/build.d.ts

@@ -1,10 +1,33 @@
 export { copyPlanEntries } from "./stage-sources.js";
-import type { BuildOptions, BuildResult } from "./types.js";
+import type { BuildOptions, BuildProjectWithPlanOptions, BuildResult, SelectionPlan, SkillExporterOptions, SkillExportResult } from "./types.js";
+/**
+ * 基于预先计算的 SelectionPlan 方案直接构建 Node.js 目录型交付产物。
+ *
+ * 核心构建管线涵盖可复现性检查、暂存区构建、清单与入口脚本生成、生产依赖物化及归档打包。
+ *
+ * 规划方案复用场景：
+ * - 当调用方已通过 SelectionPlanner.plan 计算出依赖与资产规划方案（例如技能导出 exportSkill、复合技能导出 exportCompositeSkill 或定制资产选择）时，直接消费 buildProjectWithPlan 核心管线，无需且严禁再次重复规划。
+ *
+ * 路径冲突仲裁策略：
+ * - 若 options.projectRoot 显式提供，则以 options.projectRoot 为准覆盖。
+ * - 若未提供，则兜底回退采用 plan.projectRoot。
+ *
+ * @param plan 已规划的依赖与资产选择方案
+ * @param options 构建执行选项
+ * @returns 构建产物结果描述
+ */
+export declare function buildProjectWithPlan(plan: SelectionPlan, options?: BuildProjectWithPlanOptions): Promise<BuildResult>;
 /**
  * 构建 Node.js 目录型交付产物。
- * 主流程仅做编排，各阶段职责由独立函数承担。
+ * 委托 SelectionPlanner 执行构建规划，随后直接消费核心构建管线 buildProjectWithPlan。
  *
  * @param options 构建选项
  * @returns 构建产物结果描述
  */
 export declare function buildProject(options: BuildOptions): Promise<BuildResult>;
+/**
+ * 执行 Node 目录型 Skill 导出。
+ * 复用传入的 SelectionPlan 方案与 buildProjectWithPlan 核心构建管线，
+ * 产出可执行交付目录，并在目录内生成调用该入口的 SKILL.md 说明书。
+ */
+export declare function exportNodeSkill(root: string, targetSkillDir: string, plan: SelectionPlan, options: SkillExporterOptions, pkgSlug: string): Promise<SkillExportResult>;

package/dist/build.js

@@ -1,7 +1,6 @@
 import { createHash } from "node:crypto";
-import { chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync, } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
-import { STANDALONE_ASYNC_UNSUPPORTED, } from "@actiondock/core";
 import { getPackageSlug } from "@actiondock/core/project";
 import { createZipArchiveAsync } from "./archive.js";
 import { BuilderError } from "./errors.js";
@@ -9,7 +8,12 @@ import { collectRelativeFiles, getInternalDependencyVersion, replaceDirAtomic }
 import { assertValidManifestActionIds, serializePlanManifest } from "./manifest.js";
 import { SelectionPlanner } from "./planner.js";
 import { copyPlanEntries } from "./stage-sources.js";
-import { isOwnAction } from "./types.js";
+import { generateNodeHostEntrySource, generateNodeSupervisorEntrySource } from "./entry-generators.js";
+import { vendorDependencies } from "./vendor.js";
+import { generateStandaloneSkillMd } from "./skill/templates.js";
+import { writeRuntimeReferenceFile } from "./export-source.js";
+import { buildConfigForTemplates, writeSkillMd, } from "./skill-md.js";
+import { createArchive, resolveArchiveFormat } from "./export-archive.js";
 export { copyPlanEntries } from "./stage-sources.js";
 /**
  * 检查外部依赖中声明的生命周期安装脚本。
@@ -42,8 +46,9 @@ function detectLifecycleScripts(root, dependencies) {
                         }
                     }
                 }
-                catch {
-                    // 忽略单个依赖解析异常
+                catch (err) {
+                    // 防御与透明：依赖生命周期解析失败透传警告日志
+                    console.warn(`[actiondock] Warning: Failed to inspect lifecycle scripts for dependency '${dep.name}': ${err instanceof Error ? err.message : String(err)}`);
                 }
                 break;
             }
@@ -64,227 +69,6 @@ function calculateDirectoryDigest(dir) {
     }
     return hasher.digest("hex");
 }
-/**
- * 生成 Host 子进程入口脚本源码（负责运行 ActionDockHost，通过 Node IPC 暴露 Target）。
- * 与 serializePlanManifest / stageSources 的过滤条件保持一致：跨包外部 Action 不进入 import 与运行时注册，
- * 避免入口 import 清单没有的源文件产生孤儿模块（外部源码未物化进本包目录，运行时必然加载失败）。
- */
-function generateNodeHostEntrySource(plan) {
-    // 仅包自有 Action 参与 import 与注册，与产物清单保持同一事实源
-    const ownActions = plan.actions.filter((a) => isOwnAction(a));
-    const imports = ownActions
-        .map((act, idx) => `import action_${idx} from ${JSON.stringify(`./${act.entry.replace(/\\/g, "/")}`)};`)
-        .join("\n");
-    const actionsDict = {};
-    for (const a of ownActions) {
-        actionsDict[a.id] = {
-            entry: a.entry,
-            description: a.description || "",
-            inputSchema: a.inputSchema ?? null,
-            outputSchema: a.outputSchema ?? null,
-            uses: a.uses || [],
-            tags: a.tags || [],
-            annotations: a.annotations || {},
-        };
-    }
-    const actionItems = ownActions
-        .map((a, idx) => {
-        const entryObj = `{
-      ...(typeof action_${idx} === "function" ? { run: action_${idx} } : action_${idx}),
-      id: action_${idx}?.id || ${JSON.stringify(a.id)},
-      description: action_${idx}?.description || ${JSON.stringify(a.description || "")},
-      inputSchema: action_${idx}?.inputSchema ?? ${JSON.stringify(a.inputSchema ?? null)},
-      outputSchema: action_${idx}?.outputSchema ?? ${JSON.stringify(a.outputSchema ?? null)},
-      uses: action_${idx}?.uses || ${JSON.stringify(a.uses || [])},
-      tags: action_${idx}?.tags || ${JSON.stringify(a.tags || [])},
-      annotations: action_${idx}?.annotations || ${JSON.stringify(a.annotations || {})},
-    }`;
-        return entryObj;
-    })
-        .join(",\n    ");
-    return `#!/usr/bin/env node
-// AUTO-GENERATED HOST ENTRYPOINT BY ACTIONDOCK BUILDER. DO NOT EDIT.
-import {
-  createActionDock,
-  createNodePlatform,
-} from "@actiondock/core";
-import { serveParentIpc } from "@actiondock/core/server";
-${imports}
-
-let dataDir;
-const configOverrides = {};
-const args = process.argv.slice(2);
-for (let i = 0; i < args.length; i++) {
-  if (args[i] === "--data-dir" && i + 1 < args.length) {
-    dataDir = args[++i];
-  } else if (args[i].startsWith("--data-dir=")) {
-    dataDir = args[i].slice(11);
-  } else if (args[i] === "--config" && i + 1 < args.length) {
-    const raw = args[++i];
-    const [k, ...v] = raw.split("=");
-    if (k) configOverrides[k] = v.join("=");
-  } else if (args[i].startsWith("--config=")) {
-    const raw = args[i].slice(9);
-    const [k, ...v] = raw.split("=");
-    if (k) configOverrides[k] = v.join("=");
-  }
-}
-
-const service = await createActionDock({
-  dataDir,
-  packages: [
-    {
-      dataDir,
-      configOverrides,
-      projectConfig: {
-        id: ${JSON.stringify(plan.packageId)},
-        name: ${JSON.stringify(plan.packageName)},
-        version: ${JSON.stringify(plan.version)},
-        description: ${JSON.stringify(plan.description || "")},
-        config: ${JSON.stringify(plan.configDefs || {})},
-        actions: ${JSON.stringify(actionsDict)},
-      },
-      actions: [
-        ${actionItems}
-      ],
-    },
-  ],
-  platform: createNodePlatform({ dataDir }),
-  autoLoadCurrentProject: false,
-  scanLinkedPackages: false,
-});
-await serveParentIpc(service);
-`;
-}
-/**
- * 生成轻量监督父进程脚本源码（负责参数解析、诊断日志限流、退出码管理与标准输出隔离）。
- */
-function generateNodeSupervisorEntrySource(plan) {
-    return `#!/usr/bin/env node
-// AUTO-GENERATED SUPERVISOR ENTRYPOINT BY ACTIONDOCK BUILDER. DO NOT EDIT.
-import { spawn } from "node:child_process";
-import { join } from "node:path";
-import {
-  STANDALONE_ASYNC_UNSUPPORTED,
-} from "@actiondock/core";
-import {
-  ExitCode,
-  IpcActionDockService,
-  StandaloneDispatcher,
-} from "@actiondock/core/server";
-
-const METADATA = {
-  packageId: ${JSON.stringify(plan.packageId)},
-  version: ${JSON.stringify(plan.version)},
-  description: ${JSON.stringify(plan.description || "")},
-};
-
-const argv = process.argv.slice(2);
-
-// 1. 监督进程接管参数校验，明确拒绝 --async
-if (argv.includes("--async")) {
-  const isJson = argv.includes("--json");
-  if (isJson) {
-    console.log(
-      JSON.stringify(
-        {
-          ok: false,
-          error: {
-            code: ${JSON.stringify(STANDALONE_ASYNC_UNSUPPORTED)},
-            message:
-              "Async execution is not supported in standalone single-execution binaries. Use 'ad serve' or remote target.",
-          },
-        },
-        null,
-        2
-      )
-    );
-  } else {
-    console.error(
-      "Error [" + STANDALONE_ASYNC_UNSUPPORTED + "]: Async execution is not supported in standalone single-execution binaries."
-    );
-  }
-  process.exit(ExitCode.FAILURE);
-}
-
-// 2. 静态元数据快速返回
-if (argv.includes("-v") || argv.includes("-V") || argv.includes("--version") || argv[0] === "version") {
-  console.log(\`\${METADATA.packageId} v\${METADATA.version}\`);
-  process.exit(ExitCode.SUCCESS);
-}
-
-if (argv.includes("-h") || argv.includes("--help") || argv[0] === "help") {
-  console.log(\`\${METADATA.packageId} (v\${METADATA.version})\`);
-  if (METADATA.description) console.log(METADATA.description + "\\n");
-  console.log("Usage:");
-  console.log("  <cmd> list [--json]                         List available actions");
-  console.log("  <cmd> describe <id> [--json]                Show action details and schemas");
-  console.log("  <cmd> run <id> [--input '<json>']           Execute action with JSON input");
-  console.log("  <cmd> config list/get/set/delete            Manage package configuration");
-  console.log("  <cmd> state list/get/set/delete             Manage shared state store");
-  console.log("\\nGlobal options:");
-  console.log("  --data-dir <path>                           Custom runtime database directory");
-  console.log("  --config <KEY=val>                          Temporary config override");
-  process.exit(ExitCode.SUCCESS);
-}
-
-// 3. 建立物理隔离监督边界，启动运行 ActionDockHost 的独立子进程
-const hostScript = join(import.meta.dirname, "entry-host.js");
-const child = spawn(process.execPath, [hostScript, ...argv], {
-  cwd: process.cwd(),
-  env: process.env,
-  stdio: ["pipe", "pipe", "pipe", "ipc"],
-});
-
-// 4. 标准输出通道物理隔离与受控限流排空
-const service = new IpcActionDockService({
-  childProcess: child,
-  maxDiagnosticBytes: 512 * 1024,
-  maxDiagnosticRate: 64 * 1024,
-  diagnosticTarget: process.stderr,
-});
-
-let cleanedUp = false;
-const cleanup = async () => {
-  if (cleanedUp) return;
-  cleanedUp = true;
-  try {
-    await service.close();
-  } catch {}
-};
-
-process.once("SIGINT", async () => {
-  await cleanup();
-  process.exit(ExitCode.SIGINT);
-});
-
-process.once("SIGTERM", async () => {
-  await cleanup();
-  process.exit(143);
-});
-
-const dispatcher = new StandaloneDispatcher({
-  packageId: METADATA.packageId,
-  version: METADATA.version,
-  description: METADATA.description,
-  service,
-});
-
-try {
-  const exitCode = await dispatcher.dispatch(argv);
-  await cleanup();
-  process.exit(exitCode);
-} catch (err) {
-  if (err?.code === "HOST_PROCESS_EXITED") {
-    console.error("[Supervisor] Host process exited unexpectedly:", err.message);
-  } else {
-    console.error("[Supervisor] Error:", err?.message || err);
-  }
-  await cleanup();
-  process.exit(ExitCode.FAILURE);
-}
-`;
-}
 /**
  * 拷贝 Action 源码、Playbook 规程与声明的代码文件/静态资产到暂存目录。
  * 拷贝内核统一复用 stage-sources 的 copyPlanEntries，无差异化调优时直接全量拷贝。
@@ -358,96 +142,31 @@ function writeEntrypoints(stagingDir, plan) {
         chmodSync(supervisorPath, 0o755);
         chmodSync(forwarderPath, 0o755);
     }
-    catch {
-        // 忽略部分平台权限设置异常
-    }
-}
-/**
- * 物化锁定生产依赖到产物 node_modules 目录（vendorDeps 开启时）。
- */
-function vendorDependencies(root, stagingDir, plan) {
-    const destNodeModules = join(stagingDir, "node_modules");
-    mkdirSync(destNodeModules, { recursive: true });
-    // 尝试复制本地已解析的生产依赖
-    const sourceCandidates = [
-        join(root, "node_modules"),
-        resolve(import.meta.dirname, "../../../node_modules"),
-    ];
-    // 嵌套 node_modules 不再跳过：多版本共存时传递依赖必须完整物化，
-    // 否则产物运行时 Cannot find module 且构建阶段无任何警告；
-    // 保留 .git、.bin 等目录排除（.bin 为平台相关的命令行 shim，不参与运行时模块解析）
-    const copyVendorPackage = (srcDir, destDir) => {
-        if (!existsSync(srcDir))
-            return;
-        mkdirSync(destDir, { recursive: true });
-        const entries = readdirSync(srcDir);
-        for (const entry of entries) {
-            if (entry === ".git" ||
-                entry === ".actiondock" ||
-                entry === ".bin" ||
-                entry === "test" ||
-                entry === "tests") {
-                continue;
-            }
-            const srcPath = join(srcDir, entry);
-            const destPath = join(destDir, entry);
-            try {
-                const stat = statSync(srcPath);
-                if (stat.isDirectory()) {
-                    copyVendorPackage(srcPath, destPath);
-                }
-                else if (stat.isFile()) {
-                    copyFileSync(srcPath, destPath);
-                }
-            }
-            catch {
-                // 忽略无法读取的文件或死链接
-            }
-        }
-    };
-    for (const dep of plan.dependencies.external) {
-        if (dep.isDev)
-            continue;
-        for (const baseModules of sourceCandidates) {
-            const srcDep = join(baseModules, dep.name);
-            if (existsSync(srcDep)) {
-                const targetDep = join(destNodeModules, dep.name);
-                mkdirSync(dirname(targetDep), { recursive: true });
-                copyVendorPackage(srcDep, targetDep);
-                break;
-            }
-        }
-    }
-    // 复制 ActionDock 内部依赖
-    for (const internalPkg of ["@actiondock/core", "@actiondock/sdk"]) {
-        for (const baseModules of sourceCandidates) {
-            const srcDep = join(baseModules, internalPkg);
-            if (existsSync(srcDep)) {
-                const targetDep = join(destNodeModules, internalPkg);
-                mkdirSync(dirname(targetDep), { recursive: true });
-                copyVendorPackage(srcDep, targetDep);
-                break;
-            }
+    catch (err) {
+        // Windows 平台不支持类 Unix 权限模式；非 Windows 环境下输出预警
+        if (process.platform !== "win32") {
+            console.warn(`[actiondock] Warning: Failed to set executable permissions on entry scripts: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
 }
 /**
- * 构建 Node.js 目录型交付产物。
- * 主流程仅做编排，各阶段职责由独立函数承担。
+ * 基于预先计算的 SelectionPlan 方案直接构建 Node.js 目录型交付产物。
  *
- * @param options 构建选项
+ * 核心构建管线涵盖可复现性检查、暂存区构建、清单与入口脚本生成、生产依赖物化及归档打包。
+ *
+ * 规划方案复用场景：
+ * - 当调用方已通过 SelectionPlanner.plan 计算出依赖与资产规划方案（例如技能导出 exportSkill、复合技能导出 exportCompositeSkill 或定制资产选择）时，直接消费 buildProjectWithPlan 核心管线，无需且严禁再次重复规划。
+ *
+ * 路径冲突仲裁策略：
+ * - 若 options.projectRoot 显式提供，则以 options.projectRoot 为准覆盖。
+ * - 若未提供，则兜底回退采用 plan.projectRoot。
+ *
+ * @param plan 已规划的依赖与资产选择方案
+ * @param options 构建执行选项
  * @returns 构建产物结果描述
  */
-export async function buildProject(options) {
-    const root = resolve(options.projectRoot);
-    const plan = SelectionPlanner.plan({
-        projectRoot: root,
-        config: options.config,
-        manifest: options.manifest,
-        actions: options.actions,
-        playbooks: options.playbooks,
-        skipDependencyValidation: options.skipDependencyValidation,
-    });
+export async function buildProjectWithPlan(plan, options = {}) {
+    const root = resolve(options.projectRoot || plan.projectRoot);
     if (plan.actions.length === 0) {
         throw new BuilderError("No actions resolved for build");
     }
@@ -551,3 +270,74 @@ export async function buildProject(options) {
         sha256,
     };
 }
+/**
+ * 构建 Node.js 目录型交付产物。
+ * 委托 SelectionPlanner 执行构建规划，随后直接消费核心构建管线 buildProjectWithPlan。
+ *
+ * @param options 构建选项
+ * @returns 构建产物结果描述
+ */
+export async function buildProject(options) {
+    const root = resolve(options.projectRoot);
+    const plan = SelectionPlanner.plan({
+        projectRoot: root,
+        config: options.config,
+        manifest: options.manifest,
+        actions: options.actions,
+        playbooks: options.playbooks,
+        skipDependencyValidation: options.skipDependencyValidation,
+    });
+    return buildProjectWithPlan(plan, {
+        projectRoot: root,
+        outDir: options.outDir,
+        outfile: options.outfile,
+        archive: options.archive,
+        vendorDeps: options.vendorDeps,
+        allowInstallScripts: options.allowInstallScripts,
+        requireReproducible: options.requireReproducible,
+    });
+}
+/**
+ * 执行 Node 目录型 Skill 导出。
+ * 复用传入的 SelectionPlan 方案与 buildProjectWithPlan 核心构建管线，
+ * 产出可执行交付目录，并在目录内生成调用该入口的 SKILL.md 说明书。
+ */
+export async function exportNodeSkill(root, targetSkillDir, plan, options, pkgSlug) {
+    await buildProjectWithPlan(plan, {
+        projectRoot: root,
+        outDir: targetSkillDir,
+        vendorDeps: options.vendorDeps,
+        allowInstallScripts: options.allowInstallScripts,
+        requireReproducible: options.requireReproducible,
+    });
+    const usedExistingSkillMd = writeSkillMd(root, targetSkillDir, { skipSkillMd: options.skipSkillMd, skillMdPath: options.skillMdPath, pkgSlug }, () => {
+        const configForTemplates = buildConfigForTemplates(plan, plan.actionsDir || "actions", plan.playbooksDir || "playbooks");
+        return generateStandaloneSkillMd(configForTemplates, plan.actions, plan.playbooks, "node ./entry.mjs");
+    });
+    // 仅在使用自动模板时生成默认运行参考文件；Node 目录型使用自身入口，不要求全局安装 ad
+    if (usedExistingSkillMd === undefined && !options.skipSkillMd) {
+        writeRuntimeReferenceFile(targetSkillDir, {
+            dependencyStepLabel: "安装技能运行目录依赖",
+            relinkStepLabel: "完成安装后重新链接本技能",
+            invocationStyle: "node-entry",
+            entryRelPath: "node ./entry.mjs",
+        });
+    }
+    let archivePath;
+    if (options.archive) {
+        archivePath = await createArchive(targetSkillDir, resolveArchiveFormat(options));
+    }
+    return {
+        packageId: plan.packageId,
+        version: plan.version,
+        mode: "node",
+        skillDir: targetSkillDir,
+        archivePath,
+        actionsCount: plan.actions.length,
+        playbooksCount: plan.playbooks.length,
+        actions: plan.actions.map((a) => a.id),
+        playbooks: plan.playbooks.map((p) => p.id),
+        files: collectRelativeFiles(targetSkillDir),
+        usedExistingSkillMd,
+    };
+}

package/dist/dependency-check.js

@@ -175,9 +175,9 @@ export function assertRelativeDependenciesIntegrity(projectRoot, plan) {
                 const relToParent = relative(resolvedParent, resolvedTarget);
                 const isSiblingPackage = !isPathOutsideBoundary(relToParent);
                 const detail = isSiblingPackage
-                    ? `它位于项目根的父目录内，疑似 monorepo 相邻包。若确需依赖，请将其纳入本项目或改用包管理器依赖声明；若为本地辅助模块，请调整目录结构或将其声明进 files`
-                    : `它完全位于项目外部。导出的 Skill 产物不允许携带项目外部的相对路径依赖，请将所需模块移入项目内并声明进 files`;
-                throw new BuilderError(`Action '${actionId}' 通过相对路径 '${specifier}' 引用了项目根之外的模块（解析到 '${resolvedTarget}'）。${detail}`, "EXTERNAL_LOCAL_DEPENDENCY");
+                    ? `It is located in the parent directory of the project root, likely a neighboring package in a monorepo. If this dependency is required, please include it in this project or declare it as a package manager dependency; if it is a local helper module, please adjust the directory structure or declare it in 'files'`
+                    : `It is completely outside the project. Exported Skill assets must not contain relative path dependencies outside the project. Please move the required module into the project and declare it in 'files'`;
+                throw new BuilderError(`Action '${actionId}' imports a module outside the project root via relative path '${specifier}' (resolved to '${resolvedTarget}'). ${detail}`, "EXTERNAL_LOCAL_DEPENDENCY");
             }
             // 检查目标文件是否在构建收集集合中
             if (!collectedPaths.has(resolvedTarget)) {

package/dist/dependency-resolver.d.ts

@@ -0,0 +1,17 @@
+import type { ExternalDependency } from "./types.js";
+/**
+ * 测试与类型声明文件后缀常量（供 fallback 清单过滤与 isIgnoredPath 共享同一口径）。
+ */
+export declare const TEST_FILE_SUFFIXES: string[];
+/**
+ * 忽略的文件模式判断（排除测试文件、类型声明文件以及构建/版本控制等私有目录）。
+ */
+export declare function isIgnoredPath(relPath: string): boolean;
+/**
+ * 收集项目根目录 package.json 中声明的外部 npm 依赖。
+ *
+ * 防御与透明原则：文件不存在返回空集合（合法的无依赖工程）；
+ * 文件存在但不可读或 JSON 损坏时抛 PlannerError 并携带路径与原因，
+ * 严禁静默吞掉导致后续 build 的生产依赖、pack 的产物依赖与 vendorDeps 全部无声缺失。
+ */
+export declare function extractExternalDependencies(projectRoot: string): ExternalDependency[];

package/dist/dependency-resolver.js

@@ -0,0 +1,69 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { PlannerError } from "./errors.js";
+/**
+ * 测试与类型声明文件后缀常量（供 fallback 清单过滤与 isIgnoredPath 共享同一口径）。
+ */
+export const TEST_FILE_SUFFIXES = [
+    ".test.ts",
+    ".test.js",
+    ".test.tsx",
+    ".test.jsx",
+    ".spec.ts",
+    ".spec.js",
+    ".spec.tsx",
+    ".spec.jsx",
+    ".d.ts",
+];
+/**
+ * 忽略的文件模式判断（排除测试文件、类型声明文件以及构建/版本控制等私有目录）。
+ */
+export function isIgnoredPath(relPath) {
+    const normalized = relPath.replace(/\\/g, "/");
+    return (normalized.startsWith("node_modules/") ||
+        normalized.includes("/node_modules/") ||
+        normalized.startsWith(".git/") ||
+        normalized.startsWith("dist/") ||
+        normalized.startsWith(".actiondock/") ||
+        TEST_FILE_SUFFIXES.some((suffix) => normalized.endsWith(suffix)));
+}
+/**
+ * 收集项目根目录 package.json 中声明的外部 npm 依赖。
+ *
+ * 防御与透明原则：文件不存在返回空集合（合法的无依赖工程）；
+ * 文件存在但不可读或 JSON 损坏时抛 PlannerError 并携带路径与原因，
+ * 严禁静默吞掉导致后续 build 的生产依赖、pack 的产物依赖与 vendorDeps 全部无声缺失。
+ */
+export function extractExternalDependencies(projectRoot) {
+    const pkgPath = join(projectRoot, "package.json");
+    if (!existsSync(pkgPath))
+        return [];
+    let parsed;
+    try {
+        const raw = readFileSync(pkgPath, "utf-8");
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        throw new PlannerError(`Failed to read or parse package.json at ${pkgPath}: ${err?.message || String(err)}`, "EXTRACT_DEPS_ERROR");
+    }
+    const deps = [];
+    if (parsed.dependencies && typeof parsed.dependencies === "object") {
+        for (const [name, versionRange] of Object.entries(parsed.dependencies)) {
+            deps.push({
+                name,
+                versionRange: String(versionRange),
+                isDev: false,
+            });
+        }
+    }
+    if (parsed.devDependencies && typeof parsed.devDependencies === "object") {
+        for (const [name, versionRange] of Object.entries(parsed.devDependencies)) {
+            deps.push({
+                name,
+                versionRange: String(versionRange),
+                isDev: true,
+            });
+        }
+    }
+    return deps;
+}

package/dist/entry-generators.d.ts

@@ -0,0 +1,15 @@
+import type { SelectionPlan } from "./types.js";
+/**
+ * 生成 Host 子进程入口脚本源码（负责运行 ActionDockHost，通过 Node IPC 暴露 Target）。
+ *
+ * 按需装配契约：
+ * - 不再静态导入全部包内 Action（消除发现路径的业务模块顶层副作用）；
+ * - 仅携带清单元数据，执行时由现有执行服务通过清单 entry 与 NodeModuleLoader
+ *   按需加载业务实现；跨包外部 Action 不混入本包源码，依赖调用继续经 Host 路由；
+ * - 入口路径以产物包根目录为基准（import.meta.dirname），不依赖调用者当前工作目录。
+ */
+export declare function generateNodeHostEntrySource(plan: SelectionPlan): string;
+/**
+ * 生成轻量监督父进程脚本源码（负责参数解析、诊断日志限流、退出码管理与标准输出隔离）。
+ */
+export declare function generateNodeSupervisorEntrySource(plan: SelectionPlan): string;