@ai-setting/roy-agent-cli 1.3.15 → 1.3.17

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

@@ -0,0 +1,304 @@
+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

@@ -0,0 +1,20 @@
+/**
+ * @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

@@ -0,0 +1,33 @@
+/**
+ * @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

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

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

@@ -0,0 +1,164 @@
+/**
+ * @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

@@ -0,0 +1,8 @@
+/**
+ * @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

@@ -0,0 +1,8 @@
+/**
+ * @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

@@ -0,0 +1,19 @@
+/**
+ * @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

@@ -0,0 +1,97 @@
+/**
+ * @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

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