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

package/dist/core/src/config/config-component.test.js

@@ -1,486 +0,0 @@
-/**
- * ConfigComponent 单元测试 (bun test)
- */
-import { z } from "zod";
-import { MemorySource, ConfigComponent, AsyncPersistQueue, } from "./config-component.js";
-// Helper: create a mock function that tracks calls
-function createMockFn() {
-    const calls = [];
-    const fn = ((...args) => {
-        calls.push(...args);
-    });
-    fn.calls = calls;
-    fn.mockImplementation = (newFn) => {
-        const impl = (...args) => {
-            calls.push(...args);
-            newFn(...args);
-        };
-        return impl;
-    };
-    return fn;
-}
-// Helper: check if object contains expected properties
-function expectObjectContaining(obj, expected) {
-    for (const [key, value] of Object.entries(expected)) {
-        if (!(key in obj) || !deepEqual(obj[key], value)) {
-            return false;
-        }
-    }
-    return true;
-}
-function deepEqual(a, b) {
-    if (a === b)
-        return true;
-    if (typeof a !== typeof b)
-        return false;
-    if (a === null || b === null)
-        return a === b;
-    if (Array.isArray(a) && Array.isArray(b)) {
-        if (a.length !== b.length)
-            return false;
-        return a.every((item, i) => deepEqual(item, b[i]));
-    }
-    if (typeof a === "object" && typeof b === "object") {
-        const aKeys = Object.keys(a);
-        const bKeys = Object.keys(b);
-        if (aKeys.length !== bKeys.length)
-            return false;
-        return aKeys.every(key => deepEqual(a[key], b[key]));
-    }
-    return false;
-}
-describe("MemorySource", () => {
-    let source;
-    beforeEach(() => {
-        source = new MemorySource();
-    });
-    describe("read", () => {
-        it("returns undefined for non-existent key", () => {
-            expect(source.read("nonExistent")).toBeUndefined();
-        });
-        it("returns written value", () => {
-            source.write("key1", "value1");
-            expect(source.read("key1")).toBe("value1");
-        });
-        it("returns correct value types", () => {
-            source.write("string", "test");
-            source.write("number", 42);
-            source.write("boolean", true);
-            source.write("object", { nested: true });
-            source.write("array", [1, 2, 3]);
-            expect(source.read("string")).toBe("test");
-            expect(source.read("number")).toBe(42);
-            expect(source.read("boolean")).toBe(true);
-            expect(source.read("object")).toEqual({ nested: true });
-            expect(source.read("array")).toEqual([1, 2, 3]);
-        });
-    });
-    describe("write", () => {
-        it("stores value and returns true", () => {
-            expect(source.write("key", "value")).toBe(true);
-            expect(source.read("key")).toBe("value");
-        });
-        it("overwrites existing value", () => {
-            source.write("key", "old");
-            source.write("key", "new");
-            expect(source.read("key")).toBe("new");
-        });
-    });
-    describe("delete", () => {
-        it("removes entry and returns true", () => {
-            source.write("key", "value");
-            expect(source.delete("key")).toBe(true);
-            expect(source.read("key")).toBeUndefined();
-        });
-        it("returns false for non-existent key", () => {
-            expect(source.delete("nonExistent")).toBe(false);
-        });
-    });
-    describe("list", () => {
-        it("returns all entries", () => {
-            source.write("key1", "value1");
-            source.write("key2", "value2");
-            const entries = source.list();
-            expect(entries).toHaveLength(2);
-            expect(entries.some(e => e.key === "key1" && e.value === "value1")).toBe(true);
-            expect(entries.some(e => e.key === "key2" && e.value === "value2")).toBe(true);
-        });
-        it("returns empty array for empty store", () => {
-            expect(source.list()).toEqual([]);
-        });
-    });
-    describe("watch", () => {
-        it("triggers callback on add", () => {
-            const events = [];
-            const unwatch = source.watch((event) => events.push(event));
-            source.write("key", "value");
-            expect(events.length).toBe(1);
-            expect(events[0].type).toBe("add");
-            expect(events[0].key).toBe("key");
-            expect(events[0].oldValue).toBeUndefined();
-            expect(events[0].newValue).toBe("value");
-            expect(events[0].source).toBe("memory");
-            unwatch();
-        });
-        it("triggers callback on change", () => {
-            const events = [];
-            source.write("key", "oldValue");
-            const unwatch = source.watch((event) => events.push(event));
-            source.write("key", "newValue");
-            expect(events.length).toBe(1);
-            expect(events[0].type).toBe("change");
-            expect(events[0].key).toBe("key");
-            expect(events[0].oldValue).toBe("oldValue");
-            expect(events[0].newValue).toBe("newValue");
-            unwatch();
-        });
-        it("triggers callback on delete", () => {
-            const events = [];
-            source.write("key", "value");
-            const unwatch = source.watch((event) => events.push(event));
-            source.delete("key");
-            expect(events.length).toBe(1);
-            expect(events[0].type).toBe("delete");
-            expect(events[0].key).toBe("key");
-            expect(events[0].oldValue).toBe("value");
-            expect(events[0].newValue).toBeUndefined();
-            unwatch();
-        });
-        it("returns unsubscribe function", () => {
-            const events = [];
-            const unwatch = source.watch((event) => events.push(event));
-            unwatch();
-            source.write("key", "value");
-            expect(events.length).toBe(0);
-        });
-        it("handles multiple watchers", () => {
-            const events1 = [];
-            const events2 = [];
-            source.watch((event) => events1.push(event));
-            source.watch((event) => events2.push(event));
-            source.write("key", "value");
-            expect(events1.length).toBe(1);
-            expect(events2.length).toBe(1);
-        });
-    });
-});
-describe("AsyncPersistQueue", () => {
-    let persistCalls;
-    let mockPersistFn;
-    let queue;
-    // Helper to wait for debounce to complete
-    const waitForDebounce = (ms) => new Promise(resolve => setTimeout(resolve, ms + 10));
-    const createQueue = (debounceMs = 30) => {
-        persistCalls = [];
-        mockPersistFn = async (entries) => {
-            persistCalls.push(entries);
-        };
-        queue = new AsyncPersistQueue({
-            debounceMs,
-            persistFn: mockPersistFn,
-        });
-        return queue;
-    };
-    // Cleanup between tests
-    afterEach(async () => {
-        if (queue) {
-            queue.clear();
-        }
-        await waitForDebounce(100); // Wait for any pending timers
-    });
-    describe("add", () => {
-        it("schedules flush after add", async () => {
-            const q = createQueue(50);
-            q.add("key1", "value1");
-            // Should not flush immediately
-            expect(persistCalls.length).toBe(0);
-            expect(q.size()).toBe(1);
-        });
-        it("batches multiple adds within debounce window", async () => {
-            const q = createQueue(30);
-            q.add("key1", "value1");
-            q.add("key2", "value2");
-            q.add("key3", "value3");
-            expect(q.size()).toBe(3);
-            expect(persistCalls.length).toBe(0);
-            // Wait for debounce to elapse
-            await waitForDebounce(30);
-            expect(persistCalls.length).toBe(1);
-        });
-    });
-    describe("flush", () => {
-        it("calls persistFn with all entries", async () => {
-            const q = createQueue(30);
-            q.add("key1", "value1");
-            q.add("key2", "value2");
-            await waitForDebounce(30);
-            expect(persistCalls.length).toBe(1);
-            const entries = persistCalls[0];
-            expect(entries.some((e) => e.key === "key1" && e.value === "value1")).toBe(true);
-            expect(entries.some((e) => e.key === "key2" && e.value === "value2")).toBe(true);
-        });
-        it("clears queue after flush", async () => {
-            const q = createQueue(30);
-            q.add("key1", "value1");
-            await waitForDebounce(30);
-            expect(q.size()).toBe(0);
-        });
-        it("handles empty queue gracefully", async () => {
-            const q = createQueue(50);
-            await q.flush();
-            expect(persistCalls.length).toBe(0);
-        });
-        it("handles persistFn errors gracefully", async () => {
-            let errorThrown = false;
-            const errorQueue = new AsyncPersistQueue({
-                debounceMs: 30,
-                persistFn: async () => {
-                    throw new Error("Persist failed");
-                },
-            });
-            // Capture console.error
-            const originalError = console.error;
-            let capturedArgs = [];
-            console.error = (...args) => {
-                capturedArgs = args;
-                errorThrown = true;
-            };
-            errorQueue.add("key", "value");
-            await waitForDebounce(30);
-            expect(errorThrown).toBe(true);
-            // console.error 被调用，第一个参数是 "Failed to persist config:"
-            expect(capturedArgs.length).toBeGreaterThan(0);
-            expect(capturedArgs[0]).toContain("Failed to persist config");
-            console.error = originalError;
-            errorQueue.clear();
-        });
-    });
-    describe("pause/resume", () => {
-        it("pause prevents new flush when called before add", async () => {
-            const q = createQueue(30);
-            q.pause(); // Pause before adding
-            q.add("key", "value");
-            await waitForDebounce(50);
-            expect(q.size()).toBe(1);
-            expect(persistCalls.length).toBe(0);
-        });
-        it("resume schedules flush when queue has items", async () => {
-            const q = createQueue(30);
-            q.pause();
-            q.add("key", "value");
-            q.resume();
-            expect(q.size()).toBe(1);
-            await waitForDebounce(30);
-            expect(persistCalls.length).toBe(1);
-        });
-    });
-    describe("clear", () => {
-        it("clears queue and timer", () => {
-            const q = createQueue(50);
-            q.add("key1", "value1");
-            q.add("key2", "value2");
-            expect(q.size()).toBe(2);
-            q.clear();
-            expect(q.size()).toBe(0);
-        });
-    });
-});
-describe("ConfigComponent", () => {
-    let config;
-    const createTestSchema = (name, defaults) => ({
-        name,
-        schema: z.object({}),
-        defaults,
-    });
-    beforeEach(() => {
-        config = new ConfigComponent({ debounceMs: 50 });
-    });
-    afterEach(() => {
-        // Clean up timers
-        config["persistQueue"].clear();
-    });
-    describe("name and version", () => {
-        it("has correct name", () => {
-            expect(config.name).toBe("config");
-        });
-        it("has correct version", () => {
-            expect(config.version).toBe("1.0.0");
-        });
-    });
-    describe("Component registration", () => {
-        it("register adds schema", () => {
-            const schema = createTestSchema("test", { key: "value" });
-            config.register(schema);
-            expect(config.isRegistered("test")).toBe(true);
-        });
-        it("register initializes defaults", () => {
-            const schema = createTestSchema("test", { key: "defaultValue" });
-            config.register(schema);
-            expect(config.get("test.key")).toBe("defaultValue");
-        });
-        it("register does not overwrite existing values", () => {
-            const schema = createTestSchema("test", { key: "defaultValue" });
-            config.register(schema);
-            config.set("test.key", "customValue");
-            config.register(schema);
-            expect(config.get("test.key")).toBe("customValue");
-        });
-        it("unregister removes schema", () => {
-            const schema = createTestSchema("test", { key: "value" });
-            config.register(schema);
-            config.unregister("test");
-            expect(config.isRegistered("test")).toBe(false);
-        });
-        it("listComponents returns all registered", () => {
-            config.register(createTestSchema("comp1", {}));
-            config.register(createTestSchema("comp2", {}));
-            const components = config.listComponents();
-            expect(components).toContain("comp1");
-            expect(components).toContain("comp2");
-        });
-    });
-    describe("get/set", () => {
-        beforeEach(() => {
-            config.register(createTestSchema("test", {}));
-        });
-        it("get returns nested value with dot notation", async () => {
-            await config.set("test.nested", { deep: { value: 42 } });
-            const result = config.get("test.nested");
-            expect(result).toEqual({ deep: { value: 42 } });
-        });
-        it("get returns nested object property", async () => {
-            await config.set("test.nested", { deep: { value: 42 } });
-            const result = config.get("test.nested.deep.value");
-            expect(result).toBe(42);
-        });
-        it("get returns undefined for non-existent key", () => {
-            expect(config.get("nonExistent")).toBeUndefined();
-        });
-        it("set updates value", async () => {
-            await config.set("test.key", "newValue");
-            expect(config.get("test.key")).toBe("newValue");
-        });
-        it("setMany sets multiple values", async () => {
-            await config.setMany({
-                "test.key1": "value1",
-                "test.key2": "value2",
-            });
-            expect(config.get("test.key1")).toBe("value1");
-            expect(config.get("test.key2")).toBe("value2");
-        });
-        it("getMany returns multiple values", async () => {
-            await config.set("test.key1", "value1");
-            await config.set("test.key2", "value2");
-            const result = config.getMany(["test.key1", "test.key2", "nonExistent"]);
-            expect(result).toEqual({
-                "test.key1": "value1",
-                "test.key2": "value2",
-                nonExistent: undefined,
-            });
-        });
-    });
-    describe("reset", () => {
-        it("resets to default value", async () => {
-            const schema = createTestSchema("test", { key: "default" });
-            config.register(schema);
-            await config.set("test.key", "custom");
-            expect(config.get("test.key")).toBe("custom");
-            await config.reset("test.key");
-            expect(config.get("test.key")).toBe("default");
-        });
-        it("does nothing for unregistered component", async () => {
-            await config.reset("nonExistent.key");
-            // Should not throw
-        });
-    });
-    describe("watch", () => {
-        it("triggers on change", async () => {
-            const events = [];
-            config.watch("test.key", (event) => events.push(event));
-            await config.set("test.key", "value");
-            expect(events.length).toBe(1);
-            expect(events[0].component).toBe("test");
-            expect(events[0].key).toBe("test.key");
-            expect(events[0].oldValue).toBeUndefined();
-            expect(events[0].newValue).toBe("value");
-            expect(events[0].persisted).toBe(false);
-        });
-        it("pattern matching with wildcard", async () => {
-            const events = [];
-            config.watch("test.*", (event) => events.push(event));
-            await config.set("test.key1", "value1");
-            await config.set("test.key2", "value2");
-            expect(events.length).toBe(2);
-        });
-        it("pattern matching with global wildcard", async () => {
-            const events = [];
-            config.watch("*", (event) => events.push(event));
-            await config.set("test.key", "value");
-            expect(events.length).toBe(1);
-        });
-        it("returns unsubscribe function", async () => {
-            const events = [];
-            const unwatch = config.watch("test.key", (event) => events.push(event));
-            unwatch();
-            await config.set("test.key", "value");
-            expect(events.length).toBe(0);
-        });
-        it("handles nested key changes", async () => {
-            const events = [];
-            config.watch("test.*", (event) => events.push(event));
-            await config.set("test.nested.deep", "value");
-            expect(events.length).toBe(1);
-        });
-    });
-    describe("getPath", () => {
-        it("throws for unregistered component", () => {
-            expect(() => config.getPath("nonExistent")).toThrow("Component not registered: nonExistent");
-        });
-    });
-    describe("config sources", () => {
-        it("addSource adds to sources list", () => {
-            const customSource = {
-                name: "custom",
-                priority: 1,
-                read: () => undefined,
-                list: () => [],
-            };
-            config.addSource(customSource);
-            const sources = config.getSources();
-            expect(sources.length).toBe(2); // memory + custom
-        });
-        it("removeSource removes non-memory source", () => {
-            const customSource = {
-                name: "custom",
-                priority: 1,
-                read: () => undefined,
-                list: () => [],
-            };
-            config.addSource(customSource);
-            const result = config.removeSource("custom");
-            expect(result).toBe(true);
-            expect(config.getSources().length).toBe(1);
-        });
-        it("cannot remove memory source", () => {
-            const result = config.removeSource("memory");
-            expect(result).toBe(false);
-        });
-        it("getSources returns copy of sources", () => {
-            const sources = config.getSources();
-            sources.push({});
-            expect(config.getSources().length).toBe(1);
-        });
-    });
-    describe("save", () => {
-        it("flushes persist queue", async () => {
-            // Add something to the queue first
-            config.register(createTestSchema("test", {}));
-            await config.set("test.key", "value");
-            // Wait for any pending flush
-            await new Promise(resolve => setTimeout(resolve, 60));
-            await config.save();
-            // If we get here without error, the test passes
-        });
-    });
-});
-//# sourceMappingURL=config-component.test.js.map

package/dist/core/src/config/config-parser.d.ts

@@ -1,46 +0,0 @@
-import { ProtocolResolver } from "./protocol-resolver";
-/**
- * Parse JSONC (JSON with Comments) content
- * Supports single-line comments (//) and multi-line comments
- *
- * @param content - JSONC content string
- * @returns Parsed JSON object
- */
-export declare function parseJSONC(content: string): Record<string, unknown>;
-/**
- * Substitute environment variables in a value
- * Supports ${VAR} and ${VAR:-default} syntax
- *
- * @param value - Value to substitute (string, object, array, or primitive)
- * @returns Value with environment variables substituted
- */
-export declare function substituteEnvVars(value: unknown): unknown;
-/**
- * Parse JSONC content and substitute environment variables
- *
- * @param content - JSONC content string
- * @returns Parsed JSON object with env vars substituted
- */
-export declare function parseJSONCWithEnv(content: string): Record<string, unknown>;
-/**
- * Substitute protocol references in a value using the provided resolver
- *
- * Supports:
- * - ${file://path#key} - Read from file
- * - ${env://varName} - Read from environment variable
- * - All above with default values: ${protocol://...:-default}
- *
- * @param value - Value to substitute (string, object, array, or primitive)
- * @param resolver - ProtocolResolver instance
- * @returns Value with protocol references substituted
- */
-export declare function substituteProtocolRefs(value: unknown, resolver: ProtocolResolver): unknown;
-/**
- * Parse JSONC content and substitute protocol references
- *
- * @param content - JSONC content string
- * @param resolver - ProtocolResolver instance
- * @returns Parsed JSON object with protocol refs substituted
- */
-export declare function parseJSONCWithProtocols(content: string, resolver: ProtocolResolver): Record<string, unknown>;
-//# sourceMappingURL=config-parser.d.ts.map