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

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

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

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

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

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