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

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

@@ -1,212 +0,0 @@
-/**
- * @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

@@ -1,20 +0,0 @@
-/**
- * @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

@@ -1,40 +0,0 @@
-/**
- * @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

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

@@ -1,295 +0,0 @@
-/**
- * @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

@@ -1,84 +0,0 @@
-/**
- * @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