@ai-setting/roy-agent-core 1.3.10 → 1.3.14

package/src/env/environment-service.test.ts

@@ -1,332 +0,0 @@
-/**
- * @fileoverview Environment Service 集成测试
- * 
- * TDD: 测试 Environment 从配置文件加载组件配置并初始化组件的能力
- */
-
-import { describe, test, expect, beforeEach, afterEach, vi } from "bun:test";
-import { BaseEnvironment } from "./environment";
-import { ConfigComponent } from "../config/config-component";
-import { BaseComponent } from "./component";
-import * as fsSync from "fs";
-import * as path from "path";
-import * as os from "os";
-
-// ============================================================================
-// 测试用的 Mock Component
-// ============================================================================
-
-/**
- * Mock LLMComponent - 模拟 LLMComponent 的配置加载
- */
-class MockLLMComponent extends BaseComponent {
-  readonly name = "llm";
-  readonly version = "1.0.0";
-  
-  // 存储初始化时的配置
-  initOptions: any = null;
-  loadedConfig: any = null;
-  
-  async init(config: import("./component").ComponentConfig): Promise<void> {
-    await super.init(config);
-    
-    // 从 options 获取配置
-    const options = config.options as any;
-    this.initOptions = options;
-    this.loadedConfig = options?.config;
-    
-    this.setStatus("running");
-  }
-  
-  getLoadedConfig() {
-    return this.loadedConfig;
-  }
-}
-
-/**
- * Mock ToolComponent - 模拟 ToolComponent 的配置加载
- */
-class MockToolComponent extends BaseComponent {
-  readonly name = "tool";
-  readonly version = "1.0.0";
-  
-  initOptions: any = null;
-  loadedConfig: any = null;
-  
-  async init(config: import("./component").ComponentConfig): Promise<void> {
-    await super.init(config);
-    
-    const options = config.options as any;
-    this.initOptions = options;
-    this.loadedConfig = options?.config;
-    
-    this.setStatus("running");
-  }
-  
-  getLoadedConfig() {
-    return this.loadedConfig;
-  }
-}
-
-// ============================================================================
-// 测试
-// ============================================================================
-
-describe("Environment Service Configuration", () => {
-  let env: BaseEnvironment;
-  let configComponent: ConfigComponent;
-  let tempDir: string;
-
-  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;
-    });
-  });
-});

package/src/env/environment.handle-query.test.ts

@@ -1,96 +0,0 @@
-/**
- * @fileoverview handle_query 集成测试
- */
-
-import { describe, it, expect, vi, beforeEach } from "bun:test";
-import { BaseEnvironment } from "./environment";
-import { AgentComponent } from "./agent/agent-component";
-import { ConfigComponent } from "../config/config-component";
-import type { EnvEvent } from "./types";
-
-describe("BaseEnvironment.handle_query", () => {
-  let env: BaseEnvironment;
-  let agentComponent: AgentComponent;
-  let configComponent: ConfigComponent;
-
-  beforeEach(async () => {
-    env = new BaseEnvironment({ name: "test-env" });
-    configComponent = new ConfigComponent();
-    agentComponent = new AgentComponent();
-    
-    // 注册到 Environment
-    env.registerComponent(configComponent);
-    env.registerComponent(agentComponent);
-    
-    // 通过 init 方法设置 env（BaseComponent 需要 env）
-    // AgentComponent 需要 ConfigComponent
-    await agentComponent.init({
-      name: "agent",
-      version: "1.0.0",
-      enabled: true,
-      env: env as any,
-      options: { configComponent },
-    });
-  });
-
-  it("should delegate to AgentComponent.run", async () => {
-    const result = await env.handle_query("Hello");
-    
-    // AgentComponent 没有 LLMComponent 时会返回 Mock 响应
-    expect(result).toBe("Mock response: Hello!");
-  });
-
-  it("should pass context to AgentComponent.run", async () => {
-    const context = {
-      sessionId: "test-session-123",
-      metadata: { key: "value" },
-    };
-
-    // 由于没有 LLMComponent，使用 mock
-    // 这个测试主要验证 context 被正确传递
-    const result = await env.handle_query("Test query", context);
-    expect(result).toBe("Mock response: Hello!");
-  });
-
-  it("should emit events via subscribe", async () => {
-    const events: EnvEvent[] = [];
-    
-    // 订阅 EnvEvent
-    const unsubscribe = env.subscribe((event) => {
-      events.push(event);
-    });
-    
-    const result = await env.handle_query("Hello");
-
-    expect(result).toBe("Mock response: Hello!");
-    
-    // 验证事件被触发
-    expect(events.length).toBeGreaterThan(0);
-    
-    // 应该包含 agent.start 和 agent.completed 事件
-    // 注意：llm.content 事件只有在有真实 LLMComponent 时才会发送
-    const eventTypes = events.map(e => e.type);
-    expect(eventTypes).toContain("agent.start");
-    expect(eventTypes).toContain("agent.completed");
-    
-    unsubscribe();
-  });
-
-  it("should throw error if AgentComponent is not registered", async () => {
-    const emptyEnv = new BaseEnvironment({ name: "empty-env" });
-    
-    await expect(
-      emptyEnv.handle_query("Hello")
-    ).rejects.toThrow("AgentComponent not found");
-  });
-
-  it("should work without event subscription", async () => {
-    const result = await env.handle_query("Hello");
-    expect(result).toBe("Mock response: Hello!");
-  });
-
-  it("should work without context", async () => {
-    const result = await env.handle_query("Hello");
-    expect(result).toBe("Mock response: Hello!");
-  });
-});

package/src/env/environment.test.ts

@@ -1,232 +0,0 @@
-/**
- * @fileoverview BaseEnvironment Unit Tests
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { BaseEnvironment, type BaseEnvironmentConfig } from "./environment";
-import type { EnvEvent, EnvEventHandler, Action, ToolResult, Context } from "./types";
-
-describe("BaseEnvironment", () => {
-  let env: BaseEnvironment;
-
-  beforeEach(() => {
-    env = new BaseEnvironment({ name: "test-env", version: "1.0.0" });
-  });
-
-  afterEach(async () => {
-    await env.stop();
-  });
-
-  describe("构造函数", () => {
-    it("应该使用默认配置", () => {
-      const defaultEnv = new BaseEnvironment();
-      expect(defaultEnv.name).toBe("base-environment");
-      expect(defaultEnv.version).toBe("1.0.0");
-    });
-
-    it("应该使用提供的配置", () => {
-      expect(env.name).toBe("test-env");
-      expect(env.version).toBe("1.0.0");
-    });
-  });
-
-  describe("getConfig()", () => {
-    it("应该返回正确的配置", () => {
-      const config = env.getConfig();
-      expect(config.name).toBe("test-env");
-      expect(config.version).toBe("1.0.0");
-      expect(config.enabled).toBe(true);
-    });
-  });
-
-  describe("组件管理", () => {
-    it("应该注册和获取组件", () => {
-      const mockComponent = {
-        name: "test-component",
-        version: "1.0.0",
-        hooks: {},
-        getStatus: () => "created" as const,
-        getConfig: () => ({ name: "test-component", version: "1.0.0", enabled: true }),
-        init: vi.fn(),
-        start: vi.fn(),
-        stop: vi.fn(),
-      };
-
-      env.registerComponent(mockComponent as any);
-      expect(env.getComponent("test-component")).toBe(mockComponent);
-      expect(env.listComponents()).toHaveLength(1);
-    });
-
-    it("应该注销组件", () => {
-      const mockComponent = {
-        name: "test-component",
-        version: "1.0.0",
-        hooks: {},
-        getStatus: () => "created" as const,
-        getConfig: () => ({ name: "test-component", version: "1.0.0", enabled: true }),
-        init: vi.fn(),
-        start: vi.fn(),
-        stop: vi.fn(),
-      };
-
-      env.registerComponent(mockComponent as any);
-      env.unregisterComponent("test-component");
-      expect(env.getComponent("test-component")).toBeUndefined();
-      expect(env.listComponents()).toHaveLength(0);
-    });
-
-    it("获取不存在的组件应返回 undefined", () => {
-      expect(env.getComponent("non-existent")).toBeUndefined();
-    });
-  });
-
-  describe("handle_query", () => {
-    it("应该抛出错误（AgentComponent 未注册）", async () => {
-      await env.init();
-      await expect(env.handle_query("hello")).rejects.toThrow("AgentComponent not found");
-    });
-  });
-
-  describe("handle_action", () => {
-    it("应该抛出错误（未实现）", async () => {
-      await env.init();
-      const action: Action = { type: "test", params: {} };
-      const context: Context = {};
-      await expect(env.handle_action(action, context)).rejects.toThrow("handle_action not implemented");
-    });
-  });
-
-  describe("EnvEvent 机制", () => {
-    it("应该订阅和取消订阅", () => {
-      const handler = vi.fn();
-      const unsubscribe = env.subscribe(handler);
-      
-      // 推送事件
-      env.pushEnvEvent({
-        id: "test-id",
-        type: "test.event",
-        timestamp: Date.now(),
-        metadata: { env_name: "test" },
-        payload: {},
-      });
-      
-      expect(handler).toHaveBeenCalledTimes(1);
-      
-      // 取消订阅
-      unsubscribe();
-      
-      // 再次推送事件
-      env.pushEnvEvent({
-        id: "test-id-2",
-        type: "test.event",
-        timestamp: Date.now(),
-        metadata: { env_name: "test" },
-        payload: {},
-      });
-      
-      expect(handler).toHaveBeenCalledTimes(1); // 不应再调用
-    });
-
-    it("subscribeAll 应该等同于 subscribe", () => {
-      const handler = vi.fn();
-      const unsubscribe = env.subscribeAll(handler);
-      
-      env.pushEnvEvent({ id: "1", type: "any.event", timestamp: Date.now(), metadata: {}, payload: {} });
-      env.pushEnvEvent({ id: "2", type: "another.event", timestamp: Date.now(), metadata: {}, payload: {} });
-      
-      expect(handler).toHaveBeenCalledTimes(2);
-      
-      unsubscribe();
-    });
-
-    it("应该订阅指定类型事件", () => {
-      const handler = vi.fn();
-      const unsubscribe = env.subscribeTo("specific.event", handler);
-      
-      // 推送指定类型事件
-      env.pushEnvEvent({
-        id: "test-id",
-        type: "specific.event",
-        timestamp: Date.now(),
-        metadata: { env_name: "test" },
-        payload: {},
-      });
-      
-      // 推送其他类型事件
-      env.pushEnvEvent({
-        id: "test-id-2",
-        type: "other.event",
-        timestamp: Date.now(),
-        metadata: { env_name: "test" },
-        payload: {},
-      });
-      
-      expect(handler).toHaveBeenCalledTimes(1);
-      
-      unsubscribe();
-    });
-
-    it("应该订阅多个类型事件", () => {
-      const handler = vi.fn();
-      const unsubscribe = env.subscribeTo(["event1", "event2"], handler);
-      
-      env.pushEnvEvent({ id: "1", type: "event1", timestamp: Date.now(), metadata: {}, payload: {} });
-      env.pushEnvEvent({ id: "2", type: "event2", timestamp: Date.now(), metadata: {}, payload: {} });
-      env.pushEnvEvent({ id: "3", type: "event3", timestamp: Date.now(), metadata: {}, payload: {} });
-      
-      expect(handler).toHaveBeenCalledTimes(2);
-      
-      unsubscribe();
-    });
-
-    it("pushEnvEvent 应该自动填充元信息", () => {
-      const handler = vi.fn();
-      env.subscribe(handler);
-      
-      env.pushEnvEvent({
-        type: "test.event",
-        payload: { data: "test" },
-      } as any);
-      
-      const event = handler.mock.calls[0][0] as EnvEvent;
-      expect(event.id).toBeDefined();
-      expect(event.timestamp).toBeDefined();
-      expect(event.metadata.env_name).toBe("test-env");
-    });
-  });
-
-  describe("生命周期", () => {
-    it("应该正确初始化", async () => {
-      await env.init();
-      expect(env.getStatus()).toBe("running");
-    });
-
-    it("应该正确启动", async () => {
-      await env.start();
-      expect(env.getStatus()).toBe("running");
-    });
-
-    it("重复启动不应报错", async () => {
-      await env.start();
-      await env.start();
-      expect(env.getStatus()).toBe("running");
-    });
-
-    it("应该正确停止", async () => {
-      await env.stop();
-      expect(env.getStatus()).toBe("stopped");
-    });
-
-    it("停止后应清理事件处理器", async () => {
-      const handler = vi.fn();
-      env.subscribe(handler);
-      
-      await env.stop();
-      
-      // 停止后推送事件应该不触发
-      env.pushEnvEvent({ id: "test", type: "test", timestamp: Date.now(), metadata: {}, payload: {} });
-      
-      expect(handler).not.toHaveBeenCalled();
-    });
-  });
-});