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

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

@@ -0,0 +1,686 @@
+import { BaseComponent, } from "../env/component.js";
+import { XDG_PATHS, } from "../env/paths.js";
+import { ProtocolResolver } from "./protocol-resolver.js";
+import { FileSource } from "./file-source.js";
+import { EnvSource } from "./env-source.js";
+import * as os from "os";
+import * as path from "path";
+/**
+ * 配置源不存在错误
+ */
+export class ConfigSourceNotFoundError extends Error {
+    constructor(sourceType, path) {
+        const message = path
+            ? `Config source not found: ${sourceType} at ${path}`
+            : `Config source not found: ${sourceType}`;
+        super(message);
+        this.name = "ConfigSourceNotFoundError";
+    }
+}
+/**
+ * 配置文件不存在错误
+ */
+export class ConfigFileNotFoundError extends Error {
+    constructor(filePath) {
+        super(`Config file not found: ${filePath}`);
+        this.name = "ConfigFileNotFoundError";
+    }
+}
+/**
+ * MemorySource 实现
+ */
+export class MemorySource {
+    name = "memory";
+    priority = 0;
+    store = new Map();
+    watchers = new Set();
+    read(key) {
+        return this.store.get(key)?.value;
+    }
+    write(key, value) {
+        const oldEntry = this.store.get(key);
+        const entry = {
+            value,
+            timestamp: Date.now(),
+            version: (oldEntry?.version ?? 0) + 1,
+        };
+        this.store.set(key, entry);
+        this.notifyWatchers({
+            type: oldEntry ? "change" : "add",
+            key,
+            oldValue: oldEntry?.value,
+            newValue: value,
+            source: "memory",
+            timestamp: entry.timestamp,
+        });
+        return true;
+    }
+    delete(key) {
+        const entry = this.store.get(key);
+        if (!entry)
+            return false;
+        this.store.delete(key);
+        this.notifyWatchers({
+            type: "delete",
+            key,
+            oldValue: entry.value,
+            newValue: undefined,
+            source: "memory",
+            timestamp: Date.now(),
+        });
+        return true;
+    }
+    list() {
+        return Array.from(this.store.entries()).map(([key, entry]) => ({
+            key,
+            value: entry.value,
+        }));
+    }
+    watch(callback) {
+        this.watchers.add(callback);
+        return () => this.watchers.delete(callback);
+    }
+    notifyWatchers(event) {
+        this.watchers.forEach((cb) => cb(event));
+    }
+}
+/**
+ * 异步持久化队列
+ */
+export class AsyncPersistQueue {
+    options;
+    queue = new Map();
+    timer;
+    paused = false;
+    constructor(options) {
+        this.options = options;
+    }
+    add(key, value) {
+        this.queue.set(key, { key, value, timestamp: Date.now() });
+        this.scheduleFlush();
+    }
+    scheduleFlush() {
+        if (this.paused || this.timer)
+            return;
+        this.timer = setTimeout(async () => {
+            this.timer = undefined;
+            await this.flush();
+        }, this.options.debounceMs);
+    }
+    async flush() {
+        if (this.queue.size === 0)
+            return;
+        const entries = Array.from(this.queue.values());
+        this.queue.clear();
+        try {
+            await this.options.persistFn(entries);
+        }
+        catch (error) {
+            console.error("Failed to persist config:", error);
+        }
+    }
+    clear() {
+        this.queue.clear();
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = undefined;
+        }
+    }
+    size() {
+        return this.queue.size;
+    }
+    pause() {
+        this.paused = true;
+    }
+    resume() {
+        this.paused = false;
+        if (this.queue.size > 0) {
+            this.scheduleFlush();
+        }
+    }
+}
+/**
+ * ConfigComponent
+ */
+export class ConfigComponent extends BaseComponent {
+    name = "config";
+    version = "1.0.0";
+    memorySource = new MemorySource();
+    sources = [this.memorySource];
+    componentSchemas = new Map();
+    componentPaths = new Map();
+    watchers = new Map();
+    /** Source watch unsubscribe 函数 */
+    sourceUnwatchFns = new Map();
+    persistQueue;
+    persistFile;
+    // === 去中心化配置注册 ===
+    /** Key 注册表：key -> KeyRegistration */
+    keyRegistry = new Map();
+    /** Component 注册表：name -> ComponentRegistration */
+    componentRegistrations = new Map();
+    /** 协议解析器 */
+    protocolResolver;
+    /** XDG_DATA_HOME 缓存（用于测试注入） */
+    __xdgDataHome;
+    /** Source 注册配置（延迟创建） */
+    pendingSources = [];
+    /** Source 唯一标识缓存：type:relativePath -> true */
+    sourceKeys = new Map();
+    /**
+     * 获取 XDG_DATA_HOME（动态获取，支持运行时覆盖）
+     */
+    getXdgDataHome() {
+        return this.__xdgDataHome ?? process.env.XDG_DATA_HOME ??
+            path.join(os.homedir(), ".local", "share");
+    }
+    /**
+     * 设置 XDG_DATA_HOME（用于测试）
+     */
+    setXdgDataHome(path) {
+        this.__xdgDataHome = path;
+        // 同时更新 ProtocolResolver 的 xdgDataHome
+        if (this.protocolResolver) {
+            this.protocolResolver.xdgDataHome = path;
+        }
+    }
+    constructor(options = {}) {
+        super();
+        this.persistFile = options.persistFile;
+        this.persistQueue = new AsyncPersistQueue({
+            debounceMs: options.debounceMs ?? 300,
+            persistFn: this.persistToFile.bind(this),
+        });
+        // 初始化协议解析器（延迟初始化，依赖 getXdgDataHome）
+        this.protocolResolver = new ProtocolResolver();
+    }
+    // === Component 注册 ===
+    /**
+     * 注册 Component Schema
+     */
+    register(schema) {
+        this.componentSchemas.set(schema.name, schema);
+        // 注册路径
+        if (schema.paths) {
+            this.componentPaths.set(schema.name, schema.paths);
+        }
+        // 初始化默认值到内存
+        for (const [key, value] of Object.entries(schema.defaults)) {
+            const fullKey = `${schema.name}.${key}`;
+            if (this.memorySource.read(fullKey) === undefined) {
+                this.memorySource.write(fullKey, value);
+            }
+        }
+    }
+    /**
+     * 注销 Component
+     */
+    unregister(name) {
+        this.componentSchemas.delete(name);
+        this.componentPaths.delete(name);
+        return true;
+    }
+    /**
+     * 检查是否已注册
+     */
+    isRegistered(name) {
+        return this.componentSchemas.has(name);
+    }
+    /**
+     * 列出所有注册的 Component
+     */
+    listComponents() {
+        return Array.from(this.componentSchemas.keys());
+    }
+    // === 层级 Key 访问 ===
+    /**
+     * 获取配置值（支持 xxx.yyy.zzz 嵌套访问）
+     * 支持两种模式：
+     * 1. 完整 key：直接查找，如 "component.key" -> 读取 "component.key"
+     * 2. 嵌套对象：查找 component 对象后从中获取属性，如 "component.nested.deep"
+     *    -> 先找 "component.nested"，再获取其 "deep" 属性
+     */
+    get(key) {
+        // 先检查内存层
+        const memoryValue = this.memorySource.read(key);
+        if (memoryValue !== undefined) {
+            return memoryValue;
+        }
+        // 尝试解析嵌套 key（从短到长尝试）
+        if (key.includes(".")) {
+            const parts = key.split(".");
+            // 从第二部分开始尝试，逐级向上查找父对象
+            for (let i = parts.length - 1; i >= 1; i--) {
+                const componentParts = parts.slice(0, i);
+                const component = componentParts.join(".");
+                const restParts = parts.slice(i);
+                const restKey = restParts.join(".");
+                const componentValue = this.memorySource.read(component);
+                if (typeof componentValue === "object" && componentValue !== null) {
+                    const nestedValue = this.getNestedValue(componentValue, restKey);
+                    if (nestedValue !== undefined) {
+                        return nestedValue;
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
+    /**
+     * 批量获取
+     */
+    getMany(keys) {
+        const result = {};
+        for (const key of keys) {
+            result[key] = this.get(key);
+        }
+        return result;
+    }
+    /**
+     * 设置配置值（内存级别 + 异步持久化）
+     */
+    async set(key, value) {
+        const oldValue = this.get(key);
+        // 写入内存（立即生效）
+        this.memorySource.write(key, value);
+        // 触发监听器
+        const event = {
+            component: key.split(".")[0],
+            key,
+            oldValue,
+            newValue: value,
+            persisted: false,
+            timestamp: Date.now(),
+        };
+        this.notifyWatchers(key, event);
+        // 队列化持久化（异步）
+        this.persistQueue.add(key, value);
+    }
+    /**
+     * 批量设置
+     */
+    async setMany(config) {
+        for (const [key, value] of Object.entries(config)) {
+            await this.set(key, value);
+        }
+    }
+    // === 路径 ===
+    /**
+     * 获取 Component 的路径
+     */
+    getPath(component, subPath) {
+        const paths = this.componentPaths.get(component);
+        if (!paths) {
+            throw new Error(`Component not registered: ${component}`);
+        }
+        if (subPath && paths[subPath]) {
+            const { base, subPath: relativePath } = paths[subPath];
+            return XDG_PATHS.getComponentPath(base, relativePath);
+        }
+        // 返回第一个注册的路径
+        const firstKey = Object.keys(paths)[0];
+        if (!firstKey) {
+            throw new Error(`No paths registered for component: ${component}`);
+        }
+        const { base, subPath: relativePath } = paths[firstKey];
+        return XDG_PATHS.getComponentPath(base, relativePath);
+    }
+    // === 持久化 ===
+    /**
+     * 手动持久化
+     */
+    async save(key) {
+        await this.persistQueue.flush();
+    }
+    /**
+     * 重置到默认值
+     */
+    async reset(key) {
+        const [component, ...rest] = key.split(".");
+        const schema = this.componentSchemas.get(component);
+        if (!schema)
+            return;
+        const partialKey = rest.join(".");
+        const defaultValue = schema.defaults[partialKey] ?? schema.defaults[key];
+        if (defaultValue !== undefined) {
+            await this.set(key, defaultValue);
+        }
+    }
+    // === 监听 ===
+    /**
+     * 监听配置变更
+     */
+    watch(pattern, callback) {
+        if (!this.watchers.has(pattern)) {
+            this.watchers.set(pattern, new Set());
+        }
+        this.watchers.get(pattern).add(callback);
+        return () => {
+            this.watchers.get(pattern)?.delete(callback);
+        };
+    }
+    // === 配置源 ===
+    /**
+     * 添加配置源
+     */
+    addSource(source) {
+        this.sources.push(source);
+        this.sources.sort((a, b) => a.priority - b.priority);
+        // 启用监听
+        if (source.watch) {
+            const callback = (event) => {
+                this.notifyWatchers(event.key, {
+                    component: event.key.split(".")[0],
+                    key: event.key,
+                    oldValue: event.oldValue,
+                    newValue: event.newValue,
+                    persisted: true,
+                    timestamp: event.timestamp,
+                });
+            };
+            // 调用 watch 并忽略错误（确保初始化错误不会中断流程）
+            try {
+                const unwatch = source.watch(callback);
+                const sourceKey = this.getSourceKey(source);
+                this.sourceUnwatchFns.set(sourceKey, unwatch);
+            }
+            catch {
+                // 忽略错误
+            }
+        }
+    }
+    /**
+     * 获取 Source 唯一标识
+     */
+    getSourceKey(source) {
+        if ("filePath" in source) {
+            return `file:${source.filePath}`;
+        }
+        if ("prefix" in source) {
+            return `env:${source.prefix}`;
+        }
+        return source.name;
+    }
+    /**
+     * 移除配置源
+     */
+    removeSource(name) {
+        const index = this.sources.findIndex((s) => s.name === name);
+        if (index > 0) {
+            // 清理 watcher
+            const source = this.sources[index];
+            const sourceKey = this.getSourceKey(source);
+            const unwatch = this.sourceUnwatchFns.get(sourceKey);
+            if (unwatch) {
+                unwatch();
+                this.sourceUnwatchFns.delete(sourceKey);
+            }
+            // 不移除 memorySource
+            this.sources.splice(index, 1);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * 关闭所有配置源的 watcher（用于优雅退出）
+     */
+    unwatchAll() {
+        for (const unwatch of this.sourceUnwatchFns.values()) {
+            unwatch();
+        }
+        this.sourceUnwatchFns.clear();
+    }
+    /**
+     * 获取配置源列表
+     */
+    getSources() {
+        return [...this.sources];
+    }
+    // === 私有方法 ===
+    getNestedValue(obj, key) {
+        const keys = key.split(".");
+        let current = obj;
+        for (const k of keys) {
+            if (typeof current !== "object" || current === null)
+                return undefined;
+            current = current[k];
+        }
+        return current;
+    }
+    notifyWatchers(key, event) {
+        // 精确匹配
+        const exactWatchers = this.watchers.get(key);
+        exactWatchers?.forEach((cb) => cb(event));
+        // 通配符匹配
+        const [component] = key.split(".");
+        const wildcardWatchers = this.watchers.get(`${component}.*`);
+        wildcardWatchers?.forEach((cb) => cb(event));
+        // 全局匹配
+        const globalWatchers = this.watchers.get("*");
+        globalWatchers?.forEach((cb) => cb(event));
+    }
+    async persistToFile(entries) {
+        if (!this.persistFile)
+            return;
+        // 简化实现：追加到文件
+        // 实际应该读取文件、合并、更新
+        console.log(`[ConfigComponent] Persisting ${entries.length} entries to ${this.persistFile}`);
+        // TODO: 实现完整文件持久化
+    }
+    // === 去中心化配置注册 ===
+    /**
+     * 注册配置 Source
+     *
+     * Source 会在首次 load() 时被创建
+     *
+     * @example
+     * config.registerSource({ type: "file", relativePath: "llm-config.jsonc" });
+     * config.registerSource({ type: "env", envPrefix: "LLM" });
+     */
+    registerSource(registration) {
+        const { type, relativePath, envPrefix } = registration;
+        // 生成唯一标识
+        const sourceKey = type === "file" && relativePath
+            ? `file:${relativePath}`
+            : `${type}:${envPrefix ?? ""}`;
+        // 检查是否已注册
+        if (this.sourceKeys.has(sourceKey)) {
+            return; // 忽略重复注册
+        }
+        // 延迟创建：只保存注册配置
+        this.pendingSources.push(registration);
+        this.sourceKeys.set(sourceKey, true);
+    }
+    /**
+     * 创建 Source 实例
+     */
+    createSource(registration) {
+        const { type, relativePath, envPrefix, priority, optional, watch } = registration;
+        switch (type) {
+            case "memory": {
+                // MemorySource 是内置的，直接返回
+                return this.memorySource;
+            }
+            case "file": {
+                if (!relativePath) {
+                    throw new Error("File source requires relativePath");
+                }
+                // 判断是绝对路径还是相对路径
+                // 注意：在 Bun 环境中，import.meta.url 返回的是 file:/// URL
+                const isAbsolutePath = path.isAbsolute(relativePath) || relativePath.startsWith("file://");
+                let filePath;
+                if (isAbsolutePath) {
+                    // 绝对路径：直接使用
+                    filePath = relativePath.startsWith("file://")
+                        ? relativePath.replace(/^file:\/\//, "")
+                        : relativePath;
+                }
+                else {
+                    // 相对路径：基于 XDG_DATA_HOME
+                    // 更新 ProtocolResolver 的 XDG_DATA_HOME 为当前值
+                    if (this.protocolResolver) {
+                        this.protocolResolver.xdgDataHome = this.getXdgDataHome();
+                    }
+                    filePath = path.join(this.getXdgDataHome(), relativePath);
+                }
+                return new FileSource({
+                    filePath,
+                    optional: optional ?? false,
+                    resolver: this.protocolResolver,
+                    watch: watch,
+                });
+            }
+            case "env": {
+                return new EnvSource({
+                    prefix: envPrefix ?? "",
+                    priority: priority ?? 20,
+                    watch: watch,
+                });
+            }
+            default:
+                throw new Error(`Unknown source type: ${type}`);
+        }
+    }
+    /**
+     * 确保所有待创建的 Source 已被创建
+     */
+    ensureSourcesCreated() {
+        for (const pending of this.pendingSources) {
+            const source = this.createSource(pending);
+            this.addSource(source);
+        }
+        this.pendingSources = [];
+    }
+    /**
+     * 注册配置 Key
+     *
+     * @example
+     * config.registerKeys([
+     *   { key: "llm.provider", sources: ["file", "memory"], default: "openai" },
+     *   { key: "llm.model", sources: ["file"] },
+     * ]);
+     */
+    registerKeys(keys) {
+        for (const keyReg of keys) {
+            // 如果已存在，跳过（保留原有注册）
+            if (this.keyRegistry.has(keyReg.key)) {
+                continue;
+            }
+            this.keyRegistry.set(keyReg.key, keyReg);
+            // 自动将默认值写入 memory source
+            if (keyReg.default !== undefined) {
+                if (this.memorySource.read(keyReg.key) === undefined) {
+                    this.memorySource.write(keyReg.key, keyReg.default);
+                }
+            }
+        }
+    }
+    /**
+     * 注册 Component（一次性注册 Source 和 Keys）
+     *
+     * @example
+     * config.registerComponent({
+     *   name: "llm",
+     *   sources: [
+     *     { type: "file", relativePath: "llm-config.jsonc" },
+     *     { type: "env", envPrefix: "LLM" },
+     *   ],
+     *   keys: [
+     *     { key: "llm.provider", sources: ["file", "env", "memory"] },
+     *   ],
+     * });
+     */
+    registerComponent(registration) {
+        const { name, sources, keys, defaults } = registration;
+        // 存储 Component 注册信息
+        this.componentRegistrations.set(name, registration);
+        // 注册所有 Source
+        for (const sourceReg of sources) {
+            this.registerSource(sourceReg);
+        }
+        // 注册所有 Keys
+        this.registerKeys(keys);
+        // 注册默认值（如果提供）
+        if (defaults) {
+            for (const [key, value] of Object.entries(defaults)) {
+                const fullKey = `${name}.${key}`;
+                if (this.memorySource.read(fullKey) === undefined) {
+                    this.memorySource.write(fullKey, value);
+                }
+            }
+        }
+    }
+    /**
+     * 按需加载配置
+     *
+     * 从注册的 Source 加载已注册 Keys 的配置值到内存中
+     *
+     * @param componentName - 可选，指定要加载的 Component 名称
+     *
+     * @example
+     * // 加载所有已注册的 Keys
+     * await config.load();
+     *
+     * // 只加载指定 Component 的 Keys
+     * await config.load("llm");
+     */
+    async load(componentName) {
+        // 确保所有待创建的 Source 已被创建
+        this.ensureSourcesCreated();
+        // 确定要加载哪些 Keys
+        let keysToLoad;
+        if (componentName) {
+            // 只加载指定 Component 的 Keys
+            const registration = this.componentRegistrations.get(componentName);
+            if (!registration) {
+                return; // Component 未注册，直接返回
+            }
+            keysToLoad = registration.keys.map(k => ({
+                key: k.key,
+                sources: k.sources,
+            }));
+        }
+        else {
+            // 加载所有已注册的 Keys
+            keysToLoad = Array.from(this.keyRegistry.values()).map(k => ({
+                key: k.key,
+                sources: k.sources,
+            }));
+        }
+        // 按 Source 分组加载
+        const sourcesByType = new Map();
+        for (const source of this.sources) {
+            sourcesByType.set(source.name, source);
+        }
+        // 加载每个 Key
+        for (const { key, sources: sourceTypes } of keysToLoad) {
+            // 检查内存中是否已有值
+            if (this.memorySource.read(key) !== undefined) {
+                continue; // 已有值，跳过
+            }
+            // 按优先级加载
+            // sources 参数指定了要查询的 Source 类型列表
+            // 我们需要从这些 Source 中找到第一个有值的
+            for (const sourceType of sourceTypes) {
+                const source = sourcesByType.get(sourceType);
+                if (!source)
+                    continue;
+                const value = source.read(key);
+                if (value !== undefined) {
+                    // 加载到内存
+                    this.memorySource.write(key, value);
+                    break;
+                }
+            }
+        }
+    }
+    /**
+     * 获取已注册的 Source 列表
+     */
+    getRegisteredSources() {
+        // 确保所有延迟创建的 Source 已被创建
+        this.ensureSourcesCreated();
+        return [...this.sources];
+    }
+}
+//# sourceMappingURL=config-component.js.map

package/dist/core/src/config/config-component.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=config-component.test.d.ts.map