@ai-setting/roy-agent-cli 1.3.18 → 1.3.22

package/dist/core/src/env/commands/commands-component.test.js

@@ -1,304 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { CommandsComponent } from "./commands-component.js";
-import * as fs from "fs/promises";
-import * as path from "path";
-import * as os from "os";
-/**
- * 创建 Mock ConfigComponent
- */
-function createMockConfigComponent(initialConfig = {}) {
-    const storage = new Map(Object.entries(initialConfig));
-    return {
-        get(key) {
-            return storage.get(key);
-        },
-        set(key, value) {
-            storage.set(key, value);
-        },
-        has(key) {
-            return storage.has(key);
-        },
-        delete(key) {
-            return storage.delete(key);
-        },
-        clear() {
-            storage.clear();
-        },
-        getAll() {
-            return Object.fromEntries(storage);
-        },
-        registerComponent: vi.fn(),
-        registerSource: vi.fn(),
-        load: vi.fn().mockResolvedValue(undefined),
-        getSources: vi.fn().mockReturnValue([]),
-        ensureSourcesCreated: vi.fn(),
-    };
-}
-describe("CommandsComponent", () => {
-    let component;
-    let tempDir;
-    let userCommandsDir;
-    let projectCommandsDir;
-    let mockConfigComponent;
-    beforeEach(async () => {
-        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "roy-commands-test-"));
-        userCommandsDir = path.join(tempDir, "user-commands");
-        projectCommandsDir = path.join(tempDir, "project-commands");
-        await fs.mkdir(userCommandsDir);
-        await fs.mkdir(projectCommandsDir);
-        component = new CommandsComponent();
-        // 确保 mockConfigComponent 预先设置了命令目录配置
-        // 避免测试污染真实的 ~/.roy-agent/commands 目录
-        mockConfigComponent = createMockConfigComponent({
-            "command.userCommandsDir": userCommandsDir,
-            "command.projectCommandsDir": projectCommandsDir,
-        });
-    });
-    afterEach(async () => {
-        await fs.rm(tempDir, { recursive: true, force: true });
-    });
-    describe("init", () => {
-        it("should initialize with config from ConfigComponent", async () => {
-            // 验证 mockConfigComponent 的配置被正确应用
-            await component.init({
-                name: "commands",
-                version: "1.0.0",
-                enabled: true,
-                options: {
-                    configComponent: mockConfigComponent,
-                },
-            });
-            const dirs = await component.getCommandDirs();
-            // 验证使用 mockConfigComponent 中预设的配置（临时目录）
-            expect(dirs.user).toBe(userCommandsDir);
-            expect(dirs.project).toBe(projectCommandsDir);
-        });
-        it("should use config from options object", async () => {
-            await component.init({
-                name: "commands",
-                version: "1.0.0",
-                enabled: true,
-                options: {
-                    configComponent: mockConfigComponent,
-                    config: {
-                        userCommandsDir,
-                        projectCommandsDir,
-                    },
-                },
-            });
-            const dirs = await component.getCommandDirs();
-            expect(dirs.user).toBe(userCommandsDir);
-            expect(dirs.project).toBe(projectCommandsDir);
-        });
-        it("should use config from ConfigComponent", async () => {
-            mockConfigComponent.set("command.userCommandsDir", userCommandsDir);
-            mockConfigComponent.set("command.projectCommandsDir", projectCommandsDir);
-            await component.init({
-                name: "commands",
-                version: "1.0.0",
-                enabled: true,
-                options: {
-                    configComponent: mockConfigComponent,
-                },
-            });
-            const dirs = await component.getCommandDirs();
-            expect(dirs.user).toBe(userCommandsDir);
-            expect(dirs.project).toBe(projectCommandsDir);
-        });
-        it("should throw error without ConfigComponent", async () => {
-            await expect(component.init({
-                name: "commands",
-                version: "1.0.0",
-                enabled: true,
-            })).rejects.toThrow("ConfigComponent is required");
-        });
-    });
-    describe("discover", () => {
-        beforeEach(async () => {
-            mockConfigComponent.set("command.userCommandsDir", userCommandsDir);
-            mockConfigComponent.set("command.projectCommandsDir", projectCommandsDir);
-            await component.init({
-                name: "commands",
-                version: "1.0.0",
-                enabled: true,
-                options: {
-                    configComponent: mockConfigComponent,
-                },
-            });
-        });
-        it("should return empty list when no commands exist", async () => {
-            const result = await component.discover();
-            expect(result.commands).toEqual([]);
-            expect(result.stats.userCount).toBe(0);
-            expect(result.stats.projectCount).toBe(0);
-        });
-        it("should discover commands from user directory", async () => {
-            const testScript = path.join(userCommandsDir, "test-cmd");
-            await fs.writeFile(testScript, "#!/bin/bash\necho hello", { mode: 0o755 });
-            const result = await component.discover();
-            expect(result.commands.length).toBe(1);
-            expect(result.commands[0].name).toBe("test-cmd");
-            expect(result.commands[0].source).toBe("user");
-            expect(result.stats.userCount).toBe(1);
-        });
-        it("should discover commands from project directory", async () => {
-            const testScript = path.join(projectCommandsDir, "project-cmd");
-            await fs.writeFile(testScript, "#!/bin/bash\necho project", { mode: 0o755 });
-            const result = await component.discover();
-            expect(result.commands.length).toBe(1);
-            expect(result.commands[0].name).toBe("project-cmd");
-            expect(result.commands[0].source).toBe("project");
-            expect(result.stats.projectCount).toBe(1);
-        });
-        it("should deduplicate and prefer project commands", async () => {
-            const userCmd = path.join(userCommandsDir, "duplicate");
-            await fs.writeFile(userCmd, "#!/bin/bash\necho user", { mode: 0o755 });
-            const projectCmd = path.join(projectCommandsDir, "duplicate");
-            await fs.writeFile(projectCmd, "#!/bin/bash\necho project", { mode: 0o755 });
-            const result = await component.discover();
-            expect(result.commands.length).toBe(1);
-            expect(result.commands[0].source).toBe("project");
-        });
-        it("should filter by glob pattern", async () => {
-            await fs.writeFile(path.join(userCommandsDir, "git-status"), "#!/bin/bash", { mode: 0o755 });
-            await fs.writeFile(path.join(userCommandsDir, "npm-ci"), "#!/bin/bash", { mode: 0o755 });
-            await fs.writeFile(path.join(userCommandsDir, "git-log"), "#!/bin/bash", { mode: 0o755 });
-            const result = await component.discover({ pattern: "git*" });
-            expect(result.commands.length).toBe(2);
-            expect(result.commands.map((c) => c.name).sort()).toEqual(["git-log", "git-status"]);
-        });
-        it("should skip hidden files", async () => {
-            await fs.writeFile(path.join(userCommandsDir, ".hidden"), "#!/bin/bash", { mode: 0o755 });
-            await fs.writeFile(path.join(userCommandsDir, "visible"), "#!/bin/bash", { mode: 0o755 });
-            const result = await component.discover();
-            expect(result.commands.length).toBe(1);
-            expect(result.commands[0].name).toBe("visible");
-        });
-    });
-    describe("add", () => {
-        beforeEach(async () => {
-            mockConfigComponent.set("command.userCommandsDir", userCommandsDir);
-            mockConfigComponent.set("command.projectCommandsDir", projectCommandsDir);
-            await component.init({
-                name: "commands",
-                version: "1.0.0",
-                enabled: true,
-                options: {
-                    configComponent: mockConfigComponent,
-                },
-            });
-        });
-        it("should add command to user directory by default", async () => {
-            await component.add({
-                name: "test-cmd",
-                target: "/usr/bin/echo",
-            });
-            const exists = await fs
-                .access(path.join(userCommandsDir, "test-cmd"))
-                .then(() => true)
-                .catch(() => false);
-            expect(exists).toBe(true);
-            const stat = await fs.lstat(path.join(userCommandsDir, "test-cmd"));
-            expect(stat.isSymbolicLink()).toBe(true);
-        });
-        it("should add command to project directory when specified", async () => {
-            await component.add({
-                name: "test-project-cmd",
-                target: "/usr/bin/echo",
-                source: "project",
-            });
-            const exists = await fs
-                .access(path.join(projectCommandsDir, "test-project-cmd"))
-                .then(() => true)
-                .catch(() => false);
-            expect(exists).toBe(true);
-        });
-        it("should throw error when command already exists", async () => {
-            await component.add({ name: "existing", target: "/usr/bin/echo" });
-            await expect(component.add({ name: "existing", target: "/usr/bin/cat" })).rejects.toThrow("already exists");
-        });
-    });
-    describe("remove", () => {
-        beforeEach(async () => {
-            mockConfigComponent.set("command.userCommandsDir", userCommandsDir);
-            mockConfigComponent.set("command.projectCommandsDir", projectCommandsDir);
-            await component.init({
-                name: "commands",
-                version: "1.0.0",
-                enabled: true,
-                options: {
-                    configComponent: mockConfigComponent,
-                },
-            });
-        });
-        it("should remove command from user directory", async () => {
-            await component.add({ name: "remove-me", target: "/usr/bin/echo" });
-            await component.remove({ name: "remove-me" });
-            const exists = await fs
-                .access(path.join(userCommandsDir, "remove-me"))
-                .then(() => true)
-                .catch(() => false);
-            expect(exists).toBe(false);
-        });
-        it("should throw error when command not found", async () => {
-            await expect(component.remove({ name: "nonexistent" })).rejects.toThrow("not found");
-        });
-    });
-    describe("getInfo", () => {
-        beforeEach(async () => {
-            mockConfigComponent.set("command.userCommandsDir", userCommandsDir);
-            mockConfigComponent.set("command.projectCommandsDir", projectCommandsDir);
-            await component.init({
-                name: "commands",
-                version: "1.0.0",
-                enabled: true,
-                options: {
-                    configComponent: mockConfigComponent,
-                },
-            });
-        });
-        it("should return command info", async () => {
-            await component.add({ name: "info-test", target: "/usr/bin/echo" });
-            const info = await component.getInfo("info-test");
-            expect(info).not.toBeNull();
-            expect(info.name).toBe("info-test");
-            expect(info.source).toBe("user");
-        });
-        it("should return null for nonexistent command", async () => {
-            const info = await component.getInfo("nonexistent");
-            expect(info).toBeNull();
-        });
-    });
-    describe("exec", () => {
-        beforeEach(async () => {
-            mockConfigComponent.set("command.userCommandsDir", userCommandsDir);
-            mockConfigComponent.set("command.projectCommandsDir", projectCommandsDir);
-            await component.init({
-                name: "commands",
-                version: "1.0.0",
-                enabled: true,
-                options: {
-                    configComponent: mockConfigComponent,
-                },
-            });
-        });
-        it("should execute command with args", async () => {
-            await component.add({ name: "my-echo", target: "/bin/echo" });
-            const result = await component.exec({
-                name: "my-echo",
-                args: ["hello", "world"],
-            });
-            expect(result.success).toBe(true);
-            expect(result.stdout.trim()).toBe("hello world");
-        });
-        it("should return error for nonexistent command", async () => {
-            const result = await component.exec({
-                name: "nonexistent-command-xyz",
-                args: [],
-            });
-            expect(result.success).toBe(false);
-            expect(result.exitCode).toBe(127);
-        });
-    });
-});
-//# sourceMappingURL=commands-component.test.js.map

package/dist/core/src/env/commands/commands-config-registration.d.ts

@@ -1,20 +0,0 @@
-/**
- * @fileoverview Commands Component 配置注册
- *
- * 使用 ConfigComponent.registerComponent() 机制统一管理配置
- */
-import type { ComponentRegistration } from "../../config/config-component";
-/**
- * Commands Component 默认配置值（占位，实际值在 registerConfig 中动态设置）
- *
- * 注意：这些默认值在 CommandsComponent.registerConfig() 中
- * 通过 configComponent.set() 设置到 ConfigComponent，使用基于 HOME 的绝对路径
- */
-export declare const COMMANDS_DEFAULTS: Record<string, unknown>;
-/**
- * Commands Component 配置注册常量
- *
- * 定义了所有 Commands 相关的配置项和来源
- */
-export declare const COMMANDS_CONFIG_REGISTRATION: ComponentRegistration;
-//# sourceMappingURL=commands-config-registration.d.ts.map

package/dist/core/src/env/commands/commands-config-registration.js

@@ -1,33 +0,0 @@
-/**
- * @fileoverview Commands Component 配置注册
- *
- * 使用 ConfigComponent.registerComponent() 机制统一管理配置
- */
-/**
- * Commands Component 默认配置值（占位，实际值在 registerConfig 中动态设置）
- *
- * 注意：这些默认值在 CommandsComponent.registerConfig() 中
- * 通过 configComponent.set() 设置到 ConfigComponent，使用基于 HOME 的绝对路径
- */
-export const COMMANDS_DEFAULTS = {
-    "command.userCommandsDir": undefined, // 动态设置：${HOME}/.roy-agent/commands
-    "command.projectCommandsDir": undefined, // 动态设置：${cwd}/.roy/commands
-    "command.cacheDir": undefined, // 动态设置：${HOME}/.cache/roy-agent/commands
-};
-/**
- * Commands Component 配置注册常量
- *
- * 定义了所有 Commands 相关的配置项和来源
- */
-export const COMMANDS_CONFIG_REGISTRATION = {
-    name: "command",
-    sources: [
-        { type: "env", envPrefix: "COMMAND", priority: 20, watch: false },
-    ],
-    keys: [
-        { key: "command.userCommandsDir", sources: ["env", "file"] },
-        { key: "command.projectCommandsDir", sources: ["env", "file"] },
-        { key: "command.cacheDir", sources: ["env", "file"] },
-    ],
-};
-//# sourceMappingURL=commands-config-registration.js.map

package/dist/core/src/env/commands/commands-config-registration.test.d.ts

@@ -1,7 +0,0 @@
-/**
- * @fileoverview Commands Component 配置注册测试
- *
- * TDD: 先写测试，验证配置注册机制
- */
-export {};
-//# sourceMappingURL=commands-config-registration.test.d.ts.map

package/dist/core/src/env/commands/commands-config-registration.test.js

@@ -1,164 +0,0 @@
-/**
- * @fileoverview Commands Component 配置注册测试
- *
- * TDD: 先写测试，验证配置注册机制
- */
-import { describe, it, expect, beforeEach } from "vitest";
-import os from "os";
-import path from "path";
-import { ConfigComponent } from "../../config/config-component.js";
-import { CommandsComponent } from "./commands-component.js";
-import { COMMANDS_CONFIG_REGISTRATION, COMMANDS_DEFAULTS } from "./commands-config-registration.js";
-describe("Commands Config Registration", () => {
-    let configComponent;
-    let component;
-    beforeEach(() => {
-        configComponent = new ConfigComponent();
-        component = new CommandsComponent();
-    });
-    describe("COMMANDS_CONFIG_REGISTRATION", () => {
-        it("应该包含正确的 name", () => {
-            expect(COMMANDS_CONFIG_REGISTRATION.name).toBe("command");
-        });
-        it("应该包含 env source 配置", () => {
-            const envSource = COMMANDS_CONFIG_REGISTRATION.sources.find((s) => s.type === "env");
-            expect(envSource).toBeDefined();
-            expect(envSource?.envPrefix).toBe("COMMAND");
-            expect(envSource?.priority).toBe(20);
-        });
-        it("应该包含所有配置 keys", () => {
-            const keys = COMMANDS_CONFIG_REGISTRATION.keys;
-            expect(keys).toContainEqual(expect.objectContaining({ key: "command.userCommandsDir" }));
-            expect(keys).toContainEqual(expect.objectContaining({ key: "command.projectCommandsDir" }));
-            expect(keys).toContainEqual(expect.objectContaining({ key: "command.cacheDir" }));
-        });
-    });
-    describe("COMMANDS_DEFAULTS", () => {
-        it("应该包含 userCommandsDir 键（动态默认值在 registerConfig 中设置）", () => {
-            expect("command.userCommandsDir" in COMMANDS_DEFAULTS).toBe(true);
-        });
-        it("应该包含 projectCommandsDir 键（动态默认值在 registerConfig 中设置）", () => {
-            expect("command.projectCommandsDir" in COMMANDS_DEFAULTS).toBe(true);
-        });
-        it("应该包含 cacheDir 键（动态默认值在 registerConfig 中设置）", () => {
-            expect("command.cacheDir" in COMMANDS_DEFAULTS).toBe(true);
-        });
-    });
-    describe("配置注册到 ConfigComponent", () => {
-        it("应该能够注册 COMMANDS_CONFIG_REGISTRATION", () => {
-            configComponent.registerComponent(COMMANDS_CONFIG_REGISTRATION);
-            expect(() => configComponent.registerComponent(COMMANDS_CONFIG_REGISTRATION)).not.toThrow();
-        });
-        // 注意：defaults 字段已被移除，默认值通过 configComponent.set() 在 registerConfig 中设置
-        it("注册后 keys 应该被注册（默认值需要通过 configComponent.set() 设置）", async () => {
-            configComponent.registerComponent(COMMANDS_CONFIG_REGISTRATION);
-            await configComponent.load();
-            // 注意：默认值需要通过 configComponent.set() 设置，不会自动加载
-            // 但 keys 已注册
-            expect(configComponent.get("command.userCommandsDir")).toBeUndefined();
-        });
-    });
-    describe("Component 配置加载", () => {
-        it("应该需要 ConfigComponent 初始化", async () => {
-            await expect(component.init({
-                options: {},
-            })).rejects.toThrow("ConfigComponent is required");
-        });
-        it("应该能够使用 ConfigComponent 初始化", async () => {
-            await component.init({
-                options: {
-                    configComponent,
-                },
-            });
-            expect(component.name).toBe("commands");
-            expect(component.version).toBe("2.0.0");
-        });
-        it("应该能够通过 config 对象传入配置", async () => {
-            // 使用 tmpdir 作为测试路径
-            const tmpDir = os.tmpdir();
-            await component.init({
-                options: {
-                    configComponent,
-                    config: {
-                        userCommandsDir: path.join(tmpDir, "test-user-commands"),
-                        projectCommandsDir: path.join(tmpDir, "test-project-commands"),
-                    },
-                },
-            });
-            expect(component.name).toBe("commands");
-        });
-    });
-    describe("环境变量覆盖", () => {
-        it("应该能够通过环境变量覆盖配置", async () => {
-            // 设置环境变量（使用有效的 tmp 路径）
-            const originalValue = process.env.COMMAND_COMMAND_USER_COMMANDS_DIR;
-            const tmpPath = path.join(os.tmpdir(), "test-env-path");
-            process.env.COMMAND_COMMAND_USER_COMMANDS_DIR = tmpPath;
-            try {
-                await component.init({
-                    options: {
-                        configComponent,
-                    },
-                });
-                expect(component.name).toBe("commands");
-            }
-            finally {
-                // 恢复环境变量
-                if (originalValue !== undefined) {
-                    process.env.COMMAND_COMMAND_USER_COMMANDS_DIR = originalValue;
-                }
-                else {
-                    delete process.env.COMMAND_COMMAND_USER_COMMANDS_DIR;
-                }
-            }
-        });
-        it("环境变量应该能够覆盖默认值", async () => {
-            const originalValue = process.env.COMMAND_COMMAND_USER_COMMANDS_DIR;
-            const tmpPath = path.join(os.tmpdir(), "env-override-test");
-            process.env.COMMAND_COMMAND_USER_COMMANDS_DIR = tmpPath;
-            try {
-                // 创建新 component 来使用新的环境变量
-                const newComponent = new CommandsComponent();
-                await newComponent.init({
-                    options: {
-                        configComponent,
-                    },
-                });
-                // 环境变量应该覆盖默认值
-                // 注意：在 CommandsComponent.init 中，registerConfig 会在 load 之后再次设置环境变量
-                expect(configComponent.get("command.userCommandsDir")).toBe(tmpPath);
-            }
-            finally {
-                if (originalValue !== undefined) {
-                    process.env.COMMAND_COMMAND_USER_COMMANDS_DIR = originalValue;
-                }
-                else {
-                    delete process.env.COMMAND_COMMAND_USER_COMMANDS_DIR;
-                }
-            }
-        });
-    });
-    describe("ConfigComponent.registerComponent 模式集成", () => {
-        it("初始化后 ConfigComponent 应该包含命令配置", async () => {
-            await component.init({
-                options: {
-                    configComponent,
-                },
-            });
-            // 验证 ConfigComponent 有命令相关配置
-            const value = configComponent.get("command.userCommandsDir");
-            expect(value).toBeDefined();
-            expect(typeof value).toBe("string");
-        });
-        it("registerComponent 注册后应该能通过 load 获取已配置的 keys", async () => {
-            // 直接使用 registerComponent 和 load 验证模式
-            configComponent.registerComponent(COMMANDS_CONFIG_REGISTRATION);
-            await configComponent.load("command");
-            // 注意：默认值不会自动加载，需要通过 configComponent.set() 设置
-            // 验证 keys 已注册（从 ConfigComponent 获取会返回 undefined）
-            const userDir = configComponent.get("command.userCommandsDir");
-            expect(userDir).toBeUndefined(); // 默认值未设置
-        });
-    });
-});
-//# sourceMappingURL=commands-config-registration.test.js.map

package/dist/core/src/env/commands/index.d.ts

@@ -1,8 +0,0 @@
-/**
- * @fileoverview Commands Component Module
- *
- * 导出 CommandsComponent 及其类型
- */
-export { CommandsComponent } from "./commands-component";
-export type { CommandsComponentOptions, CommandsComponentConfig, CommandSource, CommandIndex, ScanResult, DiscoverOptions, AddCommandOptions, RemoveCommandOptions, ExecutionResult, } from "./types";
-//# sourceMappingURL=index.d.ts.map

package/dist/core/src/env/commands/index.js

@@ -1,8 +0,0 @@
-/**
- * @fileoverview Commands Component Module
- *
- * 导出 CommandsComponent 及其类型
- */
-// Component
-export { CommandsComponent } from "./commands-component.js";
-//# sourceMappingURL=index.js.map

package/dist/core/src/env/commands/parser.d.ts

@@ -1,19 +0,0 @@
-/**
- * @fileoverview Command Meta.md Parser
- *
- * 解析命令目录下的 meta.md 文件，提取 Frontmatter 元信息
- */
-import type { CommandMeta, CommandSource } from "./types";
-/**
- * 解析 frontmatter 文本
- */
-export declare function parseFrontmatter(text: string): Record<string, string>;
-/**
- * 解析单个 meta.md 文件
- */
-export declare function parseMetaFile(filePath: string, source: CommandSource): Promise<CommandMeta | null>;
-/**
- * 扫描目录下的所有 meta.md 文件
- */
-export declare function scanMetaFiles(dirPath: string, source: CommandSource): Promise<CommandMeta[]>;
-//# sourceMappingURL=parser.d.ts.map

package/dist/core/src/env/commands/parser.js

@@ -1,97 +0,0 @@
-/**
- * @fileoverview Command Meta.md Parser
- *
- * 解析命令目录下的 meta.md 文件，提取 Frontmatter 元信息
- */
-import fs from "fs/promises";
-import path from "path";
-import { createLogger } from "../log-trace/logger.js";
-const logger = createLogger("commands-parser");
-/**
- * 解析 frontmatter 文本
- */
-export function parseFrontmatter(text) {
-    const result = {};
-    const lines = text.split("\n");
-    for (const line of lines) {
-        // 匹配 key: value 格式
-        const match = line.match(/^(\w+):\s*"?(.+?)"?\s*$/);
-        if (match) {
-            const key = match[1];
-            let value = match[2];
-            // 移除首尾引号
-            if (value.startsWith('"') && value.endsWith('"')) {
-                value = value.slice(1, -1);
-            }
-            result[key] = value;
-        }
-    }
-    return result;
-}
-/**
- * 解析单个 meta.md 文件
- */
-export async function parseMetaFile(filePath, source) {
-    try {
-        const content = await fs.readFile(filePath, "utf-8");
-        // 匹配 frontmatter: --- ... ---
-        const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n?/);
-        if (!frontmatterMatch) {
-            logger.warn(`[Parser] Missing frontmatter in: ${filePath}`);
-            return null;
-        }
-        const frontmatter = parseFrontmatter(frontmatterMatch[1]);
-        const name = frontmatter.name;
-        const description = frontmatter.description;
-        if (!name) {
-            logger.warn(`[Parser] Missing name in frontmatter: ${filePath}`);
-            return null;
-        }
-        if (!description) {
-            logger.warn(`[Parser] Missing description in frontmatter: ${filePath}`);
-            return null;
-        }
-        return {
-            name,
-            description,
-            tips: frontmatter.tips,
-            filePath,
-            source,
-        };
-    }
-    catch (error) {
-        logger.error(`[Parser] Failed to parse file: ${filePath}`, error);
-        return null;
-    }
-}
-/**
- * 扫描目录下的所有 meta.md 文件
- */
-export async function scanMetaFiles(dirPath, source) {
-    try {
-        const entries = await fs.readdir(dirPath, { withFileTypes: true });
-        const metaList = [];
-        for (const entry of entries) {
-            // 跳过隐藏文件和目录
-            if (entry.name.startsWith("."))
-                continue;
-            if (entry.isFile() && entry.name === "meta.md") {
-                const metaFilePath = path.join(dirPath, entry.name);
-                const meta = await parseMetaFile(metaFilePath, source);
-                if (meta) {
-                    metaList.push(meta);
-                }
-            }
-        }
-        return metaList;
-    }
-    catch (error) {
-        // 目录不存在时返回空数组
-        if (error.code === "ENOENT") {
-            return [];
-        }
-        logger.error(`[Parser] Failed to scan directory: ${dirPath}`, error);
-        return [];
-    }
-}
-//# sourceMappingURL=parser.js.map

package/dist/core/src/env/commands/parser.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=parser.test.d.ts.map