@decohere/scribe 0.0.1-dev.39 → 0.0.1-dev.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decohere/scribe",
-  "version": "0.0.1-dev.39",
+  "version": "0.0.1-dev.4",
   "description": "Structured logging interface with pluggable adapters",
   "keywords": [
     "typescript",

package/src/console.adapter.js

@@ -0,0 +1,64 @@
+import { LogAdapter } from "./logger.adapter.js";
+import { DefaultLogLevel, LogLevels } from "./types.js";
+export class ConsoleAdapter extends LogAdapter {
+    configuredLevels;
+    configuredLogLevel = DefaultLogLevel;
+    configuredLogLevelValue = LogLevels.info;
+    constructor(_options = {}){
+        super();
+    }
+    configure(scribeOptions) {
+        // Get merged log levels (default + custom) using parent class method
+        this.configuredLevels = this.getLogLevels(scribeOptions);
+        const logLevelStr = scribeOptions.logLevel ?? DefaultLogLevel;
+        this.configuredLogLevel = logLevelStr;
+        this.configuredLogLevelValue = this.configuredLevels[logLevelStr] ?? LogLevels.info;
+    }
+    getLogger(name) {
+        const loggerName = name || "default";
+        return this.createConsoleLogger(loggerName);
+    }
+    createConsoleLogger(name) {
+        // Use the levels configured during the configure() call
+        const allLevels = this.configuredLevels;
+        const currentLevel = this.configuredLogLevel;
+        const threshold = this.configuredLogLevelValue;
+        const baseLogger = {
+            get currentLevel () {
+                return currentLevel;
+            },
+            get logLevels () {
+                return allLevels;
+            }
+        };
+        const logFunction = (level)=>(msg, ...args)=>{
+                const timestamp = new Date().toISOString();
+                let message;
+                if (typeof msg === "object") {
+                    message = JSON.stringify(msg);
+                } else {
+                    message = String(msg);
+                }
+                const logLine = `[${timestamp}] ${level.toUpperCase()} [${name}]: ${message}`;
+                if (args.length > 0) {
+                    console.log(logLine, ...args);
+                } else {
+                    console.log(logLine);
+                }
+            };
+        const noop = ()=>{};
+        // Start with base logger and isLevelEnabled method
+        const logger = Object.assign(baseLogger, {
+            isLevelEnabled: (level)=>(allLevels[level] ?? 0) >= threshold
+        });
+        // Dynamically add all log level methods (default + custom)
+        // Levels below the configured threshold are patched to noop
+        for (const [levelName, levelValue] of Object.entries(allLevels)){
+            // biome-ignore lint/suspicious/noExplicitAny: Dynamic logger level creation requires any
+            logger[levelName] = levelValue >= threshold ? logFunction(levelName) : noop;
+        }
+        return logger;
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/src/logger.adapter.js

@@ -0,0 +1,24 @@
+import { LogLevels } from "./types.js";
+export class LogAdapter {
+    flush(cb) {
+        cb?.();
+    }
+    // biome-ignore lint/suspicious/noExplicitAny: Generic utility method needs flexible typing
+    getLogLevels(options) {
+        const { customOnly, customLevels } = options;
+        if (customOnly) {
+            return customLevels;
+        }
+        const levels = this.getUniqueLevels(LogLevels, customLevels);
+        return Object.fromEntries(levels);
+    }
+    getUniqueLevels(defaultLevels, customLevels) {
+        const defaultEntries = Object.entries(defaultLevels ?? {});
+        const customEntries = Object.entries(customLevels ?? {});
+        const defaultNotInCustom = defaultEntries.filter(([dk])=>customEntries.findIndex(([ck])=>ck === dk) === -1);
+        const unique = defaultNotInCustom.concat(customEntries);
+        return unique;
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/tests/console.adapter.custom-levels.spec.js

@@ -0,0 +1,69 @@
+import { describe, expect, it, vi } from "vitest";
+import { ConsoleAdapter } from "../src/console.adapter.js";
+import { scribe } from "../src/logger.factory.js";
+describe("Console Adapter Custom Levels", ()=>{
+    it("should support custom log levels", ()=>{
+        const spy = vi.spyOn(console, "log").mockImplementation(()=>{});
+        const customLevels = {
+            custom: 100,
+            debug2: 25
+        };
+        // Use trace level so all custom levels (including debug2: 25) are enabled
+        const loggerFactory = scribe.configure({
+            adapter: new ConsoleAdapter(),
+            options: {
+                logLevel: "trace",
+                customLevels
+            }
+        });
+        const logger = loggerFactory("test");
+        // Test custom level methods exist and work
+        expect(typeof logger.custom).toBe("function");
+        expect(typeof logger.debug2).toBe("function");
+        logger.custom("Custom level message");
+        logger.debug2("Debug2 level message");
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining("CUSTOM [test]: Custom level message"));
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining("DEBUG2 [test]: Debug2 level message"));
+        spy.mockRestore();
+    });
+    it("should include custom levels in logLevels property", ()=>{
+        const customLevels = {
+            custom: 100,
+            special: 15
+        };
+        const logger = scribe.logger("test", customLevels);
+        const logLevels = logger.logLevels;
+        // Should include default levels
+        expect(logLevels.fatal).toBe(60);
+        expect(logLevels.error).toBe(50);
+        expect(logLevels.info).toBe(30);
+        // Should include custom levels
+        expect(logLevels.custom).toBe(100);
+        expect(logLevels.special).toBe(15);
+    });
+    it("should work without custom levels (backwards compatibility)", ()=>{
+        const spy = vi.spyOn(console, "log").mockImplementation(()=>{});
+        const logger = scribe.logger("test");
+        logger.info("Regular message");
+        logger.error("Error message");
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining("INFO [test]: Regular message"));
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining("ERROR [test]: Error message"));
+        spy.mockRestore();
+    });
+    it("should override default levels with custom levels", ()=>{
+        const customLevels = {
+            info: 999,
+            newLevel: 50
+        };
+        const logger = scribe.logger("test", customLevels);
+        const logLevels = logger.logLevels;
+        // Custom level should override default
+        expect(logLevels.info).toBe(999);
+        expect(logLevels.newLevel).toBe(50);
+        // Other defaults should remain
+        expect(logLevels.fatal).toBe(60);
+        expect(logLevels.error).toBe(50);
+    });
+});
+
+//# sourceMappingURL=data:application/json;base64,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

package/tests/console.adapter.spec.js

@@ -0,0 +1,74 @@
+import { describe, expect, it, vi } from "vitest";
+import { ConsoleAdapter } from "../src/console.adapter.js";
+import { scribe } from "../src/logger.factory.js";
+describe("Console Adapter", ()=>{
+    it("should work without configuration", ()=>{
+        const spy = vi.spyOn(console, "log").mockImplementation(()=>{});
+        const logger = scribe.logger("test");
+        logger.info("Hello world");
+        expect(spy).toHaveBeenCalledWith(expect.stringMatching(/\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z\] INFO \[test\]: Hello world/));
+        spy.mockRestore();
+    });
+    it("should support all log levels when configured at trace", ()=>{
+        const spy = vi.spyOn(console, "log").mockImplementation(()=>{});
+        const loggerFactory = scribe.configure({
+            adapter: new ConsoleAdapter(),
+            options: {
+                logLevel: "trace"
+            }
+        });
+        const logger = loggerFactory("test");
+        logger.fatal("Fatal message");
+        logger.error("Error message");
+        logger.warn("Warning message");
+        logger.info("Info message");
+        logger.debug("Debug message");
+        logger.trace("Trace message");
+        expect(spy).toHaveBeenCalledTimes(6);
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining("FATAL"));
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining("ERROR"));
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining("WARN"));
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining("INFO"));
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining("DEBUG"));
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining("TRACE"));
+        spy.mockRestore();
+    });
+    it("should filter logs below the configured level", ()=>{
+        const spy = vi.spyOn(console, "log").mockImplementation(()=>{});
+        const loggerFactory = scribe.configure({
+            adapter: new ConsoleAdapter(),
+            options: {
+                logLevel: "warn"
+            }
+        });
+        const logger = loggerFactory("test");
+        logger.fatal("Fatal message");
+        logger.error("Error message");
+        logger.warn("Warning message");
+        logger.info("Info message");
+        logger.debug("Debug message");
+        logger.trace("Trace message");
+        // Only fatal (60), error (50), warn (40) are >= warn threshold (40)
+        expect(spy).toHaveBeenCalledTimes(3);
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining("FATAL"));
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining("ERROR"));
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining("WARN"));
+        spy.mockRestore();
+    });
+    it("should have logger properties", ()=>{
+        const loggerFactory = scribe.configure({
+            adapter: new ConsoleAdapter(),
+            options: {
+                logLevel: "info"
+            }
+        });
+        const logger = loggerFactory("test");
+        expect(logger.currentLevel).toBe("info");
+        expect(logger.logLevels).toBeDefined();
+        expect(logger.isLevelEnabled("info")).toBe(true);
+        expect(logger.isLevelEnabled("debug")).toBe(false);
+        expect(logger.isLevelEnabled("warn")).toBe(true);
+    });
+});
+
+//# sourceMappingURL=data:application/json;base64,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

package/tests/env.spec.js

@@ -0,0 +1,187 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { ConsoleAdapter } from "../src/console.adapter.js";
+import { getLogLevelFromArgv, getLogLevelFromEnv, isValidLogLevel, resolveLogLevel } from "../src/env.js";
+import { scribe } from "../src/logger.factory.js";
+describe("getLogLevelFromArgv", ()=>{
+    it("reads long-form flag with separate value", ()=>{
+        expect(getLogLevelFromArgv([
+            "node",
+            "cli.js",
+            "--log-level",
+            "trace"
+        ])).toBe("trace");
+    });
+    it("reads short-form flag with separate value", ()=>{
+        expect(getLogLevelFromArgv([
+            "node",
+            "cli.js",
+            "-l",
+            "debug"
+        ])).toBe("debug");
+    });
+    it("reads equals-form flag", ()=>{
+        expect(getLogLevelFromArgv([
+            "node",
+            "cli.js",
+            "--log-level=warn"
+        ])).toBe("warn");
+    });
+    it("returns undefined when flag is absent", ()=>{
+        expect(getLogLevelFromArgv([
+            "node",
+            "cli.js",
+            "build"
+        ])).toBeUndefined();
+    });
+});
+describe("getLogLevelFromEnv", ()=>{
+    beforeEach(()=>{
+        vi.stubEnv("LOG_LEVEL", undefined);
+        vi.stubEnv("SCRIBE_LOG_LEVEL", undefined);
+        vi.stubEnv("LOGGING_LEVEL", undefined);
+    });
+    afterEach(()=>{
+        vi.unstubAllEnvs();
+    });
+    it("returns null when no env vars are set", ()=>{
+        expect(getLogLevelFromEnv()).toBeNull();
+    });
+    it("reads LOG_LEVEL", ()=>{
+        vi.stubEnv("LOG_LEVEL", "debug");
+        expect(getLogLevelFromEnv()).toBe("debug");
+    });
+    it("reads SCRIBE_LOG_LEVEL", ()=>{
+        vi.stubEnv("SCRIBE_LOG_LEVEL", "warn");
+        expect(getLogLevelFromEnv()).toBe("warn");
+    });
+    it("reads LOGGING_LEVEL", ()=>{
+        vi.stubEnv("LOGGING_LEVEL", "error");
+        expect(getLogLevelFromEnv()).toBe("error");
+    });
+    it("LOG_LEVEL takes precedence over SCRIBE_LOG_LEVEL", ()=>{
+        vi.stubEnv("LOG_LEVEL", "fatal");
+        vi.stubEnv("SCRIBE_LOG_LEVEL", "trace");
+        expect(getLogLevelFromEnv()).toBe("fatal");
+    });
+    it("SCRIBE_LOG_LEVEL takes precedence over LOGGING_LEVEL", ()=>{
+        vi.stubEnv("SCRIBE_LOG_LEVEL", "debug");
+        vi.stubEnv("LOGGING_LEVEL", "error");
+        expect(getLogLevelFromEnv()).toBe("debug");
+    });
+    it("normalises to lowercase", ()=>{
+        vi.stubEnv("LOG_LEVEL", "DEBUG");
+        expect(getLogLevelFromEnv()).toBe("debug");
+    });
+    it("trims whitespace", ()=>{
+        vi.stubEnv("LOG_LEVEL", "  info  ");
+        expect(getLogLevelFromEnv()).toBe("info");
+    });
+    it("treats empty string as not set and falls through to next var", ()=>{
+        vi.stubEnv("LOG_LEVEL", "");
+        vi.stubEnv("SCRIBE_LOG_LEVEL", "warn");
+        expect(getLogLevelFromEnv()).toBe("warn");
+    });
+    it("returns null when all vars are empty", ()=>{
+        vi.stubEnv("LOG_LEVEL", "");
+        vi.stubEnv("SCRIBE_LOG_LEVEL", "");
+        vi.stubEnv("LOGGING_LEVEL", "");
+        expect(getLogLevelFromEnv()).toBeNull();
+    });
+});
+describe("isValidLogLevel", ()=>{
+    it.each([
+        "fatal",
+        "error",
+        "warn",
+        "info",
+        "debug",
+        "trace"
+    ])("returns true for valid level '%s'", (level)=>{
+        expect(isValidLogLevel(level)).toBe(true);
+    });
+    it("returns false for unknown level", ()=>{
+        expect(isValidLogLevel("verbose")).toBe(false);
+    });
+    it("returns false for empty string", ()=>{
+        expect(isValidLogLevel("")).toBe(false);
+    });
+});
+describe("resolveLogLevel", ()=>{
+    beforeEach(()=>{
+        vi.stubEnv("LOG_LEVEL", undefined);
+        vi.stubEnv("SCRIBE_LOG_LEVEL", undefined);
+        vi.stubEnv("LOGGING_LEVEL", undefined);
+    });
+    afterEach(()=>{
+        vi.unstubAllEnvs();
+    });
+    it("uses explicit log level when valid", ()=>{
+        expect(resolveLogLevel("debug")).toBe("debug");
+    });
+    it("uses env log level when explicit is missing", ()=>{
+        vi.stubEnv("LOG_LEVEL", "warn");
+        expect(resolveLogLevel()).toBe("warn");
+    });
+    it("returns null when explicit and env are invalid using simple form", ()=>{
+        vi.stubEnv("LOG_LEVEL", "verbose");
+        expect(resolveLogLevel("nope")).toBeNull();
+    });
+    it("falls back to default when explicit and env are invalid using object form", ()=>{
+        expect(resolveLogLevel({
+            explicitLogLevel: "verbose",
+            envLogLevel: "nope",
+            defaultLogLevel: "info"
+        })).toBe("info");
+    });
+});
+describe("scribe logger factory — env var log level", ()=>{
+    beforeEach(()=>{
+        vi.stubEnv("LOG_LEVEL", undefined);
+        vi.stubEnv("SCRIBE_LOG_LEVEL", undefined);
+        vi.stubEnv("LOGGING_LEVEL", undefined);
+    });
+    afterEach(()=>{
+        vi.unstubAllEnvs();
+    });
+    it("falls back to 'info' when no env var and no explicit logLevel", ()=>{
+        const spy = vi.spyOn(console, "log").mockImplementation(()=>{});
+        const loggerFn = scribe.configure({
+            adapter: new ConsoleAdapter()
+        });
+        const logger = loggerFn("env-test");
+        logger.debug("should not appear");
+        expect(spy).not.toHaveBeenCalledWith(expect.stringContaining("DEBUG"));
+        logger.info("should appear");
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining("INFO"));
+        spy.mockRestore();
+    });
+    it("uses SCRIBE_LOG_LEVEL env var when no explicit logLevel", ()=>{
+        vi.stubEnv("SCRIBE_LOG_LEVEL", "debug");
+        const spy = vi.spyOn(console, "log").mockImplementation(()=>{});
+        const loggerFn = scribe.configure({
+            adapter: new ConsoleAdapter()
+        });
+        const logger = loggerFn("env-debug-test");
+        logger.debug("should appear via env var");
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining("DEBUG"));
+        spy.mockRestore();
+    });
+    it("explicit logLevel overrides env var", ()=>{
+        vi.stubEnv("SCRIBE_LOG_LEVEL", "debug");
+        const spy = vi.spyOn(console, "log").mockImplementation(()=>{});
+        const loggerFn = scribe.configure({
+            adapter: new ConsoleAdapter(),
+            options: {
+                logLevel: "error"
+            }
+        });
+        const logger = loggerFn("explicit-override-test");
+        logger.debug("should NOT appear");
+        expect(spy).not.toHaveBeenCalledWith(expect.stringContaining("DEBUG"));
+        logger.error("should appear");
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining("ERROR"));
+        spy.mockRestore();
+    });
+});
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scribe/scribe/tests/env.spec.ts"],"sourcesContent":["import { afterEach, beforeEach, describe, expect, it, vi } from \"vitest\";\nimport { ConsoleAdapter } from \"../src/console.adapter.js\";\nimport {\n\tgetLogLevelFromArgv,\n\tgetLogLevelFromEnv,\n\tisValidLogLevel,\n\tresolveLogLevel,\n} from \"../src/env.js\";\nimport { scribe } from \"../src/logger.factory.js\";\n\ndescribe(\"getLogLevelFromArgv\", () => {\n\tit(\"reads long-form flag with separate value\", () => {\n\t\texpect(getLogLevelFromArgv([\"node\", \"cli.js\", \"--log-level\", \"trace\"])).toBe(\"trace\");\n\t});\n\n\tit(\"reads short-form flag with separate value\", () => {\n\t\texpect(getLogLevelFromArgv([\"node\", \"cli.js\", \"-l\", \"debug\"])).toBe(\"debug\");\n\t});\n\n\tit(\"reads equals-form flag\", () => {\n\t\texpect(getLogLevelFromArgv([\"node\", \"cli.js\", \"--log-level=warn\"])).toBe(\"warn\");\n\t});\n\n\tit(\"returns undefined when flag is absent\", () => {\n\t\texpect(getLogLevelFromArgv([\"node\", \"cli.js\", \"build\"])).toBeUndefined();\n\t});\n});\n\ndescribe(\"getLogLevelFromEnv\", () => {\n\tbeforeEach(() => {\n\t\tvi.stubEnv(\"LOG_LEVEL\", undefined);\n\t\tvi.stubEnv(\"SCRIBE_LOG_LEVEL\", undefined);\n\t\tvi.stubEnv(\"LOGGING_LEVEL\", undefined);\n\t});\n\n\tafterEach(() => {\n\t\tvi.unstubAllEnvs();\n\t});\n\n\tit(\"returns null when no env vars are set\", () => {\n\t\texpect(getLogLevelFromEnv()).toBeNull();\n\t});\n\n\tit(\"reads LOG_LEVEL\", () => {\n\t\tvi.stubEnv(\"LOG_LEVEL\", \"debug\");\n\t\texpect(getLogLevelFromEnv()).toBe(\"debug\");\n\t});\n\n\tit(\"reads SCRIBE_LOG_LEVEL\", () => {\n\t\tvi.stubEnv(\"SCRIBE_LOG_LEVEL\", \"warn\");\n\t\texpect(getLogLevelFromEnv()).toBe(\"warn\");\n\t});\n\n\tit(\"reads LOGGING_LEVEL\", () => {\n\t\tvi.stubEnv(\"LOGGING_LEVEL\", \"error\");\n\t\texpect(getLogLevelFromEnv()).toBe(\"error\");\n\t});\n\n\tit(\"LOG_LEVEL takes precedence over SCRIBE_LOG_LEVEL\", () => {\n\t\tvi.stubEnv(\"LOG_LEVEL\", \"fatal\");\n\t\tvi.stubEnv(\"SCRIBE_LOG_LEVEL\", \"trace\");\n\t\texpect(getLogLevelFromEnv()).toBe(\"fatal\");\n\t});\n\n\tit(\"SCRIBE_LOG_LEVEL takes precedence over LOGGING_LEVEL\", () => {\n\t\tvi.stubEnv(\"SCRIBE_LOG_LEVEL\", \"debug\");\n\t\tvi.stubEnv(\"LOGGING_LEVEL\", \"error\");\n\t\texpect(getLogLevelFromEnv()).toBe(\"debug\");\n\t});\n\n\tit(\"normalises to lowercase\", () => {\n\t\tvi.stubEnv(\"LOG_LEVEL\", \"DEBUG\");\n\t\texpect(getLogLevelFromEnv()).toBe(\"debug\");\n\t});\n\n\tit(\"trims whitespace\", () => {\n\t\tvi.stubEnv(\"LOG_LEVEL\", \"  info  \");\n\t\texpect(getLogLevelFromEnv()).toBe(\"info\");\n\t});\n\n\tit(\"treats empty string as not set and falls through to next var\", () => {\n\t\tvi.stubEnv(\"LOG_LEVEL\", \"\");\n\t\tvi.stubEnv(\"SCRIBE_LOG_LEVEL\", \"warn\");\n\t\texpect(getLogLevelFromEnv()).toBe(\"warn\");\n\t});\n\n\tit(\"returns null when all vars are empty\", () => {\n\t\tvi.stubEnv(\"LOG_LEVEL\", \"\");\n\t\tvi.stubEnv(\"SCRIBE_LOG_LEVEL\", \"\");\n\t\tvi.stubEnv(\"LOGGING_LEVEL\", \"\");\n\t\texpect(getLogLevelFromEnv()).toBeNull();\n\t});\n});\n\ndescribe(\"isValidLogLevel\", () => {\n\tit.each([\n\t\t\"fatal\",\n\t\t\"error\",\n\t\t\"warn\",\n\t\t\"info\",\n\t\t\"debug\",\n\t\t\"trace\",\n\t])(\"returns true for valid level '%s'\", (level) => {\n\t\texpect(isValidLogLevel(level)).toBe(true);\n\t});\n\n\tit(\"returns false for unknown level\", () => {\n\t\texpect(isValidLogLevel(\"verbose\")).toBe(false);\n\t});\n\n\tit(\"returns false for empty string\", () => {\n\t\texpect(isValidLogLevel(\"\")).toBe(false);\n\t});\n});\n\ndescribe(\"resolveLogLevel\", () => {\n\tbeforeEach(() => {\n\t\tvi.stubEnv(\"LOG_LEVEL\", undefined);\n\t\tvi.stubEnv(\"SCRIBE_LOG_LEVEL\", undefined);\n\t\tvi.stubEnv(\"LOGGING_LEVEL\", undefined);\n\t});\n\n\tafterEach(() => {\n\t\tvi.unstubAllEnvs();\n\t});\n\n\tit(\"uses explicit log level when valid\", () => {\n\t\texpect(resolveLogLevel(\"debug\")).toBe(\"debug\");\n\t});\n\n\tit(\"uses env log level when explicit is missing\", () => {\n\t\tvi.stubEnv(\"LOG_LEVEL\", \"warn\");\n\t\texpect(resolveLogLevel()).toBe(\"warn\");\n\t});\n\n\tit(\"returns null when explicit and env are invalid using simple form\", () => {\n\t\tvi.stubEnv(\"LOG_LEVEL\", \"verbose\");\n\t\texpect(resolveLogLevel(\"nope\")).toBeNull();\n\t});\n\n\tit(\"falls back to default when explicit and env are invalid using object form\", () => {\n\t\texpect(\n\t\t\tresolveLogLevel({\n\t\t\t\texplicitLogLevel: \"verbose\",\n\t\t\t\tenvLogLevel: \"nope\",\n\t\t\t\tdefaultLogLevel: \"info\",\n\t\t\t}),\n\t\t).toBe(\"info\");\n\t});\n});\n\ndescribe(\"scribe logger factory — env var log level\", () => {\n\tbeforeEach(() => {\n\t\tvi.stubEnv(\"LOG_LEVEL\", undefined);\n\t\tvi.stubEnv(\"SCRIBE_LOG_LEVEL\", undefined);\n\t\tvi.stubEnv(\"LOGGING_LEVEL\", undefined);\n\t});\n\n\tafterEach(() => {\n\t\tvi.unstubAllEnvs();\n\t});\n\n\tit(\"falls back to 'info' when no env var and no explicit logLevel\", () => {\n\t\tconst spy = vi.spyOn(console, \"log\").mockImplementation(() => {});\n\n\t\tconst loggerFn = scribe.configure({ adapter: new ConsoleAdapter() });\n\t\tconst logger = loggerFn(\"env-test\");\n\n\t\tlogger.debug(\"should not appear\");\n\t\texpect(spy).not.toHaveBeenCalledWith(expect.stringContaining(\"DEBUG\"));\n\n\t\tlogger.info(\"should appear\");\n\t\texpect(spy).toHaveBeenCalledWith(expect.stringContaining(\"INFO\"));\n\n\t\tspy.mockRestore();\n\t});\n\n\tit(\"uses SCRIBE_LOG_LEVEL env var when no explicit logLevel\", () => {\n\t\tvi.stubEnv(\"SCRIBE_LOG_LEVEL\", \"debug\");\n\t\tconst spy = vi.spyOn(console, \"log\").mockImplementation(() => {});\n\n\t\tconst loggerFn = scribe.configure({ adapter: new ConsoleAdapter() });\n\t\tconst logger = loggerFn(\"env-debug-test\");\n\n\t\tlogger.debug(\"should appear via env var\");\n\t\texpect(spy).toHaveBeenCalledWith(expect.stringContaining(\"DEBUG\"));\n\n\t\tspy.mockRestore();\n\t});\n\n\tit(\"explicit logLevel overrides env var\", () => {\n\t\tvi.stubEnv(\"SCRIBE_LOG_LEVEL\", \"debug\");\n\t\tconst spy = vi.spyOn(console, \"log\").mockImplementation(() => {});\n\n\t\tconst loggerFn = scribe.configure({\n\t\t\tadapter: new ConsoleAdapter(),\n\t\t\toptions: { logLevel: \"error\" },\n\t\t});\n\t\tconst logger = loggerFn(\"explicit-override-test\");\n\n\t\tlogger.debug(\"should NOT appear\");\n\t\texpect(spy).not.toHaveBeenCalledWith(expect.stringContaining(\"DEBUG\"));\n\n\t\tlogger.error(\"should appear\");\n\t\texpect(spy).toHaveBeenCalledWith(expect.stringContaining(\"ERROR\"));\n\n\t\tspy.mockRestore();\n\t});\n});\n"],"names":["afterEach","beforeEach","describe","expect","it","vi","ConsoleAdapter","getLogLevelFromArgv","getLogLevelFromEnv","isValidLogLevel","resolveLogLevel","scribe","toBe","toBeUndefined","stubEnv","undefined","unstubAllEnvs","toBeNull","each","level","explicitLogLevel","envLogLevel","defaultLogLevel","spy","spyOn","console","mockImplementation","loggerFn","configure","adapter","logger","debug","not","toHaveBeenCalledWith","stringContaining","info","mockRestore","options","logLevel","error"],"mappings":"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"}

package/tests/logger.factory.default.spec.js

@@ -0,0 +1,36 @@
+import { describe, expect, it, vi } from "vitest";
+import { ConsoleAdapter } from "../src/console.adapter.js";
+import { scribe } from "../src/logger.factory.js";
+describe("Logger Factory with Default Adapter", ()=>{
+    it("should use console adapter by default", ()=>{
+        const spy = vi.spyOn(console, "log").mockImplementation(()=>{});
+        // No configuration needed
+        const logger = scribe.logger("default-test");
+        logger.info("This should work");
+        expect(spy).toHaveBeenCalled();
+        spy.mockRestore();
+    });
+    it("should allow configuring a different adapter", ()=>{
+        const spy = vi.spyOn(console, "log").mockImplementation(()=>{});
+        // Configure with explicit console adapter
+        const loggerFn = scribe.configure({
+            adapter: new ConsoleAdapter()
+        });
+        const logger = loggerFn("configured-test");
+        logger.warn("Configured message");
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining("WARN [configured-test]: Configured message"));
+        spy.mockRestore();
+    });
+    it("should work for multiple logger instances", ()=>{
+        const spy = vi.spyOn(console, "log").mockImplementation(()=>{});
+        const logger1 = scribe.logger("service1");
+        const logger2 = scribe.logger("service2");
+        logger1.info("Message from service1");
+        logger2.error("Message from service2");
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining("INFO [service1]: Message from service1"));
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining("ERROR [service2]: Message from service2"));
+        spy.mockRestore();
+    });
+});
+
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/src/console.adapter.js

@@ -1,74 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "ConsoleAdapter", {
-    enumerable: true,
-    get: function() {
-        return ConsoleAdapter;
-    }
-});
-const _loggeradapter = require("./logger.adapter.js");
-const _types = require("./types.js");
-class ConsoleAdapter extends _loggeradapter.LogAdapter {
-    configuredLevels;
-    configuredLogLevel = _types.DefaultLogLevel;
-    configuredLogLevelValue = _types.LogLevels.info;
-    constructor(_options = {}){
-        super();
-    }
-    configure(scribeOptions) {
-        // Get merged log levels (default + custom) using parent class method
-        this.configuredLevels = this.getLogLevels(scribeOptions);
-        const logLevelStr = scribeOptions.logLevel ?? _types.DefaultLogLevel;
-        this.configuredLogLevel = logLevelStr;
-        this.configuredLogLevelValue = this.configuredLevels[logLevelStr] ?? _types.LogLevels.info;
-    }
-    getLogger(name) {
-        const loggerName = name || "default";
-        return this.createConsoleLogger(loggerName);
-    }
-    createConsoleLogger(name) {
-        // Use the levels configured during the configure() call
-        const allLevels = this.configuredLevels;
-        const currentLevel = this.configuredLogLevel;
-        const threshold = this.configuredLogLevelValue;
-        const baseLogger = {
-            get currentLevel () {
-                return currentLevel;
-            },
-            get logLevels () {
-                return allLevels;
-            }
-        };
-        const logFunction = (level)=>(msg, ...args)=>{
-                const timestamp = new Date().toISOString();
-                let message;
-                if (typeof msg === "object") {
-                    message = msg instanceof Error ? (0, _loggeradapter.formatError)(msg) : JSON.stringify(msg);
-                } else {
-                    message = String(msg);
-                }
-                const logLine = `[${timestamp}] ${level.toUpperCase()} [${name}]: ${message}`;
-                if (args.length > 0) {
-                    console.log(logLine, ...args);
-                } else {
-                    console.log(logLine);
-                }
-            };
-        const noop = ()=>{};
-        // Start with base logger and isLevelEnabled method
-        const logger = Object.assign(baseLogger, {
-            isLevelEnabled: (level)=>(allLevels[level] ?? 0) >= threshold
-        });
-        // Dynamically add all log level methods (default + custom)
-        // Levels below the configured threshold are patched to noop
-        for (const [levelName, levelValue] of Object.entries(allLevels)){
-            // biome-ignore lint/suspicious/noExplicitAny: Dynamic logger level creation requires any
-            logger[levelName] = levelValue >= threshold ? logFunction(levelName) : noop;
-        }
-        return logger;
-    }
-}
-
-//# sourceMappingURL=data:application/json;base64,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