@mks2508/mks-ui 0.3.2 → 0.4.0

package/dist/react-ui/blocks/Terminal/parsing/MultilineAggregator.js

@@ -0,0 +1,313 @@
+//#region src/react-ui/blocks/Terminal/parsing/MultilineAggregator.ts
+/**
+* Box-drawing characters used for table borders.
+* Unicode range: U+2500-U+257F
+*/
+const TABLE_CHARS = [
+	"─",
+	"│",
+	"┌",
+	"┐",
+	"└",
+	"┘",
+	"├",
+	"┤",
+	"┬",
+	"┴",
+	"┼",
+	"═",
+	"║",
+	"╔",
+	"╗",
+	"╚",
+	"╝",
+	"╠",
+	"╣",
+	"╦",
+	"╩",
+	"╬"
+];
+/**
+* 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
+* ```
+*/
+var MultilineAggregator = class {
+	/**
+	* 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, state) {
+		const trimmed = line.trim();
+		if (state.isMultiline) {
+			if (this.isClosingBrace(trimmed, state.expectedClose)) return true;
+			if (this.isOpeningBrace(trimmed)) return true;
+			if (this.isContinuationLine(line)) return true;
+			if (this.isJsonContinuation(trimmed)) return true;
+			return false;
+		}
+		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, initialState) {
+		const result = [];
+		const state = initialState ?? {
+			buffer: [],
+			isMultiline: false,
+			depth: 0
+		};
+		for (const entry of entries) {
+			const trimmed = entry.raw.trim();
+			if (trimmed.length === 0) {
+				if (state.isMultiline) {
+					state.isMultiline = false;
+					state.buffer = [];
+					state.parentEntry = void 0;
+					state.depth = 0;
+					state.expectedClose = void 0;
+				}
+				continue;
+			}
+			if (!state.isMultiline && 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;
+			}
+			if (state.isMultiline) {
+				if (this.isClosingBrace(trimmed, state.expectedClose)) {
+					state.depth--;
+					if (state.depth <= 0) {
+						entry.is_continuation = true;
+						entry.parent_line_number = state.parentEntry?.line_number;
+						result.push(entry);
+						state.isMultiline = false;
+						state.buffer = [];
+						state.parentEntry = void 0;
+						state.depth = 0;
+						state.expectedClose = void 0;
+						continue;
+					}
+				}
+				if (this.isOpeningBrace(trimmed)) state.depth += this.countOpeningBraces(trimmed);
+				if (this.isJsonContinuation(trimmed)) {
+					entry.is_continuation = true;
+					entry.parent_line_number = state.parentEntry?.line_number;
+					result.push(entry);
+					continue;
+				}
+				if (this.looksLikeNewEntry(trimmed)) {
+					state.isMultiline = false;
+					state.parentEntry = void 0;
+					state.depth = 0;
+					state.expectedClose = void 0;
+					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;
+				}
+				entry.is_continuation = true;
+				entry.parent_line_number = state.parentEntry?.line_number;
+				result.push(entry);
+				continue;
+			}
+			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
+	*/
+	opensMultiline(trimmed) {
+		if (trimmed === "{" || trimmed === "[") return true;
+		const openCount = (trimmed.match(/\{/g) ?? []).length;
+		const closeCount = (trimmed.match(/\}/g) ?? []).length;
+		const bracketOpen = (trimmed.match(/\[/g) ?? []).length;
+		const bracketClose = (trimmed.match(/\]/g) ?? []).length;
+		if (openCount > closeCount || bracketOpen > bracketClose) return true;
+		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
+	*/
+	isOpeningBrace(trimmed) {
+		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
+	*/
+	isClosingBrace(trimmed, expected) {
+		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
+	*/
+	getExpectedClose(trimmed) {
+		if (trimmed.includes("{")) return "}";
+		if (trimmed.includes("[")) return "]";
+	}
+	/**
+	* Count opening braces/brackets in a line.
+	*
+	* @param trimmed - Trimmed line to check
+	* @returns Count of opening braces/brackets
+	* @private
+	*/
+	countOpeningBraces(trimmed) {
+		return (trimmed.match(/\{/g) ?? []).length + (trimmed.match(/\[/g) ?? []).length;
+	}
+	/**
+	* 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
+	*/
+	isTableLine(trimmed) {
+		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
+	*/
+	looksLikeNewEntry(trimmed) {
+		if (/^\d{1,2}:\d{2}:\d{2}(\.\d+)?\s+(TRACE|DEBUG|INFO|WARN|ERROR|FATAL)/i.test(trimmed)) return true;
+		if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(trimmed)) return true;
+		if (/^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS|CONNECT|TRACE)\s+/i.test(trimmed)) return true;
+		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
+	*/
+	isJsonContinuation(trimmed) {
+		if (trimmed === "}" || trimmed === "]") return true;
+		if (trimmed.endsWith(",")) return true;
+		if (trimmed.endsWith("{") || trimmed.endsWith("[")) return true;
+		if (trimmed.includes("│") && !this.isTableLine(trimmed)) return true;
+		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();
+		if ([
+			/^[\w"']+\s*:\s*[\w"'\{[]/,
+			/^[\w"']+\s*:\s*".*",?\s*$/,
+			/^[\w"']+\s*:\s*\d+/,
+			/^[\w"']+\s*:\s*true|false/
+		].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
+	*/
+	isContinuationLine(line) {
+		return line.length > 0 && (line[0] === " " || line[0] === "	");
+	}
+	/**
+	* Create initial multiline state.
+	*
+	* @returns Fresh multiline state
+	*/
+	createInitialState() {
+		return {
+			buffer: [],
+			isMultiline: false,
+			depth: 0
+		};
+	}
+};
+
+//#endregion
+export { MultilineAggregator };

package/dist/react-ui/blocks/Terminal/parsing/PersistentLogBuffer.d.ts

@@ -0,0 +1,181 @@
+/**
+ * Persistent circular buffer for log entries with periodic cleanup.
+ *
+ * Maintains a large history of logs without memory leaks by using
+ * a circular buffer with periodic cleanup. Supports pagination,
+ * search, and efficient querying.
+ *
+ * @module components/devenv/terminal/parsing/PersistentLogBuffer
+ */
+import type { IParsedLogEntry } from './LogParser.types';
+/**
+ * Configuration for the persistent log buffer.
+ */
+export interface IPersistentLogBufferConfig {
+    /** Maximum number of entries to store (default: 50,000) */
+    maxSize: number;
+    /** Soft limit that triggers cleanup (default: 40,000) */
+    softLimit: number;
+    /** Number of entries to remove per cleanup batch (default: 5,000) */
+    cleanupBatch: number;
+    /** Cleanup interval in milliseconds (default: 30,000 ms = 30s) */
+    cleanupInterval: number;
+}
+/**
+ * Buffer statistics for monitoring.
+ */
+export interface IBufferStats {
+    /** Current number of entries */
+    size: number;
+    /** Maximum configured size */
+    maxSize: number;
+    /** Usage ratio (0-1) */
+    usage: number;
+    /** First line number in buffer */
+    firstLine: number | undefined;
+    /** Last line number in buffer */
+    lastLine: number | undefined;
+    /** Memory usage estimate (bytes) */
+    memoryUsage: number;
+}
+/**
+ * Search options for querying the buffer.
+ */
+export interface ISearchOptions {
+    /** Start from line number */
+    fromLine?: number;
+    /** Maximum results to return */
+    limit?: number;
+    /** Case insensitive search */
+    caseInsensitive?: boolean;
+}
+/**
+ * Persistent circular buffer for log entries.
+ *
+ * Features:
+ * - Circular buffer with automatic cleanup
+ * - Pagination support for large datasets
+ * - Search by pattern
+ * - Memory-efficient storage
+ * - Periodic cleanup to prevent memory leaks
+ *
+ * @example
+ * ```ts
+ * const buffer = new PersistentLogBuffer({ maxSize: 50000 });
+ * buffer.append(entries);
+ * const page1 = buffer.getEntries({ offset: 0, limit: 100 });
+ * const results = buffer.search(/error/i);
+ * ```
+ */
+export declare class PersistentLogBuffer {
+    /** Internal storage for entries */
+    private buffer;
+    /** Buffer configuration */
+    private config;
+    /** Cleanup timer reference */
+    private cleanupTimer?;
+    /** Cleanup scheduled flag */
+    private cleanupScheduled;
+    /**
+     * Create a new persistent log buffer.
+     *
+     * @param config - Buffer configuration
+     */
+    constructor(config?: Partial<IPersistentLogBufferConfig>);
+    /**
+     * Append entries to the buffer.
+     *
+     * If the buffer exceeds the soft limit, schedules a cleanup.
+     *
+     * @param entries - Entries to append
+     */
+    append(entries: IParsedLogEntry[]): void;
+    /**
+     * Prepend entries to the buffer (for loading historical logs).
+     *
+     * @param entries - Entries to prepend
+     */
+    prepend(entries: IParsedLogEntry[]): void;
+    /**
+     * Get entries from the buffer with pagination.
+     *
+     * @param options - Query options
+     * @returns Array of entries
+     */
+    getEntries(options?: {
+        offset?: number;
+        limit?: number;
+        fromLine?: number;
+        toLine?: number;
+    }): IParsedLogEntry[];
+    /**
+     * Get all entries in the buffer.
+     *
+     * @returns All entries
+     */
+    getAllEntries(): IParsedLogEntry[];
+    /**
+     * Get the total number of entries.
+     *
+     * @returns Entry count
+     */
+    getSize(): number;
+    /**
+     * Search entries by pattern.
+     *
+     * @param pattern - RegExp pattern or string to search
+     * @param options - Search options
+     * @returns Matching entries
+     */
+    search(pattern: RegExp | string, options?: ISearchOptions): IParsedLogEntry[];
+    /**
+     * Find entries by line number.
+     *
+     * @param lineNumbers - Array of line numbers to find
+     * @returns Matching entries
+     */
+    findByLineNumbers(lineNumbers: number[]): IParsedLogEntry[];
+    /**
+     * Get entries filtered by log level.
+     *
+     * @param level - Log level to filter by
+     * @returns Filtered entries
+     */
+    getByLevel(level: string): IParsedLogEntry[];
+    /**
+     * Clear all entries from the buffer.
+     */
+    clear(): void;
+    /**
+     * Get buffer statistics.
+     *
+     * @returns Buffer statistics
+     */
+    getStats(): IBufferStats;
+    /**
+     * Schedule a cleanup operation.
+     */
+    private scheduleCleanup;
+    /**
+     * Perform cleanup of old entries.
+     *
+     * Removes the oldest entries to keep the buffer within limits.
+     */
+    private cleanup;
+    /**
+     * Start the periodic cleanup timer.
+     */
+    private startCleanupTimer;
+    /**
+     * Stop the cleanup timer and clear resources.
+     */
+    destroy(): void;
+}
+/**
+ * Create a new persistent log buffer with default configuration.
+ *
+ * @param config - Optional configuration overrides
+ * @returns New buffer instance
+ */
+export declare function createPersistentLogBuffer(config?: Partial<IPersistentLogBufferConfig>): PersistentLogBuffer;
+//# sourceMappingURL=PersistentLogBuffer.d.ts.map

package/dist/react-ui/blocks/Terminal/parsing/PersistentLogBuffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersistentLogBuffer.d.ts","sourceRoot":"","sources":["../../../../../src/react-ui/blocks/Terminal/parsing/PersistentLogBuffer.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,2DAA2D;IAC3D,OAAO,EAAE,MAAM,CAAC;IAEhB,yDAAyD;IACzD,SAAS,EAAE,MAAM,CAAC;IAElB,qEAAqE;IACrE,YAAY,EAAE,MAAM,CAAC;IAErB,kEAAkE;IAClE,eAAe,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAC;IAEb,8BAA8B;IAC9B,OAAO,EAAE,MAAM,CAAC;IAEhB,wBAAwB;IACxB,KAAK,EAAE,MAAM,CAAC;IAEd,kCAAkC;IAClC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAE9B,iCAAiC;IACjC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAE7B,oCAAoC;IACpC,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,6BAA6B;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,gCAAgC;IAChC,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,8BAA8B;IAC9B,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,mBAAmB;IAC9B,mCAAmC;IACnC,OAAO,CAAC,MAAM,CAAyB;IAEvC,2BAA2B;IAC3B,OAAO,CAAC,MAAM,CAA6B;IAE3C,8BAA8B;IAC9B,OAAO,CAAC,YAAY,CAAC,CAAgC;IAErD,6BAA6B;IAC7B,OAAO,CAAC,gBAAgB,CAAS;IAEjC;;;;OAIG;gBACS,MAAM,GAAE,OAAO,CAAC,0BAA0B,CAAM;IAW5D;;;;;;OAMG;IACH,MAAM,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,IAAI;IAUxC;;;;OAIG;IACH,OAAO,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,IAAI;IAWzC;;;;;OAKG;IACH,UAAU,CAAC,OAAO,GAAE;QAClB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,MAAM,CAAC,EAAE,MAAM,CAAC;KACZ,GAAG,eAAe,EAAE;IAuB1B;;;;OAIG;IACH,aAAa,IAAI,eAAe,EAAE;IAIlC;;;;OAIG;IACH,OAAO,IAAI,MAAM;IAIjB;;;;;;OAMG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,OAAO,GAAE,cAAmB,GAAG,eAAe,EAAE;IAsBjF;;;;;OAKG;IACH,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,eAAe,EAAE;IAK3D;;;;;OAKG;IACH,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe,EAAE;IAI5C;;OAEG;IACH,KAAK,IAAI,IAAI;IAKb;;;;OAIG;IACH,QAAQ,IAAI,YAAY;IAoBxB;;OAEG;IACH,OAAO,CAAC,eAAe;IAQvB;;;;OAIG;IACH,OAAO,CAAC,OAAO;IAgBf;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAMzB;;OAEG;IACH,OAAO,IAAI,IAAI;CAOhB;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,0BAA0B,CAAC,GAAG,mBAAmB,CAE3G"}