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

package/dist/core/src/env/log-trace/log-trace-component.test.js

@@ -0,0 +1,212 @@
+/**
+ * @fileoverview LogTraceComponent Tests
+ *
+ * 使用 TDD 方法测试 LogTraceComponent 配置加载
+ */
+import { describe, test, expect, beforeEach, afterEach, vi } from "bun:test";
+import { LogTraceComponent } from "./log-trace-component.js";
+import { ConfigComponent } from "../../config/config-component.js";
+import * as fsSync from "fs";
+import * as path from "path";
+import * as os from "os";
+describe("LogTraceComponent Config Loading", () => {
+    let component;
+    let configComponent;
+    let mockEnv;
+    let tempDir;
+    beforeEach(() => {
+        component = new LogTraceComponent();
+        configComponent = new ConfigComponent();
+        // Create temp directory for config files
+        tempDir = fsSync.mkdtempSync(path.join(os.tmpdir(), "logtrace-config-test-"));
+        // Set XDG_DATA_HOME to temp directory so ConfigComponent can find config files
+        configComponent.setXdgDataHome(tempDir);
+        // Mock environment
+        mockEnv = {
+            name: "test-env",
+            version: "1.0.0",
+            getComponent: vi.fn((name) => {
+                if (name === "config")
+                    return configComponent;
+                return undefined;
+            }),
+            hasComponent: vi.fn((name) => name === "config"),
+            logger: vi.fn(),
+            trace: vi.fn(),
+        };
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+        // Clean up environment variables
+        delete process.env.LOG_TRACE_LOGGING_LEVEL;
+        delete process.env.LOG_TRACE_LOGGING_QUIET;
+        delete process.env.LOG_TRACE_TRACING_ENABLED;
+        delete process.env.LOG_TRACE_TRACING_STORAGE;
+        delete process.env.LOG_LOGGING_LEVEL;
+        delete process.env.LOG_LOGGING_LEVEL;
+        // Clean up temp directory
+        try {
+            fsSync.rmSync(tempDir, { recursive: true });
+        }
+        catch { }
+    });
+    describe("LogTraceComponentOptions", () => {
+        test("should accept configComponent only", async () => {
+            await component.init({
+                name: "log-trace",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent }
+            });
+            expect(component.getStatus()).toBe("running");
+        });
+        test("should accept configPath option", async () => {
+            fsSync.writeFileSync(path.join(tempDir, "config.jsonc"), JSON.stringify({
+                "log-trace": {
+                    logging: {
+                        level: "debug"
+                    }
+                }
+            }), "utf-8");
+            await component.init({
+                name: "log-trace",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent, configPath: "config.jsonc" }
+            });
+            expect(component.getStatus()).toBe("running");
+        });
+        test("should accept envPrefix option", async () => {
+            process.env.LOG_TRACE_LOGGING_LEVEL = "warn";
+            await component.init({
+                name: "log-trace",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent, envPrefix: "LOG_TRACE" }
+            });
+            expect(component.getStatus()).toBe("running");
+            delete process.env.LOG_TRACE_LOGGING_LEVEL;
+        });
+        test("should accept config option with direct object", async () => {
+            await component.init({
+                name: "log-trace",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: {
+                    configComponent,
+                    config: {
+                        logging: {
+                            level: "error"
+                        }
+                    }
+                }
+            });
+            expect(component.getStatus()).toBe("running");
+        });
+    });
+    describe("config priority: Object > Env > File", () => {
+        test("should Object config override Env config", async () => {
+            // Set environment variable (使用正确的格式)
+            // LOG_TRACE_LOGGING_LEVEL -> log-trace.logging.level
+            process.env.LOG_TRACE_LOGGING_LEVEL = "warn";
+            // Create file config
+            fsSync.writeFileSync(path.join(tempDir, "config.jsonc"), JSON.stringify({
+                "log-trace": { logging: { level: "info" } }
+            }), "utf-8");
+            await component.init({
+                name: "log-trace",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: {
+                    configComponent,
+                    configPath: "config.jsonc",
+                    envPrefix: "LOG_TRACE",
+                    config: { logging: { level: "error" } } // Object has highest priority
+                }
+            });
+            // Object config should have highest priority
+            expect(configComponent.get("log-trace.logging.level")).toBe("error");
+            delete process.env.LOG_TRACE_LOGGING_LEVEL;
+        });
+        test("should Env config override File config", async () => {
+            // Set environment variable (使用正确的格式: PREFIX + KEY)
+            // LOG_TRACE_LOGGING_LEVEL -> log-trace.logging.level
+            process.env.LOG_TRACE_LOGGING_LEVEL = "warn";
+            // Create file config
+            fsSync.writeFileSync(path.join(tempDir, "config.jsonc"), JSON.stringify({
+                "log-trace": { logging: { level: "info" } }
+            }), "utf-8");
+            await component.init({
+                name: "log-trace",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: {
+                    configComponent,
+                    configPath: "config.jsonc",
+                    envPrefix: "LOG_TRACE"
+                }
+            });
+            // Env should override file
+            expect(configComponent.get("log-trace.logging.level")).toBe("warn");
+            delete process.env.LOG_TRACE_LOGGING_LEVEL;
+        });
+        test("should File config be loaded when present", async () => {
+            fsSync.writeFileSync(path.join(tempDir, "config.jsonc"), JSON.stringify({
+                "log-trace": {
+                    logging: {
+                        level: "debug",
+                        quiet: true
+                    },
+                    tracing: {
+                        enabled: false
+                    }
+                }
+            }), "utf-8");
+            await component.init({
+                name: "log-trace",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: {
+                    configComponent,
+                    configPath: "config.jsonc"
+                }
+            });
+            expect(configComponent.get("log-trace.logging.level")).toBe("debug");
+            expect(configComponent.get("log-trace.logging.quiet")).toBe(true);
+            expect(configComponent.get("log-trace.tracing.enabled")).toBe(false);
+        });
+        test("should use default values when no config provided", async () => {
+            await component.init({
+                name: "log-trace",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent }
+            });
+            // Default values should be set from LOG_TRACE_DEFAULTS
+            expect(configComponent.get("log-trace.logging.level")).toBe("info");
+        });
+    });
+    describe("config hot reload", () => {
+        test("should register config watcher for hot reload", async () => {
+            const watcherFn = vi.fn();
+            vi.spyOn(configComponent, "watch").mockReturnValue(watcherFn);
+            await component.init({
+                name: "log-trace",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent }
+            });
+            expect(configComponent.watch).toHaveBeenCalledWith("log-trace.*", expect.any(Function));
+        });
+    });
+});
+//# sourceMappingURL=log-trace-component.test.js.map

package/dist/core/src/env/log-trace/log-trace-config-registration.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @fileoverview LogTrace Component 配置注册
+ *
+ * 使用 ConfigComponent.registerComponent() 机制统一管理配置
+ */
+import type { ComponentRegistration } from "../../config/config-component";
+/**
+ * LogTrace Component 默认配置值
+ *
+ * 注意：键使用完整格式（带 "log-trace." 前缀），在 registerConfig 中手动设置
+ * 注意：动态默认值（logging.dir, logging.file, logging.maxOutput）在 registerConfig 中单独处理
+ */
+export declare const LOG_TRACE_DEFAULTS: Record<string, unknown>;
+/**
+ * LogTrace Component 配置注册常量
+ *
+ * 定义了所有 LogTrace 相关的配置项和来源
+ */
+export declare const LOG_TRACE_CONFIG_REGISTRATION: ComponentRegistration;
+//# sourceMappingURL=log-trace-config-registration.d.ts.map

package/dist/core/src/env/log-trace/log-trace-config-registration.js

@@ -0,0 +1,40 @@
+/**
+ * @fileoverview LogTrace Component 配置注册
+ *
+ * 使用 ConfigComponent.registerComponent() 机制统一管理配置
+ */
+/**
+ * LogTrace Component 默认配置值
+ *
+ * 注意：键使用完整格式（带 "log-trace." 前缀），在 registerConfig 中手动设置
+ * 注意：动态默认值（logging.dir, logging.file, logging.maxOutput）在 registerConfig 中单独处理
+ */
+export const LOG_TRACE_DEFAULTS = {
+    "log-trace.logging.enabled": true,
+    "log-trace.logging.level": "info",
+    "log-trace.logging.quiet": false,
+    "log-trace.tracing.enabled": true,
+};
+/**
+ * LogTrace Component 配置注册常量
+ *
+ * 定义了所有 LogTrace 相关的配置项和来源
+ */
+export const LOG_TRACE_CONFIG_REGISTRATION = {
+    name: "log-trace",
+    sources: [
+        { type: "env", envPrefix: "LOG_TRACE", priority: 20, watch: false },
+    ],
+    keys: [
+        { key: "log-trace.logging.enabled", sources: ["env", "file"] },
+        { key: "log-trace.logging.level", sources: ["env", "file"] },
+        { key: "log-trace.logging.quiet", sources: ["env", "file"] },
+        { key: "log-trace.logging.dir", sources: ["env", "file"] },
+        { key: "log-trace.logging.file", sources: ["env", "file"] },
+        { key: "log-trace.logging.maxOutput", sources: ["env", "file"] },
+        { key: "log-trace.tracing.enabled", sources: ["env", "file"] },
+        { key: "log-trace.tracing.dbPath", sources: ["env", "file"] },
+    ],
+    // 注意：不使用 defaults 字段，默认值在 registerConfig 中手动 set
+};
+//# sourceMappingURL=log-trace-config-registration.js.map

package/dist/core/src/env/log-trace/log-trace-config-registration.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview LogTrace Component 配置注册测试
+ *
+ * TDD: 先写测试，验证配置注册机制
+ */
+export {};
+//# sourceMappingURL=log-trace-config-registration.test.d.ts.map

package/dist/core/src/env/log-trace/log-trace-config-registration.test.js

@@ -0,0 +1,295 @@
+/**
+ * @fileoverview LogTrace Component 配置注册测试
+ *
+ * TDD: 先写测试，验证配置注册机制
+ */
+import { describe, it, expect, beforeEach } from "vitest";
+import { ConfigComponent } from "../../config/config-component.js";
+import { LogTraceComponent } from "./log-trace-component.js";
+import { LOG_TRACE_CONFIG_REGISTRATION, LOG_TRACE_DEFAULTS } from "./log-trace-config-registration.js";
+describe("LogTrace Config Registration (TDD)", () => {
+    let configComponent;
+    let component;
+    beforeEach(() => {
+        configComponent = new ConfigComponent();
+        component = new LogTraceComponent();
+    });
+    // ========================================================================
+    // 核心验收标准：registerConfig 必须遵循 SessionComponent 模式
+    // ========================================================================
+    describe("【验收标准】默认值注册", () => {
+        it("应该注册 log-trace.logging.enabled 的默认值为 true", async () => {
+            await component.init({
+                options: { configComponent },
+            });
+            const enabled = configComponent.get("log-trace.logging.enabled");
+            expect(enabled).toBe(true);
+        });
+        it("应该注册 log-trace.logging.level 的默认值为 info", async () => {
+            await component.init({
+                options: { configComponent },
+            });
+            const level = configComponent.get("log-trace.logging.level");
+            expect(level).toBe("info");
+        });
+        it("应该注册 log-trace.logging.quiet 的默认值为 false", async () => {
+            await component.init({
+                options: { configComponent },
+            });
+            const quiet = configComponent.get("log-trace.logging.quiet");
+            expect(quiet).toBe(false);
+        });
+        it("应该注册 log-trace.tracing.enabled 的默认值为 true", async () => {
+            await component.init({
+                options: { configComponent },
+            });
+            const enabled = configComponent.get("log-trace.tracing.enabled");
+            expect(enabled).toBe(true);
+        });
+        it("应该注册 log-trace.logging.dir 的默认值", async () => {
+            await component.init({
+                options: { configComponent },
+            });
+            const logDir = configComponent.get("log-trace.logging.dir");
+            expect(logDir).toBeDefined();
+            expect(typeof logDir).toBe("string");
+        });
+        it("应该注册 log-trace.logging.maxOutput 的默认值为 0", async () => {
+            await component.init({
+                options: { configComponent },
+            });
+            const maxOutput = configComponent.get("log-trace.logging.maxOutput");
+            expect(maxOutput).toBe(0);
+        });
+    });
+    describe("【验收标准】配置优先级 - config 对象覆盖默认值", () => {
+        it("应该允许 config 对象覆盖 logging.level", async () => {
+            await component.init({
+                options: {
+                    configComponent,
+                    config: {
+                        logging: {
+                            level: "debug",
+                        },
+                    },
+                },
+            });
+            const level = configComponent.get("log-trace.logging.level");
+            expect(level).toBe("debug");
+        });
+        it("应该允许 config 对象覆盖 logging.enabled", async () => {
+            await component.init({
+                options: {
+                    configComponent,
+                    config: {
+                        logging: {
+                            enabled: false,
+                        },
+                    },
+                },
+            });
+            const enabled = configComponent.get("log-trace.logging.enabled");
+            expect(enabled).toBe(false);
+        });
+        it("应该允许 config 对象覆盖 tracing.enabled", async () => {
+            await component.init({
+                options: {
+                    configComponent,
+                    config: {
+                        tracing: {
+                            enabled: false,
+                        },
+                    },
+                },
+            });
+            const enabled = configComponent.get("log-trace.tracing.enabled");
+            expect(enabled).toBe(false);
+        });
+    });
+    describe("【验收标准】环境变量覆盖", () => {
+        it("应该通过环境变量覆盖 logging.level", async () => {
+            // 设置环境变量：LOG_TRACE_LOGGING_LEVEL -> log-trace.logging.level
+            const originalValue = process.env.LOG_TRACE_LOGGING_LEVEL;
+            process.env.LOG_TRACE_LOGGING_LEVEL = "debug";
+            try {
+                await component.init({
+                    options: { configComponent },
+                });
+                const level = configComponent.get("log-trace.logging.level");
+                expect(level).toBe("debug");
+            }
+            finally {
+                if (originalValue !== undefined) {
+                    process.env.LOG_TRACE_LOGGING_LEVEL = originalValue;
+                }
+                else {
+                    delete process.env.LOG_TRACE_LOGGING_LEVEL;
+                }
+            }
+        });
+        // 注意：环境变量总是字符串，ConfigComponent.get 返回的也是字符串
+        // 如果需要布尔值，应该在应用层进行类型转换
+        it("应该通过环境变量覆盖 logging.enabled (字符串形式)", async () => {
+            const originalValue = process.env.LOG_TRACE_LOGGING_ENABLED;
+            process.env.LOG_TRACE_LOGGING_ENABLED = "false";
+            try {
+                await component.init({
+                    options: { configComponent },
+                });
+                const enabled = configComponent.get("log-trace.logging.enabled");
+                expect(enabled).toBe("false");
+            }
+            finally {
+                if (originalValue !== undefined) {
+                    process.env.LOG_TRACE_LOGGING_ENABLED = originalValue;
+                }
+                else {
+                    delete process.env.LOG_TRACE_LOGGING_ENABLED;
+                }
+            }
+        });
+        it("应该通过环境变量覆盖 tracing.enabled (字符串形式)", async () => {
+            const originalValue = process.env.LOG_TRACE_TRACING_ENABLED;
+            process.env.LOG_TRACE_TRACING_ENABLED = "false";
+            try {
+                await component.init({
+                    options: { configComponent },
+                });
+                const enabled = configComponent.get("log-trace.tracing.enabled");
+                expect(enabled).toBe("false");
+            }
+            finally {
+                if (originalValue !== undefined) {
+                    process.env.LOG_TRACE_TRACING_ENABLED = originalValue;
+                }
+                else {
+                    delete process.env.LOG_TRACE_TRACING_ENABLED;
+                }
+            }
+        });
+    });
+    describe("【验收标准】LOG_TRACE_CONFIG_REGISTRATION 使用", () => {
+        it("应该导出正确的 registration 对象", () => {
+            expect(LOG_TRACE_CONFIG_REGISTRATION.name).toBe("log-trace");
+        });
+        it("应该包含所有必需的 keys", () => {
+            const expectedKeys = [
+                "log-trace.logging.enabled",
+                "log-trace.logging.level",
+                "log-trace.logging.quiet",
+                "log-trace.tracing.enabled",
+            ];
+            for (const key of expectedKeys) {
+                const found = LOG_TRACE_CONFIG_REGISTRATION.keys.some((k) => k.key === key);
+                expect(found).toBe(true);
+            }
+        });
+        it("应该导出默认值常量（完整格式）", () => {
+            expect(LOG_TRACE_DEFAULTS).toBeDefined();
+            expect(LOG_TRACE_DEFAULTS["log-trace.logging.enabled"]).toBe(true);
+            expect(LOG_TRACE_DEFAULTS["log-trace.logging.level"]).toBe("info");
+            expect(LOG_TRACE_DEFAULTS["log-trace.tracing.enabled"]).toBe(true);
+        });
+    });
+});
+// Legacy tests preserved for reference
+describe("LogTrace Config Registration (Legacy)", () => {
+    let configComponent;
+    let component;
+    beforeEach(() => {
+        configComponent = new ConfigComponent();
+        component = new LogTraceComponent();
+    });
+    describe("LOG_TRACE_CONFIG_REGISTRATION", () => {
+        it("应该包含正确的 name", () => {
+            expect(LOG_TRACE_CONFIG_REGISTRATION.name).toBe("log-trace");
+        });
+        it("应该包含 env source 配置", () => {
+            const envSource = LOG_TRACE_CONFIG_REGISTRATION.sources.find((s) => s.type === "env");
+            expect(envSource).toBeDefined();
+            expect(envSource?.envPrefix).toBe("LOG_TRACE");
+            expect(envSource?.priority).toBe(20);
+        });
+        it("应该包含所有配置 keys", () => {
+            const keys = LOG_TRACE_CONFIG_REGISTRATION.keys;
+            expect(keys).toContainEqual(expect.objectContaining({ key: "log-trace.logging.enabled" }));
+            expect(keys).toContainEqual(expect.objectContaining({ key: "log-trace.logging.level" }));
+            expect(keys).toContainEqual(expect.objectContaining({ key: "log-trace.tracing.enabled" }));
+        });
+    });
+    describe("LOG_TRACE_DEFAULTS", () => {
+        it("应该包含 logging.enabled 默认值（完整格式）", () => {
+            expect(LOG_TRACE_DEFAULTS["log-trace.logging.enabled"]).toBe(true);
+        });
+        it("应该包含 logging.level 默认值（完整格式）", () => {
+            expect(LOG_TRACE_DEFAULTS["log-trace.logging.level"]).toBe("info");
+        });
+        it("应该包含 tracing.enabled 默认值（完整格式）", () => {
+            expect(LOG_TRACE_DEFAULTS["log-trace.tracing.enabled"]).toBe(true);
+        });
+    });
+    describe("配置注册到 ConfigComponent", () => {
+        it("应该能够注册 LOG_TRACE_CONFIG_REGISTRATION", () => {
+            configComponent.registerComponent(LOG_TRACE_CONFIG_REGISTRATION);
+            expect(() => configComponent.registerComponent(LOG_TRACE_CONFIG_REGISTRATION)).not.toThrow();
+        });
+    });
+    describe("Component 配置加载", () => {
+        it("应该需要 ConfigComponent 初始化", async () => {
+            await expect(component.init({
+                options: {},
+            })).rejects.toThrow("ConfigComponent is required");
+        });
+        it("应该能够使用 ConfigComponent 初始化", async () => {
+            await component.init({
+                options: {
+                    configComponent,
+                },
+            });
+            expect(component.name).toBe("log-trace");
+            expect(component.version).toBe("1.0.0");
+        });
+        it("应该能够通过 config 对象传入配置", async () => {
+            await component.init({
+                options: {
+                    configComponent,
+                    config: {
+                        logging: {
+                            enabled: false,
+                            level: "debug",
+                        },
+                        tracing: {
+                            enabled: true,
+                        },
+                    },
+                },
+            });
+            expect(component.name).toBe("log-trace");
+        });
+    });
+    describe("环境变量覆盖", () => {
+        it("应该能够通过环境变量覆盖配置", async () => {
+            // 设置环境变量
+            const originalValue = process.env.LOG_TRACE_LOGGING_LEVEL;
+            process.env.LOG_TRACE_LOGGING_LEVEL = "debug";
+            try {
+                await component.init({
+                    options: {
+                        configComponent,
+                    },
+                });
+                expect(component.name).toBe("log-trace");
+            }
+            finally {
+                // 恢复环境变量
+                if (originalValue !== undefined) {
+                    process.env.LOG_TRACE_LOGGING_LEVEL = originalValue;
+                }
+                else {
+                    delete process.env.LOG_TRACE_LOGGING_LEVEL;
+                }
+            }
+        });
+    });
+});
+//# sourceMappingURL=log-trace-config-registration.test.js.map

package/dist/core/src/env/log-trace/logger.d.ts

@@ -0,0 +1,84 @@
+/**
+ * @fileoverview Logger - 统一日志系统
+ *
+ * 遵循 XDG Base Directory Specification:
+ * - 日志存储在 XDG_DATA_HOME/roy-agent/logs/ (默认 ~/.local/share/roy-agent/logs/)
+ * 无需配置，自动创建目录
+ *
+ * 支持 traceId 追踪：通过 trace-context 模块自动注入
+ *
+ * 配置优先级（从高到低）：
+ * 1. ConfigComponent (log-trace.logging.level, log-trace.logging.dir)
+ * 2. 环境变量 (LOG_LEVEL, LOG_DIR)
+ * 3. setLogDirOverride() 手动设置
+ * 4. XDG 默认路径
+ */
+/**
+ * 简化 Bun file: 协议的编码路径
+ * 例如: packages+core/node_modules/.bun/@roy-agent+core@file+packages+core/node_modules/@roy-agent/core/src/env/agent/agent-component.ts
+ * 转换为: packages/core/src/env/agent/agent-component.ts
+ */
+export declare function simplifyFilePath(fullPath: string): string;
+import type { LogLevel, ILogger } from "./types";
+export declare function isQuietMode(): boolean;
+export declare function setQuietMode(enabled: boolean): void;
+/**
+ * 设置 ConfigComponent 实例（用于实时配置读取）
+ */
+export declare function setConfigComponent(component: any): void;
+/**
+ * 获取日志级别（支持热更新）
+ */
+export declare function getLogLevel(): LogLevel;
+/**
+ * 获取指定类别的日志级别
+ *
+ * 支持按类别配置日志级别，配置路径：log-trace.logging.levels.<category>
+ *
+ * @param category 日志类别（如 "llm", "agent", "tool"）
+ * @returns 该类别的日志级别，如果未配置则返回全局级别
+ */
+export declare function getCategoryLogLevel(category: string): LogLevel;
+/**
+ * 获取日志文件名
+ * 实时从 ConfigComponent 读取（支持 env/file/memory 多 source）
+ */
+export declare function getLogFile(): string;
+export declare function getLogDir(): string;
+/**
+ * 获取日志输出最大长度配置
+ * 实时从 ConfigComponent 读取
+ *
+ * @returns 配置的值（0 表示不限制），如果未配置则返回 undefined
+ */
+export declare function getMaxOutput(): number | undefined;
+export declare function setLogDirOverride(dir: string): void;
+export declare function getLogDirOverride(): string | undefined;
+declare class Logger implements ILogger {
+    private prefix;
+    constructor(prefix: string);
+    private shouldLog;
+    private ensureLogDirectory;
+    private getCallerLocation;
+    private getRelativePath;
+    private formatMessage;
+    private writeToFile;
+    private log;
+    debug(message: string, data?: unknown): void;
+    info(message: string, data?: unknown): void;
+    warn(message: string, data?: unknown): void;
+    error(message: string, data?: unknown): void;
+}
+/**
+ * 创建或获取 Logger 实例
+ * @param prefix Logger 前缀
+ *
+ * 日志文件名通过 ConfigComponent 实时读取（log-trace.logging.file）
+ */
+export declare function createLogger(prefix: string): Logger;
+/**
+ * 获取所有日志级别
+ */
+export declare function getLogLevels(): LogLevel[];
+export type { LogLevel, ILogger } from "./types";
+//# sourceMappingURL=logger.d.ts.map