@cicctencent/agent-core 1.0.17 → 1.0.20

package/dist/cjs/skill/manager.js

@@ -39,6 +39,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SkillManager = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const frontmatter_ts_1 = require("./frontmatter.js");
+/** 需要透传到 metadata 的标准/已知 frontmatter 字段集合 */
+const KNOWN_FM_KEYS = new Set([
+    'name', 'description', 'tags', 'keywords', 'aliases',
+    'requires', 'required_mcps', 'version', 'author',
+    'referenced_skills', 'referencedSkills',
+    'allowed-tools', 'allowedTools', 'allowed_tools',
+    'license', 'compatibility', 'metadata',
+]);
 /** 简单 LRU 缓存（基于 Map 插入顺序） */
 class LRUCache {
     cache = new Map();
@@ -90,6 +99,8 @@ class SkillManager {
     nameIndex = new Map();
     /** content LRU 缓存（懒加载时按需填充） */
     contentCache;
+    /** 嵌套子包扫描结果缓存：packageDir -> Skill[] */
+    nestedSkillsCache = new Map();
     /** 是否启用懒加载 */
     lazy;
     /** 记录加载的目录，用于 reload */
@@ -127,16 +138,47 @@ class SkillManager {
             : path.resolve(dir);
         if (!fs.existsSync(resolvedDir))
             return;
-        // 递归扫描目录及子目录中的所有 .md 文件
+        const isSkippableDir = (name) => name === 'node_modules' || name === '.git' || name === '.hg' || name.startsWith('.');
+        // 第一遍：递归识别所有标准目录包（含 SKILL.md 的目录）。
+        // 关键：识别到包后【继续向下递归】，因此父包内的子目录若也含 SKILL.md
+        // （如 modules/zk-strategy/SKILL.md）会被识别为独立子包，支持任意层级嵌套。
+        const packageEntries = [];
+        const collectPackages = (currentDir, relId) => {
+            const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+            const hasSkillMd = entries.some(e => e.isFile() && e.name.toLowerCase() === 'skill.md');
+            if (hasSkillMd) {
+                packageEntries.push({ dir: currentDir, relId: relId || path.basename(currentDir) });
+                // 继续递归（而非 return），以发现嵌套子包
+            }
+            for (const entry of entries) {
+                if (entry.isDirectory() && !isSkippableDir(entry.name)) {
+                    const childRel = relId ? `${relId}/${entry.name}` : entry.name;
+                    collectPackages(path.join(currentDir, entry.name), childRel);
+                }
+            }
+        };
+        collectPackages(resolvedDir, '');
+        const packageSet = packageEntries.map(p => path.resolve(p.dir));
+        // 加载目录包（SKILL.md + 资源目录），relId 作为嵌套 storageId
+        for (const { dir, relId } of packageEntries) {
+            this.loadPackageDir(dir, relId, source, connectorId);
+        }
+        // 判断路径是否位于某个包目录内
+        const isInPackage = (fp) => {
+            const abs = path.resolve(fp);
+            return packageSet.some(pkg => abs === pkg || abs.startsWith(pkg + path.sep));
+        };
+        // 第二遍：递归扫描散落的 .md 文件（跳过任何包目录内的文件）
         const walkDir = (currentDir) => {
             const entries = fs.readdirSync(currentDir, { withFileTypes: true });
             const mdFiles = [];
             for (const entry of entries) {
                 const fullPath = path.join(currentDir, entry.name);
                 if (entry.isDirectory()) {
-                    mdFiles.push(...walkDir(fullPath));
+                    if (!isInPackage(fullPath))
+                        mdFiles.push(...walkDir(fullPath));
                 }
-                else if (entry.isFile() && entry.name.endsWith('.md')) {
+                else if (entry.isFile() && entry.name.endsWith('.md') && !isInPackage(fullPath)) {
                     mdFiles.push(fullPath);
                 }
             }
@@ -170,10 +212,210 @@ class SkillManager {
             }
         }
     }
+    /** 扫描目录包的资源清单（scripts/ references/ assets/ skills/），返回相对路径（POSIX 风格） */
+    static scanPackageResources(packageDir) {
+        const scan = (sub) => {
+            const dir = path.join(packageDir, sub);
+            if (!fs.existsSync(dir))
+                return [];
+            const out = [];
+            const walk = (d) => {
+                for (const e of fs.readdirSync(d, { withFileTypes: true })) {
+                    const fp = path.join(d, e.name);
+                    if (e.isDirectory())
+                        walk(fp);
+                    else if (e.isFile())
+                        out.push(path.relative(packageDir, fp).split(path.sep).join('/'));
+                }
+            };
+            walk(dir);
+            return out.sort();
+        };
+        const resources = {};
+        const scripts = scan('scripts');
+        const references = scan('references');
+        const assets = scan('assets');
+        // 兼容：包根目录下除 SKILL.md 外的 .md 文档也视为 references（WorkBuddy 旧格式，如 reference.md）
+        try {
+            for (const e of fs.readdirSync(packageDir, { withFileTypes: true })) {
+                if (e.isFile() && e.name.toLowerCase().endsWith('.md') && e.name.toLowerCase() !== 'skill.md') {
+                    references.push(e.name);
+                }
+            }
+        }
+        catch {
+            /* ignore */
+        }
+        if (scripts.length)
+            resources.scripts = scripts;
+        if (references.length)
+            resources.references = [...new Set(references)].sort();
+        if (assets.length)
+            resources.assets = assets;
+        // 扫描嵌套子包（skills/ 目录下的子目录含 SKILL.md）
+        const skillsDir = path.join(packageDir, 'skills');
+        if (fs.existsSync(skillsDir) && fs.statSync(skillsDir).isDirectory()) {
+            const nestedSkills = this.scanNestedPackages(skillsDir);
+            if (nestedSkills.length > 0) {
+                resources.skills = nestedSkills;
+            }
+        }
+        return resources;
+    }
+    /** 扫描嵌套子包（skills/ 目录下的子目录含 SKILL.md） */
+    static scanNestedPackages(skillsDir) {
+        const nestedSkills = [];
+        const scanDir = (dir, relPath) => {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                const subDir = path.join(dir, entry.name);
+                const skillMd = path.join(subDir, 'SKILL.md');
+                if (fs.existsSync(skillMd)) {
+                    // 这是一个嵌套子包
+                    nestedSkills.push(relPath ? `${relPath}/${entry.name}` : entry.name);
+                    // 继续递归扫描子包的 skills/ 目录
+                    const subSkillsDir = path.join(subDir, 'skills');
+                    if (fs.existsSync(subSkillsDir)) {
+                        scanDir(subSkillsDir, relPath ? `${relPath}/${entry.name}` : entry.name);
+                    }
+                }
+                else {
+                    // 不是子包，继续向下扫描
+                    scanDir(subDir, relPath ? `${relPath}/${entry.name}` : entry.name);
+                }
+            }
+        };
+        scanDir(skillsDir, '');
+        return nestedSkills;
+    }
+    /**
+     * 扫描嵌套子包并返回完整的 Skill 对象列表
+     * @param parentPkgDir 父包的物化目录
+     * @param parentRuntimeId 父包的运行时 ID
+     * @param parentPath 父包的 path
+     * @returns 嵌套子包列表
+     */
+    static scanNestedSkills(parentPkgDir, parentRuntimeId, parentPath) {
+        const nestedSkills = [];
+        const skillsDir = path.join(parentPkgDir, 'skills');
+        if (!fs.existsSync(skillsDir)) {
+            return nestedSkills;
+        }
+        const scanDir = (dir, relPath) => {
+            try {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (!entry.isDirectory())
+                        continue;
+                    const subDir = path.join(dir, entry.name);
+                    const skillMd = path.join(subDir, 'SKILL.md');
+                    if (fs.existsSync(skillMd)) {
+                        // 这是一个嵌套子包
+                        const subPath = `${parentPath}/skills/${entry.name}`;
+                        // 使用 / 作为分隔符，避免与 connectorSkillKey 冲突
+                        const subRuntimeId = `${parentRuntimeId}/${entry.name}`;
+                        // 解析 SKILL.md 的 frontmatter
+                        let name = entry.name;
+                        let description = '';
+                        let content = '';
+                        try {
+                            const raw = fs.readFileSync(skillMd, 'utf-8');
+                            const { data, body } = (0, frontmatter_ts_1.parseFrontmatter)(raw);
+                            name = String(data.name || entry.name);
+                            description = String(data.description || '');
+                            content = body.trim();
+                        }
+                        catch (error) {
+                            console.warn(`[SkillManager] 解析嵌套子包 SKILL.md 失败: ${subDir}`, error);
+                            // 使用默认值，继续处理其他子包
+                        }
+                        nestedSkills.push({
+                            id: subRuntimeId,
+                            name: name,
+                            description: description,
+                            tags: [],
+                            aliases: [],
+                            content: content,
+                            source: 'user',
+                            packageDir: subDir,
+                        });
+                        // 继续递归扫描子包的 skills/ 目录
+                        const subSkillsDir = path.join(subDir, 'skills');
+                        if (fs.existsSync(subSkillsDir)) {
+                            scanDir(subSkillsDir, relPath ? `${relPath}/${entry.name}` : entry.name);
+                        }
+                    }
+                    else {
+                        // 不是子包，继续向下扫描
+                        scanDir(subDir, relPath ? `${relPath}/${entry.name}` : entry.name);
+                    }
+                }
+            }
+            catch (error) {
+                console.warn(`[SkillManager] 扫描嵌套子包目录失败: ${dir}`, error);
+            }
+        };
+        scanDir(skillsDir, 'skills');
+        return nestedSkills;
+    }
+    /**
+     * 加载单个标准目录包（含 SKILL.md 的目录）。
+     * 自动扫描资源目录并注册资源清单。
+     * @param relId 相对于加载根目录的嵌套 id（如 `master-investment/modules/zk-strategy`）；
+     *              无连接器时直接作为 storageId，确保不同层级的同名目录互不覆盖。
+     */
+    loadPackageDir(packageDir, relId, source, connectorId) {
+        const resolvedDir = path.resolve(packageDir);
+        const skillMd = path.join(resolvedDir, 'SKILL.md');
+        if (!fs.existsSync(skillMd))
+            return;
+        // 嵌套 id：连接器前缀 + 相对路径（用 '/' 分隔，跨平台统一）
+        const storageId = connectorId ? SkillManager.connectorSkillKey(connectorId, relId) : relId;
+        const baseId = path.basename(resolvedDir);
+        // 父包 id：去掉最后一段（如 `master-investment/modules/zk-strategy` -> `master-investment`）
+        const parentId = relId.includes('/') ? relId.substring(0, relId.lastIndexOf('/')) : undefined;
+        const resources = SkillManager.scanPackageResources(resolvedDir);
+        if (this.lazy) {
+            const manifest = this.parseManifest(storageId, skillMd, source, connectorId);
+            if (manifest) {
+                manifest.baseId = baseId;
+                manifest.parentId = parentId;
+                this.manifests.set(storageId, manifest);
+                this.indexManifest(manifest, storageId);
+                this.registerPackageResources(storageId, resources, resolvedDir);
+            }
+        }
+        else {
+            const raw = fs.readFileSync(skillMd, 'utf-8');
+            const skill = this.parse(storageId, raw, source);
+            if (connectorId)
+                skill.metadata = { ...skill.metadata, connectorId };
+            const manifest = this.toManifest(skill, skillMd);
+            manifest.baseId = baseId;
+            manifest.parentId = parentId;
+            this.manifests.set(storageId, manifest);
+            this.indexManifest(manifest, storageId);
+            this.contentCache.set(storageId, skill.content);
+            this.registerPackageResources(storageId, resources, resolvedDir);
+        }
+    }
     /** 手动注册 Skill（全量，含 content） */
     register(skill) {
-        this.manifests.set(skill.id, this.toManifest(skill));
-        this.indexManifest(this.manifests.get(skill.id), skill.id);
+        const manifest = this.toManifest(skill);
+        // 带 packageDir 的物化包：若未携带 resources 清单，自动扫描目录补全过程资源，
+        // 使 list_skill_resources / run_skill_script 能正确枚举脚本与文档（多级嵌套同包各自独立）。
+        if (skill.packageDir && !manifest.resources) {
+            try {
+                manifest.resources = SkillManager.scanPackageResources(skill.packageDir);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        this.manifests.set(skill.id, manifest);
+        this.indexManifest(manifest, skill.id);
         if (skill.content) {
             this.contentCache.set(skill.id, skill.content);
         }
@@ -285,17 +527,95 @@ class SkillManager {
             lazyMode: this.lazy,
         };
     }
+    // ---- Agent Skills 规范：资源访问（Layer3 按需加载） ----
+    /**
+     * 注册 Skill 包的资源清单与根目录（标准目录包形态）。
+     * 供管理端注入运行时 Skill 时调用，或 loadFromDir 扫描目录包时自动调用。
+     */
+    registerPackageResources(skillId, resources, packageDir) {
+        const manifest = this.resolveManifest(skillId);
+        if (!manifest)
+            return;
+        manifest.resources = resources;
+        manifest.packageDir = packageDir;
+    }
+    /** 列出 Skill 的资源清单（无则返回 null） */
+    listResources(skillIdOrName) {
+        const manifest = this.resolveManifest(skillIdOrName);
+        return manifest?.resources ?? null;
+    }
+    /**
+     * 按需加载 Skill 资源文件文本内容（references/ assets/ 等）。
+     * 仅允许读取 packageDir 内的文件，含路径穿越防护。
+     */
+    loadResource(skillIdOrName, resourcePath) {
+        const abs = this.resolveResourcePathByName(skillIdOrName, resourcePath);
+        if (!abs)
+            return null;
+        try {
+            return fs.readFileSync(abs, 'utf-8');
+        }
+        catch (err) {
+            console.warn(`[SkillManager] Failed to load resource "${resourcePath}" for "${skillIdOrName}":`, err?.message);
+            return null;
+        }
+    }
+    /** 获取资源文件绝对路径（供执行/二进制读取），含路径穿越防护 */
+    resolveResourcePathByName(skillIdOrName, resourcePath) {
+        const manifest = this.resolveManifest(skillIdOrName);
+        return this.resolveResourcePath(manifest, resourcePath);
+    }
+    /** 解析脚本绝对路径（scripts/ 下），供脚本执行工具调用 */
+    resolveScriptPath(skillIdOrName, scriptRel) {
+        const rel = scriptRel.startsWith('scripts/') ? scriptRel : `scripts/${scriptRel}`;
+        return this.resolveResourcePath(this.resolveManifest(skillIdOrName), rel);
+    }
+    /** 内部：解析并校验资源路径，确保位于 packageDir 内（防路径穿越） */
+    resolveResourcePath(manifest, resourcePath) {
+        if (!manifest?.packageDir || !resourcePath)
+            return null;
+        const base = path.resolve(manifest.packageDir);
+        const abs = path.resolve(base, resourcePath);
+        // 必须位于包根目录内
+        if (abs !== base && !abs.startsWith(base + path.sep))
+            return null;
+        if (!fs.existsSync(abs))
+            return null;
+        return abs;
+    }
     /** 重新加载（文件变更后刷新） */
     reload() {
         this.manifests.clear();
         this.nameIndex.clear();
         this.contentCache.clear();
+        this.nestedSkillsCache.clear();
         const dirs = [...this.loadedDirs];
         this.loadedDirs = []; // 重置，loadFromDir 会重新填充
         for (const { dir, source, connectorId } of dirs) {
             this.loadFromDir(dir, source, connectorId);
         }
     }
+    /**
+     * 清除嵌套子包缓存
+     * @param packageDir 包目录路径，不传则清除所有缓存
+     */
+    clearNestedSkillsCache(packageDir) {
+        if (packageDir) {
+            this.nestedSkillsCache.delete(packageDir);
+        }
+        else {
+            this.nestedSkillsCache.clear();
+        }
+    }
+    /**
+     * 获取嵌套子包缓存统计信息
+     */
+    getNestedSkillsCacheStats() {
+        return {
+            size: this.nestedSkillsCache.size,
+            keys: Array.from(this.nestedSkillsCache.keys()),
+        };
+    }
     // ---- 内部方法 ----
     /**
      * 从磁盘懒加载 content
@@ -308,12 +628,8 @@ class SkillManager {
             if (!fs.existsSync(manifest.filePath))
                 return '';
             const raw = fs.readFileSync(manifest.filePath, 'utf-8');
-            const normalized = raw.replace(/\r\n/g, '\n');
-            const match = normalized.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
-            if (match) {
-                return match[2].trim();
-            }
-            return raw;
+            const { data, body } = (0, frontmatter_ts_1.parseFrontmatter)(raw);
+            return Object.keys(data).length > 0 ? body.trim() : raw;
         }
         catch (err) {
             console.warn(`[SkillManager] Failed to lazy-load content for "${manifest.id}":`, err?.message);
@@ -349,20 +665,20 @@ class SkillManager {
     }
     /**
      * 仅解析 front matter（不读 content），用于懒加载模式
-     * 通过读取文件前 N 字节提取 YAML front matter，避免加载整个文件
+     * 通过读取文件前 32KB 提取 YAML front matter，避免加载整个文件。
+     * 使用标准解析器，兼容嵌套 map / 多行折叠语法。
      */
     parseManifest(id, filePath, source, connectorId) {
         try {
-            // 只读取文件前 2KB 来提取 front matter
+            // 读取文件前 32KB 提取 front matter（覆盖长 description / metadata 场景）
             const fd = fs.openSync(filePath, 'r');
-            const buf = Buffer.alloc(2048);
-            const bytesRead = fs.readSync(fd, buf, 0, 2048, 0);
+            const buf = Buffer.alloc(32768);
+            const bytesRead = fs.readSync(fd, buf, 0, 32768, 0);
             fs.closeSync(fd);
             const head = buf.toString('utf-8', 0, bytesRead);
-            const normalized = head.replace(/\r\n/g, '\n');
-            const match = normalized.match(/^---\n([\s\S]*?)\n---/);
             const fileSize = fs.statSync(filePath).size;
-            if (!match) {
+            const { data } = (0, frontmatter_ts_1.parseFrontmatter)(head);
+            if (Object.keys(data).length === 0) {
                 // 无 front matter，使用文件名作为 name
                 return {
                     id,
@@ -378,23 +694,9 @@ class SkillManager {
                     ...(connectorId ? { metadata: { connectorId } } : {}),
                 };
             }
-            const fm = match[1];
-            const referencedSkills = this.parseTags(this.extractField(fm, 'referenced_skills') || this.extractField(fm, 'referencedSkills') || '');
-            const manifest = {
-                id,
-                name: this.extractField(fm, 'name') || id,
-                description: this.extractField(fm, 'description') || '',
-                tags: this.parseTags(this.extractField(fm, 'tags') || ''),
-                aliases: this.parseTags(this.extractField(fm, 'aliases') || ''),
-                source,
-                version: this.extractField(fm, 'version') || undefined,
-                author: this.extractField(fm, 'author') || undefined,
-                requires: this.parseTags(this.extractField(fm, 'requires') || ''),
-                referencedSkills: referencedSkills.length > 0 ? referencedSkills : undefined,
-                filePath,
-                contentSize: fileSize,
-                ...(connectorId ? { metadata: { connectorId } } : {}),
-            };
+            const manifest = this.buildManifest(id, data, source, filePath, fileSize);
+            if (connectorId)
+                manifest.metadata = { ...manifest.metadata, connectorId };
             return manifest;
         }
         catch (err) {
@@ -402,12 +704,61 @@ class SkillManager {
             return null;
         }
     }
+    /**
+     * 由解析后的 frontmatter data 构建 SkillManifest（公共逻辑，parse/parseManifest 复用）。
+     * content 字段由调用方按需补充（parse 全量 / parseManifest 仅清单）。
+     */
+    buildManifest(id, data, source, filePath, contentSize) {
+        const metadataMap = (0, frontmatter_ts_1.fmMap)(data, 'metadata');
+        const tags = [...(0, frontmatter_ts_1.fmStringArray)(data, 'tags', 'keywords'), ...(0, frontmatter_ts_1.fmStringArray)(metadataMap ?? {}, 'tags')];
+        const aliases = [...(0, frontmatter_ts_1.fmStringArray)(data, 'aliases'), ...(0, frontmatter_ts_1.fmStringArray)(metadataMap ?? {}, 'aliases')];
+        const requires = (0, frontmatter_ts_1.fmStringArray)(data, 'requires', 'required_mcps');
+        const referencedSkills = (0, frontmatter_ts_1.fmStringArray)(data, 'referenced_skills', 'referencedSkills');
+        const allowedTools = (0, frontmatter_ts_1.fmStringArray)(data, 'allowed-tools', 'allowedTools', 'allowed_tools');
+        const manifest = {
+            id,
+            name: (0, frontmatter_ts_1.fmString)(data, 'name') || id,
+            description: (0, frontmatter_ts_1.fmString)(data, 'description'),
+            tags,
+            aliases,
+            source,
+            version: (0, frontmatter_ts_1.fmString)(data, 'version') || (0, frontmatter_ts_1.fmString)(metadataMap ?? {}, 'version') || undefined,
+            author: (0, frontmatter_ts_1.fmString)(data, 'author') || (0, frontmatter_ts_1.fmString)(metadataMap ?? {}, 'author') || undefined,
+            requires: requires.length ? requires : [],
+            referencedSkills: referencedSkills.length ? referencedSkills : undefined,
+            filePath,
+            contentSize,
+            license: (0, frontmatter_ts_1.fmString)(data, 'license') || undefined,
+            compatibility: (0, frontmatter_ts_1.fmString)(data, 'compatibility') || undefined,
+            allowedTools: allowedTools.length ? allowedTools : undefined,
+        };
+        // 未识别的扩展字段归入 metadata（标准 parser 忽略未知 key，此处保留以便回写）
+        const extra = {};
+        for (const [k, v] of Object.entries(data)) {
+            if (!KNOWN_FM_KEYS.has(k))
+                extra[k] = v;
+        }
+        if (Object.keys(extra).length)
+            manifest.metadata = extra;
+        return manifest;
+    }
     /** 解析完整的 Markdown 文件（含 content），用于兼容模式 */
     parse(id, raw, source) {
         // 统一行尾为 \n（兼容 Windows CRLF）
         const normalized = raw.replace(/\r\n/g, '\n');
-        const match = normalized.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
-        if (!match) {
+        let { data, body } = (0, frontmatter_ts_1.parseFrontmatter)(normalized);
+        // 检测双重 frontmatter（旧版 createSkillFromFile 产生的问题）
+        const doubleMatch = body.match(/^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/);
+        if (doubleMatch) {
+            const fm1Fields = Object.keys(data).length;
+            const fm2Fields = doubleMatch[1].split('\n').filter(l => /^\w+:/.test(l)).length;
+            if (fm2Fields > fm1Fields) {
+                const reparsed = (0, frontmatter_ts_1.parseFrontmatter)(body);
+                data = reparsed.data;
+                body = reparsed.body;
+            }
+        }
+        if (Object.keys(data).length === 0) {
             return {
                 id,
                 name: id,
@@ -419,52 +770,9 @@ class SkillManager {
                 requires: [],
             };
         }
-        let frontMatter = match[1];
-        let content = match[2].trim();
-        // 检测双重 frontmatter（旧版 createSkillFromFile 产生的问题）
-        const doubleMatch = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
-        if (doubleMatch) {
-            const fm1Fields = frontMatter.split('\n').filter(l => /^\w+:/.test(l)).length;
-            const fm2Fields = doubleMatch[1].split('\n').filter(l => /^\w+:/.test(l)).length;
-            if (fm2Fields > fm1Fields) {
-                frontMatter = doubleMatch[1];
-                content = doubleMatch[2].trim();
-            }
-        }
-        return {
-            id,
-            name: this.extractField(frontMatter, 'name') || id,
-            description: this.extractField(frontMatter, 'description') || '',
-            tags: this.parseTags(this.extractField(frontMatter, 'tags') || ''),
-            aliases: this.parseTags(this.extractField(frontMatter, 'aliases') || ''),
-            content,
-            source,
-            version: this.extractField(frontMatter, 'version') || undefined,
-            author: this.extractField(frontMatter, 'author') || undefined,
-            requires: this.parseTags(this.extractField(frontMatter, 'requires') || ''),
-            referencedSkills: this.parseReferencedSkills(frontMatter),
-        };
-    }
-    /** 解析 referenced_skills 字段 */
-    parseReferencedSkills(frontMatter) {
-        const raw = this.extractField(frontMatter, 'referenced_skills') || this.extractField(frontMatter, 'referencedSkills') || '';
-        const tags = this.parseTags(raw);
-        return tags.length > 0 ? tags : undefined;
-    }
-    extractField(frontMatter, field) {
-        const regex = new RegExp(`^${field}:\\s*(.+)$`, 'm');
-        const match = frontMatter.match(regex);
-        return match ? match[1].trim() : '';
-    }
-    parseTags(raw) {
-        // 支持 [tag1, tag2] 和 tag1, tag2 两种格式
-        const cleaned = raw.replace(/^\[|\]$/g, '');
-        if (!cleaned.trim())
-            return [];
-        return cleaned
-            .split(',')
-            .map((t) => t.trim())
-            .filter(Boolean);
+        const content = body.trim();
+        const manifest = this.buildManifest(id, data, source, undefined, content.length);
+        return { ...manifest, content };
     }
 }
 exports.SkillManager = SkillManager;