evlog 0.1.0 → 1.0.1

package/README.md

@@ -96,6 +96,8 @@ export default defineNuxtConfig({
       service: 'my-app',
       environment: process.env.NODE_ENV,
     },
+    // Optional: only log specific routes (supports glob patterns)
+    include: ['/api/**'],
   },
 })
 ```
@@ -104,7 +106,7 @@ That's it. Now use `useLogger(event)` in any API route:
 
 ```typescript
 // server/api/checkout.post.ts
-import { useLogger, defineError } from 'evlog'
+import { useLogger, createError } from 'evlog'
 
 export default defineEventHandler(async (event) => {
   const log = useLogger(event)
@@ -124,8 +126,9 @@ export default defineEventHandler(async (event) => {
   } catch (error) {
     log.error(error, { step: 'payment' })
 
-    throw defineError({
+    throw createError({
       message: 'Payment failed',
+      status: 402,
       why: error.message,
       fix: 'Try a different payment method or contact your bank',
     })
@@ -173,7 +176,7 @@ Same API, same wide events:
 
 ```typescript
 // routes/api/documents/[id]/export.post.ts
-import { useLogger, defineError } from 'evlog'
+import { useLogger, createError } from 'evlog'
 
 export default defineEventHandler(async (event) => {
   const log = useLogger(event)
@@ -189,8 +192,9 @@ export default defineEventHandler(async (event) => {
   // Load document from database
   const document = await db.documents.findUnique({ where: { id: documentId } })
   if (!document) {
-    throw defineError({
+    throw createError({
       message: 'Document not found',
+      status: 404,
       why: `No document with ID "${documentId}" exists`,
       fix: 'Check the document ID and try again',
     })
@@ -206,8 +210,9 @@ export default defineEventHandler(async (event) => {
   } catch (error) {
     log.error(error, { step: 'export-generation' })
 
-    throw defineError({
+    throw createError({
       message: 'Export failed',
+      status: 500,
       why: `Failed to generate ${body.format} export: ${error.message}`,
       fix: 'Try a different format or contact support',
     })
@@ -238,7 +243,7 @@ Errors should tell you **what** happened, **why**, and **how to fix it**.
 
 ```typescript
 // server/api/repos/sync.post.ts
-import { useLogger, defineError } from 'evlog'
+import { useLogger, createError } from 'evlog'
 
 export default defineEventHandler(async (event) => {
   const log = useLogger(event)
@@ -252,8 +257,9 @@ export default defineEventHandler(async (event) => {
   } catch (error) {
     log.error(error, { step: 'github-sync' })
 
-    throw defineError({
+    throw createError({
       message: 'Failed to sync repository',
+      status: 503,
       why: 'GitHub API rate limit exceeded',
       fix: 'Wait 1 hour or use a different token',
       link: 'https://docs.github.com/en/rest/rate-limit',
@@ -302,7 +308,7 @@ migrationLog.emit()
 
 ```typescript
 // workers/sync-job.ts
-import { initLogger, createRequestLogger, defineError } from 'evlog'
+import { initLogger, createRequestLogger, createError } from 'evlog'
 
 initLogger({
   env: {
@@ -346,9 +352,23 @@ initLogger({
     region?: string      // Deployment region
   },
   pretty?: boolean       // Pretty print (default: true in dev)
+  include?: string[]     // Route patterns to log (glob), e.g. ['/api/**']
 })
 ```
 
+### Pretty Output Format
+
+In development, evlog uses a compact tree format:
+
+```
+16:45:31.060 INFO [my-app] GET /api/checkout 200 in 234ms
+  ├─ user: id=123 plan=premium
+  ├─ cart: items=3 total=9999
+  └─ payment: id=pay_xyz method=card
+```
+
+In production (`pretty: false`), logs are emitted as JSON for machine parsing.
+
 ### `log`
 
 Simple logging API.
@@ -378,13 +398,18 @@ log.emit()                         // Emit final event
 log.getContext()                   // Get current context
 ```
 
-### `defineError(options)`
+### `createError(options)`
+
+Create a structured error with HTTP status support. Import from `evlog` directly to avoid conflicts with Nuxt/Nitro's `createError`.
 
-Create a structured error.
+> **Note**: `createEvlogError` is also available as an auto-imported alias in Nuxt/Nitro to avoid conflicts.
 
 ```typescript
-defineError({
+import { createError } from 'evlog'
+
+createError({
   message: string   // What happened
+  status?: number   // HTTP status code (default: 500)
   why?: string      // Why it happened
   fix?: string      // How to fix it
   link?: string     // Documentation URL
@@ -392,6 +417,34 @@ defineError({
 })
 ```
 
+### `parseError(error)`
+
+Parse a caught error into a flat structure with all evlog fields. Auto-imported in Nuxt.
+
+```typescript
+import { parseError } from 'evlog'
+
+try {
+  await $fetch('/api/checkout')
+} catch (err) {
+  const error = parseError(err)
+
+  // Direct access to all fields
+  console.log(error.message)  // "Payment failed"
+  console.log(error.status)   // 402
+  console.log(error.why)      // "Card declined"
+  console.log(error.fix)      // "Try another card"
+  console.log(error.link)     // "https://docs.example.com/..."
+
+  // Use with toast
+  toast.add({
+    title: error.message,
+    description: error.why,
+    color: 'error',
+  })
+}
+```
+
 ## Framework Support
 
 evlog works with any framework powered by [Nitro](https://nitro.unjs.io/):
@@ -405,9 +458,35 @@ evlog works with any framework powered by [Nitro](https://nitro.unjs.io/):
 | **TanStack Start** | `plugins: ['evlog/nitro']` |
 | **Standalone Nitro** | `plugins: ['evlog/nitro']` |
 
+## Agent Skills
+
+evlog provides [Agent Skills](https://github.com/boristane/agent-skills) to help AI coding assistants understand and implement proper logging patterns in your codebase.
+
+### Installation
+
+```bash
+npx add-skill hugorcd/evlog
+```
+
+### What it does
+
+Once installed, your AI assistant will:
+- Review your logging code and suggest wide event patterns
+- Help refactor scattered `console.log` calls into structured events
+- Guide you to use `createError()` for self-documenting errors
+- Ensure proper use of `useLogger(event)` in Nuxt/Nitro routes
+
+### Examples
+
+```
+Add logging to this endpoint
+Review my logging code
+Help me set up logging for this service
+```
+
 ## Philosophy
 
-Inspired by [Logging Sucks](https://loggingsucks.com/) by [Boris Tane](https://github.com/boristane).
+Inspired by [Logging Sucks](https://loggingsucks.com/) by [Boris Tane](https://x.com/boristane).
 
 1. **Wide Events**: One log per request with all context
 2. **Structured Errors**: Errors that explain themselves

package/dist/error.d.mts

@@ -7,6 +7,7 @@ import { ErrorOptions } from './types.mjs';
  * ```ts
  * throw new EvlogError({
  *   message: 'Failed to sync repository',
+ *   status: 503,
  *   why: 'GitHub API rate limit exceeded',
  *   fix: 'Wait 1 hour or use a different token',
  *   link: 'https://docs.github.com/en/rest/rate-limit',
@@ -15,33 +16,42 @@ import { ErrorOptions } from './types.mjs';
  * ```
  */
 declare class EvlogError extends Error {
+    readonly status: number;
     readonly why?: string;
     readonly fix?: string;
     readonly link?: string;
     constructor(options: ErrorOptions | string);
-    /**
-     * Format error for console output with colors
-     */
+    get statusCode(): number;
+    get data(): {
+        why: string | undefined;
+        fix: string | undefined;
+        link: string | undefined;
+    } | undefined;
     toString(): string;
-    /**
-     * Convert to plain object for JSON serialization
-     */
     toJSON(): Record<string, unknown>;
 }
 /**
- * Create an EvlogError (functional alternative to `new EvlogError()`)
+ * Create a structured error with context for debugging and user-facing messages.
  *
- * Named `defineError` to avoid conflict with Nuxt's built-in `createError`
+ * @param options - Error message string or full options object
+ * @returns EvlogError instance compatible with Nitro's error handling
  *
  * @example
  * ```ts
- * throw defineError({
+ * // Simple error
+ * throw createError('Something went wrong')
+ *
+ * // Structured error with context
+ * throw createError({
  *   message: 'Payment failed',
+ *   status: 402,
  *   why: 'Card declined by issuer',
  *   fix: 'Try a different payment method',
+ *   link: 'https://docs.example.com/payments',
  * })
  * ```
  */
-declare function defineError(options: ErrorOptions | string): EvlogError;
+declare function createError(options: ErrorOptions | string): EvlogError;
+declare const createEvlogError: typeof createError;
 
-export { EvlogError, defineError };
+export { EvlogError, createError, createEvlogError };

package/dist/error.d.ts

@@ -7,6 +7,7 @@ import { ErrorOptions } from './types.js';
  * ```ts
  * throw new EvlogError({
  *   message: 'Failed to sync repository',
+ *   status: 503,
  *   why: 'GitHub API rate limit exceeded',
  *   fix: 'Wait 1 hour or use a different token',
  *   link: 'https://docs.github.com/en/rest/rate-limit',
@@ -15,33 +16,42 @@ import { ErrorOptions } from './types.js';
  * ```
  */
 declare class EvlogError extends Error {
+    readonly status: number;
     readonly why?: string;
     readonly fix?: string;
     readonly link?: string;
     constructor(options: ErrorOptions | string);
-    /**
-     * Format error for console output with colors
-     */
+    get statusCode(): number;
+    get data(): {
+        why: string | undefined;
+        fix: string | undefined;
+        link: string | undefined;
+    } | undefined;
     toString(): string;
-    /**
-     * Convert to plain object for JSON serialization
-     */
     toJSON(): Record<string, unknown>;
 }
 /**
- * Create an EvlogError (functional alternative to `new EvlogError()`)
+ * Create a structured error with context for debugging and user-facing messages.
  *
- * Named `defineError` to avoid conflict with Nuxt's built-in `createError`
+ * @param options - Error message string or full options object
+ * @returns EvlogError instance compatible with Nitro's error handling
  *
  * @example
  * ```ts
- * throw defineError({
+ * // Simple error
+ * throw createError('Something went wrong')
+ *
+ * // Structured error with context
+ * throw createError({
  *   message: 'Payment failed',
+ *   status: 402,
  *   why: 'Card declined by issuer',
  *   fix: 'Try a different payment method',
+ *   link: 'https://docs.example.com/payments',
  * })
  * ```
  */
-declare function defineError(options: ErrorOptions | string): EvlogError;
+declare function createError(options: ErrorOptions | string): EvlogError;
+declare const createEvlogError: typeof createError;
 
-export { EvlogError, defineError };
+export { EvlogError, createError, createEvlogError };

package/dist/error.mjs

@@ -1,6 +1,7 @@
 import { colors, isServer } from './utils.mjs';
 
 class EvlogError extends Error {
+  status;
   why;
   fix;
   link;
@@ -8,6 +9,7 @@ class EvlogError extends Error {
     const opts = typeof options === "string" ? { message: options } : options;
     super(opts.message, { cause: opts.cause });
     this.name = "EvlogError";
+    this.status = opts.status ?? 500;
     this.why = opts.why;
     this.fix = opts.fix;
     this.link = opts.link;
@@ -15,9 +17,12 @@ class EvlogError extends Error {
       Error.captureStackTrace(this, EvlogError);
     }
   }
-  /**
-   * Format error for console output with colors
-   */
+  get statusCode() {
+    return this.status;
+  }
+  get data() {
+    return this.why || this.fix || this.link ? { why: this.why, fix: this.fix, link: this.link } : void 0;
+  }
   toString() {
     const useColors = isServer();
     const red = useColors ? colors.red : "";
@@ -42,13 +47,11 @@ class EvlogError extends Error {
     }
     return lines.join("\n");
   }
-  /**
-   * Convert to plain object for JSON serialization
-   */
   toJSON() {
     return {
       name: this.name,
       message: this.message,
+      status: this.status,
       why: this.why,
       fix: this.fix,
       link: this.link,
@@ -57,8 +60,9 @@ class EvlogError extends Error {
     };
   }
 }
-function defineError(options) {
+function createError(options) {
   return new EvlogError(options);
 }
+const createEvlogError = createError;
 
-export { EvlogError, defineError };
+export { EvlogError, createError, createEvlogError };

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-export { EvlogError, defineError } from './error.mjs';
+export { EvlogError, createError, createEvlogError } from './error.mjs';
 export { createRequestLogger, getEnvironment, initLogger, log } from './logger.mjs';
-export { useLogger } from './runtime/composables/useLogger.mjs';
-export { BaseWideEvent, EnvironmentContext, ErrorOptions, EvlogEventContext, Log, LogLevel, LoggerConfig, RequestLogger, WideEvent } from './types.mjs';
-import 'h3';
+export { useLogger } from './runtime/server/useLogger.mjs';
+export { parseError } from './runtime/utils/parseError.mjs';
+export { BaseWideEvent, EnvironmentContext, ErrorOptions, H3EventContext, Log, LogLevel, LoggerConfig, ParsedError, RequestLogger, RequestLoggerOptions, ServerEvent, WideEvent } from './types.mjs';

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-export { EvlogError, defineError } from './error.js';
+export { EvlogError, createError, createEvlogError } from './error.js';
 export { createRequestLogger, getEnvironment, initLogger, log } from './logger.js';
-export { useLogger } from './runtime/composables/useLogger.js';
-export { BaseWideEvent, EnvironmentContext, ErrorOptions, EvlogEventContext, Log, LogLevel, LoggerConfig, RequestLogger, WideEvent } from './types.js';
-import 'h3';
+export { useLogger } from './runtime/server/useLogger.js';
+export { parseError } from './runtime/utils/parseError.js';
+export { BaseWideEvent, EnvironmentContext, ErrorOptions, H3EventContext, Log, LogLevel, LoggerConfig, ParsedError, RequestLogger, RequestLoggerOptions, ServerEvent, WideEvent } from './types.js';

package/dist/index.mjs

@@ -1,4 +1,5 @@
-export { EvlogError, defineError } from './error.mjs';
+export { EvlogError, createError, createEvlogError } from './error.mjs';
 export { createRequestLogger, getEnvironment, initLogger, log } from './logger.mjs';
-export { useLogger } from './runtime/composables/useLogger.mjs';
+export { useLogger } from './runtime/server/useLogger.mjs';
+export { parseError } from './runtime/utils/parseError.mjs';
 import './utils.mjs';

package/dist/logger.d.mts

@@ -1,4 +1,4 @@
-import { RequestLogger, EnvironmentContext, LoggerConfig, Log } from './types.mjs';
+import { RequestLoggerOptions, RequestLogger, EnvironmentContext, LoggerConfig, Log } from './types.mjs';
 
 /**
  * Initialize the logger with configuration.
@@ -15,11 +15,6 @@ declare function initLogger(config?: LoggerConfig): void;
  * ```
  */
 declare const log: Log;
-interface RequestLoggerOptions {
-    method?: string;
-    path?: string;
-    requestId?: string;
-}
 /**
  * Create a request-scoped logger for building wide events.
  *

package/dist/logger.d.ts

@@ -1,4 +1,4 @@
-import { RequestLogger, EnvironmentContext, LoggerConfig, Log } from './types.js';
+import { RequestLoggerOptions, RequestLogger, EnvironmentContext, LoggerConfig, Log } from './types.js';
 
 /**
  * Initialize the logger with configuration.
@@ -15,11 +15,6 @@ declare function initLogger(config?: LoggerConfig): void;
  * ```
  */
 declare const log: Log;
-interface RequestLoggerOptions {
-    method?: string;
-    path?: string;
-    requestId?: string;
-}
 /**
  * Create a request-scoped logger for building wide events.
  *

package/dist/logger.mjs

@@ -1,4 +1,4 @@
-import { isDev, detectEnvironment, formatDuration, colors, getLevelColor } from './utils.mjs';
+import { isDev, detectEnvironment, formatDuration, getConsoleMethod, colors, getLevelColor } from './utils.mjs';
 
 let globalEnv = {
   service: "app",
@@ -16,9 +16,6 @@ function initLogger(config = {}) {
   };
   globalPretty = config.pretty ?? isDev();
 }
-function getConsoleMethod(level) {
-  return level === "error" ? "error" : level === "warn" ? "warn" : "log";
-}
 function emitWideEvent(level, event) {
   const formatted = {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -41,6 +38,25 @@ function emitTaggedLog(level, tag, message) {
     emitWideEvent(level, { tag, message });
   }
 }
+function formatValue(value) {
+  if (value === null || value === void 0) {
+    return String(value);
+  }
+  if (typeof value === "object") {
+    const pairs = [];
+    for (const [k, v] of Object.entries(value)) {
+      if (v !== void 0 && v !== null) {
+        if (typeof v === "object") {
+          pairs.push(`${k}=${JSON.stringify(v)}`);
+        } else {
+          pairs.push(`${k}=${v}`);
+        }
+      }
+    }
+    return pairs.join(" ");
+  }
+  return String(value);
+}
 function prettyPrintWideEvent(event) {
   const { timestamp, level, service, environment, version, ...rest } = event;
   const levelColor = getLevelColor(level);
@@ -52,24 +68,24 @@ function prettyPrintWideEvent(event) {
     delete rest.method;
     delete rest.path;
   }
-  if (rest.duration) {
-    header += ` ${colors.dim}${rest.duration}${colors.reset}`;
-    delete rest.duration;
-  }
   if (rest.status) {
     const statusColor = rest.status >= 400 ? colors.red : colors.green;
     header += ` ${statusColor}${rest.status}${colors.reset}`;
     delete rest.status;
   }
-  console.log(header);
-  if (Object.keys(rest).length > 0) {
-    for (const [key, value] of Object.entries(rest)) {
-      if (value !== void 0) {
-        const formatted = typeof value === "object" ? JSON.stringify(value) : value;
-        console.log(`  ${colors.dim}${key}:${colors.reset} ${formatted}`);
-      }
-    }
+  if (rest.duration) {
+    header += ` ${colors.dim}in ${rest.duration}${colors.reset}`;
+    delete rest.duration;
   }
+  console.log(header);
+  const entries = Object.entries(rest).filter(([_, v]) => v !== void 0);
+  const lastIndex = entries.length - 1;
+  entries.forEach(([key, value], index) => {
+    const isLast = index === lastIndex;
+    const prefix = isLast ? "\u2514\u2500" : "\u251C\u2500";
+    const formatted = formatValue(value);
+    console.log(`  ${colors.dim}${prefix}${colors.reset} ${colors.cyan}${key}:${colors.reset} ${formatted}`);
+  });
 }
 function createLogMethod(level) {
   return function logMethod(tagOrEvent, message) {

package/dist/nitro/plugin.mjs

@@ -1,29 +1,60 @@
-import { defineNitroPlugin } from 'nitropack/runtime';
+import { defineNitroPlugin, useRuntimeConfig } from 'nitropack/runtime';
 import { initLogger, createRequestLogger } from '../logger.mjs';
 import '../utils.mjs';
 
+function matchesPattern(path, pattern) {
+  const regexPattern = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/{{GLOBSTAR}}/g, ".*").replace(/\?/g, "[^/]");
+  const regex = new RegExp(`^${regexPattern}$`);
+  return regex.test(path);
+}
+function shouldLog(path, include) {
+  if (!include || include.length === 0) {
+    return true;
+  }
+  return include.some((pattern) => matchesPattern(path, pattern));
+}
 function getResponseStatus(event) {
-  return event.node?.res?.statusCode ?? 200;
+  if (event.node?.res?.statusCode) {
+    return event.node.res.statusCode;
+  }
+  if (event.response?.status) {
+    return event.response.status;
+  }
+  if (typeof event.context.status === "number") {
+    return event.context.status;
+  }
+  return 200;
 }
 const plugin = defineNitroPlugin((nitroApp) => {
-  initLogger();
+  const config = useRuntimeConfig();
+  const evlogConfig = config.evlog;
+  initLogger({
+    env: evlogConfig?.env,
+    pretty: evlogConfig?.pretty
+  });
   nitroApp.hooks.hook("request", (event) => {
+    const e = event;
+    if (!shouldLog(e.path, evlogConfig?.include)) {
+      return;
+    }
     const log = createRequestLogger({
-      method: event.method,
-      path: event.path,
-      requestId: event.context.requestId || crypto.randomUUID()
+      method: e.method,
+      path: e.path,
+      requestId: e.context.requestId || crypto.randomUUID()
     });
-    event.context.log = log;
+    e.context.log = log;
   });
   nitroApp.hooks.hook("afterResponse", (event) => {
-    const log = event.context.log;
+    const e = event;
+    const log = e.context.log;
     if (log) {
-      log.set({ status: getResponseStatus(event) });
+      log.set({ status: getResponseStatus(e) });
       log.emit();
     }
   });
   nitroApp.hooks.hook("error", (error, { event }) => {
-    const log = event?.context.log;
+    const e = event;
+    const log = e?.context.log;
     if (log) {
       log.error(error);
     }

package/dist/nuxt/module.d.mts

@@ -11,6 +11,13 @@ interface ModuleOptions {
      * @default true in development, false in production
      */
     pretty?: boolean;
+    /**
+     * Route patterns to include in logging.
+     * Supports glob patterns like '/api/**'.
+     * If not set, all routes are logged.
+     * @example ['/api/**', '/auth/**']
+     */
+    include?: string[];
 }
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
 

package/dist/nuxt/module.d.ts

@@ -11,6 +11,13 @@ interface ModuleOptions {
      * @default true in development, false in production
      */
     pretty?: boolean;
+    /**
+     * Route patterns to include in logging.
+     * Supports glob patterns like '/api/**'.
+     * If not set, all routes are logged.
+     * @example ['/api/**', '/auth/**']
+     */
+    include?: string[];
 }
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
 

package/dist/nuxt/module.mjs

@@ -4,7 +4,7 @@ const module$1 = defineNuxtModule({
   meta: {
     name: "evlog",
     configKey: "evlog",
-    docs: "https://github.com/hugorcd/evlog"
+    docs: "https://evlog.dev"
   },
   defaults: {},
   setup(options, nuxt) {
@@ -15,30 +15,34 @@ const module$1 = defineNuxtModule({
     };
     addServerPlugin(resolver.resolve("../nitro/plugin"));
     addPlugin({
-      src: resolver.resolve("../runtime/plugin.client"),
+      src: resolver.resolve("../runtime/client/plugin"),
       mode: "client"
     });
     addImports([
       {
         name: "log",
-        from: resolver.resolve("../runtime/composables/log")
+        from: resolver.resolve("../runtime/client/log")
       },
       {
-        name: "defineError",
+        name: "createEvlogError",
         from: resolver.resolve("../error")
+      },
+      {
+        name: "parseError",
+        from: resolver.resolve("../runtime/utils/parseError")
       }
     ]);
     addServerImports([
       {
         name: "useLogger",
-        from: resolver.resolve("../runtime/composables/useLogger")
+        from: resolver.resolve("../runtime/server/useLogger")
       },
       {
         name: "log",
-        from: resolver.resolve("../runtime/composables/log")
+        from: resolver.resolve("../runtime/client/log")
       },
       {
-        name: "defineError",
+        name: "createEvlogError",
         from: resolver.resolve("../error")
       }
     ]);

package/dist/runtime/client/log.d.mts

@@ -0,0 +1,9 @@
+import { Log } from '../../types.mjs';
+
+declare function initLog(options?: {
+    pretty?: boolean;
+    service?: string;
+}): void;
+declare const log: Log;
+
+export { initLog, log };

package/dist/runtime/client/log.d.ts

@@ -0,0 +1,9 @@
+import { Log } from '../../types.js';
+
+declare function initLog(options?: {
+    pretty?: boolean;
+    service?: string;
+}): void;
+declare const log: Log;
+
+export { initLog, log };

package/dist/runtime/{composables → client}/log.mjs

@@ -1,3 +1,5 @@
+import { getConsoleMethod } from '../../utils.mjs';
+
 const IS_CLIENT = typeof window !== "undefined";
 let clientPretty = true;
 let clientService = "client";
@@ -11,9 +13,6 @@ function initLog(options = {}) {
   clientPretty = options.pretty ?? true;
   clientService = options.service ?? "client";
 }
-function getConsoleMethod(level) {
-  return level === "error" ? "error" : level === "warn" ? "warn" : "log";
-}
 function emitClientWideEvent(level, event) {
   const formatted = {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),

package/dist/runtime/{plugin.client.mjs → client/plugin.mjs}

@@ -1,7 +1,8 @@
-import { initLog } from './composables/log.mjs';
+import { initLog } from './log.mjs';
 import { defineNuxtPlugin, useRuntimeConfig } from '#app';
+import '../../utils.mjs';
 
-const plugin_client = defineNuxtPlugin((_nuxtApp) => {
+const plugin = defineNuxtPlugin(() => {
   const config = useRuntimeConfig();
   const evlogConfig = config.public?.evlog;
   initLog({
@@ -10,4 +11,4 @@ const plugin_client = defineNuxtPlugin((_nuxtApp) => {
   });
 });
 
-export { plugin_client as default };
+export { plugin as default };

package/dist/runtime/server/useLogger.d.mts

@@ -0,0 +1,5 @@
+import { ServerEvent, RequestLogger } from '../../types.mjs';
+
+declare function useLogger(event: ServerEvent): RequestLogger;
+
+export { useLogger };

package/dist/runtime/server/useLogger.d.ts

@@ -0,0 +1,5 @@
+import { ServerEvent, RequestLogger } from '../../types.js';
+
+declare function useLogger(event: ServerEvent): RequestLogger;
+
+export { useLogger };

package/dist/runtime/utils/parseError.d.mts

@@ -0,0 +1,5 @@
+import { ParsedError } from '../../types.mjs';
+
+declare function parseError(error: unknown): ParsedError;
+
+export { ParsedError, parseError };

package/dist/runtime/utils/parseError.d.ts

@@ -0,0 +1,5 @@
+import { ParsedError } from '../../types.js';
+
+declare function parseError(error: unknown): ParsedError;
+
+export { ParsedError, parseError };

package/dist/runtime/utils/parseError.mjs

@@ -0,0 +1,28 @@
+function parseError(error) {
+  if (error && typeof error === "object" && "data" in error) {
+    const { data, message: fetchMessage, statusCode: fetchStatusCode } = error;
+    const evlogData = data?.data;
+    return {
+      message: data?.message || fetchMessage || "An error occurred",
+      status: data?.statusCode || fetchStatusCode || 500,
+      why: evlogData?.why,
+      fix: evlogData?.fix,
+      link: evlogData?.link,
+      raw: error
+    };
+  }
+  if (error instanceof Error) {
+    return {
+      message: error.message,
+      status: 500,
+      raw: error
+    };
+  }
+  return {
+    message: String(error),
+    status: 500,
+    raw: error
+  };
+}
+
+export { parseError };

package/dist/types.d.mts

@@ -116,6 +116,8 @@ interface Log {
 interface ErrorOptions {
     /** What actually happened */
     message: string;
+    /** HTTP status code (default: 500) */
+    status?: number;
     /** Why this error occurred */
     why?: string;
     /** How to fix this issue */
@@ -125,11 +127,47 @@ interface ErrorOptions {
     /** The original error that caused this */
     cause?: Error;
 }
+/**
+ * Options for creating a request logger
+ */
+interface RequestLoggerOptions {
+    method?: string;
+    path?: string;
+    requestId?: string;
+}
 /**
  * H3 event context with evlog logger attached
  */
-interface EvlogEventContext {
+interface H3EventContext {
     log?: RequestLogger;
+    requestId?: string;
+    status?: number;
+    [key: string]: unknown;
+}
+/**
+ * Server event type for Nitro/h3 handlers
+ */
+interface ServerEvent {
+    method: string;
+    path: string;
+    context: H3EventContext;
+    node?: {
+        res?: {
+            statusCode?: number;
+        };
+    };
+    response?: Response;
+}
+/**
+ * Parsed evlog error with all fields at the top level
+ */
+interface ParsedError {
+    message: string;
+    status: number;
+    why?: string;
+    fix?: string;
+    link?: string;
+    raw: unknown;
 }
 
-export type { BaseWideEvent, EnvironmentContext, ErrorOptions, EvlogEventContext, Log, LogLevel, LoggerConfig, RequestLogger, WideEvent };
+export type { BaseWideEvent, EnvironmentContext, ErrorOptions, H3EventContext, Log, LogLevel, LoggerConfig, ParsedError, RequestLogger, RequestLoggerOptions, ServerEvent, WideEvent };

package/dist/types.d.ts

@@ -116,6 +116,8 @@ interface Log {
 interface ErrorOptions {
     /** What actually happened */
     message: string;
+    /** HTTP status code (default: 500) */
+    status?: number;
     /** Why this error occurred */
     why?: string;
     /** How to fix this issue */
@@ -125,11 +127,47 @@ interface ErrorOptions {
     /** The original error that caused this */
     cause?: Error;
 }
+/**
+ * Options for creating a request logger
+ */
+interface RequestLoggerOptions {
+    method?: string;
+    path?: string;
+    requestId?: string;
+}
 /**
  * H3 event context with evlog logger attached
  */
-interface EvlogEventContext {
+interface H3EventContext {
     log?: RequestLogger;
+    requestId?: string;
+    status?: number;
+    [key: string]: unknown;
+}
+/**
+ * Server event type for Nitro/h3 handlers
+ */
+interface ServerEvent {
+    method: string;
+    path: string;
+    context: H3EventContext;
+    node?: {
+        res?: {
+            statusCode?: number;
+        };
+    };
+    response?: Response;
+}
+/**
+ * Parsed evlog error with all fields at the top level
+ */
+interface ParsedError {
+    message: string;
+    status: number;
+    why?: string;
+    fix?: string;
+    link?: string;
+    raw: unknown;
 }
 
-export type { BaseWideEvent, EnvironmentContext, ErrorOptions, EvlogEventContext, Log, LogLevel, LoggerConfig, RequestLogger, WideEvent };
+export type { BaseWideEvent, EnvironmentContext, ErrorOptions, H3EventContext, Log, LogLevel, LoggerConfig, ParsedError, RequestLogger, RequestLoggerOptions, ServerEvent, WideEvent };

package/dist/utils.d.mts

@@ -1,27 +1,11 @@
-import { EnvironmentContext } from './types.mjs';
+import { EnvironmentContext, LogLevel } from './types.mjs';
 
-/**
- * Format duration for display
- * < 1s: shows milliseconds (e.g., "42ms")
- * >= 1s: shows seconds (e.g., "1.5s")
- */
 declare function formatDuration(ms: number): string;
-/**
- * Check if running on server
- */
 declare function isServer(): boolean;
-/**
- * Check if running on client
- */
 declare function isClient(): boolean;
-/**
- * Check if in development mode
- */
 declare function isDev(): boolean;
-/**
- * Auto-detect environment context from env variables
- */
 declare function detectEnvironment(): Partial<EnvironmentContext>;
+declare function getConsoleMethod(level: LogLevel): 'log' | 'error' | 'warn';
 declare const colors: {
     readonly reset: "\u001B[0m";
     readonly bold: "\u001B[1m";
@@ -35,9 +19,6 @@ declare const colors: {
     readonly white: "\u001B[37m";
     readonly gray: "\u001B[90m";
 };
-/**
- * Get color for log level
- */
 declare function getLevelColor(level: string): string;
 
-export { colors, detectEnvironment, formatDuration, getLevelColor, isClient, isDev, isServer };
+export { colors, detectEnvironment, formatDuration, getConsoleMethod, getLevelColor, isClient, isDev, isServer };

package/dist/utils.d.ts

@@ -1,27 +1,11 @@
-import { EnvironmentContext } from './types.js';
+import { EnvironmentContext, LogLevel } from './types.js';
 
-/**
- * Format duration for display
- * < 1s: shows milliseconds (e.g., "42ms")
- * >= 1s: shows seconds (e.g., "1.5s")
- */
 declare function formatDuration(ms: number): string;
-/**
- * Check if running on server
- */
 declare function isServer(): boolean;
-/**
- * Check if running on client
- */
 declare function isClient(): boolean;
-/**
- * Check if in development mode
- */
 declare function isDev(): boolean;
-/**
- * Auto-detect environment context from env variables
- */
 declare function detectEnvironment(): Partial<EnvironmentContext>;
+declare function getConsoleMethod(level: LogLevel): 'log' | 'error' | 'warn';
 declare const colors: {
     readonly reset: "\u001B[0m";
     readonly bold: "\u001B[1m";
@@ -35,9 +19,6 @@ declare const colors: {
     readonly white: "\u001B[37m";
     readonly gray: "\u001B[90m";
 };
-/**
- * Get color for log level
- */
 declare function getLevelColor(level: string): string;
 
-export { colors, detectEnvironment, formatDuration, getLevelColor, isClient, isDev, isServer };
+export { colors, detectEnvironment, formatDuration, getConsoleMethod, getLevelColor, isClient, isDev, isServer };

package/dist/utils.mjs

@@ -26,6 +26,9 @@ function detectEnvironment() {
     region: env.VERCEL_REGION || env.AWS_REGION || env.FLY_REGION || env.CF_REGION
   };
 }
+function getConsoleMethod(level) {
+  return level === "error" ? "error" : level === "warn" ? "warn" : "log";
+}
 const colors = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
@@ -54,4 +57,4 @@ function getLevelColor(level) {
   }
 }
 
-export { colors, detectEnvironment, formatDuration, getLevelColor, isClient, isDev, isServer };
+export { colors, detectEnvironment, formatDuration, getConsoleMethod, getLevelColor, isClient, isDev, isServer };

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "evlog",
-  "version": "0.1.0",
+  "version": "1.0.1",
   "description": "Wide event logging library with structured error handling. Inspired by LoggingSucks.",
   "author": "HugoRCD <contact@hrcd.fr>",
-  "homepage": "https://github.com/HugoRCD/evlog",
+  "homepage": "https://evlog.dev",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/HugoRCD/evlog.git"
@@ -57,7 +57,7 @@
   ],
   "scripts": {
     "build": "unbuild",
-    "dev:prepare": "unbuild --stub",
+    "dev:prepare": "unbuild",
     "release": "bun run lint && bun run test && bun run build && changelogen --release && npm publish && git push --follow-tags",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
@@ -74,15 +74,16 @@
     "@nuxt/schema": "^4.3.0",
     "@nuxt/test-utils": "^3.23.0",
     "changelogen": "^0.6.2",
-    "h3": "^1.15.0",
-    "nitropack": "^2.13.0",
+    "h3": "^1.15.5",
+    "nitropack": "^2.13.1",
     "nuxt": "^4.3.0",
     "typescript": "^5.9.3",
-    "unbuild": "^3.5.0"
+    "unbuild": "^3.6.1"
   },
   "peerDependencies": {
-    "h3": "^1.13.0",
-    "nitropack": "^2.10.0"
+    "h3": "^1.15.5",
+    "nitropack": "^2.13.1",
+    "ofetch": "^1.5.1"
   },
   "peerDependenciesMeta": {
     "h3": {
@@ -90,6 +91,9 @@
     },
     "nitropack": {
       "optional": true
+    },
+    "ofetch": {
+      "optional": true
     }
   }
 }

package/dist/runtime/composables/index.d.mts

@@ -1,4 +0,0 @@
-export { initLog, log } from './log.mjs';
-export { useLogger } from './useLogger.mjs';
-import '../../types.mjs';
-import 'h3';

package/dist/runtime/composables/index.d.ts

@@ -1,4 +0,0 @@
-export { initLog, log } from './log.js';
-export { useLogger } from './useLogger.js';
-import '../../types.js';
-import 'h3';

package/dist/runtime/composables/index.mjs

@@ -1,2 +0,0 @@
-export { initLog, log } from './log.mjs';
-export { useLogger } from './useLogger.mjs';

package/dist/runtime/composables/log.d.mts

@@ -1,18 +0,0 @@
-import { Log } from '../../types.mjs';
-
-declare function initLog(options?: {
-    pretty?: boolean;
-    service?: string;
-}): void;
-/**
- * Universal logging API - works on both client and server.
- *
- * @example
- * ```ts
- * log.info('auth', 'User logged in')
- * log.info({ action: 'checkout', items: 3 })
- * ```
- */
-declare const log: Log;
-
-export { initLog, log };

package/dist/runtime/composables/log.d.ts

@@ -1,18 +0,0 @@
-import { Log } from '../../types.js';
-
-declare function initLog(options?: {
-    pretty?: boolean;
-    service?: string;
-}): void;
-/**
- * Universal logging API - works on both client and server.
- *
- * @example
- * ```ts
- * log.info('auth', 'User logged in')
- * log.info({ action: 'checkout', items: 3 })
- * ```
- */
-declare const log: Log;
-
-export { initLog, log };

package/dist/runtime/composables/useLogger.d.mts

@@ -1,21 +0,0 @@
-import { H3Event } from 'h3';
-import { RequestLogger } from '../../types.mjs';
-
-/**
- * Get the request-scoped logger from the event context.
- * Must be called within a server handler with an H3 event.
- *
- * @example
- * ```ts
- * export default defineEventHandler((event) => {
- *   const logger = useLogger(event)
- *   logger.set({ userId: '123' })
- *   logger.set({ action: 'checkout' })
- *   return { ok: true }
- *   // emit() is called automatically by the Nitro plugin
- * })
- * ```
- */
-declare function useLogger(event: H3Event): RequestLogger;
-
-export { useLogger };

package/dist/runtime/composables/useLogger.d.ts

@@ -1,21 +0,0 @@
-import { H3Event } from 'h3';
-import { RequestLogger } from '../../types.js';
-
-/**
- * Get the request-scoped logger from the event context.
- * Must be called within a server handler with an H3 event.
- *
- * @example
- * ```ts
- * export default defineEventHandler((event) => {
- *   const logger = useLogger(event)
- *   logger.set({ userId: '123' })
- *   logger.set({ action: 'checkout' })
- *   return { ok: true }
- *   // emit() is called automatically by the Nitro plugin
- * })
- * ```
- */
-declare function useLogger(event: H3Event): RequestLogger;
-
-export { useLogger };