@loglayer/transport-pretty-terminal 1.0.0

package/dist/index.js

@@ -0,0 +1,1525 @@
+// src/PrettyTerminalTransport.ts
+import { LoggerlessTransport } from "@loglayer/transport";
+import chalk5 from "chalk";
+
+// src/LogRenderer.ts
+import chalk2 from "chalk";
+import truncate from "cli-truncate";
+import wrap from "wrap-ansi";
+
+// src/vendor/prettyjson.js
+import chalk from "chalk";
+
+// src/vendor/utils.js
+function indent(numSpaces) {
+  return new Array(numSpaces + 1).join(" ");
+}
+function getMaxIndexLength(input) {
+  var maxWidth = 0;
+  Object.getOwnPropertyNames(input).forEach(function(key) {
+    if (input[key] === void 0) {
+      return;
+    }
+    maxWidth = Math.max(maxWidth, key.length);
+  });
+  return maxWidth;
+}
+function isIsoStringDate(isoString) {
+  if (typeof isoString !== "string") {
+    return false;
+  }
+  if (!/^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?$/.test(isoString)) {
+    return false;
+  }
+  const testDate = new Date(isoString);
+  return !Number.isNaN(testDate.getTime());
+}
+
+// src/vendor/prettyjson.js
+var conflictChars = /[^\w\s\n\r\v\t\.,]/i;
+var isPrintable = (input, options) => input !== void 0 || options.renderUndefined;
+var isSerializable = (input, onlyPrimitives, options) => {
+  if (typeof input === "boolean" || typeof input === "number" || typeof input === "function" || input === null || input === void 0 || input instanceof Date) {
+    return true;
+  }
+  if (typeof input === "string" && input.indexOf("\n") === -1) {
+    return true;
+  }
+  if (options.inlineArrays && !onlyPrimitives) {
+    if (Array.isArray(input) && isSerializable(input[0], true, options)) {
+      return true;
+    }
+  }
+  return false;
+};
+var getColorRenderer = (colorFn, options) => {
+  if (options.noColor) {
+    return (text) => text;
+  }
+  if (typeof colorFn !== "function") {
+    return (text) => text;
+  }
+  return colorFn;
+};
+var addColorToData = (input, options) => {
+  if (options.noColor) {
+    return input;
+  }
+  if (input instanceof Date) {
+    return getColorRenderer(options.dateColor, options)(input.toISOString());
+  }
+  if (typeof input === "string") {
+    if (isIsoStringDate(input)) {
+      return getColorRenderer(options.dateColor, options)(input);
+    }
+    return getColorRenderer(options.stringColor, options)(input);
+  }
+  const sInput = `${input}`;
+  if (typeof input === "boolean") {
+    return getColorRenderer(options.booleanColor, options)(sInput);
+  }
+  if (input === null || input === void 0) {
+    return getColorRenderer(options.nullUndefinedColor, options)(sInput);
+  }
+  if (typeof input === "number") {
+    if (input >= 0) {
+      return getColorRenderer(options.positiveNumberColor, options)(sInput);
+    }
+    return getColorRenderer(options.negativeNumberColor, options)(sInput);
+  }
+  if (typeof input === "function") {
+    return "function() {}";
+  }
+  if (Array.isArray(input)) {
+    return input.join(", ");
+  }
+  return sInput;
+};
+var colorMultilineString = (options, line) => getColorRenderer(options.multilineStringColor, options)(line);
+var indentLines = (string, spaces, options) => {
+  let lines = string.split("\n");
+  lines = lines.map((line) => indent(spaces) + colorMultilineString(options, line));
+  return lines.join("\n");
+};
+var renderToArray = (data, options, indentation) => {
+  if (typeof data === "string" && data.match(conflictChars) && options.escape) {
+    data = JSON.stringify(data);
+  }
+  if (!isPrintable(data, options)) {
+    return [];
+  }
+  if (isSerializable(data, false, options)) {
+    return [indent(indentation) + addColorToData(data, options)];
+  }
+  if (typeof data === "string") {
+    return [
+      indent(indentation) + colorMultilineString(options, '"""'),
+      indentLines(data, indentation + options.defaultIndentation, options),
+      indent(indentation) + colorMultilineString(options, '"""')
+    ];
+  }
+  if (Array.isArray(data)) {
+    if (data.length === 0) {
+      return [indent(indentation) + options.emptyArrayMsg];
+    }
+    if (options.collapseArrays && data.length > 0) {
+      return [indent(indentation) + `[... ${data.length} items]`];
+    }
+    const outputArray = [];
+    data.forEach((element) => {
+      if (!isPrintable(element, options)) {
+        return;
+      }
+      let line = "- ";
+      line = getColorRenderer(options.dashColor, options)(line);
+      line = indent(indentation) + line;
+      if (isSerializable(element, false, options)) {
+        line += renderToArray(element, options, 0)[0];
+        outputArray.push(line);
+      } else {
+        outputArray.push(line);
+        outputArray.push.apply(outputArray, renderToArray(element, options, indentation + options.defaultIndentation));
+      }
+    });
+    return outputArray;
+  }
+  if (data instanceof Error) {
+    return renderToArray(
+      {
+        message: data.message,
+        stack: data.stack.split("\n")
+      },
+      options,
+      indentation
+    );
+  }
+  const maxIndexLength = options.noAlign ? 0 : getMaxIndexLength(data);
+  let key;
+  const output = [];
+  Object.getOwnPropertyNames(data).forEach((i) => {
+    if (!isPrintable(data[i], options)) {
+      return;
+    }
+    key = `${i}: `;
+    key = getColorRenderer(options.keysColor, options)(key);
+    key = indent(indentation) + key;
+    if (isSerializable(data[i], false, options)) {
+      const nextIndentation = options.noAlign ? 0 : maxIndexLength - i.length;
+      key += renderToArray(data[i], options, nextIndentation)[0];
+      output.push(key);
+    } else {
+      output.push(key);
+      output.push.apply(output, renderToArray(data[i], options, indentation + options.defaultIndentation));
+    }
+  });
+  return output;
+};
+var validateOptionsAndSetDefaults = (options) => {
+  options = options || {};
+  options.emptyArrayMsg = options.emptyArrayMsg || "(empty array)";
+  options.keysColor = options.keysColor || chalk.green;
+  options.dashColor = options.dashColor || chalk.green;
+  options.booleanColor = options.booleanColor || chalk.cyan;
+  options.nullUndefinedColor = options.nullUndefinedColor || chalk.grey;
+  options.numberColor = options.numberColor || chalk.blue;
+  options.positiveNumberColor = options.positiveNumberColor || options.numberColor;
+  options.negativeNumberColor = options.negativeNumberColor || options.numberColor;
+  options.dateColor = options.dateColor || chalk.magenta;
+  options.defaultIndentation = options.defaultIndentation || 2;
+  options.noColor = !!options.noColor;
+  options.noAlign = !!options.noAlign;
+  options.escape = !!options.escape;
+  options.renderUndefined = !!options.renderUndefined;
+  options.collapseArrays = !!options.collapseArrays;
+  options.stringColor = options.stringColor || null;
+  options.multilineStringColor = options.multilineStringColor || options.stringColor || null;
+  return options;
+};
+function render(data, options, indentation) {
+  indentation = indentation || 0;
+  options = validateOptionsAndSetDefaults(options);
+  return renderToArray(data, options, indentation).join("\n");
+}
+
+// src/LogRenderer.ts
+var LogRenderer = class {
+  /** Current terminal width in characters */
+  termWidth;
+  /** Maximum depth for displaying nested objects inline */
+  maxInlineDepth;
+  /** Maximum length for inline data before truncating */
+  maxInlineLength;
+  /** Whether arrays are currently collapsed in detail view */
+  isArraysCollapsed = false;
+  /** Color and formatting config for simple log view */
+  simpleViewConfig;
+  /** Color and formatting config for detailed view */
+  detailedViewConfig;
+  /** Current scroll position in detailed view */
+  detailViewScrollPos = 0;
+  /** Cached content lines for detailed view */
+  detailViewContent = [];
+  /**
+   * Creates a new LogRenderer instance.
+   *
+   * @param simpleViewConfig - Configuration for simple log view
+   * @param detailedViewConfig - Configuration for detailed view
+   * @param maxInlineDepth - Maximum depth for inline object display
+   * @param maxInlineLength - Maximum length before truncation
+   */
+  constructor(simpleViewConfig, detailedViewConfig, maxInlineDepth, maxInlineLength) {
+    this.simpleViewConfig = simpleViewConfig;
+    this.detailedViewConfig = detailedViewConfig;
+    this.maxInlineDepth = maxInlineDepth;
+    this.maxInlineLength = maxInlineLength;
+    this.termWidth = process.stdout.columns || 80;
+    process.stdout.on("resize", () => {
+      this.termWidth = process.stdout.columns || 80;
+    });
+  }
+  /**
+   * Gets the appropriate color for a log level.
+   * Handles both simple and detailed view color schemes.
+   *
+   * @param level - Log level (trace, debug, info, etc.)
+   * @param isDetailView - Whether to use detailed view colors
+   * @returns Chalk instance for the color
+   */
+  getLevelColor(level, isDetailView = false) {
+    const colors = isDetailView ? this.detailedViewConfig.colors : this.simpleViewConfig.colors;
+    return colors[level] || chalk2.white;
+  }
+  /**
+   * Formats a timestamp into a human-readable string.
+   * Format: HH:MM:SS.mmm
+   *
+   * @param timestamp - Unix timestamp in milliseconds
+   * @returns Formatted and colored timestamp string
+   */
+  formatTimestamp(timestamp) {
+    const date = new Date(timestamp);
+    return this.simpleViewConfig.logIdColor(
+      `${date.getHours().toString().padStart(2, "0")}:${date.getMinutes().toString().padStart(2, "0")}:${date.getSeconds().toString().padStart(2, "0")}.${date.getMilliseconds().toString().padStart(3, "0")}`
+    );
+  }
+  /**
+   * Formats structured data for inline display.
+   * Handles nested objects, arrays, and primitive values.
+   * Truncates output to maintain readability.
+   *
+   * @param data - Data to format
+   * @returns Formatted string with color coding
+   */
+  formatInlineData(data) {
+    if (!data) return "";
+    const formatValue = (value) => {
+      if (typeof value === "string") return value;
+      if (typeof value === "number" || typeof value === "boolean") return value.toString();
+      if (value === null) return "null";
+      if (value === void 0) return "undefined";
+      if (Array.isArray(value)) return "[...]";
+      if (typeof value === "object") return "{...}";
+      return value.toString();
+    };
+    const pairs = [];
+    const traverse = (obj, prefix = "", depth = 0) => {
+      if (depth >= this.maxInlineDepth) return;
+      for (const [key, value] of Object.entries(obj)) {
+        const fullKey = prefix ? `${prefix}.${key}` : key;
+        if (value && typeof value === "object" && !Array.isArray(value)) {
+          traverse(value, fullKey, depth + 1);
+        } else {
+          pairs.push(
+            `${this.simpleViewConfig.dataKeyColor(fullKey)}=${this.simpleViewConfig.dataValueColor(formatValue(value))}`
+          );
+        }
+      }
+    };
+    traverse(data);
+    const result = pairs.join(" ");
+    return truncate(result, this.maxInlineLength);
+  }
+  /**
+   * Renders a single log line in simple view format.
+   * Format: [timestamp] LEVEL [id] message data
+   *
+   * @param entry - Log entry to render
+   */
+  renderLogLine(entry) {
+    const levelColor = this.getLevelColor(entry.level);
+    const timestamp = this.formatTimestamp(entry.timestamp);
+    const chevron = levelColor(`\u25B6 ${entry.level.toUpperCase()} `);
+    const logId = this.simpleViewConfig.logIdColor(`[${entry.id}]`);
+    const message = entry.message;
+    const data = entry.data ? this.formatInlineData(JSON.parse(entry.data)) : "";
+    const line = `${timestamp} ${chevron}${logId} ${message}${data ? ` ${data}` : ""}`;
+    console.log(wrap(line, this.termWidth, { hard: true }));
+  }
+  /**
+   * Formats a compact single-line version of a log entry.
+   * Used for showing context in detailed view.
+   *
+   * @param entry - Log entry to render
+   * @param prefix - Optional prefix (e.g., "←" for previous entry)
+   * @returns Formatted log line
+   */
+  formatCompactLogLine(entry, prefix = "") {
+    if (!entry) return "";
+    const levelColor = this.getLevelColor(entry.level, true);
+    const logId = this.detailedViewConfig.logIdColor(`[${entry.id}]`);
+    const line = `${prefix}${levelColor(entry.level.toUpperCase())} ${logId} ${entry.message}`;
+    return this.detailedViewConfig.separatorColor(wrap(line, this.termWidth, { hard: true }));
+  }
+  /**
+   * Renders the detailed view of a log entry.
+   * Shows full entry details with context and formatted data.
+   *
+   * @param entry - Log entry to show in detail
+   * @param prevEntry - Previous entry for context
+   * @param nextEntry - Next entry for context
+   * @param scrollPos - Current scroll position
+   */
+  renderDetailView(entry, prevEntry, nextEntry, scrollPos = 0) {
+    console.clear();
+    if (this.isJsonView) {
+      if (entry.data) {
+        console.log(JSON.stringify(JSON.parse(entry.data)));
+      } else {
+        console.log("{}");
+      }
+      console.log(`
+${this.detailedViewConfig.separatorColor("TAB to return to detailed view")}`);
+      return;
+    }
+    const headerContent = [];
+    if (prevEntry) {
+      const prevLine = this.formatCompactLogLine(prevEntry, "\u2190 ");
+      headerContent.push(prevLine);
+      headerContent.push(this.detailedViewConfig.separatorColor("\u2500".repeat(this.termWidth)));
+    }
+    const footerContent = [];
+    if (nextEntry) {
+      footerContent.push(this.detailedViewConfig.separatorColor("\u2500".repeat(this.termWidth)));
+      const nextLine = this.formatCompactLogLine(nextEntry, "\u2192 ");
+      footerContent.push(nextLine);
+    }
+    footerContent.push("");
+    footerContent.push(
+      this.detailedViewConfig.separatorColor("TAB to exit \u2022 \u2191/\u2193 scroll \u2022 Q/W page up/down \u2022 J raw JSON")
+    );
+    footerContent.push(this.detailedViewConfig.separatorColor("\u2190/\u2192 navigate \u2022 A/S first/last log \u2022 C toggle arrays"));
+    const mainContent = [];
+    const levelColor = this.getLevelColor(entry.level, true);
+    const header = levelColor(`=== Log Detail [${entry.id}] ===`);
+    mainContent.push(header);
+    const timestamp = new Date(entry.timestamp);
+    const isoTime = timestamp.toISOString();
+    const relativeTime = this.formatRelativeTime(timestamp);
+    mainContent.push(
+      `${this.detailedViewConfig.labelColor("Timestamp:")} ${this.detailedViewConfig.dataValueColor(isoTime)} (${relativeTime})`
+    );
+    mainContent.push(`${this.detailedViewConfig.labelColor("Level:")} ${levelColor.bold(entry.level.toUpperCase())}`);
+    mainContent.push(
+      `${this.detailedViewConfig.labelColor("Message:")} ${this.detailedViewConfig.dataValueColor(entry.message)}`
+    );
+    if (entry.data) {
+      mainContent.push(this.detailedViewConfig.labelColor("\nData:"));
+      const jsonLines = render(JSON.parse(entry.data), {
+        ...this.detailedViewConfig.jsonColors,
+        defaultIndentation: 2,
+        collapseArrays: this.isArraysCollapsed
+      }).split("\n");
+      mainContent.push(...jsonLines);
+    }
+    this.detailViewContent = mainContent;
+    const headerHeight = headerContent.length;
+    const footerHeight = footerContent.length;
+    const scrollIndicatorLines = 2;
+    const bufferSpace = 2;
+    const availableHeight = Math.max(
+      0,
+      process.stdout.rows - headerHeight - footerHeight - scrollIndicatorLines - bufferSpace
+    );
+    this.detailViewScrollPos = Math.max(0, Math.min(scrollPos, mainContent.length - availableHeight));
+    for (const line of headerContent) {
+      console.log(line);
+    }
+    if (this.detailViewScrollPos > 0) {
+      console.log(chalk2.dim("\u2191 More content above"));
+    }
+    const startIndex = this.detailViewScrollPos;
+    const visibleContent = mainContent.slice(startIndex, startIndex + availableHeight);
+    for (const line of visibleContent) {
+      console.log(line);
+    }
+    if (this.detailViewScrollPos + availableHeight < mainContent.length) {
+      console.log(chalk2.dim("\u2193 More content below"));
+    }
+    for (const line of footerContent) {
+      console.log(line);
+    }
+  }
+  /**
+   * Updates the scroll position in detailed view
+   * @param delta - Number of lines to scroll (positive for down, negative for up)
+   */
+  scrollDetailView(delta) {
+    const headerHeight = 2;
+    const footerHeight = 5;
+    const scrollIndicatorLines = 2;
+    const bufferSpace = 2;
+    const availableHeight = Math.max(
+      0,
+      process.stdout.rows - headerHeight - footerHeight - scrollIndicatorLines - bufferSpace
+    );
+    const maxScroll = Math.max(0, this.detailViewContent.length - availableHeight);
+    this.detailViewScrollPos = Math.max(0, Math.min(maxScroll, this.detailViewScrollPos + delta));
+  }
+  /**
+   * Gets the current scroll position
+   */
+  getDetailViewScrollPos() {
+    return this.detailViewScrollPos;
+  }
+  /**
+   * Renders the interactive selection view.
+   * Shows a scrollable list of logs with current selection.
+   *
+   * Features:
+   * - Pagination for large log sets
+   * - Active filter display
+   * - Scroll indicators
+   * - Selected item highlighting
+   *
+   * @param logs - Array of log entries to display
+   * @param selectedIndex - Index of currently selected log
+   * @param filterText - Current filter text (if any)
+   * @param newLogCount - Number of new logs since last render (optional)
+   */
+  renderSelectionView(logs, selectedIndex, filterText, newLogCount = 0) {
+    console.clear();
+    const headerHeight = filterText ? 2 : 0;
+    const footerHeight = 2;
+    const availableHeight = process.stdout.rows - headerHeight - footerHeight;
+    if (filterText) {
+      console.log(chalk2.cyan("Filter:"), chalk2.white(filterText));
+      console.log(chalk2.dim("\u2500".repeat(this.termWidth)));
+    }
+    if (logs.length === 0) {
+      console.log(chalk2.yellow("No matching logs found"));
+    } else {
+      const visibleLines = Math.min(availableHeight, 20);
+      const bottomPadding = 2;
+      let startIdx = Math.max(0, selectedIndex - (visibleLines - bottomPadding - 1));
+      const endIdx = Math.min(logs.length, startIdx + visibleLines);
+      if (endIdx - startIdx < visibleLines && endIdx < logs.length) {
+        startIdx = Math.max(0, endIdx - visibleLines);
+      }
+      if (startIdx > 0) {
+        console.log(chalk2.dim("  \u2191 More logs above"));
+      }
+      logs.slice(startIdx, endIdx).forEach((entry, index) => {
+        const actualIndex = startIdx + index;
+        const isSelected = actualIndex === selectedIndex;
+        const prefix = isSelected ? this.simpleViewConfig.selectorColor("\u25BA ") : "  ";
+        const timestamp = this.formatTimestamp(entry.timestamp);
+        const levelColor = this.getLevelColor(entry.level);
+        const chevron = levelColor(`${entry.level.toUpperCase()} `);
+        const logId = chalk2.dim(`[${entry.id}]`);
+        const message = entry.message;
+        const data = entry.data ? this.formatInlineData(JSON.parse(entry.data)) : "";
+        const mainLine = `${prefix}${timestamp} ${chevron}${logId} ${message}`;
+        console.log(wrap(mainLine, this.termWidth - 2, { hard: true }));
+        if (data) {
+          const wrappedData = wrap(data, this.termWidth - (isSelected ? 6 : 2), { hard: true });
+          const indentedLines = wrappedData.split("\n").map((line) => isSelected ? `    ${line}` : line);
+          console.log(indentedLines.join("\n"));
+        }
+      });
+      if (endIdx < logs.length || newLogCount > 0) {
+        const moreLogsText = newLogCount > 0 ? this.simpleViewConfig.selectorColor(
+          `  \u2193 ${newLogCount} new log${newLogCount === 1 ? "" : "s"} available (press \u2193 to view)`
+        ) : chalk2.dim("  \u2193 More logs below");
+        console.log(moreLogsText);
+      }
+    }
+    console.log(chalk2.dim("\nType to filter \u2022 Enter to view details \u2022 TAB to exit"));
+  }
+  /**
+   * Formats a timestamp into a human-readable relative time
+   * @param timestamp - Date to format
+   * @returns Formatted relative time string
+   */
+  formatRelativeTime(timestamp) {
+    const now = /* @__PURE__ */ new Date();
+    const diffMs = now.getTime() - timestamp.getTime();
+    const diffSecs = Math.floor(diffMs / 1e3);
+    const diffMins = Math.floor(diffSecs / 60);
+    const diffHours = Math.floor(diffMins / 60);
+    const diffDays = Math.floor(diffHours / 24);
+    if (diffSecs < 60) return `${diffSecs}s ago`;
+    if (diffMins < 60) return `${diffMins}m ago`;
+    if (diffHours < 24) return `${diffHours}h ago`;
+    if (diffDays === 1) return "yesterday";
+    if (diffDays < 30) return `${diffDays}d ago`;
+    return timestamp.toLocaleDateString();
+  }
+  /** Whether we're showing raw JSON view */
+  isJsonView = false;
+  /**
+   * Toggles JSON view state
+   */
+  toggleJsonView() {
+    this.isJsonView = !this.isJsonView;
+  }
+  /**
+   * Gets current JSON view state
+   */
+  isInJsonView() {
+    return this.isJsonView;
+  }
+  /**
+   * Toggles array collapse state in detail view
+   */
+  toggleArrayCollapse() {
+    this.isArraysCollapsed = !this.isArraysCollapsed;
+  }
+};
+
+// src/LogStorage.ts
+import { resolve } from "node:path";
+import Database from "better-sqlite3";
+var LogStorage = class {
+  /** SQLite database instance */
+  db;
+  /**
+   * Creates a new LogStorage instance.
+   * Initializes a SQLite database and creates the logs table.
+   *
+   * @param logFile - Optional path to SQLite file for persistent storage.
+   *                 If not provided, uses in-memory database.
+   *                 Relative paths are resolved from the current working directory.
+   */
+  constructor(logFile) {
+    const dbPath = logFile ? logFile.startsWith("/") ? logFile : resolve(process.cwd(), logFile) : ":memory:";
+    this.db = new Database(dbPath);
+    this.initializeDatabase();
+  }
+  /**
+   * Initializes the database schema.
+   * Creates the logs table with appropriate columns and indexes.
+   * If the table already exists, it will be dropped to ensure a clean state.
+   * @private
+   */
+  initializeDatabase() {
+    this.db.exec(`
+      DROP TABLE IF EXISTS logs;
+      CREATE TABLE logs (
+        id TEXT PRIMARY KEY,
+        timestamp INTEGER,
+        level TEXT,
+        message TEXT,
+        data TEXT
+      )
+    `);
+  }
+  /**
+   * Stores a new log entry in the database.
+   * Uses prepared statements for efficient and safe insertion.
+   *
+   * @param entry - The log entry to store
+   * @example
+   * storage.store({
+   *   id: "abc123",
+   *   timestamp: Date.now(),
+   *   level: "info",
+   *   message: "User logged in",
+   *   data: JSON.stringify({ userId: 123 })
+   * });
+   */
+  store(entry) {
+    this.db.prepare(`
+        INSERT INTO logs (id, timestamp, level, message, data)
+        VALUES (?, ?, ?, ?, ?)
+      `).run(entry.id, entry.timestamp, entry.level, entry.message, entry.data);
+  }
+  /**
+   * Retrieves all logs from the database in chronological order.
+   * Used when displaying the full log history or clearing filters.
+   *
+   * @returns Array of log entries sorted by timestamp
+   */
+  getAllLogs() {
+    return this.db.prepare("SELECT * FROM logs ORDER BY timestamp ASC").all();
+  }
+  /**
+   * Searches logs based on a text query.
+   * Performs a case-insensitive search across multiple fields:
+   * - Log ID
+   * - Message content
+   * - Structured data
+   *
+   * @param searchText - Text to search for
+   * @returns Array of matching log entries sorted by timestamp
+   * @example
+   * const errorLogs = storage.searchLogs("error");
+   * const userLogs = storage.searchLogs("userId:123");
+   */
+  searchLogs(searchText) {
+    const query = `
+      SELECT * FROM logs 
+      WHERE id LIKE ? 
+      OR message LIKE ? 
+      OR data LIKE ? 
+      ORDER BY timestamp ASC
+    `;
+    const pattern = `%${searchText}%`;
+    return this.db.prepare(query).all(pattern, pattern, pattern);
+  }
+  /**
+   * Closes the database connection and performs cleanup.
+   * Should be called when the application exits or the transport is destroyed.
+   */
+  close() {
+    this.db.close();
+  }
+};
+
+// src/UIManager.ts
+import chalk3 from "chalk";
+import keypress from "keypress";
+var UIManager = class {
+  /**
+   * Creates a new UIManager instance.
+   * Sets up keyboard handling and cleanup handlers.
+   *
+   * @param renderer - Instance for handling log display
+   * @param storage - Instance for log persistence
+   */
+  constructor(renderer, storage) {
+    this.renderer = renderer;
+    this.storage = storage;
+    this.setupKeyboardHandling();
+    process.stdout.on("resize", () => {
+      this.termWidth = process.stdout.columns || 80;
+      if (this.isDetailView) {
+        const entry = this.logs[this.selectedIndex];
+        const prevEntry = this.selectedIndex > 0 ? this.logs[this.selectedIndex - 1] : null;
+        const nextEntry = this.selectedIndex < this.logs.length - 1 ? this.logs[this.selectedIndex + 1] : null;
+        this.renderer.renderDetailView(entry, prevEntry, nextEntry, this.renderer.getDetailViewScrollPos());
+      } else if (this.isSelectionMode) {
+        this.renderer.renderSelectionView(this.logs, this.selectedIndex, this.filterText, this.selectionBuffer.length);
+      }
+    });
+  }
+  /** Whether the UI is in log selection mode */
+  isSelectionMode = false;
+  /** Whether the UI is showing detailed log view */
+  isDetailView = false;
+  /** Whether log streaming is paused */
+  isPaused = false;
+  /** Buffer for logs received while paused */
+  pauseBuffer = [];
+  /** Buffer for new logs in selection mode */
+  selectionBuffer = [];
+  /** Index of currently selected log entry */
+  selectedIndex = 0;
+  /** Current filter text for log searching */
+  filterText = "";
+  /** Cached array of filtered log entries */
+  logs = [];
+  /** Polling interval for checking new logs in detail view */
+  detailViewPollInterval = null;
+  /** Polling interval for checking new logs in selection view */
+  selectionViewPollInterval = null;
+  /** Current terminal width in characters */
+  termWidth = process.stdout.columns || 80;
+  /**
+   * Sets up keyboard input handling and cleanup.
+   * Configures raw mode for immediate key processing.
+   * Sets up process exit handlers for cleanup.
+   * @private
+   */
+  setupKeyboardHandling() {
+    keypress(process.stdin);
+    process.stdin.setRawMode(true);
+    process.stdin.on("keypress", this.handleKeypress.bind(this));
+    const cleanup = () => {
+      if (this.detailViewPollInterval) {
+        clearInterval(this.detailViewPollInterval);
+      }
+      if (this.selectionViewPollInterval) {
+        clearInterval(this.selectionViewPollInterval);
+      }
+      process.stdin.setRawMode(false);
+      process.stdin.removeAllListeners("keypress");
+      console.clear();
+      this.storage.close();
+      process.exit(0);
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+  }
+  /**
+   * Starts polling for new logs in selection view
+   * @private
+   */
+  startSelectionViewPolling() {
+    if (this.selectionViewPollInterval) {
+      clearInterval(this.selectionViewPollInterval);
+    }
+    this.selectionViewPollInterval = setInterval(() => {
+      if (!this.isSelectionMode) {
+        clearInterval(this.selectionViewPollInterval);
+        this.selectionViewPollInterval = null;
+        return;
+      }
+      if (this.selectionBuffer.length > 0) {
+        this.renderer.renderSelectionView(this.logs, this.selectedIndex, this.filterText, this.selectionBuffer.length);
+      }
+    }, 2e3);
+  }
+  /**
+   * Starts polling for new logs in detail view
+   * @private
+   */
+  startDetailViewPolling() {
+    if (this.detailViewPollInterval) {
+      clearInterval(this.detailViewPollInterval);
+    }
+    this.detailViewPollInterval = setInterval(() => {
+      if (!this.isDetailView) {
+        clearInterval(this.detailViewPollInterval);
+        this.detailViewPollInterval = null;
+        return;
+      }
+      const currentLogs = this.storage.getAllLogs();
+      if (currentLogs.length > this.logs.length && this.selectedIndex === this.logs.length - 1) {
+        this.logs = currentLogs;
+        const entry = this.logs[this.selectedIndex];
+        const prevEntry = this.selectedIndex > 0 ? this.logs[this.selectedIndex - 1] : null;
+        const nextEntry = this.selectedIndex < this.logs.length - 1 ? this.logs[this.selectedIndex + 1] : null;
+        this.renderer.renderDetailView(entry, prevEntry, nextEntry, this.renderer.getDetailViewScrollPos());
+      }
+    }, 2e3);
+  }
+  /**
+   * Updates the filtered list of logs based on search text.
+   * Handles both full list and filtered views.
+   * Maintains selection state when filter changes.
+   * @private
+   */
+  updateFilteredLogs() {
+    const storedLogs = this.filterText ? this.storage.searchLogs(this.filterText) : this.storage.getAllLogs();
+    this.logs = storedLogs.slice(0, storedLogs.length - this.selectionBuffer.length);
+    if (this.logs.length > 0) {
+      this.selectedIndex = Math.min(this.selectedIndex, Math.max(0, this.logs.length - 1));
+    } else {
+      this.selectedIndex = 0;
+    }
+  }
+  updateNewLogsNotification() {
+    if (!this.isSelectionMode || !this.selectionBuffer.length) return;
+    process.stdout.write(`\x1B[2A\r${" ".repeat(this.termWidth)}\r`);
+    const notification = chalk3.dim(
+      `${this.selectionBuffer.length} new log${this.selectionBuffer.length === 1 ? "" : "s"} available (press \u2193 to view)`
+    );
+    process.stdout.write(`${notification}
+
+`);
+  }
+  /**
+   * Handles new log entries from the transport.
+   * Stores the log and updates the display if needed.
+   *
+   * @param entry - New log entry to process
+   */
+  handleNewLog(entry) {
+    this.storage.store(entry);
+    if (this.isSelectionMode) {
+      this.selectionBuffer.push(entry);
+      this.renderer.renderSelectionView(this.logs, this.selectedIndex, this.filterText, this.selectionBuffer.length);
+      return;
+    }
+    if (!this.isDetailView) {
+      if (this.isPaused) {
+        this.pauseBuffer.push(entry);
+        process.stdout.write(`\r${chalk3.yellow(`\u23F8  Paused (${this.pauseBuffer.length} new logs)`)}${" ".repeat(20)}`);
+      } else {
+        this.renderer.renderLogLine(entry);
+      }
+    }
+  }
+  /**
+   * Processes keyboard input and manages UI state.
+   * Handles navigation, mode switching, and filtering.
+   *
+   * Key mappings:
+   * - CTRL+C: Exit application
+   * - TAB: Toggle selection mode
+   * - Up/Down: Navigate logs
+   * - Enter: View log details
+   * - Backspace: Edit filter
+   * - P: Toggle pause in simple view
+   * - Other keys: Add to filter
+   *
+   * @param ch - Character input if available
+   * @param key - Key event information
+   * @private
+   */
+  handleKeypress(ch, key) {
+    if (key?.ctrl && key?.name === "c") {
+      process.stdin.setRawMode(false);
+      process.stdin.removeAllListeners("keypress");
+      console.clear();
+      this.storage.close();
+      process.exit(0);
+      return;
+    }
+    if (!this.isSelectionMode && !this.isDetailView && ch === "p") {
+      this.isPaused = !this.isPaused;
+      if (!this.isPaused && this.pauseBuffer.length > 0) {
+        process.stdout.write(`\r${" ".repeat(50)}\r`);
+        for (const entry of this.pauseBuffer) {
+          this.renderer.renderLogLine(entry);
+        }
+        this.pauseBuffer = [];
+      } else if (this.isPaused) {
+        process.stdout.write(`\r${chalk3.yellow("\u23F8  Paused (0 new logs)")}${" ".repeat(20)}`);
+      }
+      return;
+    }
+    if (!this.isSelectionMode && !this.isDetailView && key?.name === "tab") {
+      if (this.isPaused) {
+        this.isPaused = false;
+        this.pauseBuffer = [];
+        process.stdout.write(`\r${" ".repeat(50)}\r`);
+      }
+      this.isSelectionMode = true;
+      this.filterText = "";
+      this.updateFilteredLogs();
+      this.selectedIndex = Math.max(0, this.logs.length - 1);
+      this.renderer.renderSelectionView(this.logs, this.selectedIndex, this.filterText, this.selectionBuffer.length);
+      this.startSelectionViewPolling();
+      return;
+    }
+    if (this.isSelectionMode) {
+      if (key) {
+        switch (key.name) {
+          case "up": {
+            this.selectedIndex = Math.max(0, this.selectedIndex - 1);
+            this.renderer.renderSelectionView(
+              this.logs,
+              this.selectedIndex,
+              this.filterText,
+              this.selectionBuffer.length
+            );
+            return;
+          }
+          case "down": {
+            if (this.selectedIndex === this.logs.length - 1 && this.selectionBuffer.length > 0) {
+              this.logs.push(...this.selectionBuffer);
+              this.selectionBuffer = [];
+            }
+            this.selectedIndex = Math.min(this.logs.length - 1, this.selectedIndex + 1);
+            this.renderer.renderSelectionView(
+              this.logs,
+              this.selectedIndex,
+              this.filterText,
+              this.selectionBuffer.length
+            );
+            return;
+          }
+          case "return": {
+            if (this.logs.length > 0) {
+              this.isSelectionMode = false;
+              this.isDetailView = true;
+              console.clear();
+              const selectedEntry = this.logs[this.selectedIndex];
+              const prevEntry = this.selectedIndex > 0 ? this.logs[this.selectedIndex - 1] : null;
+              const nextEntry = this.selectedIndex < this.logs.length - 1 ? this.logs[this.selectedIndex + 1] : null;
+              this.renderer.renderDetailView(selectedEntry, prevEntry, nextEntry);
+              this.startDetailViewPolling();
+            }
+            return;
+          }
+          case "backspace": {
+            if (this.filterText.length > 0) {
+              this.filterText = this.filterText.slice(0, -1);
+              this.updateFilteredLogs();
+              this.renderer.renderSelectionView(
+                this.logs,
+                this.selectedIndex,
+                this.filterText,
+                this.selectionBuffer.length
+              );
+            }
+            return;
+          }
+          case "tab": {
+            this.isSelectionMode = false;
+            if (this.selectionViewPollInterval) {
+              clearInterval(this.selectionViewPollInterval);
+              this.selectionViewPollInterval = null;
+            }
+            this.filterText = "";
+            console.clear();
+            const logs = [...this.storage.getAllLogs()].reverse();
+            for (const entry of logs) {
+              this.renderer.renderLogLine(entry);
+            }
+            return;
+          }
+        }
+      }
+      if (ch && (!key || !key.ctrl && !key.meta) && ch.length === 1) {
+        this.filterText += ch;
+        this.updateFilteredLogs();
+        this.renderer.renderSelectionView(this.logs, this.selectedIndex, this.filterText, this.selectionBuffer.length);
+        return;
+      }
+    }
+    if (this.isDetailView) {
+      if (key?.name) {
+        switch (key.name) {
+          case "up": {
+            this.renderer.scrollDetailView(-1);
+            const entry = this.logs[this.selectedIndex];
+            const prevEntry = this.selectedIndex > 0 ? this.logs[this.selectedIndex - 1] : null;
+            const nextEntry = this.selectedIndex < this.logs.length - 1 ? this.logs[this.selectedIndex + 1] : null;
+            this.renderer.renderDetailView(entry, prevEntry, nextEntry, this.renderer.getDetailViewScrollPos());
+            break;
+          }
+          case "down": {
+            this.renderer.scrollDetailView(1);
+            const entry = this.logs[this.selectedIndex];
+            const prevEntry = this.selectedIndex > 0 ? this.logs[this.selectedIndex - 1] : null;
+            const nextEntry = this.selectedIndex < this.logs.length - 1 ? this.logs[this.selectedIndex + 1] : null;
+            this.renderer.renderDetailView(entry, prevEntry, nextEntry, this.renderer.getDetailViewScrollPos());
+            break;
+          }
+          case "left": {
+            if (this.selectedIndex > 0) {
+              this.selectedIndex = Math.max(0, this.selectedIndex - 1);
+              const entry = this.logs[this.selectedIndex];
+              const prevEntry = this.selectedIndex > 0 ? this.logs[this.selectedIndex - 1] : null;
+              const nextEntry = this.selectedIndex < this.logs.length - 1 ? this.logs[this.selectedIndex + 1] : null;
+              this.renderer.renderDetailView(entry, prevEntry, nextEntry);
+            }
+            break;
+          }
+          case "right": {
+            if (this.selectedIndex < this.logs.length - 1) {
+              this.selectedIndex = Math.min(this.logs.length - 1, this.selectedIndex + 1);
+              const entry = this.logs[this.selectedIndex];
+              const prevEntry = this.selectedIndex > 0 ? this.logs[this.selectedIndex - 1] : null;
+              const nextEntry = this.selectedIndex < this.logs.length - 1 ? this.logs[this.selectedIndex + 1] : null;
+              this.renderer.renderDetailView(entry, prevEntry, nextEntry);
+            }
+            break;
+          }
+          case "tab": {
+            if (this.renderer.isInJsonView()) {
+              this.renderer.toggleJsonView();
+              const entry = this.logs[this.selectedIndex];
+              const prevEntry = this.selectedIndex > 0 ? this.logs[this.selectedIndex - 1] : null;
+              const nextEntry = this.selectedIndex < this.logs.length - 1 ? this.logs[this.selectedIndex + 1] : null;
+              this.renderer.renderDetailView(entry, prevEntry, nextEntry, this.renderer.getDetailViewScrollPos());
+              break;
+            }
+            this.isDetailView = false;
+            if (this.detailViewPollInterval) {
+              clearInterval(this.detailViewPollInterval);
+              this.detailViewPollInterval = null;
+            }
+            this.isSelectionMode = true;
+            this.updateFilteredLogs();
+            this.renderer.renderSelectionView(
+              this.logs,
+              this.selectedIndex,
+              this.filterText,
+              this.selectionBuffer.length
+            );
+            break;
+          }
+        }
+      }
+      if (ch) {
+        switch (ch.toLowerCase()) {
+          case "w": {
+            this.renderer.scrollDetailView(process.stdout.rows - 8);
+            const entry = this.logs[this.selectedIndex];
+            const prevEntry = this.selectedIndex > 0 ? this.logs[this.selectedIndex - 1] : null;
+            const nextEntry = this.selectedIndex < this.logs.length - 1 ? this.logs[this.selectedIndex + 1] : null;
+            this.renderer.renderDetailView(entry, prevEntry, nextEntry, this.renderer.getDetailViewScrollPos());
+            break;
+          }
+          case "q": {
+            this.renderer.scrollDetailView(-process.stdout.rows + 8);
+            const entry = this.logs[this.selectedIndex];
+            const prevEntry = this.selectedIndex > 0 ? this.logs[this.selectedIndex - 1] : null;
+            const nextEntry = this.selectedIndex < this.logs.length - 1 ? this.logs[this.selectedIndex + 1] : null;
+            this.renderer.renderDetailView(entry, prevEntry, nextEntry, this.renderer.getDetailViewScrollPos());
+            break;
+          }
+          case "a": {
+            if (this.selectedIndex !== 0) {
+              this.selectedIndex = 0;
+              const entry = this.logs[this.selectedIndex];
+              const prevEntry = null;
+              const nextEntry = this.logs.length > 1 ? this.logs[1] : null;
+              this.renderer.renderDetailView(entry, prevEntry, nextEntry);
+            }
+            break;
+          }
+          case "s": {
+            const lastIndex = this.logs.length - 1;
+            if (this.selectedIndex !== lastIndex) {
+              this.selectedIndex = lastIndex;
+              const entry = this.logs[this.selectedIndex];
+              const prevEntry = lastIndex > 0 ? this.logs[lastIndex - 1] : null;
+              const nextEntry = null;
+              this.renderer.renderDetailView(entry, prevEntry, nextEntry);
+            }
+            break;
+          }
+          case "c": {
+            this.renderer.toggleArrayCollapse();
+            const entry = this.logs[this.selectedIndex];
+            const prevEntry = this.selectedIndex > 0 ? this.logs[this.selectedIndex - 1] : null;
+            const nextEntry = this.selectedIndex < this.logs.length - 1 ? this.logs[this.selectedIndex + 1] : null;
+            this.renderer.renderDetailView(entry, prevEntry, nextEntry, this.renderer.getDetailViewScrollPos());
+            break;
+          }
+          case "j": {
+            this.renderer.toggleJsonView();
+            const entry = this.logs[this.selectedIndex];
+            const prevEntry = this.selectedIndex > 0 ? this.logs[this.selectedIndex - 1] : null;
+            const nextEntry = this.selectedIndex < this.logs.length - 1 ? this.logs[this.selectedIndex + 1] : null;
+            this.renderer.renderDetailView(entry, prevEntry, nextEntry);
+            break;
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/themes.ts
+import chalk4 from "chalk";
+var moonlight = {
+  simpleView: {
+    colors: {
+      trace: chalk4.rgb(114, 135, 153),
+      // Muted blue-grey for less important info
+      debug: chalk4.rgb(130, 170, 255),
+      // Soft blue that pops but doesn't strain
+      info: chalk4.rgb(195, 232, 141),
+      // Sage green for good readability
+      warn: chalk4.rgb(255, 203, 107),
+      // Warm yellow, less harsh than pure yellow
+      error: chalk4.rgb(247, 118, 142),
+      // Soft red that stands out without being aggressive
+      fatal: chalk4.bgRgb(247, 118, 142).white
+      // Inverted soft red for maximum visibility
+    },
+    logIdColor: chalk4.rgb(84, 98, 117),
+    // Darker blue-grey for secondary information
+    dataValueColor: chalk4.rgb(209, 219, 231),
+    // Light grey-blue for primary content
+    dataKeyColor: chalk4.rgb(130, 170, 255),
+    // Matching debug blue for consistency
+    selectorColor: chalk4.rgb(137, 221, 255)
+    // Ice blue for selection indicators
+  },
+  detailedView: {
+    colors: {
+      trace: chalk4.rgb(114, 135, 153),
+      debug: chalk4.rgb(130, 170, 255),
+      info: chalk4.rgb(195, 232, 141),
+      warn: chalk4.rgb(255, 203, 107),
+      error: chalk4.rgb(247, 118, 142),
+      fatal: chalk4.bgRgb(247, 118, 142).white
+    },
+    logIdColor: chalk4.rgb(84, 98, 117),
+    dataValueColor: chalk4.rgb(209, 219, 231),
+    dataKeyColor: chalk4.rgb(130, 170, 255),
+    selectorColor: chalk4.rgb(137, 221, 255),
+    // Ice blue for selection indicators
+    headerColor: chalk4.rgb(137, 221, 255),
+    labelColor: chalk4.rgb(137, 221, 255).bold,
+    separatorColor: chalk4.rgb(84, 98, 117),
+    jsonColors: {
+      keysColor: chalk4.rgb(130, 170, 255),
+      dashColor: chalk4.rgb(209, 219, 231),
+      numberColor: chalk4.rgb(247, 140, 108),
+      stringColor: chalk4.rgb(195, 232, 141),
+      multilineStringColor: chalk4.rgb(195, 232, 141),
+      positiveNumberColor: chalk4.rgb(195, 232, 141),
+      negativeNumberColor: chalk4.rgb(247, 118, 142),
+      booleanColor: chalk4.rgb(255, 203, 107),
+      nullUndefinedColor: chalk4.rgb(114, 135, 153),
+      dateColor: chalk4.rgb(199, 146, 234)
+    }
+  }
+};
+var sunlight = {
+  simpleView: {
+    colors: {
+      trace: chalk4.rgb(110, 110, 110),
+      // Dark grey for subtle information
+      debug: chalk4.rgb(32, 96, 159),
+      // Deep blue for strong contrast on white
+      info: chalk4.rgb(35, 134, 54),
+      // Forest green, easier on the eyes than bright green
+      warn: chalk4.rgb(176, 95, 0),
+      // Brown-orange for natural warning color
+      error: chalk4.rgb(191, 0, 0),
+      // Deep red for clear visibility on light backgrounds
+      fatal: chalk4.bgRgb(191, 0, 0).white
+      // White on deep red for critical issues
+    },
+    logIdColor: chalk4.rgb(110, 110, 110),
+    dataValueColor: chalk4.rgb(0, 0, 0),
+    dataKeyColor: chalk4.rgb(32, 96, 159),
+    selectorColor: chalk4.rgb(0, 91, 129)
+    // Deep blue for strong contrast
+  },
+  detailedView: {
+    colors: {
+      trace: chalk4.rgb(110, 110, 110),
+      debug: chalk4.rgb(32, 96, 159),
+      info: chalk4.rgb(35, 134, 54),
+      warn: chalk4.rgb(176, 95, 0),
+      error: chalk4.rgb(191, 0, 0),
+      fatal: chalk4.bgRgb(191, 0, 0).white
+    },
+    logIdColor: chalk4.rgb(110, 110, 110),
+    dataValueColor: chalk4.rgb(0, 0, 0),
+    dataKeyColor: chalk4.rgb(32, 96, 159),
+    selectorColor: chalk4.rgb(0, 91, 129),
+    // Deep blue for strong contrast
+    headerColor: chalk4.rgb(0, 91, 129),
+    labelColor: chalk4.rgb(0, 91, 129).bold,
+    separatorColor: chalk4.rgb(110, 110, 110),
+    jsonColors: {
+      keysColor: chalk4.rgb(32, 96, 159),
+      dashColor: chalk4.rgb(0, 0, 0),
+      numberColor: chalk4.rgb(170, 55, 49),
+      stringColor: chalk4.rgb(35, 134, 54),
+      multilineStringColor: chalk4.rgb(35, 134, 54),
+      positiveNumberColor: chalk4.rgb(46, 125, 50),
+      negativeNumberColor: chalk4.rgb(183, 28, 28),
+      booleanColor: chalk4.rgb(176, 95, 0),
+      nullUndefinedColor: chalk4.rgb(110, 110, 110),
+      dateColor: chalk4.rgb(123, 31, 162)
+    }
+  }
+};
+var neon = {
+  simpleView: {
+    colors: {
+      trace: chalk4.rgb(108, 108, 255),
+      // Electric blue
+      debug: chalk4.rgb(255, 82, 246),
+      // Hot pink
+      info: chalk4.rgb(0, 255, 163),
+      // Cyber green
+      warn: chalk4.rgb(255, 231, 46),
+      // Electric yellow
+      error: chalk4.rgb(255, 53, 91),
+      // Neon red
+      fatal: chalk4.bgRgb(255, 53, 91).rgb(0, 255, 163)
+      // Neon red bg with cyber green text
+    },
+    logIdColor: chalk4.rgb(187, 134, 252),
+    // Bright purple
+    dataValueColor: chalk4.rgb(255, 255, 255),
+    // Pure white
+    dataKeyColor: chalk4.rgb(0, 255, 240),
+    // Cyan
+    selectorColor: chalk4.rgb(0, 255, 240)
+    // Electric cyan for cyberpunk feel
+  },
+  detailedView: {
+    colors: {
+      trace: chalk4.rgb(108, 108, 255),
+      debug: chalk4.rgb(255, 82, 246),
+      info: chalk4.rgb(0, 255, 163),
+      warn: chalk4.rgb(255, 231, 46),
+      error: chalk4.rgb(255, 53, 91),
+      fatal: chalk4.bgRgb(255, 53, 91).rgb(0, 255, 163)
+    },
+    logIdColor: chalk4.rgb(187, 134, 252),
+    dataValueColor: chalk4.rgb(255, 255, 255),
+    dataKeyColor: chalk4.rgb(0, 255, 240),
+    selectorColor: chalk4.rgb(0, 255, 240),
+    // Electric cyan for cyberpunk feel
+    headerColor: chalk4.rgb(255, 82, 246),
+    labelColor: chalk4.rgb(255, 82, 246).bold,
+    separatorColor: chalk4.rgb(108, 108, 255),
+    jsonColors: {
+      keysColor: chalk4.rgb(0, 255, 240),
+      dashColor: chalk4.rgb(255, 255, 255),
+      numberColor: chalk4.rgb(255, 82, 246),
+      stringColor: chalk4.rgb(0, 255, 163),
+      multilineStringColor: chalk4.rgb(0, 255, 163),
+      positiveNumberColor: chalk4.rgb(0, 255, 163),
+      negativeNumberColor: chalk4.rgb(255, 53, 91),
+      booleanColor: chalk4.rgb(255, 231, 46),
+      nullUndefinedColor: chalk4.rgb(108, 108, 255),
+      dateColor: chalk4.rgb(187, 134, 252)
+    }
+  }
+};
+var nature = {
+  simpleView: {
+    colors: {
+      trace: chalk4.rgb(121, 85, 72),
+      // Wooden brown
+      debug: chalk4.rgb(46, 125, 50),
+      // Forest green
+      info: chalk4.rgb(0, 105, 92),
+      // Deep teal
+      warn: chalk4.rgb(175, 115, 0),
+      // Golden amber
+      error: chalk4.rgb(183, 28, 28),
+      // Autumn red
+      fatal: chalk4.bgRgb(183, 28, 28).rgb(255, 250, 240)
+      // Red bg with soft white
+    },
+    logIdColor: chalk4.rgb(93, 64, 55),
+    // Deep bark brown
+    dataValueColor: chalk4.rgb(27, 27, 27),
+    // Near black
+    dataKeyColor: chalk4.rgb(56, 142, 60),
+    // Leaf green
+    selectorColor: chalk4.rgb(0, 105, 92)
+    // Deep teal for natural feel
+  },
+  detailedView: {
+    colors: {
+      trace: chalk4.rgb(121, 85, 72),
+      debug: chalk4.rgb(46, 125, 50),
+      info: chalk4.rgb(0, 105, 92),
+      warn: chalk4.rgb(175, 115, 0),
+      error: chalk4.rgb(183, 28, 28),
+      fatal: chalk4.bgRgb(183, 28, 28).rgb(255, 250, 240)
+    },
+    logIdColor: chalk4.rgb(93, 64, 55),
+    dataValueColor: chalk4.rgb(27, 27, 27),
+    dataKeyColor: chalk4.rgb(56, 142, 60),
+    selectorColor: chalk4.rgb(0, 105, 92),
+    // Deep teal for natural feel
+    headerColor: chalk4.rgb(0, 77, 64),
+    labelColor: chalk4.rgb(0, 77, 64).bold,
+    separatorColor: chalk4.rgb(121, 85, 72),
+    jsonColors: {
+      keysColor: chalk4.rgb(56, 142, 60),
+      dashColor: chalk4.rgb(27, 27, 27),
+      numberColor: chalk4.rgb(230, 81, 0),
+      stringColor: chalk4.rgb(0, 105, 92),
+      multilineStringColor: chalk4.rgb(0, 105, 92),
+      positiveNumberColor: chalk4.rgb(46, 125, 50),
+      negativeNumberColor: chalk4.rgb(183, 28, 28),
+      booleanColor: chalk4.rgb(175, 115, 0),
+      nullUndefinedColor: chalk4.rgb(121, 85, 72),
+      dateColor: chalk4.rgb(123, 31, 162)
+    }
+  }
+};
+var pastel = {
+  simpleView: {
+    colors: {
+      trace: chalk4.rgb(179, 189, 203),
+      // Soft slate blue
+      debug: chalk4.rgb(189, 178, 255),
+      // Gentle lavender
+      info: chalk4.rgb(170, 236, 205),
+      // Mint green
+      warn: chalk4.rgb(255, 223, 186),
+      // Peach
+      error: chalk4.rgb(255, 188, 188),
+      // Soft coral
+      fatal: chalk4.bgRgb(255, 188, 188).rgb(76, 40, 40)
+      // Coral bg with deep brown
+    },
+    logIdColor: chalk4.rgb(203, 195, 227),
+    // Dusty lavender
+    dataValueColor: chalk4.rgb(236, 236, 236),
+    // Soft white
+    dataKeyColor: chalk4.rgb(186, 207, 255),
+    // Baby blue
+    selectorColor: chalk4.rgb(189, 178, 255)
+    // Soft lavender for gentle highlighting
+  },
+  detailedView: {
+    colors: {
+      trace: chalk4.rgb(179, 189, 203),
+      debug: chalk4.rgb(189, 178, 255),
+      info: chalk4.rgb(170, 236, 205),
+      warn: chalk4.rgb(255, 223, 186),
+      error: chalk4.rgb(255, 188, 188),
+      fatal: chalk4.bgRgb(255, 188, 188).rgb(76, 40, 40)
+    },
+    logIdColor: chalk4.rgb(203, 195, 227),
+    dataValueColor: chalk4.rgb(236, 236, 236),
+    dataKeyColor: chalk4.rgb(186, 207, 255),
+    selectorColor: chalk4.rgb(189, 178, 255),
+    // Soft lavender for gentle highlighting
+    headerColor: chalk4.rgb(255, 198, 255),
+    // Cotton candy pink
+    labelColor: chalk4.rgb(255, 198, 255).bold,
+    separatorColor: chalk4.rgb(179, 189, 203),
+    jsonColors: {
+      keysColor: chalk4.rgb(186, 207, 255),
+      // Baby blue
+      dashColor: chalk4.rgb(236, 236, 236),
+      // Soft white
+      numberColor: chalk4.rgb(255, 198, 255),
+      // Cotton candy pink
+      stringColor: chalk4.rgb(170, 236, 205),
+      // Mint green
+      multilineStringColor: chalk4.rgb(170, 236, 205),
+      positiveNumberColor: chalk4.rgb(170, 236, 205),
+      negativeNumberColor: chalk4.rgb(255, 188, 188),
+      booleanColor: chalk4.rgb(255, 223, 186),
+      // Peach
+      nullUndefinedColor: chalk4.rgb(179, 189, 203),
+      dateColor: chalk4.rgb(189, 178, 255)
+      // Gentle lavender
+    }
+  }
+};
+
+// src/PrettyTerminalTransport.ts
+var PrettyTerminalTransport = class _PrettyTerminalTransport extends LoggerlessTransport {
+  /** Singleton instance of the transport */
+  static instance = null;
+  /** Handles all rendering and formatting of logs */
+  renderer;
+  /** Manages log persistence in SQLite database */
+  storage;
+  /** Manages user interaction and view state */
+  uiManager;
+  /** Configuration options */
+  config;
+  /**
+   * Creates a new PrettyTerminalTransport instance.
+   * This is a singleton class - only one instance can exist at a time.
+   * Use getInstance() instead of constructor directly.
+   *
+   * @param config - Configuration options for the transport
+   * @throws Error if attempting to create multiple instances
+   */
+  constructor(config = {}) {
+    if (_PrettyTerminalTransport.instance) {
+      throw new Error("PrettyTerminalTransport is a singleton. Use getPrettyTerminal() instead.");
+    }
+    super(config);
+    this.config = config;
+    if (config.enabled === false) {
+      return;
+    }
+    const maxInlineDepth = config.maxInlineDepth || 4;
+    const maxInlineLength = config.maxInlineLength || 120;
+    const theme = config.theme || moonlight;
+    const logFile = config.logFile;
+    const simpleViewConfig = {
+      colors: {
+        trace: chalk5.gray,
+        // Lowest level, used for verbose output
+        debug: chalk5.blue,
+        // Debug information
+        info: chalk5.green,
+        // Normal operation
+        warn: chalk5.yellow,
+        // Warning conditions
+        error: chalk5.red,
+        // Error conditions
+        fatal: chalk5.bgRed.white,
+        // Critical errors
+        ...theme.simpleView.colors
+      },
+      logIdColor: theme.simpleView.logIdColor || chalk5.dim,
+      dataValueColor: theme.simpleView.dataValueColor || chalk5.white,
+      dataKeyColor: theme.simpleView.dataKeyColor || chalk5.dim,
+      selectorColor: theme.simpleView.selectorColor || chalk5.cyan
+    };
+    const detailedViewConfig = {
+      colors: {
+        trace: chalk5.gray,
+        debug: chalk5.blue,
+        info: chalk5.green,
+        warn: chalk5.yellow,
+        error: chalk5.red,
+        fatal: chalk5.bgRed.white,
+        ...theme.detailedView?.colors
+      },
+      logIdColor: theme.detailedView?.logIdColor || chalk5.dim,
+      dataValueColor: theme.detailedView?.dataValueColor || chalk5.white,
+      dataKeyColor: theme.detailedView?.dataKeyColor || chalk5.dim,
+      selectorColor: theme.detailedView?.selectorColor || chalk5.cyan,
+      headerColor: theme.detailedView?.headerColor || chalk5.cyan,
+      labelColor: theme.detailedView?.labelColor || chalk5.cyan.bold,
+      separatorColor: theme.detailedView?.separatorColor || chalk5.dim,
+      // JSON formatting colors for detailed data view
+      jsonColors: {
+        keysColor: chalk5.yellow,
+        // Object property names
+        dashColor: chalk5.white,
+        // Array bullets
+        numberColor: chalk5.yellow,
+        // Default number color
+        stringColor: chalk5.white,
+        // Single-line strings
+        multilineStringColor: chalk5.white,
+        // Multi-line strings
+        positiveNumberColor: chalk5.green,
+        // Numbers > 0
+        negativeNumberColor: chalk5.red,
+        // Numbers < 0
+        booleanColor: chalk5.cyan,
+        // true/false values
+        nullUndefinedColor: chalk5.grey,
+        // null/undefined
+        dateColor: chalk5.magenta,
+        // Date objects
+        ...theme.detailedView?.jsonColors
+      }
+    };
+    this.storage = new LogStorage(logFile);
+    this.renderer = new LogRenderer(simpleViewConfig, detailedViewConfig, maxInlineDepth, maxInlineLength);
+    this.uiManager = new UIManager(this.renderer, this.storage);
+    _PrettyTerminalTransport.instance = this;
+  }
+  /**
+   * Gets or creates the singleton instance of PrettyTerminalTransport.
+   * This is the recommended way to obtain a transport instance.
+   *
+   * @param config - Configuration options for the transport
+   * @returns The singleton instance of PrettyTerminalTransport
+   */
+  static getInstance(config = {}) {
+    if (!_PrettyTerminalTransport.instance) {
+      _PrettyTerminalTransport.instance = new _PrettyTerminalTransport(config);
+    }
+    return _PrettyTerminalTransport.instance;
+  }
+  /**
+   * Generates a random ID for each log entry.
+   * Uses base36 encoding for compact, readable IDs.
+   *
+   * @returns A 6-character string ID
+   * @example
+   * "a1b2c3" // Example generated ID
+   */
+  generateId() {
+    return Math.random().toString(36).substring(2, 8);
+  }
+  /**
+   * Main transport method that receives logs from LogLayer.
+   * This method is called for each log event and handles:
+   * - Generating a unique ID for the log
+   * - Converting the log data to a storable format
+   * - Storing the log in the database
+   * - Rendering the log if not in selection mode
+   *
+   * @param logLevel - The severity level of the log
+   * @param messages - Array of message strings to be joined
+   * @param data - Additional structured data to be logged
+   * @param hasData - Whether the log includes additional data
+   * @returns The original messages array
+   */
+  shipToLogger({ logLevel, messages, data, hasData }) {
+    if (this.config.enabled === false) {
+      return messages;
+    }
+    const entry = {
+      id: this.generateId(),
+      timestamp: Date.now(),
+      level: logLevel,
+      message: messages.join(" "),
+      data: hasData ? JSON.stringify(data) : null
+    };
+    this.uiManager.handleNewLog(entry);
+    return messages;
+  }
+};
+
+// src/index.ts
+import * as chalk6 from "chalk";
+function getPrettyTerminal(config = {}) {
+  return PrettyTerminalTransport.getInstance(config);
+}
+export {
+  PrettyTerminalTransport,
+  chalk6 as chalk,
+  getPrettyTerminal,
+  moonlight,
+  nature,
+  neon,
+  pastel,
+  sunlight
+};
+//# sourceMappingURL=index.js.map