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

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

@@ -1,686 +0,0 @@
-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

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