@mks2508/mks-ui 0.5.4 → 0.5.8

package/src/react-ui/blocks/Terminal/parsing/MultilineAggregator.ts

@@ -1,466 +0,0 @@
-/**
- * Multiline log aggregator for JSON and structured data.
- *
- * Detects and aggregates multiline log entries such as JSON objects,
- * tables, and structured data that span multiple lines. Prevents
- * timestamp/level repetition on continuation lines.
- *
- * @module components/devenv/terminal/parsing/multiline
- */
-
-import type { IParsedLogEntry, TLogLevel } from './LogParser.types';
-
-/**
- * Box-drawing characters used for table borders.
- * Unicode range: U+2500-U+257F
- */
-const TABLE_CHARS = [
-  '─', '│', '┌', '┐', '└', '┘',
-  '├', '┤', '┬', '┴', '┼',
-  '═', '║', '╔', '╗', '╚', '╝',
-  '╠', '╣', '╦', '╩', '╬',
-];
-
-/**
- * Multiline aggregation state.
- *
- * Tracks buffer and context while aggregating multiline logs.
- */
-export interface IMultilineState {
-  /** Buffered lines for current multiline entry */
-  buffer: string[];
-
-  /** Parent entry for continuation lines (only line_number is used) */
-  parentEntry?: {
-    line_number: number;
-    level: TLogLevel;
-  };
-
-  /** Whether currently in multiline mode */
-  isMultiline: boolean;
-
-  /** Expected closing bracket/brace for current multiline */
-  expectedClose?: '}' | ']';
-
-  /** Current depth of nested braces/brackets */
-  depth: number;
-}
-
-/**
- * Multiline log aggregator class.
- *
- * Detects and aggregates lines that are part of a multiline JSON
- * or structured data entry. Marks continuation lines so they don't
- * get timestamp/level prefixes.
- *
- * @example
- * ```ts
- * const aggregator = new MultilineAggregator();
- * const aggregated = aggregator.aggregate(entries);
- * // Lines like '{', '  filter: {},', '}' get marked as continuation
- * ```
- */
-export class MultilineAggregator {
-  /**
-   * Detect if a line is a continuation of multiline JSON/structured data.
-   *
-   * Continuation indicators:
-   * - Line starts with `{` or `[` alone → opens multiline
-   * - Line has indentation + `key: value,` → continuation
-   * - Line is just `}` or `]` → closes multiline
-   * - Line ends with `{` or `[` without match → opens multiline
-   * - When in multiline mode: lines ending with comma or containing key-value patterns
-   *
-   * @param line - Line to check
-   * @param state - Current multiline state
-   * @returns true if line is a continuation
-   */
-  detectContinuation(line: string, state: IMultilineState): boolean {
-    const trimmed = line.trim();
-
-    // Already in multiline mode - more permissive detection
-    if (state.isMultiline) {
-      // Check if this closes the multiline
-      if (this.isClosingBrace(trimmed, state.expectedClose)) {
-        return true;
-      }
-      // Check if this opens another level
-      if (this.isOpeningBrace(trimmed)) {
-        return true;
-      }
-      // Check if this looks like a continuation (indented content)
-      if (this.isContinuationLine(line)) {
-        return true;
-      }
-      // NEW: When in multiline mode, lines ending with comma or containing JSON patterns
-      // are continuations even if they have their own timestamp/level metadata
-      if (this.isJsonContinuation(trimmed)) {
-        return true;
-      }
-      return false;
-    }
-
-    // Not in multiline mode - check if this opens one
-    return this.opensMultiline(trimmed);
-  }
-
-  /**
-   * Aggregate entries, marking continuation lines.
-   *
-   * Processes entries and marks lines that are continuations
-   * of a previous multiline entry. Handles:
-   * - JSON/structured data blocks
-   * - Table borders (box-drawing characters)
-   * - Indented continuation lines
-   *
-   * @param entries - Parsed log entries to aggregate
-   * @param initialState - Optional initial multiline state (for persistence across chunks)
-   * @returns Entries with continuation marking and new multiline state
-   */
-  aggregate(entries: IParsedLogEntry[], initialState?: IMultilineState): { entries: IParsedLogEntry[]; state: IMultilineState } {
-    const result: IParsedLogEntry[] = [];
-    const state: IMultilineState = initialState ?? {
-      buffer: [],
-      isMultiline: false,
-      depth: 0,
-    };
-
-    for (const entry of entries) {
-      const raw = entry.raw;
-      const trimmed = raw.trim();
-
-      // Skip empty lines (end previous blocks)
-      if (trimmed.length === 0) {
-        if (state.isMultiline) {
-          // End the current block
-          state.isMultiline = false;
-          state.buffer = [];
-          state.parentEntry = undefined;
-          state.depth = 0;
-          state.expectedClose = undefined;
-        }
-        // Don't add empty lines to result
-        continue;
-      }
-
-      // Check if this line starts a multiline block
-      if (!state.isMultiline && this.opensMultiline(trimmed)) {
-        // This is the start of multiline
-        state.isMultiline = true;
-        state.parentEntry = entry;
-        state.depth = this.countOpeningBraces(trimmed);
-        state.expectedClose = this.getExpectedClose(trimmed);
-
-        // Mark entry as multiline start (not a continuation)
-        entry.is_continuation = false;
-        result.push(entry);
-        continue;
-      }
-
-      // Check if this is a continuation line
-      if (state.isMultiline) {
-        // Check if this line closes the multiline
-        if (this.isClosingBrace(trimmed, state.expectedClose)) {
-          state.depth--;
-          if (state.depth <= 0) {
-            // This closes the multiline block
-            entry.is_continuation = true;
-            entry.parent_line_number = state.parentEntry?.line_number;
-            result.push(entry);
-
-            // Reset state
-            state.isMultiline = false;
-            state.buffer = [];
-            state.parentEntry = undefined;
-            state.depth = 0;
-            state.expectedClose = undefined;
-            continue;
-          }
-        }
-
-        // Check if this opens another level
-        if (this.isOpeningBrace(trimmed)) {
-          state.depth += this.countOpeningBraces(trimmed);
-        }
-
-        // Check if this looks like a continuation (even with timestamp)
-        if (this.isJsonContinuation(trimmed)) {
-          entry.is_continuation = true;
-          entry.parent_line_number = state.parentEntry?.line_number;
-          result.push(entry);
-          continue;
-        }
-
-        // If we're in multiline mode but this line doesn't look like a continuation,
-        // it might be a new log entry ending the multiline block
-        if (this.looksLikeNewEntry(trimmed)) {
-          // End the multiline block
-          state.isMultiline = false;
-          state.parentEntry = undefined;
-          state.depth = 0;
-          state.expectedClose = undefined;
-
-          // Check if this new line also starts a multiline
-          if (this.opensMultiline(trimmed)) {
-            state.isMultiline = true;
-            state.parentEntry = entry;
-            state.depth = this.countOpeningBraces(trimmed);
-            state.expectedClose = this.getExpectedClose(trimmed);
-          }
-
-          entry.is_continuation = false;
-          result.push(entry);
-          continue;
-        }
-
-        // Default: treat as continuation if in multiline mode
-        entry.is_continuation = true;
-        entry.parent_line_number = state.parentEntry?.line_number;
-        result.push(entry);
-        continue;
-      }
-
-      // Normal line, not part of multiline
-      entry.is_continuation = false;
-      result.push(entry);
-    }
-
-    return { entries: result, state };
-  }
-
-  /**
-   * Check if a line opens a multiline block.
-   *
-   * @param trimmed - Trimmed line to check
-   * @returns true if line opens multiline
-   * @private
-   */
-  private opensMultiline(trimmed: string): boolean {
-    // Line is just an opening brace
-    if (trimmed === '{' || trimmed === '[') {
-      return true;
-    }
-
-    // Line ends with opening brace without match
-    const openCount = (trimmed.match(/\{/g) ?? []).length;
-    const closeCount = (trimmed.match(/\}/g) ?? []).length;
-    const bracketOpen = (trimmed.match(/\[/g) ?? []).length;
-    const bracketClose = (trimmed.match(/\]/g) ?? []).length;
-
-    // More opening than closing = multiline start
-    if ((openCount > closeCount) || (bracketOpen > bracketClose)) {
-      return true;
-    }
-
-    // Line ends with opening brace (e.g., "GET /api/endpoint {")
-    if (trimmed.endsWith('{') || trimmed.endsWith('[')) {
-      return true;
-    }
-
-    return false;
-  }
-
-  /**
-   * Check if a line is an opening brace/bracket.
-   *
-   * @param trimmed - Trimmed line to check
-   * @returns true if line contains opening brace/bracket
-   * @private
-   */
-  private isOpeningBrace(trimmed: string): boolean {
-    return trimmed.includes('{') || trimmed.includes('[');
-  }
-
-  /**
-   * Check if a line is a closing brace/bracket for expected type.
-   *
-   * @param trimmed - Trimmed line to check
-   * @param expected - Expected close type
-   * @returns true if line closes the multiline block
-   * @private
-   */
-  private isClosingBrace(trimmed: string, expected?: '}' | ']'): boolean {
-    if (!expected) return false;
-
-    if (expected === '}' && trimmed === '}') {
-      return true;
-    }
-    if (expected === ']' && trimmed === ']') {
-      return true;
-    }
-
-    return false;
-  }
-
-  /**
-   * Get the expected closing character for a line.
-   *
-   * @param trimmed - Trimmed line to check
-   * @returns Expected closing character or undefined
-   * @private
-   */
-  private getExpectedClose(trimmed: string): '}' | ']' | undefined {
-    if (trimmed.includes('{')) return '}';
-    if (trimmed.includes('[')) return ']';
-    return undefined;
-  }
-
-  /**
-   * Count opening braces/brackets in a line.
-   *
-   * @param trimmed - Trimmed line to check
-   * @returns Count of opening braces/brackets
-   * @private
-   */
-  private countOpeningBraces(trimmed: string): number {
-    const openCount = (trimmed.match(/\{/g) ?? []).length;
-    const bracketOpen = (trimmed.match(/\[/g) ?? []).length;
-    return openCount + bracketOpen;
-  }
-
-  /**
-   * Check if a line is a table line (contains box-drawing characters).
-   *
-   * @param trimmed - Trimmed line to check
-   * @returns true if line contains table borders
-   * @private
-   */
-  private isTableLine(trimmed: string): boolean {
-    // Check if line contains multiple box-drawing characters
-    // (to avoid false positives on single characters)
-    let count = 0;
-    for (const char of TABLE_CHARS) {
-      if (trimmed.includes(char)) count++;
-      if (count >= 2) return true;
-    }
-    return count >= 2;
-  }
-
-  /**
-   * Check if a line looks like a new log entry (not a continuation).
-   *
-   * New entries typically start with:
-   * - Timestamp followed by log level
-   * - HTTP method followed by path
-   * - Component/module tag
-   *
-   * @param trimmed - Trimmed line to check
-   * @returns true if line looks like a new entry
-   * @private
-   */
-  private looksLikeNewEntry(trimmed: string): boolean {
-    // Pattern: timestamp followed by level (e.g., "01:18:52 INFO")
-    const timestampLevelPattern = /^\d{1,2}:\d{2}:\d{2}(\.\d+)?\s+(TRACE|DEBUG|INFO|WARN|ERROR|FATAL)/i;
-    if (timestampLevelPattern.test(trimmed)) {
-      return true;
-    }
-
-    // Pattern: ISO timestamp followed by level
-    const isoTimestampPattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/;
-    if (isoTimestampPattern.test(trimmed)) {
-      return true;
-    }
-
-    // Pattern: HTTP method at start (e.g., "GET /api/...")
-    const httpPattern = /^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS|CONNECT|TRACE)\s+/i;
-    if (httpPattern.test(trimmed)) {
-      return true;
-    }
-
-    // Pattern: Component tag at start (e.g., "⦗API⦘")
-    if (trimmed.startsWith('⦗') && trimmed.includes('⦘')) {
-      return true;
-    }
-
-    return false;
-  }
-
-  /**
-   * Check if a trimmed line is a JSON/structured data continuation.
-   *
-   * This handles lines that have their own timestamp/level metadata
-   * but are actually continuations of a multiline JSON block.
-   *
-   * Examples:
-   * - `container: "name",` - ends with comma
-   * - `tail: 100,` - ends with comma
-   * - `key: "value"` - key-value pattern
-   * - `}` - closing brace
-   * - Lines with pipe characters (table rows)
-   *
-   * @param trimmed - Trimmed line to check
-   * @returns true if line is a JSON continuation
-   * @private
-   */
-  private isJsonContinuation(trimmed: string): boolean {
-    // Line is just a closing brace - closes the multiline
-    if (trimmed === '}' || trimmed === ']') {
-      return true;
-    }
-
-    // Line ends with comma - likely JSON continuation
-    if (trimmed.endsWith(',')) {
-      return true;
-    }
-
-    // Line ends with opening brace - extends multiline
-    if (trimmed.endsWith('{') || trimmed.endsWith('[')) {
-      return true;
-    }
-
-    // Line contains pipe characters (table row with content)
-    // Pattern: │ key │ value │
-    if (trimmed.includes('│') && !this.isTableLine(trimmed)) {
-      // Has pipe but not enough box-drawing chars to be a border line
-      // This is likely a table content row
-      return true;
-    }
-
-    // Check for key-value pattern after timestamp/level removal
-    // Remove common prefixes: "01:18:52 INFO " or "[INFO] "
-    let content = trimmed
-      .replace(/^\d{1,2}:\d{2}:\d{2}(\.\d+)?\s+(TRACE|DEBUG|INFO|WARN|ERROR|FATAL)\s*/i, '')
-      .replace(/^\[(TRACE|DEBUG|INFO|WARN|ERROR|FATAL)\]\s*/i, '')
-      .replace(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.*?\s+/, '')
-      .trim();
-
-    // Pattern: "key": value or key: value or "key": "value"
-    const keyValuePatterns = [
-      /^[\w"']+\s*:\s*[\w"'\{[]/, // "key": { or key: [
-      /^[\w"']+\s*:\s*".*",?\s*$/, // "key": "value",
-      /^[\w"']+\s*:\s*\d+/, // key: 123
-      /^[\w"']+\s*:\s*true|false/, // key: true
-    ];
-
-    if (keyValuePatterns.some(pattern => pattern.test(content))) {
-      return true;
-    }
-
-    return false;
-  }
-
-  /**
-   * Check if a line looks like a continuation line (indented content).
-   *
-   * @param line - Line to check (not trimmed, to check indentation)
-   * @returns true if line appears to be a continuation
-   * @private
-   */
-  private isContinuationLine(line: string): boolean {
-    // Check if line starts with whitespace (indented)
-    return line.length > 0 && (line[0] === ' ' || line[0] === '\t');
-  }
-
-  /**
-   * Create initial multiline state.
-   *
-   * @returns Fresh multiline state
-   */
-  createInitialState(): IMultilineState {
-    return {
-      buffer: [],
-      isMultiline: false,
-      depth: 0,
-    };
-  }
-}