@ai-setting/roy-agent-cli 1.3.14 → 1.3.16

package/dist/core/src/env/environment-lifecycle.test.js

@@ -0,0 +1,391 @@
+/**
+ * @fileoverview Environment Lifecycle Integration Tests
+ *
+ * 测试 Environment 生命周期中组件 start() 方法的正确调用
+ *
+ * 背景：依赖 start() 生命周期钩子的组件（如 TaskComponent, MemoryComponent）
+ * 需要在 start() 中注册工具到 ToolComponent
+ *
+ * 验收标准：
+ * 1. env.start() 必须在 env.init() 之后被调用
+ * 2. TaskComponent.start() 必须被调用并注册 task tools
+ * 3. MemoryComponent.start() 必须被调用并注册 memory tools
+ * 4. AgentComponent 能从 ToolComponent 获取到这些工具
+ */
+import { describe, it, expect, vi } from "vitest";
+import { BaseEnvironment } from "./environment.js";
+import { BaseComponent } from "./component.js";
+class MockToolComponent extends BaseComponent {
+    name = "tool";
+    version = "1.0.0";
+    tools = new Map();
+    // Track calls for verification
+    calls = {
+        init: 0,
+        start: 0,
+        stop: 0,
+        register: [],
+        unregister: [],
+    };
+    async onInit() {
+        this.calls.init++;
+    }
+    async onStart() {
+        this.calls.start++;
+    }
+    async onStop() {
+        this.calls.stop++;
+    }
+    register(tool) {
+        this.tools.set(tool.name, tool);
+        this.calls.register.push(tool.name);
+    }
+    unregister(name) {
+        this.tools.delete(name);
+        this.calls.unregister.push(name);
+    }
+    getTool(name) {
+        return this.tools.get(name);
+    }
+    listTools() {
+        return Array.from(this.tools.values());
+    }
+    getToolCount() {
+        return this.tools.size;
+    }
+}
+// ============================================================================
+// Mock TaskComponent (依赖 start() 注册工具)
+// ============================================================================
+class MockTaskComponent extends BaseComponent {
+    name = "task";
+    version = "1.0.0";
+    toolComponent;
+    // Track lifecycle
+    calls = {
+        init: 0,
+        start: 0,
+        stop: 0,
+        registerTools: 0,
+    };
+    // Expected tools that should be registered
+    static EXPECTED_TOOLS = [
+        "task_create",
+        "task_get",
+        "task_list",
+        "task_update",
+        "task_delete",
+        "task_complete",
+        "operation_create",
+        "operation_get",
+        "operation_list",
+        "operation_update",
+        "operation_delete",
+        "task_delegate",
+        "task_stop",
+    ];
+    async onInit() {
+        this.calls.init++;
+    }
+    async onStart() {
+        this.calls.start++;
+        // 获取 ToolComponent（必须在 start() 中获取，因为此时其他组件已初始化）
+        if (this.env) {
+            this.toolComponent = this.env.getComponent("tool");
+        }
+        if (this.toolComponent) {
+            await this.registerTools();
+        }
+    }
+    async onStop() {
+        this.calls.stop++;
+    }
+    async registerTools() {
+        if (!this.toolComponent)
+            return;
+        this.calls.registerTools++;
+        // 注册所有 task tools
+        for (const toolName of MockTaskComponent.EXPECTED_TOOLS) {
+            this.toolComponent.register({
+                name: toolName,
+                description: `Task tool: ${toolName}`,
+                execute: vi.fn(),
+            });
+        }
+    }
+}
+// ============================================================================
+// Mock MemoryComponent (依赖 start() 注册工具)
+// ============================================================================
+class MockMemoryComponent extends BaseComponent {
+    name = "memory";
+    version = "1.0.0";
+    toolComponent;
+    // Track lifecycle
+    calls = {
+        init: 0,
+        start: 0,
+        stop: 0,
+        registerTools: 0,
+    };
+    // Expected tools that should be registered
+    static EXPECTED_TOOLS = [
+        "record_memory",
+        "recall_memory",
+    ];
+    async onInit() {
+        this.calls.init++;
+    }
+    async onStart() {
+        this.calls.start++;
+        // 获取 ToolComponent
+        if (this.env) {
+            this.toolComponent = this.env.getComponent("tool");
+        }
+        if (this.toolComponent) {
+            await this.registerTools();
+        }
+    }
+    async onStop() {
+        this.calls.stop++;
+    }
+    async registerTools() {
+        if (!this.toolComponent)
+            return;
+        this.calls.registerTools++;
+        // 注册所有 memory tools
+        for (const toolName of MockMemoryComponent.EXPECTED_TOOLS) {
+            this.toolComponent.register({
+                name: toolName,
+                description: `Memory tool: ${toolName}`,
+                execute: vi.fn(),
+            });
+        }
+    }
+}
+// ============================================================================
+// Mock AgentComponent (用于验证工具可用性)
+// ============================================================================
+class MockAgentComponent extends BaseComponent {
+    name = "agent";
+    version = "1.0.0";
+    toolComponent;
+    llmComponent;
+    async onInit() {
+        // AgentComponent 的初始化逻辑
+    }
+    refreshDependencies() {
+        if (this.env) {
+            this.toolComponent = this.env.getComponent("tool");
+            this.llmComponent = this.env.getComponent("llm");
+        }
+    }
+    getAvailableTools() {
+        if (!this.toolComponent)
+            return [];
+        return this.toolComponent.listTools();
+    }
+}
+// ============================================================================
+// Mock ConfigComponent
+// ============================================================================
+class MockConfigComponent extends BaseComponent {
+    name = "config";
+    version = "1.0.0";
+    async onInit() {
+        // ConfigComponent 初始化
+    }
+}
+// ============================================================================
+// Tests
+// ============================================================================
+describe("Environment Lifecycle - Component start() invocation", () => {
+    describe("Complete lifecycle: init() + start()", () => {
+        it("should call start() to register tools from TaskComponent and MemoryComponent", async () => {
+            // 创建环境
+            const env = new BaseEnvironment({ name: "test-env" });
+            // 创建并注册 mock components
+            const toolComponent = new MockToolComponent();
+            const taskComponent = new MockTaskComponent();
+            const memoryComponent = new MockMemoryComponent();
+            const agentComponent = new MockAgentComponent();
+            env.registerComponent(toolComponent);
+            env.registerComponent(taskComponent);
+            env.registerComponent(memoryComponent);
+            env.registerComponent(agentComponent);
+            // 调用完整的生命周期：init() + start()
+            await env.init();
+            await env.start();
+            // 验证：init() 和 start() 都被调用
+            expect(taskComponent.calls.init).toBe(1);
+            expect(taskComponent.calls.start).toBe(1);
+            expect(memoryComponent.calls.init).toBe(1);
+            expect(memoryComponent.calls.start).toBe(1);
+            // 验证：工具被注册
+            expect(taskComponent.calls.registerTools).toBe(1);
+            expect(memoryComponent.calls.registerTools).toBe(1);
+            // 验证：ToolComponent 收到注册
+            const expectedToolCount = MockTaskComponent.EXPECTED_TOOLS.length + MockMemoryComponent.EXPECTED_TOOLS.length;
+            expect(toolComponent.calls.register).toHaveLength(expectedToolCount);
+            // 验证：AgentComponent 能获取到工具
+            agentComponent.refreshDependencies();
+            const availableTools = agentComponent.getAvailableTools();
+            expect(availableTools.length).toBe(expectedToolCount);
+            // 验证：包含所有 task tools
+            for (const toolName of MockTaskComponent.EXPECTED_TOOLS) {
+                expect(availableTools.find(t => t.name === toolName)).toBeDefined();
+            }
+            // 验证：包含所有 memory tools
+            for (const toolName of MockMemoryComponent.EXPECTED_TOOLS) {
+                expect(availableTools.find(t => t.name === toolName)).toBeDefined();
+            }
+            // 清理
+            await env.stop();
+        });
+    });
+    describe("Component initialization order", () => {
+        it("should initialize ConfigComponent first, then other components", async () => {
+            const env = new BaseEnvironment({ name: "test-env" });
+            const initOrder = [];
+            class TrackedComponent extends BaseComponent {
+                name;
+                constructor(name) {
+                    super();
+                    this.name = name;
+                }
+                async onInit() {
+                    initOrder.push(`init:${this.name}`);
+                }
+                async onStart() {
+                    initOrder.push(`start:${this.name}`);
+                }
+            }
+            // 注册顺序不重要，重要的是 ConfigComponent 应该在 init 阶段最先初始化
+            env.registerComponent(new TrackedComponent("tool"));
+            env.registerComponent(new TrackedComponent("agent"));
+            env.registerComponent(new TrackedComponent("config"));
+            env.registerComponent(new TrackedComponent("task"));
+            env.registerComponent(new TrackedComponent("memory"));
+            await env.init();
+            await env.start();
+            // 验证：init 阶段 ConfigComponent 最先
+            expect(initOrder[0]).toBe("init:config");
+            // 验证：start 阶段顺序按注册顺序
+            const startOrder = initOrder.filter(s => s.startsWith("start:"));
+            // ConfigComponent 应该在 start 阶段也有记录
+            expect(startOrder.length).toBeGreaterThan(0);
+            await env.stop();
+        });
+    });
+    describe("Tool availability after complete lifecycle", () => {
+        it("should provide complete tool set to AgentComponent after init() + start()", async () => {
+            // 模拟真实的 Environment 创建流程
+            const env = new BaseEnvironment({ name: "test-env" });
+            // 创建 components
+            const configComponent = new MockConfigComponent();
+            const toolComponent = new MockToolComponent();
+            const taskComponent = new MockTaskComponent();
+            const memoryComponent = new MockMemoryComponent();
+            const agentComponent = new MockAgentComponent();
+            // 注册
+            env.registerComponent(configComponent);
+            env.registerComponent(toolComponent);
+            env.registerComponent(taskComponent);
+            env.registerComponent(memoryComponent);
+            env.registerComponent(agentComponent);
+            // 完整的生命周期
+            await env.init();
+            await env.start();
+            // 刷新 AgentComponent 的依赖
+            agentComponent.refreshDependencies();
+            // 获取可用工具
+            const availableTools = agentComponent.getAvailableTools();
+            // 验证：工具总数
+            const expectedCount = MockTaskComponent.EXPECTED_TOOLS.length + MockMemoryComponent.EXPECTED_TOOLS.length;
+            expect(availableTools.length).toBe(expectedCount);
+            // 验证：task tools 都存在
+            for (const toolName of MockTaskComponent.EXPECTED_TOOLS) {
+                expect(availableTools.some(t => t.name === toolName)).toBe(true);
+            }
+            // 验证：memory tools 都存在
+            for (const toolName of MockMemoryComponent.EXPECTED_TOOLS) {
+                expect(availableTools.some(t => t.name === toolName)).toBe(true);
+            }
+            // 清理
+            await env.stop();
+        });
+    });
+});
+// ============================================================================
+// Regression Tests: Prevent future regressions
+// ============================================================================
+describe("Environment lifecycle regression prevention", () => {
+    it("should ensure start() is called for all registered components", async () => {
+        const env = new BaseEnvironment({ name: "regression-test" });
+        const components = [];
+        const startCalls = [];
+        // 创建 5 个组件
+        for (let i = 0; i < 5; i++) {
+            class TrackedComp extends BaseComponent {
+                name = `component_${i}`;
+                async onInit() {
+                    this.setStatus("running");
+                }
+                async onStart() {
+                    startCalls.push(this.name);
+                }
+            }
+            const comp = new TrackedComp();
+            components.push(comp);
+            env.registerComponent(comp);
+        }
+        // 初始化并启动
+        await env.init();
+        await env.start();
+        // 验证：所有组件的 start() 都被调用
+        expect(startCalls).toHaveLength(5);
+        expect(startCalls).toContain("component_0");
+        expect(startCalls).toContain("component_1");
+        expect(startCalls).toContain("component_2");
+        expect(startCalls).toContain("component_3");
+        expect(startCalls).toContain("component_4");
+        await env.stop();
+    });
+    it("should prevent duplicate start() calls", async () => {
+        const env = new BaseEnvironment({ name: "duplicate-test" });
+        let startCount = 0;
+        class CountingComponent extends BaseComponent {
+            name = "counting";
+            async onInit() {
+                this.setStatus("running");
+            }
+            async onStart() {
+                startCount++;
+            }
+        }
+        env.registerComponent(new CountingComponent());
+        await env.init();
+        await env.start();
+        await env.start(); // 重复调用
+        // BaseEnvironment.start() 内部应该有防重复机制
+        expect(startCount).toBe(1);
+        await env.stop();
+    });
+    it("should have env reference available in component's onStart()", async () => {
+        const env = new BaseEnvironment({ name: "env-ref-test" });
+        let envRefInStart = null;
+        class TestComponent extends BaseComponent {
+            name = "test";
+            async onStart() {
+                envRefInStart = this.env;
+            }
+        }
+        env.registerComponent(new TestComponent());
+        await env.init();
+        await env.start();
+        // 验证：onStart() 中可以访问 env
+        expect(envRefInStart).toBe(env);
+        await env.stop();
+    });
+});
+//# sourceMappingURL=environment-lifecycle.test.js.map

package/dist/core/src/env/environment-service.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview Environment Service 集成测试
+ *
+ * TDD: 测试 Environment 从配置文件加载组件配置并初始化组件的能力
+ */
+export {};
+//# sourceMappingURL=environment-service.test.d.ts.map

package/dist/core/src/env/environment-service.test.js

@@ -0,0 +1,265 @@
+/**
+ * @fileoverview Environment Service 集成测试
+ *
+ * TDD: 测试 Environment 从配置文件加载组件配置并初始化组件的能力
+ */
+import { describe, test, expect, beforeEach, afterEach, vi } from "bun:test";
+import { BaseEnvironment } from "./environment.js";
+import { ConfigComponent } from "../config/config-component.js";
+import { BaseComponent } from "./component.js";
+import * as fsSync from "fs";
+import * as path from "path";
+import * as os from "os";
+// ============================================================================
+// 测试用的 Mock Component
+// ============================================================================
+/**
+ * Mock LLMComponent - 模拟 LLMComponent 的配置加载
+ */
+class MockLLMComponent extends BaseComponent {
+    name = "llm";
+    version = "1.0.0";
+    // 存储初始化时的配置
+    initOptions = null;
+    loadedConfig = null;
+    async init(config) {
+        await super.init(config);
+        // 从 options 获取配置
+        const options = config.options;
+        this.initOptions = options;
+        this.loadedConfig = options?.config;
+        this.setStatus("running");
+    }
+    getLoadedConfig() {
+        return this.loadedConfig;
+    }
+}
+/**
+ * Mock ToolComponent - 模拟 ToolComponent 的配置加载
+ */
+class MockToolComponent extends BaseComponent {
+    name = "tool";
+    version = "1.0.0";
+    initOptions = null;
+    loadedConfig = null;
+    async init(config) {
+        await super.init(config);
+        const options = config.options;
+        this.initOptions = options;
+        this.loadedConfig = options?.config;
+        this.setStatus("running");
+    }
+    getLoadedConfig() {
+        return this.loadedConfig;
+    }
+}
+// ============================================================================
+// 测试
+// ============================================================================
+describe("Environment Service Configuration", () => {
+    let env;
+    let configComponent;
+    let tempDir;
+    beforeEach(() => {
+        env = new BaseEnvironment({ name: "test-service-env" });
+        configComponent = new ConfigComponent();
+        // Create temp directory for config files
+        tempDir = fsSync.mkdtempSync(path.join(os.tmpdir(), "env-service-test-"));
+        configComponent.setXdgDataHome(tempDir);
+        // 注册 ConfigComponent
+        env.registerComponent(configComponent);
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+        // Clean up environment variables
+        Object.keys(process.env)
+            .filter(k => k.startsWith("TEST_"))
+            .forEach(k => delete process.env[k]);
+        // Clean up temp directory
+        try {
+            fsSync.rmSync(tempDir, { recursive: true });
+        }
+        catch { }
+    });
+    describe("loadServiceConfig", () => {
+        test("should load service config from file", async () => {
+            // 创建服务配置文件
+            const serviceConfig = {
+                environment: {
+                    name: "my-service",
+                    version: "1.0.0",
+                },
+                components: {
+                    llm: {
+                        config: {
+                            defaultModel: "gpt-4",
+                            temperature: 0.5,
+                        }
+                    }
+                }
+            };
+            fsSync.writeFileSync(path.join(tempDir, "service-config.jsonc"), JSON.stringify(serviceConfig), "utf-8");
+            // 调用 loadServiceConfig 方法
+            const loadedConfig = await env.loadServiceConfig("service-config.jsonc");
+            // 验证配置被正确加载
+            expect(loadedConfig).toBeDefined();
+            expect(loadedConfig.environment.name).toBe("my-service");
+            expect(loadedConfig.components.llm.config.defaultModel).toBe("gpt-4");
+        });
+        test("should throw error if service config not found", async () => {
+            // 尝试加载不存在的配置文件应该抛出错误
+            await expect(env.loadServiceConfig("non-existent-config.jsonc")).rejects.toThrow();
+        });
+    });
+    describe("generateComponentOptions", () => {
+        test("should generate component options from service config", async () => {
+            // 创建服务配置
+            const serviceConfig = {
+                environment: {
+                    name: "test-env",
+                },
+                components: {
+                    llm: {
+                        configPath: "llm.jsonc",
+                        envPrefix: "LLM",
+                        config: {
+                            defaultModel: "gpt-4",
+                            temperature: 0.7,
+                        }
+                    }
+                }
+            };
+            // 生成 LLM 组件的 Options
+            const options = env.generateComponentOptions("llm", serviceConfig.components.llm);
+            // 验证生成的 Options 包含正确的配置
+            expect(options.configComponent).toBe(configComponent);
+            expect(options.config.defaultModel).toBe("gpt-4");
+            expect(options.config.temperature).toBe(0.7);
+            expect(options.envPrefix).toBe("LLM");
+            expect(options.configPath).toBe("llm.jsonc");
+        });
+        test("should include configComponent in generated options", async () => {
+            const serviceConfig = {
+                components: {
+                    tool: {
+                        config: {
+                            toolsDir: "./tools",
+                        }
+                    }
+                }
+            };
+            const options = env.generateComponentOptions("tool", serviceConfig.components.tool);
+            // 必须包含 ConfigComponent
+            expect(options.configComponent).toBeDefined();
+            expect(options.configComponent).toBe(configComponent);
+        });
+    });
+    describe("registerComponentWithConfig", () => {
+        test("should register component and initialize with config", async () => {
+            const llmComponent = new MockLLMComponent();
+            const componentConfig = {
+                config: {
+                    defaultModel: "gpt-4",
+                    temperature: 0.8,
+                }
+            };
+            // 使用新 API 注册并初始化组件
+            await env.registerComponentWithConfig(llmComponent, componentConfig);
+            // 验证组件被正确初始化
+            expect(llmComponent.getStatus()).toBe("running");
+            expect(llmComponent.getLoadedConfig()).toEqual(componentConfig.config);
+        });
+        test("should support envPrefix in component registration", async () => {
+            const toolComponent = new MockToolComponent();
+            const componentConfig = {
+                envPrefix: "TOOL",
+                config: {
+                    toolsDir: "./custom-tools",
+                }
+            };
+            await env.registerComponentWithConfig(toolComponent, componentConfig);
+            expect(toolComponent.getStatus()).toBe("running");
+            expect(toolComponent.initOptions.envPrefix).toBe("TOOL");
+        });
+    });
+    describe("initFromConfig", () => {
+        test("should initialize environment from service config file", async () => {
+            // 创建完整的服务配置文件
+            const serviceConfig = {
+                environment: {
+                    name: "auto-init-env",
+                    version: "1.0.0",
+                },
+                components: {
+                    llm: {
+                        config: {
+                            defaultModel: "gpt-4",
+                        }
+                    },
+                    tool: {
+                        config: {
+                            toolsDir: "./tools",
+                        }
+                    }
+                }
+            };
+            fsSync.writeFileSync(path.join(tempDir, "auto-service.jsonc"), JSON.stringify(serviceConfig), "utf-8");
+            // 创建新的 Environment
+            const autoEnv = new BaseEnvironment();
+            autoEnv.registerComponent(configComponent);
+            // 注册 mock components
+            const llmComponent = new MockLLMComponent();
+            const toolComponent = new MockToolComponent();
+            autoEnv.registerComponent(llmComponent);
+            autoEnv.registerComponent(toolComponent);
+            // 从配置文件初始化
+            await autoEnv.initFromConfig("auto-service.jsonc");
+            // 验证环境初始化成功
+            expect(autoEnv.getStatus()).toBe("running");
+            // 验证组件被正确初始化
+            expect(llmComponent.getStatus()).toBe("running");
+            expect(llmComponent.getLoadedConfig().defaultModel).toBe("gpt-4");
+            expect(toolComponent.getStatus()).toBe("running");
+            expect(toolComponent.getLoadedConfig().toolsDir).toBe("./tools");
+        });
+        test("should set environment name from config", async () => {
+            const serviceConfig = {
+                environment: {
+                    name: "custom-named-env",
+                    version: "2.0.0",
+                },
+                components: {}
+            };
+            fsSync.writeFileSync(path.join(tempDir, "named-service.jsonc"), JSON.stringify(serviceConfig), "utf-8");
+            const namedEnv = new BaseEnvironment();
+            namedEnv.registerComponent(configComponent);
+            await namedEnv.initFromConfig("named-service.jsonc");
+            // 验证环境名称被正确设置
+            expect(namedEnv.name).toBe("custom-named-env");
+            expect(namedEnv.version).toBe("2.0.0");
+        });
+    });
+    describe("environment variable resolution", () => {
+        test("should resolve environment variables in config", async () => {
+            // 设置环境变量
+            process.env.TEST_LLM_MODEL = "gpt-5";
+            const serviceConfig = {
+                environment: { name: "env-test" },
+                components: {
+                    llm: {
+                        envPrefix: "TEST",
+                        config: {
+                            // 配置值应该能引用环境变量
+                            defaultModel: "gpt-4", // 静态值测试
+                        }
+                    }
+                }
+            };
+            const options = env.generateComponentOptions("llm", serviceConfig.components.llm);
+            // 验证配置被正确传递
+            expect(options.config.defaultModel).toBe("gpt-4");
+            delete process.env.TEST_LLM_MODEL;
+        });
+    });
+});
+//# sourceMappingURL=environment-service.test.js.map