@mks2508/mks-ui 0.3.2 → 0.5.0

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

@@ -0,0 +1,466 @@
+/**
+ * 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,
+    };
+  }
+}