@actiondock/core 2.15.0 → 2.17.0

package/dist/project/skill-dir.js

@@ -1,244 +0,0 @@
-import { existsSync, readdirSync, statSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { ActionDockError, ACTION_NOT_FOUND, PACKAGE_NOT_FOUND, PACKAGE_ID_CONFLICT, } from "../errors.js";
-import { loadProjectConfig } from "./loader.js";
-import { PackageGraphBuilder } from "../catalog/graph.js";
-import { parseActionRef } from "../catalog/resolve-action.js";
-import { createPackageIdentity } from "../runtime/identity.js";
-/**
- * 判定路径字符串是否为显式文件/目录路径形态（而非包标识符）。
- *
- * 规则：
- * - 以 .、/、~ 开头；
- * - 包含 / 或 \\，且不是 scoped 包（@scope/name 仅含一个 /）；
- * - scoped 包若包含反斜杠或多于一个 /，亦视作路径。
- */
-export function isExplicitPath(p) {
-    if (!p)
-        return false;
-    if (p.startsWith("@")) {
-        const slashCount = (p.match(/\//g) || []).length;
-        return slashCount > 1 || p.includes("\\");
-    }
-    return (p.startsWith(".") ||
-        p.startsWith("/") ||
-        p.startsWith("~") ||
-        p.includes("/") ||
-        p.includes("\\"));
-}
-/**
- * 对明确的本地封闭包集合实施一致性校验。
- *
- * 校验规则：
- * - 重复包标识防护：集合内不得存在相同 packageId；
- * - 依赖存在性与版本兼容性：声明的直接依赖必须在集合内存在且满足语义版本约束（复用 PackageGraphBuilder）；
- * - 跨包 uses 目标完整性：uses 声明引用的目标包与目标 Action 必须在集合内存在。
- *
- * @param packages 封闭包条目集合
- */
-export function validateLocalSkillPackages(packages) {
-    if (!packages || packages.length === 0)
-        return;
-    // 1. 重复 packageId 校验
-    const seenIds = new Set();
-    for (const pkg of packages) {
-        if (seenIds.has(pkg.packageId)) {
-            throw new ActionDockError(PACKAGE_ID_CONFLICT, `Package ID conflict: package '${pkg.packageId}' is declared more than once in skill packages`);
-        }
-        seenIds.add(pkg.packageId);
-    }
-    // 2. 构造包发现视图并交由 PackageGraphBuilder 校验依赖与版本
-    const discovered = packages.map((pkg) => ({
-        id: pkg.packageId,
-        root: pkg.packageRoot,
-        manifest: pkg.projectConfig,
-        identity: createPackageIdentity({
-            id: pkg.packageId,
-            instanceId: `${pkg.packageId}:${pkg.packageRoot}`,
-            generation: "skill-local",
-        }),
-        isCurrentProject: true,
-    }));
-    const builder = new PackageGraphBuilder({
-        packages: discovered,
-        validateDependencies: true,
-    });
-    builder.buildSync();
-    // 3. uses 声明目标存在性校验
-    const pkgMap = new Map();
-    for (const pkg of packages) {
-        pkgMap.set(pkg.packageId, pkg.projectConfig);
-    }
-    const validateUseRef = (rawRef, caller, currentPkg) => {
-        if (typeof rawRef !== "string" || !rawRef.trim())
-            return;
-        const trimmed = rawRef.trim();
-        // 先按完整包身份识别裸包引用，包括 scoped 包。
-        if (pkgMap.has(trimmed)) {
-            return;
-        }
-        // 裸 scoped 包只有一个斜杠，不能按限定动作拆分。
-        if (trimmed.startsWith("@") && (trimmed.match(/\//g) || []).length === 1) {
-            throw new ActionDockError(PACKAGE_NOT_FOUND, `Package '${trimmed}' referenced by uses in '${caller}' was not found in skill directory`);
-        }
-        // 限定动作与包级通配符复用统一引用解析器。
-        if (trimmed.includes("/")) {
-            const ref = parseActionRef(trimmed);
-            const targetPkgId = ref.packageId;
-            const targetActionId = ref.actionId;
-            const targetPkg = pkgMap.get(targetPkgId);
-            if (!targetPkg) {
-                throw new ActionDockError(PACKAGE_NOT_FOUND, `Package '${targetPkgId}' referenced by uses in '${caller}' was not found in skill directory`);
-            }
-            if (targetActionId !== "*") {
-                const hasAction = Boolean(targetPkg.actions && targetPkg.actions[targetActionId]);
-                if (!hasAction) {
-                    throw new ActionDockError(ACTION_NOT_FOUND, `Action '${targetActionId}' referenced by uses in '${caller}' was not found in package '${targetPkgId}'`);
-                }
-            }
-            return;
-        }
-        // 本包短动作引用。
-        if (currentPkg.actions && currentPkg.actions[trimmed]) {
-            return;
-        }
-        // 目标不存在。
-        throw new ActionDockError(PACKAGE_NOT_FOUND, `Package or action '${trimmed}' referenced by uses in '${caller}' was not found in skill directory`);
-    };
-    for (const pkg of packages) {
-        const pkgUses = pkg.projectConfig.uses;
-        if (Array.isArray(pkgUses)) {
-            for (const ref of pkgUses) {
-                validateUseRef(ref, `package '${pkg.packageId}'`, pkg.projectConfig);
-            }
-        }
-        if (pkg.projectConfig.actions && typeof pkg.projectConfig.actions === "object") {
-            for (const [actionId, actionEntry] of Object.entries(pkg.projectConfig.actions)) {
-                if (actionEntry && Array.isArray(actionEntry.uses)) {
-                    for (const ref of actionEntry.uses) {
-                        validateUseRef(ref, `action '${pkg.packageId}/${actionId}'`, pkg.projectConfig);
-                    }
-                }
-            }
-        }
-    }
-}
-/**
- * 发现本地 Skill / 包目录结构（支持单包根目录与 packages/* 复合套件布局）。
- * 仅执行物理布局发现与清单加载，不执行跨包封闭依赖集合校验。
- *
- * @param directoryPath 待检查的目录路径（相对路径将基于 cwd 解析）
- * @param cwd 解析基准工作目录（默认为 process.cwd()）
- */
-export function discoverLocalSkillDirectory(directoryPath, cwd) {
-    if (!directoryPath || typeof directoryPath !== "string") {
-        return null;
-    }
-    const absDir = resolve(cwd || process.cwd(), directoryPath);
-    if (!existsSync(absDir)) {
-        return null;
-    }
-    try {
-        const stat = statSync(absDir);
-        if (!stat.isDirectory()) {
-            return null;
-        }
-    }
-    catch {
-        return null;
-    }
-    // 单包布局：根目录包含 actiondock.json
-    const rootManifest = join(absDir, "actiondock.json");
-    if (existsSync(rootManifest)) {
-        const config = loadProjectConfig(absDir);
-        const packages = [
-            {
-                packageId: config.id,
-                packageRoot: absDir,
-                projectConfig: config,
-            },
-        ];
-        return {
-            type: "single",
-            root: absDir,
-            packages,
-        };
-    }
-    // 复合 Skill 布局：存在 packages/ 目录且包含至少一个有效子包
-    const packagesDir = join(absDir, "packages");
-    if (existsSync(packagesDir)) {
-        const pStat = statSync(packagesDir);
-        if (pStat.isDirectory()) {
-            const entries = readdirSync(packagesDir, { withFileTypes: true });
-            const packages = [];
-            const seenIds = new Set();
-            entries.sort((a, b) => a.name.localeCompare(b.name));
-            for (const entry of entries) {
-                const subDir = join(packagesDir, entry.name);
-                const sStat = statSync(subDir);
-                if (sStat.isDirectory()) {
-                    const subManifest = join(subDir, "actiondock.json");
-                    if (existsSync(subManifest)) {
-                        const childConfig = loadProjectConfig(subDir);
-                        if (seenIds.has(childConfig.id)) {
-                            throw new ActionDockError(PACKAGE_ID_CONFLICT, `Package ID conflict: package '${childConfig.id}' is declared more than once in skill directory '${absDir}'`);
-                        }
-                        seenIds.add(childConfig.id);
-                        packages.push({
-                            packageId: childConfig.id,
-                            packageRoot: subDir,
-                            projectConfig: childConfig,
-                        });
-                    }
-                }
-            }
-            if (packages.length > 0) {
-                return {
-                    type: "composite",
-                    root: absDir,
-                    packages,
-                };
-            }
-        }
-    }
-    return null;
-}
-/**
- * 查询指定路径的本地包或技能目录（供 info / 查询命令使用）。
- * 单包不要求 node_modules 依赖闭包；复合目录仍要求封闭集合完整。
- *
- * @param directoryPath 待检查的目录路径（相对路径将基于 cwd 解析）
- * @param cwd 解析基准工作目录（默认为 process.cwd()）
- */
-export function queryLocalPackageDirectory(directoryPath, cwd) {
-    const discovered = discoverLocalSkillDirectory(directoryPath, cwd);
-    if (!discovered) {
-        return null;
-    }
-    if (discovered.type === "composite") {
-        validateLocalSkillPackages(discovered.packages);
-    }
-    return discovered;
-}
-/**
- * 探测指定路径是否为本地 Skill / 包目录（支持单包根目录与 packages/* 复合套件布局）。
- *
- * 封闭包装配与校验规则：
- * - 符号链接按目录布局正常解析；Action 与规程入口的文件边界由相应加载器校验；
- * - 单包布局：目录根部存在 actiondock.json，解析为包含单一包的 LocalSkillDirectory；
- * - 复合布局：目录根部存在 packages/ 目录，遍历其直接子目录，收集包含 actiondock.json 的子包；
- * - 集合一致性校验：通过 validateLocalSkillPackages 严格核查依赖闭包、版本兼容与 uses 目标；
- * - 异常透传：坏清单或权限异常原样抛出，严禁静默回退 Registry；
- * - 若非候选技能目录，返回 null。
- *
- * @param directoryPath 待检查的目录路径（相对路径将基于 cwd 解析）
- * @param cwd 解析基准工作目录（默认为 process.cwd()）
- */
-export function inspectLocalPackageDirectory(directoryPath, cwd) {
-    const discovered = discoverLocalSkillDirectory(directoryPath, cwd);
-    if (!discovered) {
-        return null;
-    }
-    validateLocalSkillPackages(discovered.packages);
-    return discovered;
-}