@dexto/core 1.2.4 → 1.2.5

package/dist/logger/v2/schemas.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Logger Configuration Schemas
+ *
+ * Zod schemas for logger configuration with multi-transport support.
+ * Supports console, file, and optional remote (Upstash) transports.
+ */
+import { z } from 'zod';
+/**
+ * Transport configuration (discriminated union)
+ */
+export declare const LoggerTransportSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"console">;
+    colorize: z.ZodDefault<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    type: "console";
+    colorize: boolean;
+}, {
+    type: "console";
+    colorize?: boolean | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"file">;
+    path: z.ZodString;
+    maxSize: z.ZodDefault<z.ZodNumber>;
+    maxFiles: z.ZodDefault<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    path: string;
+    type: "file";
+    maxFiles: number;
+    maxSize: number;
+}, {
+    path: string;
+    type: "file";
+    maxFiles?: number | undefined;
+    maxSize?: number | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"upstash">;
+    url: z.ZodString;
+    token: z.ZodString;
+    listName: z.ZodDefault<z.ZodString>;
+    maxListLength: z.ZodDefault<z.ZodNumber>;
+    batchSize: z.ZodDefault<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    token: string;
+    type: "upstash";
+    url: string;
+    listName: string;
+    maxListLength: number;
+    batchSize: number;
+}, {
+    token: string;
+    type: "upstash";
+    url: string;
+    listName?: string | undefined;
+    maxListLength?: number | undefined;
+    batchSize?: number | undefined;
+}>]>;
+export type LoggerTransportConfig = z.output<typeof LoggerTransportSchema>;
+/**
+ * Logger configuration schema
+ */
+export declare const LoggerConfigSchema: z.ZodObject<{
+    level: z.ZodDefault<z.ZodEnum<["debug", "info", "warn", "error", "silly"]>>;
+    transports: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"console">;
+        colorize: z.ZodDefault<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        type: "console";
+        colorize: boolean;
+    }, {
+        type: "console";
+        colorize?: boolean | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"file">;
+        path: z.ZodString;
+        maxSize: z.ZodDefault<z.ZodNumber>;
+        maxFiles: z.ZodDefault<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        path: string;
+        type: "file";
+        maxFiles: number;
+        maxSize: number;
+    }, {
+        path: string;
+        type: "file";
+        maxFiles?: number | undefined;
+        maxSize?: number | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"upstash">;
+        url: z.ZodString;
+        token: z.ZodString;
+        listName: z.ZodDefault<z.ZodString>;
+        maxListLength: z.ZodDefault<z.ZodNumber>;
+        batchSize: z.ZodDefault<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        token: string;
+        type: "upstash";
+        url: string;
+        listName: string;
+        maxListLength: number;
+        batchSize: number;
+    }, {
+        token: string;
+        type: "upstash";
+        url: string;
+        listName?: string | undefined;
+        maxListLength?: number | undefined;
+        batchSize?: number | undefined;
+    }>]>, "many">>;
+}, "strict", z.ZodTypeAny, {
+    level: "debug" | "info" | "warn" | "error" | "silly";
+    transports: ({
+        type: "console";
+        colorize: boolean;
+    } | {
+        path: string;
+        type: "file";
+        maxFiles: number;
+        maxSize: number;
+    } | {
+        token: string;
+        type: "upstash";
+        url: string;
+        listName: string;
+        maxListLength: number;
+        batchSize: number;
+    })[];
+}, {
+    level?: "debug" | "info" | "warn" | "error" | "silly" | undefined;
+    transports?: ({
+        type: "console";
+        colorize?: boolean | undefined;
+    } | {
+        path: string;
+        type: "file";
+        maxFiles?: number | undefined;
+        maxSize?: number | undefined;
+    } | {
+        token: string;
+        type: "upstash";
+        url: string;
+        listName?: string | undefined;
+        maxListLength?: number | undefined;
+        batchSize?: number | undefined;
+    })[] | undefined;
+}>;
+export type LoggerConfig = z.output<typeof LoggerConfigSchema>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/logger/v2/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/logger/v2/schemas.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA4DxB;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIhC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE3E;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAamC,CAAC;AAEnE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/logger/v2/schemas.js

@@ -0,0 +1,33 @@
+import "../../chunk-C6A6W6XS.js";
+import { z } from "zod";
+const ConsoleTransportSchema = z.object({
+  type: z.literal("console"),
+  colorize: z.boolean().default(true).describe("Enable colored output")
+}).strict().describe("Console transport for terminal output");
+const FileTransportSchema = z.object({
+  type: z.literal("file"),
+  path: z.string().describe("Absolute path to log file"),
+  maxSize: z.number().positive().default(10 * 1024 * 1024).describe("Max file size in bytes before rotation (default: 10MB)"),
+  maxFiles: z.number().int().positive().default(5).describe("Max number of rotated files to keep (default: 5)")
+}).strict().describe("File transport with rotation support");
+const UpstashTransportSchema = z.object({
+  type: z.literal("upstash"),
+  url: z.string().url().describe("Upstash Redis REST URL"),
+  token: z.string().describe("Upstash Redis REST token"),
+  listName: z.string().default("dexto-logs").describe("Redis list name for log entries"),
+  maxListLength: z.number().int().positive().default(1e4).describe("Max entries in Redis list (default: 10000)"),
+  batchSize: z.number().int().positive().default(100).describe("Number of log entries to batch before sending (default: 100)")
+}).strict().describe("Upstash Redis transport for remote logging");
+const LoggerTransportSchema = z.discriminatedUnion("type", [
+  ConsoleTransportSchema,
+  FileTransportSchema,
+  UpstashTransportSchema
+]);
+const LoggerConfigSchema = z.object({
+  level: z.enum(["debug", "info", "warn", "error", "silly"]).default("info").describe("Minimum log level to record"),
+  transports: z.array(LoggerTransportSchema).min(1).default([{ type: "console", colorize: true }]).describe("Log output destinations")
+}).strict().describe("Logger configuration with multi-transport support");
+export {
+  LoggerConfigSchema,
+  LoggerTransportSchema
+};

package/dist/logger/v2/transport-factory.cjs

@@ -0,0 +1,53 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var transport_factory_exports = {};
+__export(transport_factory_exports, {
+  createTransport: () => createTransport,
+  createTransports: () => createTransports
+});
+module.exports = __toCommonJS(transport_factory_exports);
+var import_console_transport = require("./transports/console-transport.js");
+var import_file_transport = require("./transports/file-transport.js");
+var import_errors = require("./errors.js");
+function createTransport(config) {
+  switch (config.type) {
+    case "console":
+      return new import_console_transport.ConsoleTransport({
+        colorize: config.colorize
+      });
+    case "file":
+      return new import_file_transport.FileTransport({
+        path: config.path,
+        maxSize: config.maxSize,
+        maxFiles: config.maxFiles
+      });
+    case "upstash":
+      throw import_errors.LoggerError.transportNotImplemented("upstash", ["console", "file"]);
+    default:
+      throw import_errors.LoggerError.unknownTransportType(config.type);
+  }
+}
+function createTransports(configs) {
+  return configs.map(createTransport);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createTransport,
+  createTransports
+});

package/dist/logger/v2/transport-factory.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Transport Factory
+ *
+ * Creates transport instances from configuration.
+ * Used by CLI enrichment layer to instantiate transports.
+ */
+import type { ILoggerTransport } from './types.js';
+import type { LoggerTransportConfig } from './schemas.js';
+/**
+ * Create a transport instance from configuration
+ * @param config Transport configuration from schema
+ * @returns Transport instance
+ */
+export declare function createTransport(config: LoggerTransportConfig): ILoggerTransport;
+/**
+ * Create multiple transports from configuration array
+ * @param configs Array of transport configurations
+ * @returns Array of transport instances
+ */
+export declare function createTransports(configs: LoggerTransportConfig[]): ILoggerTransport[];
+//# sourceMappingURL=transport-factory.d.ts.map

package/dist/logger/v2/transport-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport-factory.d.ts","sourceRoot":"","sources":["../../../src/logger/v2/transport-factory.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACnD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAK1D;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,qBAAqB,GAAG,gBAAgB,CAqB/E;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,qBAAqB,EAAE,GAAG,gBAAgB,EAAE,CAErF"}

package/dist/logger/v2/transport-factory.js

@@ -0,0 +1,29 @@
+import "../../chunk-C6A6W6XS.js";
+import { ConsoleTransport } from "./transports/console-transport.js";
+import { FileTransport } from "./transports/file-transport.js";
+import { LoggerError } from "./errors.js";
+function createTransport(config) {
+  switch (config.type) {
+    case "console":
+      return new ConsoleTransport({
+        colorize: config.colorize
+      });
+    case "file":
+      return new FileTransport({
+        path: config.path,
+        maxSize: config.maxSize,
+        maxFiles: config.maxFiles
+      });
+    case "upstash":
+      throw LoggerError.transportNotImplemented("upstash", ["console", "file"]);
+    default:
+      throw LoggerError.unknownTransportType(config.type);
+  }
+}
+function createTransports(configs) {
+  return configs.map(createTransport);
+}
+export {
+  createTransport,
+  createTransports
+};

package/dist/logger/v2/transports/console-transport.cjs

@@ -0,0 +1,79 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var console_transport_exports = {};
+__export(console_transport_exports, {
+  ConsoleTransport: () => ConsoleTransport
+});
+module.exports = __toCommonJS(console_transport_exports);
+var import_chalk = __toESM(require("chalk"), 1);
+class ConsoleTransport {
+  colorize;
+  constructor(config = {}) {
+    this.colorize = config.colorize ?? true;
+  }
+  write(entry) {
+    const timestamp = new Date(entry.timestamp).toLocaleTimeString();
+    const component = `[${entry.component}:${entry.agentId}]`;
+    const levelLabel = `[${entry.level.toUpperCase()}]`;
+    let message = `${timestamp} ${levelLabel} ${component} ${entry.message}`;
+    if (this.colorize) {
+      const colorFn = this.getColorForLevel(entry.level);
+      message = colorFn(message);
+    }
+    if (entry.context && Object.keys(entry.context).length > 0) {
+      message += "\n" + JSON.stringify(entry.context, null, 2);
+    }
+    if (entry.level === "error" || entry.level === "warn") {
+      console.error(message);
+    } else {
+      console.log(message);
+    }
+  }
+  /**
+   * Get chalk color function for log level
+   */
+  getColorForLevel(level) {
+    switch (level) {
+      case "debug":
+        return import_chalk.default.gray;
+      case "info":
+        return import_chalk.default.cyan;
+      case "warn":
+        return import_chalk.default.yellow;
+      case "error":
+        return import_chalk.default.red;
+      default:
+        return (s) => s;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConsoleTransport
+});

package/dist/logger/v2/transports/console-transport.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Console Transport
+ *
+ * Logs to stdout/stderr with optional color support.
+ * Uses chalk for color formatting.
+ */
+import type { ILoggerTransport, LogEntry } from '../types.js';
+export interface ConsoleTransportConfig {
+    colorize?: boolean;
+}
+/**
+ * Console transport for terminal output
+ */
+export declare class ConsoleTransport implements ILoggerTransport {
+    private colorize;
+    constructor(config?: ConsoleTransportConfig);
+    write(entry: LogEntry): void;
+    /**
+     * Get chalk color function for log level
+     */
+    private getColorForLevel;
+}
+//# sourceMappingURL=console-transport.d.ts.map

package/dist/logger/v2/transports/console-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console-transport.d.ts","sourceRoot":"","sources":["../../../../src/logger/v2/transports/console-transport.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,QAAQ,EAAY,MAAM,aAAa,CAAC;AAExE,MAAM,WAAW,sBAAsB;IACnC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;GAEG;AACH,qBAAa,gBAAiB,YAAW,gBAAgB;IACrD,OAAO,CAAC,QAAQ,CAAU;gBAEd,MAAM,GAAE,sBAA2B;IAI/C,KAAK,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAyB5B;;OAEG;IACH,OAAO,CAAC,gBAAgB;CAc3B"}

package/dist/logger/v2/transports/console-transport.js

@@ -0,0 +1,46 @@
+import "../../../chunk-C6A6W6XS.js";
+import chalk from "chalk";
+class ConsoleTransport {
+  colorize;
+  constructor(config = {}) {
+    this.colorize = config.colorize ?? true;
+  }
+  write(entry) {
+    const timestamp = new Date(entry.timestamp).toLocaleTimeString();
+    const component = `[${entry.component}:${entry.agentId}]`;
+    const levelLabel = `[${entry.level.toUpperCase()}]`;
+    let message = `${timestamp} ${levelLabel} ${component} ${entry.message}`;
+    if (this.colorize) {
+      const colorFn = this.getColorForLevel(entry.level);
+      message = colorFn(message);
+    }
+    if (entry.context && Object.keys(entry.context).length > 0) {
+      message += "\n" + JSON.stringify(entry.context, null, 2);
+    }
+    if (entry.level === "error" || entry.level === "warn") {
+      console.error(message);
+    } else {
+      console.log(message);
+    }
+  }
+  /**
+   * Get chalk color function for log level
+   */
+  getColorForLevel(level) {
+    switch (level) {
+      case "debug":
+        return chalk.gray;
+      case "info":
+        return chalk.cyan;
+      case "warn":
+        return chalk.yellow;
+      case "error":
+        return chalk.red;
+      default:
+        return (s) => s;
+    }
+  }
+}
+export {
+  ConsoleTransport
+};

package/dist/logger/v2/transports/file-transport.cjs

@@ -0,0 +1,161 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var file_transport_exports = {};
+__export(file_transport_exports, {
+  FileTransport: () => FileTransport
+});
+module.exports = __toCommonJS(file_transport_exports);
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+class FileTransport {
+  filePath;
+  maxSize;
+  maxFiles;
+  writeStream = null;
+  currentSize = 0;
+  isRotating = false;
+  pendingLogs = [];
+  constructor(config) {
+    this.filePath = config.path;
+    this.maxSize = config.maxSize ?? 10 * 1024 * 1024;
+    this.maxFiles = config.maxFiles ?? 5;
+    const dir = path.dirname(this.filePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    if (fs.existsSync(this.filePath)) {
+      const stats = fs.statSync(this.filePath);
+      this.currentSize = stats.size;
+    }
+    this.createWriteStream();
+  }
+  createWriteStream() {
+    this.writeStream = fs.createWriteStream(this.filePath, {
+      flags: "a",
+      // Append mode
+      encoding: "utf8"
+    });
+    this.writeStream.on("error", (error) => {
+      console.error("FileTransport write stream error:", error);
+    });
+  }
+  write(entry) {
+    const line = JSON.stringify(entry) + "\n";
+    const lineSize = Buffer.byteLength(line, "utf8");
+    if (!this.writeStream || this.isRotating) {
+      this.pendingLogs.push(line);
+      return;
+    }
+    if (this.currentSize + lineSize > this.maxSize) {
+      this.pendingLogs.push(line);
+      void this.rotate();
+      return;
+    }
+    this.writeStream.write(line);
+    this.currentSize += lineSize;
+  }
+  /**
+   * Rotate log files asynchronously
+   * Renames current file to .1, shifts existing rotated files up (.1 -> .2, etc.)
+   * Deletes oldest file if maxFiles is exceeded, then flushes buffered logs
+   */
+  async rotate() {
+    if (this.isRotating) {
+      return;
+    }
+    this.isRotating = true;
+    try {
+      if (this.writeStream) {
+        await new Promise((resolve) => {
+          this.writeStream.end(() => resolve());
+        });
+        this.writeStream = null;
+      }
+      const promises = [];
+      const oldestFile = `${this.filePath}.${this.maxFiles}`;
+      try {
+        await fs.promises.access(oldestFile);
+        promises.push(fs.promises.unlink(oldestFile));
+      } catch {
+      }
+      await Promise.all(promises);
+      for (let i = this.maxFiles - 1; i >= 1; i--) {
+        const oldFile = `${this.filePath}.${i}`;
+        const newFile = `${this.filePath}.${i + 1}`;
+        try {
+          await fs.promises.access(oldFile);
+          await fs.promises.rename(oldFile, newFile);
+        } catch {
+        }
+      }
+      try {
+        await fs.promises.access(this.filePath);
+        await fs.promises.rename(this.filePath, `${this.filePath}.1`);
+      } catch {
+      }
+      this.currentSize = 0;
+      this.createWriteStream();
+      await this.flushPendingLogs();
+    } catch (error) {
+      console.error("FileTransport rotation error:", error);
+    } finally {
+      this.isRotating = false;
+    }
+  }
+  /**
+   * Flush buffered logs to the write stream
+   * Called after rotation completes to prevent log loss
+   */
+  async flushPendingLogs() {
+    while (this.pendingLogs.length > 0 && this.writeStream) {
+      const line = this.pendingLogs.shift();
+      const lineSize = Buffer.byteLength(line, "utf8");
+      if (this.currentSize + lineSize > this.maxSize) {
+        this.pendingLogs.unshift(line);
+        await this.rotate();
+        break;
+      }
+      this.writeStream.write(line);
+      this.currentSize += lineSize;
+    }
+  }
+  /**
+   * Cleanup resources
+   */
+  destroy() {
+    if (this.writeStream) {
+      this.writeStream.end();
+      this.writeStream = null;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FileTransport
+});

package/dist/logger/v2/transports/file-transport.d.ts

@@ -0,0 +1,46 @@
+/**
+ * File Transport
+ *
+ * Logs to a file with automatic rotation based on file size.
+ * Keeps a configurable number of rotated log files.
+ */
+import type { ILoggerTransport, LogEntry } from '../types.js';
+export interface FileTransportConfig {
+    /** Absolute path to log file */
+    path: string;
+    /** Max file size in bytes before rotation (default: 10MB) */
+    maxSize?: number;
+    /** Max number of rotated files to keep (default: 5) */
+    maxFiles?: number;
+}
+/**
+ * File transport with size-based rotation
+ */
+export declare class FileTransport implements ILoggerTransport {
+    private filePath;
+    private maxSize;
+    private maxFiles;
+    private writeStream;
+    private currentSize;
+    private isRotating;
+    private pendingLogs;
+    constructor(config: FileTransportConfig);
+    private createWriteStream;
+    write(entry: LogEntry): void;
+    /**
+     * Rotate log files asynchronously
+     * Renames current file to .1, shifts existing rotated files up (.1 -> .2, etc.)
+     * Deletes oldest file if maxFiles is exceeded, then flushes buffered logs
+     */
+    private rotate;
+    /**
+     * Flush buffered logs to the write stream
+     * Called after rotation completes to prevent log loss
+     */
+    private flushPendingLogs;
+    /**
+     * Cleanup resources
+     */
+    destroy(): void;
+}
+//# sourceMappingURL=file-transport.d.ts.map

package/dist/logger/v2/transports/file-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-transport.d.ts","sourceRoot":"","sources":["../../../../src/logger/v2/transports/file-transport.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE9D,MAAM,WAAW,mBAAmB;IAChC,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,6DAA6D;IAC7D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,uDAAuD;IACvD,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,qBAAa,aAAc,YAAW,gBAAgB;IAClD,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,WAAW,CAA+B;IAClD,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,UAAU,CAAkB;IACpC,OAAO,CAAC,WAAW,CAAgB;gBAEvB,MAAM,EAAE,mBAAmB;IAqBvC,OAAO,CAAC,iBAAiB;IAWzB,KAAK,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAwB5B;;;;OAIG;YACW,MAAM;IAgEpB;;;OAGG;YACW,gBAAgB;IAmB9B;;OAEG;IACH,OAAO,IAAI,IAAI;CAMlB"}