feat(logger): add test environment support v1.1.0

- Auto-detect test environments (vitest/jest)
- In-memory log capture with inspection utilities
- Silent by default, verbose mode support
- New entry point: @deepracticex/logger/test
- Export getTestLogs(), clearTestLogs(), getTestLogsByLevel()

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: deepracticexs

packages/logger/README.md

@@ -72,6 +72,34 @@ const logger = createLogger({
 logger.info("App initialized");
 ```
 
+### Test Environment (Vitest/Jest)
+
+```typescript
+// Uses in-memory test adapter with log capture
+import {
+  createLogger,
+  getTestLogs,
+  clearTestLogs,
+} from "@deepracticex/logger/test";
+
+const logger = createLogger({
+  level: "debug",
+  name: "my-service",
+  console: false, // Silent by default in tests
+});
+
+// Your test code
+logger.info("test message");
+
+// Assert logs were captured
+const logs = getTestLogs();
+expect(logs).toHaveLength(1);
+expect(logs[0].message).toBe("test message");
+
+// Clean up between tests
+clearTestLogs();
+```
+
 ## Quick Start
 
 ### Default Logger (Node.js)
@@ -182,6 +210,64 @@ Uses browser-optimized console adapter:
 - Source map integration
 - DevTools friendly
 
+### Test Environment
+
+Uses in-memory test adapter:
+
+- Auto-detected in vitest/jest (via `VITEST=true` or `NODE_ENV=test`)
+- Silent by default (no console output)
+- Captures all logs in memory for assertions
+- Zero I/O overhead for fast tests
+- Utilities: `getTestLogs()`, `clearTestLogs()`, `getTestLogsByLevel()`
+
+**Usage in tests:**
+
+```typescript
+import {
+  createLogger,
+  getTestLogs,
+  clearTestLogs,
+} from "@deepracticex/logger/test";
+
+describe("my feature", () => {
+  const logger = createLogger();
+
+  afterEach(() => {
+    clearTestLogs(); // Clean up between tests
+  });
+
+  it("should log messages", () => {
+    logger.info("test started");
+    logger.warn("warning message");
+
+    const logs = getTestLogs();
+    expect(logs).toHaveLength(2);
+    expect(logs[0].level).toBe("info");
+  });
+});
+```
+
+**Auto-detection:**
+
+When running in vitest, the default `@deepracticex/logger` import automatically uses the test adapter:
+
+```typescript
+// Automatically uses test adapter in vitest
+import { createLogger } from "@deepracticex/logger";
+
+const logger = createLogger(); // No console output in tests
+```
+
+**Enable console output for debugging:**
+
+```typescript
+// Show logs in test output
+const logger = createLogger({ console: true });
+
+// Or run with verbose reporter
+// pnpm test -- --reporter=verbose
+```
+
 ## Examples
 
 ### Node.js Service
@@ -247,25 +333,35 @@ document.addEventListener("click", (e) => {
 
 ## Architecture
 
-The logger uses a two-adapter architecture:
+The logger uses a multi-adapter architecture with automatic runtime detection:
 
 1. **Pino Adapter** - For Node.js (high performance, file support)
 2. **Console Adapter** - For edge/browser (lightweight, universal)
+3. **Test Adapter** - For test environments (in-memory, inspectable)
 
 Platform-specific entry points ensure only the necessary adapter is bundled:
 
 ```
-@deepracticex/logger          → nodejs.ts → pino-adapter
+@deepracticex/logger          → Auto-detect → appropriate adapter
 @deepracticex/logger/nodejs   → nodejs.ts → pino-adapter
 @deepracticex/logger/cloudflare-workers → cloudflare-workers.ts → console-adapter
 @deepracticex/logger/browser  → browser.ts → console-adapter
+@deepracticex/logger/test     → test.ts → test-adapter
 ```
 
+**Auto-detection priority:**
+
+1. Test environment (VITEST=true or NODE_ENV=test) → test adapter
+2. Cloudflare Workers (caches API present) → console adapter
+3. Node.js (process.versions.node) → pino adapter
+4. Fallback → console adapter (browser)
+
 ## Bundle Size
 
 - Node.js: Full pino functionality (~200KB with dependencies)
 - Cloudflare Workers: ~1.5KB (console adapter only)
 - Browser: ~1.5KB (console adapter only)
+- Test: ~2KB (test adapter with inspection utilities)
 
 ## FAQ
 
@@ -310,6 +406,50 @@ import { createLogger } from "@deepracticex/logger/cloudflare-workers";
 import { createLogger } from "@deepracticex/logger/browser";
 ```
 
+### How do I use it in tests?
+
+The logger automatically detects test environments (vitest/jest) and uses the test adapter:
+
+```typescript
+// Automatically silent in tests
+import { createLogger } from "@deepracticex/logger";
+const logger = createLogger();
+
+logger.info("message"); // Captured, but no console output
+```
+
+To inspect logs in tests:
+
+```typescript
+import {
+  createLogger,
+  getTestLogs,
+  clearTestLogs,
+} from "@deepracticex/logger/test";
+
+const logger = createLogger();
+logger.info("test message");
+
+const logs = getTestLogs();
+expect(logs[0].message).toBe("test message");
+
+clearTestLogs(); // Clean up
+```
+
+### How do I see logs when debugging tests?
+
+Use vitest's verbose reporter:
+
+```bash
+pnpm test -- --reporter=verbose
+```
+
+Or enable console output explicitly:
+
+```typescript
+const logger = createLogger({ console: true });
+```
+
 ## License
 
 MIT

packages/logger/features/test-environment.feature

@@ -0,0 +1,112 @@
+Feature: Test Environment Support
+  As a developer writing tests
+  I want the logger to work seamlessly in test environments
+  So that I can write reliable tests without polluting test output
+
+  Background:
+    Given I am running in a test environment
+
+  Rule: Test environment should be auto-detected
+
+    Scenario: Auto-detect vitest environment
+      Given VITEST environment variable is "true"
+      When I create a logger without specifying environment
+      Then the logger should use test adapter
+      And logs should be captured in memory
+
+    Scenario: Explicitly specify test environment
+      When I create a logger with environment "test"
+      Then the logger should use test adapter
+      And logs should be captured in memory
+
+  Rule: Logs should be captured in memory by default
+
+    Scenario: Log messages are captured silently
+      Given I have a test logger
+      When I log "test message" at level "info"
+      And I log "warning message" at level "warn"
+      And I log "error message" at level "error"
+      Then captured logs should contain 3 entries
+      And captured log at index 0 should have level "info"
+      And captured log at index 0 should have message "test message"
+      And captured log at index 1 should have level "warn"
+      And captured log at index 2 should have level "error"
+
+    Scenario: Logs can be cleared between tests
+      Given I have a test logger
+      When I log "first message" at level "info"
+      And I clear captured logs
+      And I log "second message" at level "info"
+      Then captured logs should contain 1 entries
+      And captured log at index 0 should have message "second message"
+
+  Rule: Console output should be controllable
+
+    Scenario: Default silent mode in tests
+      Given I have a test logger with default config
+      When I log "test message" at level "info"
+      Then the message should not be output to console
+      And the message should be captured in memory
+
+    Scenario: Enable console output with config
+      Given I have a test logger with console enabled
+      When I log "test message" at level "info"
+      Then the message should be output to console
+      And the message should be captured in memory
+
+  Rule: Log inspection utilities should be available
+
+    Scenario: Get captured logs
+      Given I have a test logger
+      When I log "message 1" at level "info"
+      And I log "message 2" at level "warn"
+      And I get captured logs
+      Then the result should be an array of 2 log entries
+      And each entry should have level, message, and timestamp
+
+    Scenario: Filter logs by level
+      Given I have a test logger
+      When I log "info message" at level "info"
+      And I log "warn message" at level "warn"
+      And I log "error message" at level "error"
+      And I get captured logs filtered by level "warn"
+      Then the result should contain 1 entry
+      And the entry should have message "warn message"
+
+  Rule: Test logger should support same API as production
+
+    Scenario: All log levels work in test environment
+      Given I have a test logger
+      When I call logger method "trace" with "trace msg"
+      And I call logger method "debug" with "debug msg"
+      And I call logger method "info" with "info msg"
+      And I call logger method "warn" with "warn msg"
+      And I call logger method "error" with "error msg"
+      And I call logger method "fatal" with "fatal msg"
+      Then captured logs should contain 6 entries
+      And all standard log levels should be present
+
+    Scenario: Log with context objects
+      Given I have a test logger
+      When I log "user action" at level "info" with context:
+        | key    | value  |
+        | userId | 123    |
+        | action | login  |
+      Then captured logs should contain the context data
+      And the context should have "userId" equal to "123"
+      And the context should have "action" equal to "login"
+
+  Rule: Integration with vitest reporter
+
+    Scenario: Verbose mode shows logs
+      Given I have a test logger with console enabled
+      And vitest is running with verbose reporter
+      When I log "debug message" at level "debug"
+      Then the message should be visible in test output
+
+    Scenario: Default mode hides logs
+      Given I have a test logger with default config
+      And vitest is running with default reporter
+      When I log "debug message" at level "debug"
+      Then the message should not be visible in test output
+      And the message should still be captured in memory

packages/logger/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepracticex/logger",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "Unified logging system for Deepractice projects using Pino",
   "type": "module",
   "main": "./dist/index.js",
@@ -26,6 +26,11 @@
       "types": "./dist/browser.d.ts",
       "import": "./dist/browser.js",
       "require": "./dist/browser.cjs"
+    },
+    "./test": {
+      "types": "./dist/test.d.ts",
+      "import": "./dist/test.js",
+      "require": "./dist/test.cjs"
     }
   },
   "scripts": {

packages/logger/src/core/adapter-factory.ts

@@ -7,6 +7,17 @@ import type { LoggerConfig, RuntimeEnvironment } from "~/types/config.js";
  * Detect the current runtime environment
  */
 export function detectEnvironment(): RuntimeEnvironment {
+  // Priority 0: Check for test environment (vitest, jest, etc.)
+  // Test environments should use in-memory test adapter
+  if (
+    typeof process !== "undefined" &&
+    (process.env.VITEST === "true" ||
+      process.env.JEST_WORKER_ID !== undefined ||
+      process.env.NODE_ENV === "test")
+  ) {
+    return "test";
+  }
+
   // Priority 1: Check for Cloudflare Workers specific globals
   // Workers have caches API - this is the most reliable indicator
   // If these globals exist, it's definitely Cloudflare Workers runtime
@@ -45,7 +56,11 @@ export async function createLoggerAdapter(
 ): Promise<any> {
   const env = config.environment || detectEnvironment();
 
-  if (env === "nodejs") {
+  if (env === "test") {
+    // Test adapter for vitest/jest - in-memory, silent by default
+    const { createTestLogger } = await import("./test-adapter.js");
+    return createTestLogger(config);
+  } else if (env === "nodejs") {
     // Use string concatenation to hide import from bundler static analysis
     // This prevents edge runtime bundlers from including Node.js-only dependencies
     const adapterPath = "./pino-adapter" + ".js";