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

package/dist/core/src/config/protocol-resolver.test.js

@@ -1,167 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import * as fs from "fs";
-import path from "path";
-import os from "os";
-import { ProtocolResolver } from "./protocol-resolver.js";
-// 测试用的临时目录
-const testDir = path.join(__dirname, ".test-protocol-resolver");
-describe("ProtocolResolver", () => {
-    let resolver;
-    beforeEach(async () => {
-        // 创建测试目录
-        await fs.promises.mkdir(testDir, { recursive: true });
-        // 创建实例
-        resolver = new ProtocolResolver({
-            xdgDataHome: testDir,
-        });
-    });
-    afterEach(async () => {
-        // 清理测试目录
-        try {
-            await fs.promises.rm(testDir, { recursive: true, force: true });
-        }
-        catch {
-            // ignore
-        }
-    });
-    describe("parse", () => {
-        test("should parse file:// protocol reference", () => {
-            const ref = "${file://config/app.json#api.key}";
-            const result = resolver.parse(ref);
-            expect(result).not.toBeNull();
-            expect(result?.protocol).toBe("file");
-            expect(result?.path).toBe("config/app.json");
-            expect(result?.key).toBe("api.key");
-            expect(result?.raw).toBe(ref);
-        });
-        test("should parse env:// protocol reference", () => {
-            const ref = "${env://HOME}";
-            const result = resolver.parse(ref);
-            expect(result).not.toBeNull();
-            expect(result?.protocol).toBe("env");
-            expect(result?.path).toBe("HOME");
-            expect(result?.key).toBe("");
-        });
-        test("should return null for non-protocol string", () => {
-            expect(resolver.parse("plain text")).toBeNull();
-            expect(resolver.parse("${VAR}")).toBeNull();
-            expect(resolver.parse("")).toBeNull();
-        });
-        test("should return null for unsupported protocol", () => {
-            expect(resolver.parse("${http://example.com}")).toBeNull();
-            expect(resolver.parse("${custom://path}")).toBeNull();
-        });
-    });
-    describe("isProtocolRef", () => {
-        test("should return true for valid protocol reference", () => {
-            expect(resolver.isProtocolRef("${file://path#key}")).toBe(true);
-            expect(resolver.isProtocolRef("${env://VAR}")).toBe(true);
-        });
-        test("should return false for non-protocol string", () => {
-            expect(resolver.isProtocolRef("plain text")).toBe(false);
-            expect(resolver.isProtocolRef("${VAR}")).toBe(false);
-            expect(resolver.isProtocolRef("")).toBe(false);
-        });
-    });
-    describe("resolve", () => {
-        test("should resolve env:// protocol from environment variable", () => {
-            process.env.TEST_RESOLVER_VAR = "test-value";
-            const result = resolver.resolve("${env://TEST_RESOLVER_VAR}");
-            expect(result).not.toBeNull();
-            expect(result?.value).toBe("test-value");
-            expect(result?.source).toBe("env");
-            delete process.env.TEST_RESOLVER_VAR;
-        });
-        test("should resolve file:// protocol from JSON file", async () => {
-            const configPath = path.join(testDir, "config.json");
-            await fs.promises.writeFile(configPath, JSON.stringify({
-                api: { key: "my-api-key", url: "https://api.example.com" }
-            }), "utf-8");
-            const result = resolver.resolve("${file://config.json#api.key}");
-            expect(result).not.toBeNull();
-            expect(result?.value).toBe("my-api-key");
-            expect(result?.source).toBe("file");
-        });
-        test("should resolve file:// with nested key", async () => {
-            const configPath = path.join(testDir, "config.json");
-            await fs.promises.writeFile(configPath, JSON.stringify({
-                server: { host: "localhost", port: 8080 }
-            }), "utf-8");
-            const result = resolver.resolve("${file://config.json#server.host}");
-            expect(result).not.toBeNull();
-            expect(result?.value).toBe("localhost");
-        });
-        test("should resolve file:// with absolute path", async () => {
-            const absPath = path.join(testDir, "abs-config.json");
-            await fs.promises.writeFile(absPath, JSON.stringify({ key: "abs-value" }), "utf-8");
-            // 使用字符串拼接避免模板字符串解析问题
-            const ref = "${file://" + absPath + "#key}";
-            const result = resolver.resolve(ref);
-            expect(result?.value).toBe("abs-value");
-        });
-        test("should resolve file:// with ~ path", async () => {
-            const homeDir = os.homedir();
-            const tildePath = path.join(homeDir, ".test-resolver-config.json");
-            await fs.promises.writeFile(tildePath, JSON.stringify({ key: "tilde-value" }), "utf-8");
-            const result = resolver.resolve("${file://~/.test-resolver-config.json#key}");
-            expect(result?.value).toBe("tilde-value");
-            // 清理
-            await fs.promises.unlink(tildePath).catch(() => { });
-        });
-        test("should return undefined for non-existent file key", async () => {
-            const configPath = path.join(testDir, "config.json");
-            await fs.promises.writeFile(configPath, JSON.stringify({ exists: true }), "utf-8");
-            const result = resolver.resolve("${file://config.json#nonexistent}");
-            expect(result?.value).toBeUndefined();
-        });
-        test("should return null for non-existent file", () => {
-            const result = resolver.resolve("${file://nonexistent.json#key}");
-            expect(result?.value).toBeUndefined();
-        });
-        test("should return null for non-protocol string", () => {
-            expect(resolver.resolve("plain text")).toBeNull();
-            expect(resolver.resolve("${VAR}")).toBeNull();
-        });
-    });
-    describe("XDG_DATA_HOME resolution", () => {
-        test("should resolve relative paths based on XDG_DATA_HOME", async () => {
-            const subDir = path.join(testDir, "subdir");
-            await fs.promises.mkdir(subDir, { recursive: true });
-            const configPath = path.join(subDir, "config.json");
-            await fs.promises.writeFile(configPath, JSON.stringify({ key: "xdg-value" }), "utf-8");
-            const result = resolver.resolve("${file://subdir/config.json#key}");
-            expect(result?.value).toBe("xdg-value");
-        });
-        test("should use default XDG_DATA_HOME when not specified", () => {
-            const xdgHome = ProtocolResolver.getDefaultXDGDataHome();
-            expect(xdgHome).toContain(".local/share");
-        });
-    });
-    describe("file content handling", () => {
-        test("should handle plain text file content", async () => {
-            const textPath = path.join(testDir, "plain.txt");
-            await fs.promises.writeFile(textPath, "plain text content", "utf-8");
-            // 对于纯文本文件，返回全部内容
-            const ref = "${file://" + textPath + "#$}";
-            const result = resolver.resolve(ref);
-            expect(result?.value).toBe("plain text content");
-        });
-        test("should return entire object for empty key", async () => {
-            const configPath = path.join(testDir, "config.json");
-            await fs.promises.writeFile(configPath, JSON.stringify({ nested: { data: "value" } }), "utf-8");
-            const result = resolver.resolve("${file://config.json#$}");
-            expect(result?.value).toEqual({ nested: { data: "value" } });
-        });
-    });
-});
-describe("ProtocolResolver with custom readFileFn", () => {
-    test("should use injected readFileFn", () => {
-        const customRead = () => '{"injected": "value"}';
-        const resolver = new ProtocolResolver({
-            readFileFn: customRead,
-        });
-        const result = resolver.resolve('${file://anypath.json#injected}');
-        expect(result?.value).toBe("value");
-    });
-});
-//# sourceMappingURL=protocol-resolver.test.js.map

package/dist/core/src/env/agent/agent-component.abort.test.d.ts

@@ -1,11 +0,0 @@
-/**
- * @fileoverview AgentComponent Abort 功能测试
- *
- * TDD 测试覆盖：
- * 1. AbortController Map Key 唯一性
- * 2. abort() 和 _run() finally 块状态正确性
- * 3. abort() 调用时 AbortController 已删除的边界情况
- * 4. 并发调用同一 agent 的 abort 处理
- */
-export {};
-//# sourceMappingURL=agent-component.abort.test.d.ts.map

package/dist/core/src/env/agent/agent-component.abort.test.js

@@ -1,440 +0,0 @@
-/**
- * @fileoverview AgentComponent Abort 功能测试
- *
- * TDD 测试覆盖：
- * 1. AbortController Map Key 唯一性
- * 2. abort() 和 _run() finally 块状态正确性
- * 3. abort() 调用时 AbortController 已删除的边界情况
- * 4. 并发调用同一 agent 的 abort 处理
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { AgentComponent } from "./agent-component.js";
-import { ConfigComponent } from "../../config/config-component.js";
-// ============================================================================
-// Mock Factory
-// ============================================================================
-function createMockEnvironment(configComponent) {
-    const mockEnv = {
-        name: "test-env",
-        version: "1.0.0",
-        getConfig: vi.fn(() => ({ name: "test-env", version: "1.0.0", enabled: true })),
-        registerComponent: vi.fn(),
-        unregisterComponent: vi.fn(),
-        getComponent: vi.fn((name) => {
-            if (name === "config")
-                return configComponent;
-            return undefined;
-        }),
-        hasComponent: vi.fn((name) => name === "config"),
-        listComponents: vi.fn(() => []),
-        handle_query: vi.fn(),
-        handle_action: vi.fn(),
-        subscribe: vi.fn(() => () => { }),
-        subscribeTo: vi.fn(() => () => { }),
-        subscribeAll: vi.fn(() => () => { }),
-        pushEnvEvent: vi.fn(),
-    };
-    return mockEnv;
-}
-// ============================================================================
-// Tests
-// ============================================================================
-describe("AgentComponent Abort 功能 (TDD)", () => {
-    let agentComponent;
-    let configComponent;
-    let mockEnv;
-    beforeEach(async () => {
-        vi.clearAllMocks();
-        agentComponent = new AgentComponent();
-        configComponent = new ConfigComponent();
-        mockEnv = createMockEnvironment(configComponent);
-        await agentComponent.init({ env: mockEnv, options: { configComponent } });
-    });
-    afterEach(async () => {
-        // 确保组件被正确清理
-        if (agentComponent.getStatus() !== "stopped") {
-            await agentComponent.stop();
-        }
-        vi.restoreAllMocks();
-    });
-    // ==========================================================================
-    // Test 1: AbortController Map Key 唯一性
-    // ==========================================================================
-    describe("AbortController Map Key 唯一性", () => {
-        it("每次 run() 调用应该创建唯一的 AbortController", async () => {
-            agentComponent.registerAgent("test-agent", { type: "primary" });
-            // Mock LLMComponent
-            const mockLLMComponent = {
-                invoke: vi.fn(() => Promise.resolve({
-                    output: { content: "done", toolCalls: [] }
-                }))
-            };
-            mockEnv.getComponent.mockImplementation((name) => {
-                if (name === "llm")
-                    return mockLLMComponent;
-                if (name === "config")
-                    return configComponent;
-                return undefined;
-            });
-            agentComponent.refreshDependencies();
-            // 第一次调用
-            const runPromise1 = agentComponent.run("test-agent", "query 1");
-            await new Promise(resolve => setTimeout(resolve, 50));
-            // 第二次调用（并发）
-            const runPromise2 = agentComponent.run("test-agent", "query 2");
-            await new Promise(resolve => setTimeout(resolve, 50));
-            // 等待两个调用完成
-            await Promise.all([runPromise1, runPromise2]);
-            // 验证：两个调用都完成了，没有相互干扰
-            expect(mockLLMComponent.invoke).toHaveBeenCalledTimes(2);
-        });
-        it("abort() 应该能够正确中断指定 agent 的运行", async () => {
-            agentComponent.registerAgent("test-agent", { type: "primary", maxIterations: 100 });
-            // 创建一个可以被外部控制的 Promise，用于模拟 LLM 调用
-            let rejectLLM;
-            let resolveLLM;
-            const llmPromise = new Promise((resolve, reject) => {
-                resolveLLM = resolve;
-                rejectLLM = reject;
-            });
-            // Mock LLMComponent - 模拟真实的 abort 行为
-            // 当 AbortController.abort() 被调用时，Promise 应该被 reject
-            const mockLLMComponent = {
-                invoke: vi.fn(({ abortSignal }) => {
-                    if (abortSignal) {
-                        // 如果 abortSignal 已经被触发，立即抛出 AbortError
-                        if (abortSignal.aborted) {
-                            const error = new Error("The operation was aborted");
-                            error.name = "AbortError";
-                            return Promise.reject(error);
-                        }
-                        // 监听 abort 事件
-                        abortSignal.addEventListener("abort", () => {
-                            const error = new Error("The operation was aborted");
-                            error.name = "AbortError";
-                            rejectLLM(error);
-                        });
-                    }
-                    return llmPromise;
-                })
-            };
-            mockEnv.getComponent.mockImplementation((name) => {
-                if (name === "llm")
-                    return mockLLMComponent;
-                if (name === "config")
-                    return configComponent;
-                return undefined;
-            });
-            agentComponent.refreshDependencies();
-            // 启动运行
-            const runPromise = agentComponent.run("test-agent", "long query");
-            // 等待 LLM 开始处理
-            await new Promise(resolve => setTimeout(resolve, 50));
-            // 中止 - 这会触发 AbortController.abort()
-            agentComponent.abort("test-agent");
-            // 等待 run 完成（AbortError 会被抛出）
-            const result = await runPromise;
-            // 验证：运行被中止
-            expect(result.stopped).toBe(true);
-            expect(result.stopReason).toBe("aborted");
-        });
-        it("并发调用不同 agent 应该互不干扰", async () => {
-            agentComponent.registerAgent("agent-1", { type: "primary" });
-            agentComponent.registerAgent("agent-2", { type: "primary" });
-            let invokeCount = 0;
-            const mockLLMComponent = {
-                invoke: vi.fn(() => {
-                    invokeCount++;
-                    return Promise.resolve({
-                        output: { content: `response ${invokeCount}`, toolCalls: [] }
-                    });
-                })
-            };
-            mockEnv.getComponent.mockImplementation((name) => {
-                if (name === "llm")
-                    return mockLLMComponent;
-                if (name === "config")
-                    return configComponent;
-                return undefined;
-            });
-            agentComponent.refreshDependencies();
-            // 并发调用两个不同的 agent
-            const [result1, result2] = await Promise.all([
-                agentComponent.run("agent-1", "query 1"),
-                agentComponent.run("agent-2", "query 2"),
-            ]);
-            // 验证：两个调用都成功
-            expect(result1.finalText).toBe("response 1");
-            expect(result2.finalText).toBe("response 2");
-            expect(mockLLMComponent.invoke).toHaveBeenCalledTimes(2);
-        });
-    });
-    // ==========================================================================
-    // Test 2: abort() 和 _run() finally 块状态正确性
-    // ==========================================================================
-    describe("abort() 和 _run() finally 块状态正确性", () => {
-        it("abort() 后 agent 状态应该是 stopped（不被 finally 覆盖）", async () => {
-            agentComponent.registerAgent("test-agent", { type: "primary", maxIterations: 100 });
-            let resolveLLM;
-            let rejectLLM;
-            const mockLLMComponent = {
-                invoke: vi.fn(({ abortSignal }) => {
-                    return new Promise((resolve, reject) => {
-                        resolveLLM = resolve;
-                        rejectLLM = reject;
-                        if (abortSignal?.aborted) {
-                            const error = new Error("The operation was aborted");
-                            error.name = "AbortError";
-                            reject(error);
-                        }
-                        abortSignal?.addEventListener("abort", () => {
-                            const error = new Error("The operation was aborted");
-                            error.name = "AbortError";
-                            reject(error);
-                        });
-                    });
-                })
-            };
-            mockEnv.getComponent.mockImplementation((name) => {
-                if (name === "llm")
-                    return mockLLMComponent;
-                if (name === "config")
-                    return configComponent;
-                return undefined;
-            });
-            agentComponent.refreshDependencies();
-            // 启动运行
-            const runPromise = agentComponent.run("test-agent", "query");
-            // 等待 LLM 开始
-            await new Promise(resolve => setTimeout(resolve, 50));
-            // 中止
-            agentComponent.abort("test-agent");
-            // 等待 run 完成
-            await runPromise;
-            // 验证：agent 状态应该是 stopped（如果 finally 覆盖了，会是 idle）
-            const agent = agentComponent.getAgent("test-agent");
-            expect(agent?.status).toBe("stopped");
-        });
-        it("正常完成的 agent 状态应该是 idle", async () => {
-            agentComponent.registerAgent("test-agent", { type: "primary" });
-            const mockLLMComponent = {
-                invoke: vi.fn(() => Promise.resolve({
-                    output: { content: "done", toolCalls: [] }
-                }))
-            };
-            mockEnv.getComponent.mockImplementation((name) => {
-                if (name === "llm")
-                    return mockLLMComponent;
-                if (name === "config")
-                    return configComponent;
-                return undefined;
-            });
-            agentComponent.refreshDependencies();
-            await agentComponent.run("test-agent", "query");
-            const agent = agentComponent.getAgent("test-agent");
-            expect(agent?.status).toBe("idle");
-        });
-        it("被外部 stop() 中止的 agent 状态应该是 stopped", async () => {
-            agentComponent.registerAgent("test-agent", { type: "primary", maxIterations: 100 });
-            let resolveLLM;
-            let rejectLLM;
-            const mockLLMComponent = {
-                invoke: vi.fn(({ abortSignal }) => {
-                    return new Promise((resolve, reject) => {
-                        resolveLLM = resolve;
-                        rejectLLM = reject;
-                        if (abortSignal?.aborted) {
-                            const error = new Error("The operation was aborted");
-                            error.name = "AbortError";
-                            reject(error);
-                        }
-                        abortSignal?.addEventListener("abort", () => {
-                            const error = new Error("The operation was aborted");
-                            error.name = "AbortError";
-                            reject(error);
-                        });
-                    });
-                })
-            };
-            mockEnv.getComponent.mockImplementation((name) => {
-                if (name === "llm")
-                    return mockLLMComponent;
-                if (name === "config")
-                    return configComponent;
-                return undefined;
-            });
-            agentComponent.refreshDependencies();
-            // 启动运行
-            const runPromise = agentComponent.run("test-agent", "query");
-            // 等待 LLM 开始
-            await new Promise(resolve => setTimeout(resolve, 50));
-            // 通过 stop() 停止组件（会调用 abort）
-            await agentComponent.stop();
-            // 等待 run 完成（AbortError 应该被抛出）
-            const result = await runPromise;
-            // 验证：运行被中止
-            expect(result.stopped).toBe(true);
-        });
-    });
-    // ==========================================================================
-    // Test 3: abort() 调用时 AbortController 已删除的边界情况
-    // ==========================================================================
-    describe("abort() 调用时 AbortController 已删除的边界情况", () => {
-        it("对已完成的 agent 调用 abort() 不应该抛出错误", () => {
-            agentComponent.registerAgent("test-agent", { type: "primary" });
-            // 运行完成后再中止
-            // 这应该静默失败，不抛出错误
-            expect(() => {
-                agentComponent.abort("test-agent");
-            }).not.toThrow();
-        });
-        it("onStop() 对已完成/不存在的 agent 调用 abort() 不应该抛出错误", async () => {
-            agentComponent.registerAgent("test-agent-1", { type: "primary" });
-            agentComponent.registerAgent("test-agent-2", { type: "primary" });
-            // 所有 agent 都正常完成
-            const mockLLMComponent = {
-                invoke: vi.fn(() => Promise.resolve({
-                    output: { content: "done", toolCalls: [] }
-                }))
-            };
-            mockEnv.getComponent.mockImplementation((name) => {
-                if (name === "llm")
-                    return mockLLMComponent;
-                if (name === "config")
-                    return configComponent;
-                return undefined;
-            });
-            agentComponent.refreshDependencies();
-            await agentComponent.run("test-agent-1", "query 1");
-            await agentComponent.run("test-agent-2", "query 2");
-            // 再次调用 stop（确保 idempotent）
-            await agentComponent.stop();
-            await agentComponent.stop();
-            // 验证：没有抛出错误
-            expect(agentComponent.getStatus()).toBe("stopped");
-        });
-        it("onStop() 应该清空所有 AbortController", async () => {
-            agentComponent.registerAgent("test-agent", { type: "primary", maxIterations: 100 });
-            let resolveLLM;
-            const mockLLMComponent = {
-                invoke: vi.fn(() => new Promise(resolve => {
-                    resolveLLM = resolve;
-                }))
-            };
-            mockEnv.getComponent.mockImplementation((name) => {
-                if (name === "llm")
-                    return mockLLMComponent;
-                if (name === "config")
-                    return configComponent;
-                return undefined;
-            });
-            agentComponent.refreshDependencies();
-            // 启动运行
-            const runPromise = agentComponent.run("test-agent", "query");
-            await new Promise(resolve => setTimeout(resolve, 50));
-            // 停止组件
-            await agentComponent.stop();
-            // 完成 LLM
-            resolveLLM({ output: { content: "done", toolCalls: [] } });
-            await runPromise;
-            // 验证：组件已停止
-            expect(agentComponent.getStatus()).toBe("stopped");
-        });
-    });
-    // ==========================================================================
-    // Test 4: 资源清理完整性
-    // ==========================================================================
-    describe("资源清理完整性", () => {
-        it("stop() 应该清理 doomLoopCaches", async () => {
-            agentComponent.registerAgent("test-agent", { type: "primary", doomLoopThreshold: 5 });
-            const mockLLMComponent = {
-                invoke: vi.fn(() => Promise.resolve({
-                    output: { content: "done", toolCalls: [] }
-                }))
-            };
-            mockEnv.getComponent.mockImplementation((name) => {
-                if (name === "llm")
-                    return mockLLMComponent;
-                if (name === "config")
-                    return configComponent;
-                return undefined;
-            });
-            agentComponent.refreshDependencies();
-            // 运行以创建 doomLoopCache
-            await agentComponent.run("test-agent", "query");
-            // 停止
-            await agentComponent.stop();
-            // 验证：状态是 stopped
-            expect(agentComponent.getStatus()).toBe("stopped");
-        });
-        it("stop() 应该清理 agents Map", async () => {
-            agentComponent.registerAgent("test-agent", { type: "primary" });
-            await agentComponent.stop();
-            // 验证：agents 被清空
-            const agents = agentComponent.listAgents();
-            expect(agents).toHaveLength(0);
-        });
-        it("多次调用 stop() 应该是幂等的", async () => {
-            agentComponent.registerAgent("test-agent", { type: "primary" });
-            await agentComponent.stop();
-            await agentComponent.stop();
-            await agentComponent.stop();
-            expect(agentComponent.getStatus()).toBe("stopped");
-        });
-    });
-    // ==========================================================================
-    // Test 5: 异常场景处理
-    // ==========================================================================
-    describe("异常场景处理", () => {
-        it("LLM 调用抛出 AbortError 应该被正确处理", async () => {
-            agentComponent.registerAgent("test-agent", { type: "primary", maxIterations: 100 });
-            const abortError = new Error("The operation was aborted");
-            abortError.name = "AbortError";
-            const mockLLMComponent = {
-                invoke: vi.fn(() => Promise.reject(abortError))
-            };
-            mockEnv.getComponent.mockImplementation((name) => {
-                if (name === "llm")
-                    return mockLLMComponent;
-                if (name === "config")
-                    return configComponent;
-                return undefined;
-            });
-            agentComponent.refreshDependencies();
-            const result = await agentComponent.run("test-agent", "query");
-            // 验证：错误被正确处理
-            expect(result.error).toBeDefined();
-        });
-        it("abort() 后 LLM 抛出 AbortError 应该被正确处理", async () => {
-            agentComponent.registerAgent("test-agent", { type: "primary", maxIterations: 100 });
-            let resolveLLM;
-            let rejectLLM;
-            const mockLLMComponent = {
-                invoke: vi.fn(() => new Promise((resolve, reject) => {
-                    resolveLLM = resolve;
-                    rejectLLM = reject;
-                }))
-            };
-            mockEnv.getComponent.mockImplementation((name) => {
-                if (name === "llm")
-                    return mockLLMComponent;
-                if (name === "config")
-                    return configComponent;
-                return undefined;
-            });
-            agentComponent.refreshDependencies();
-            const runPromise = agentComponent.run("test-agent", "query");
-            await new Promise(resolve => setTimeout(resolve, 50));
-            // 中止
-            agentComponent.abort("test-agent");
-            // LLM 抛出 AbortError
-            const abortError = new Error("The operation was aborted");
-            abortError.name = "AbortError";
-            rejectLLM(abortError);
-            const result = await runPromise;
-            // 验证：被正确中止
-            expect(result.stopped).toBe(true);
-        });
-    });
-});
-//# sourceMappingURL=agent-component.abort.test.js.map