logixia 1.12.4 → 1.12.6

package/dist/search-njTI2hdo.js

@@ -0,0 +1,1631 @@
+const require_coerce_utils = require('./coerce.utils-BN980Y9V.js');
+
+//#region src/search/core/basic-log-indexer.ts
+/**
+* Basic log indexer implementation
+*/
+var BasicLogIndexer = class {
+	constructor(options) {
+		this.options = options;
+		this.index = /* @__PURE__ */ new Map();
+		this.fieldIndices = /* @__PURE__ */ new Map();
+		this.indexSizeBytes = 0;
+		this.logSizeById = /* @__PURE__ */ new Map();
+		this.options = {
+			maxIndexSize: 1e6,
+			autoOptimize: true,
+			optimizeThreshold: 1e4,
+			...options
+		};
+		this.initializeFieldIndices();
+	}
+	/**
+	* Index a single log entry
+	*/
+	async indexLog(log) {
+		var _this$options, _this$options2;
+		const logId = this.generateLogId(log);
+		this.trackInsert(logId, log);
+		this.updateFieldIndices(logId, log);
+		if (((_this$options = this.options) === null || _this$options === void 0 ? void 0 : _this$options.autoOptimize) && this.index.size % (this.options.optimizeThreshold || 1e4) === 0) await this.optimizeIndex();
+		if (this.index.size > (((_this$options2 = this.options) === null || _this$options2 === void 0 ? void 0 : _this$options2.maxIndexSize) || 1e6)) {
+			var _this$options3;
+			await this.removeOldestLogs(Math.floor((((_this$options3 = this.options) === null || _this$options3 === void 0 ? void 0 : _this$options3.maxIndexSize) || 1e6) * .1));
+		}
+	}
+	/**
+	* Index multiple log entries in batch
+	*/
+	async indexBatch(logs) {
+		var _this$options4;
+		for (const log of logs) {
+			const logId = this.generateLogId(log);
+			this.trackInsert(logId, log);
+			this.updateFieldIndices(logId, log);
+		}
+		if ((_this$options4 = this.options) === null || _this$options4 === void 0 ? void 0 : _this$options4.autoOptimize) await this.optimizeIndex();
+	}
+	/**
+	* Build semantic index for intelligent search
+	*/
+	async buildSemanticIndex(logs) {
+		const clusters = await this.clusterLogs(logs);
+		this.semanticIndex = {
+			version: "1.0.0",
+			indexedCount: logs.length,
+			lastUpdated: /* @__PURE__ */ new Date(),
+			clusters
+		};
+		return this.semanticIndex;
+	}
+	/**
+	* Update search suggestions based on search history
+	*/
+	async updateSearchSuggestions(searchHistory) {
+		const patterns = /* @__PURE__ */ new Map();
+		for (const query of searchHistory) {
+			const normalizedQuery = query.query.toLowerCase().trim();
+			patterns.set(normalizedQuery, (patterns.get(normalizedQuery) || 0) + 1);
+		}
+	}
+	/**
+	* Optimize the index for better performance
+	*/
+	async optimizeIndex() {
+		this.fieldIndices.clear();
+		this.initializeFieldIndices();
+		for (const [logId, log] of this.index.entries()) this.updateFieldIndices(logId, log);
+		this.lastOptimized = /* @__PURE__ */ new Date();
+	}
+	/**
+	* Clear the index
+	*/
+	async clearIndex() {
+		this.index.clear();
+		this.fieldIndices.clear();
+		this.semanticIndex = void 0;
+		this.indexSizeBytes = 0;
+		this.logSizeById.clear();
+		this.initializeFieldIndices();
+	}
+	/**
+	* Get index statistics
+	*/
+	async getIndexStats() {
+		return {
+			totalDocuments: this.index.size,
+			indexSize: this.calculateIndexSize(),
+			...this.lastOptimized !== void 0 ? { lastOptimized: this.lastOptimized } : {}
+		};
+	}
+	/**
+	* Remove logs older than specified time
+	*/
+	async removeOldLogs(olderThan) {
+		const cutoffTime = olderThan.getTime();
+		let removedCount = 0;
+		for (const [logId, log] of this.index.entries()) if (new Date(log.timestamp).getTime() < cutoffTime) {
+			this.trackDelete(logId);
+			this.removeFromFieldIndices(logId);
+			removedCount++;
+		}
+		return removedCount;
+	}
+	/**
+	* Search logs by field
+	*/
+	searchByField(field, value) {
+		const fieldIndex = this.fieldIndices.get(field);
+		if (!fieldIndex) return [];
+		const logIds = fieldIndex.get(value.toLowerCase());
+		if (!logIds) return [];
+		return Array.from(logIds).map((id) => this.index.get(id)).filter((log) => log !== void 0);
+	}
+	/**
+	* Get all indexed logs
+	*/
+	getAllLogs() {
+		return Array.from(this.index.values());
+	}
+	initializeFieldIndices() {
+		for (const field of [
+			"level",
+			"appName",
+			"traceId",
+			"context",
+			"environment"
+		]) this.fieldIndices.set(field, /* @__PURE__ */ new Map());
+	}
+	updateFieldIndices(logId, log) {
+		this.addToFieldIndex("level", log.level, logId);
+		if (log.appName) this.addToFieldIndex("appName", log.appName, logId);
+		if (log.traceId) this.addToFieldIndex("traceId", log.traceId, logId);
+		if (log.context) this.addToFieldIndex("context", log.context, logId);
+		if (log.environment) this.addToFieldIndex("environment", log.environment, logId);
+	}
+	addToFieldIndex(field, value, logId) {
+		const fieldIndex = this.fieldIndices.get(field);
+		if (!fieldIndex) return;
+		const normalizedValue = value.toLowerCase();
+		if (!fieldIndex.has(normalizedValue)) fieldIndex.set(normalizedValue, /* @__PURE__ */ new Set());
+		fieldIndex.get(normalizedValue).add(logId);
+	}
+	removeFromFieldIndices(logId) {
+		for (const fieldIndex of this.fieldIndices.values()) for (const logIds of fieldIndex.values()) logIds.delete(logId);
+	}
+	generateLogId(log) {
+		return `${log.timestamp}_${log.level}_${Math.random().toString(36).slice(2, 11)}`;
+	}
+	calculateIndexSize() {
+		return this.indexSizeBytes;
+	}
+	/** Insert into the main index and update the running size estimate. */
+	trackInsert(logId, log) {
+		const existing = this.logSizeById.get(logId);
+		if (existing !== void 0) this.indexSizeBytes -= existing;
+		const size = JSON.stringify(log).length;
+		this.index.set(logId, log);
+		this.logSizeById.set(logId, size);
+		this.indexSizeBytes += size;
+	}
+	/** Delete from the main index and update the running size estimate. */
+	trackDelete(logId) {
+		const size = this.logSizeById.get(logId);
+		if (size !== void 0) {
+			this.indexSizeBytes -= size;
+			this.logSizeById.delete(logId);
+		}
+		this.index.delete(logId);
+	}
+	async removeOldestLogs(count) {
+		const logs = Array.from(this.index.entries()).sort((a, b) => new Date(a[1].timestamp).getTime() - new Date(b[1].timestamp).getTime()).slice(0, count);
+		for (const [logId] of logs) {
+			this.trackDelete(logId);
+			this.removeFromFieldIndices(logId);
+		}
+	}
+	async clusterLogs(logs) {
+		const clusters = /* @__PURE__ */ new Map();
+		for (const log of logs) {
+			const patternKey = `${log.level}_${log.appName}`;
+			if (!clusters.has(patternKey)) clusters.set(patternKey, []);
+			clusters.get(patternKey).push(log);
+		}
+		return Array.from(clusters.entries()).map(([pattern, clusterLogs], index) => ({
+			id: `cluster_${index}`,
+			centroid: [],
+			logs: clusterLogs,
+			pattern,
+			frequency: clusterLogs.length,
+			labels: [pattern]
+		}));
+	}
+};
+
+//#endregion
+//#region src/search/core/basic-search-engine.ts
+/**
+* Basic search engine implementation
+*/
+var BasicSearchEngine = class {
+	constructor(options) {
+		this.options = options;
+		this.logs = [];
+		this.presets = /* @__PURE__ */ new Map();
+		this.searchHistory = [];
+		this.suggestionCache = /* @__PURE__ */ new Map();
+		this.options = {
+			maxHistorySize: 1e3,
+			cacheSize: 100,
+			maxLogs: 1e5,
+			...options
+		};
+	}
+	/**
+	* Add logs to the search index.
+	*
+	* Bounded to `maxLogs` (default 100k): the buffer previously grew without
+	* limit, leaking memory in any long-running process feeding it logs. When the
+	* cap is exceeded the oldest entries are dropped (FIFO). We also append with a
+	* loop rather than `push(...logs)` to avoid a RangeError from spreading a very
+	* large array onto the call stack.
+	*/
+	addLogs(logs) {
+		var _this$options;
+		for (const log of logs) this.logs.push(log);
+		const maxLogs = ((_this$options = this.options) === null || _this$options === void 0 ? void 0 : _this$options.maxLogs) ?? 1e5;
+		if (this.logs.length > maxLogs) this.logs.splice(0, this.logs.length - maxLogs);
+	}
+	/**
+	* Clear all logs from the index
+	*/
+	clearLogs() {
+		this.logs = [];
+	}
+	/**
+	* Get all indexed logs
+	*/
+	getLogs() {
+		return this.logs;
+	}
+	/**
+	* Perform a full-text search across logs
+	*/
+	async search(query, filters, options) {
+		const filteredLogs = this.applyFilters(this.logs, filters);
+		const results = this.performTextSearch(filteredLogs, query, options);
+		this.addToSearchHistory(query);
+		const sorted = this.applySorting(results, options === null || options === void 0 ? void 0 : options.sortBy, options === null || options === void 0 ? void 0 : options.sortOrder);
+		const paginated = this.applyPagination(sorted, options === null || options === void 0 ? void 0 : options.offset, options === null || options === void 0 ? void 0 : options.limit);
+		if (options === null || options === void 0 ? void 0 : options.includeContext) await this.enrichWithContext(paginated, options.contextSize);
+		return paginated;
+	}
+	/**
+	* Natural language search (basic implementation)
+	*/
+	async naturalLanguageSearch(query) {
+		const parsed = await this.parseNaturalLanguageQuery(query);
+		return this.search(parsed.originalQuery, parsed.filters, {
+			semanticSearch: true,
+			includeContext: true
+		});
+	}
+	/**
+	* Find logs correlated by trace ID
+	*/
+	async correlateByTraceId(traceId) {
+		const correlatedLogs = this.logs.filter((log) => log.traceId === traceId);
+		correlatedLogs.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+		const timeline = correlatedLogs.map((log) => {
+			let eventType = "info";
+			if (log.level === "error") eventType = "error";
+			else if (log.message.toLowerCase().includes("start")) eventType = "start";
+			else if (log.message.toLowerCase().includes("end") || log.message.toLowerCase().includes("complete")) eventType = "end";
+			else if (log.message.toLowerCase().includes("milestone")) eventType = "milestone";
+			return {
+				timestamp: new Date(log.timestamp),
+				log,
+				eventType
+			};
+		});
+		const summary = {
+			totalLogs: correlatedLogs.length,
+			errorCount: correlatedLogs.filter((l) => l.level === "error").length,
+			warningCount: correlatedLogs.filter((l) => l.level === "warn").length,
+			services: [...new Set(correlatedLogs.map((l) => l.appName))]
+		};
+		if (timeline.length > 0) {
+			const start = timeline[0].timestamp.getTime();
+			summary.duration = timeline[timeline.length - 1].timestamp.getTime() - start;
+		}
+		return {
+			traceId,
+			correlationKey: traceId,
+			logs: correlatedLogs,
+			timeline,
+			summary
+		};
+	}
+	/**
+	* Find similar logs based on content similarity
+	*/
+	async findSimilarLogs(logEntry, limit = 10) {
+		const similarities = [];
+		for (const log of this.logs) {
+			if (log === logEntry) continue;
+			const similarity = this.calculateSimilarity(logEntry, log);
+			if (similarity > .3) similarities.push({
+				log,
+				similarity,
+				matchedPatterns: this.findMatchedPatterns(logEntry, log),
+				reason: this.generateSimilarityReason(logEntry, log, similarity)
+			});
+		}
+		return similarities.sort((a, b) => b.similarity - a.similarity).slice(0, limit);
+	}
+	/**
+	* Get search suggestions
+	*/
+	async getSuggestions(partialQuery, limit = 10) {
+		var _this$options2;
+		const cacheKey = partialQuery.toLowerCase();
+		if (this.suggestionCache.has(cacheKey)) return this.suggestionCache.get(cacheKey).slice(0, limit);
+		const suggestions = [];
+		for (const field of [
+			"level",
+			"appName",
+			"traceId",
+			"message",
+			"timestamp"
+		]) if (field.toLowerCase().includes(partialQuery.toLowerCase())) suggestions.push({
+			text: field,
+			type: "field",
+			category: "field"
+		});
+		const values = /* @__PURE__ */ new Set();
+		for (const log of this.logs.slice(-1e3)) {
+			var _log$level, _log$appName;
+			if ((_log$level = log.level) === null || _log$level === void 0 ? void 0 : _log$level.toLowerCase().includes(partialQuery.toLowerCase())) values.add(log.level);
+			if ((_log$appName = log.appName) === null || _log$appName === void 0 ? void 0 : _log$appName.toLowerCase().includes(partialQuery.toLowerCase())) values.add(log.appName);
+		}
+		for (const value of values) suggestions.push({
+			text: value,
+			type: "value",
+			category: "value"
+		});
+		for (const historyItem of this.searchHistory.slice(-50)) if (historyItem.toLowerCase().includes(partialQuery.toLowerCase())) suggestions.push({
+			text: historyItem,
+			type: "query_history",
+			category: "history"
+		});
+		this.suggestionCache.set(cacheKey, suggestions);
+		if (this.suggestionCache.size > (((_this$options2 = this.options) === null || _this$options2 === void 0 ? void 0 : _this$options2.cacheSize) || 100)) {
+			const firstKey = this.suggestionCache.keys().next().value;
+			if (firstKey !== void 0) this.suggestionCache.delete(firstKey);
+		}
+		return suggestions.slice(0, limit);
+	}
+	/**
+	* Get search statistics
+	*/
+	async getStats() {
+		return {
+			totalResults: this.logs.length,
+			executionTime: 0,
+			indexSize: this.logs.length,
+			topTerms: this.getTopTerms()
+		};
+	}
+	/**
+	* Parse natural language query
+	*/
+	async parseNaturalLanguageQuery(query) {
+		const filters = {};
+		const lowerQuery = query.toLowerCase();
+		const levels = [];
+		if (lowerQuery.includes("error")) levels.push("error");
+		if (lowerQuery.includes("warn")) levels.push("warn");
+		if (lowerQuery.includes("info")) levels.push("info");
+		if (levels.length > 0) filters.levels = levels;
+		const timeRange = this.extractTimeRange(query);
+		if (timeRange) filters.timeRange = timeRange;
+		const serviceMatch = query.match(/from\s+(?:the\s+)?(\w+)\s+service/i);
+		if (serviceMatch === null || serviceMatch === void 0 ? void 0 : serviceMatch[1]) filters.services = [serviceMatch[1]];
+		const userMatch = query.match(/user\s+(?:id\s+)?(\w+)/i);
+		if (userMatch === null || userMatch === void 0 ? void 0 : userMatch[1]) filters.userIds = [userMatch[1]];
+		let intent = "general_search";
+		if (lowerQuery.includes("error")) intent = "find_errors";
+		if (lowerQuery.includes("trace") || lowerQuery.includes("request")) intent = "trace_request";
+		if (lowerQuery.includes("user")) intent = "find_user_activity";
+		if (lowerQuery.includes("slow") || lowerQuery.includes("performance")) intent = "performance_analysis";
+		return {
+			originalQuery: query,
+			intent,
+			entities: [],
+			filters,
+			confidence: .7
+		};
+	}
+	/**
+	* Save a search preset
+	*/
+	async savePreset(preset) {
+		const id = this.generateId();
+		const now = /* @__PURE__ */ new Date();
+		const fullPreset = {
+			...preset,
+			id,
+			createdAt: now,
+			updatedAt: now
+		};
+		this.presets.set(id, fullPreset);
+		return fullPreset;
+	}
+	/**
+	* Get saved presets
+	*/
+	async getPresets(userId) {
+		const allPresets = Array.from(this.presets.values());
+		if (userId) return allPresets.filter((p) => p.userId === userId || p.shared);
+		return allPresets;
+	}
+	/**
+	* Delete a preset
+	*/
+	async deletePreset(presetId) {
+		this.presets.delete(presetId);
+	}
+	applyFilters(logs, filters) {
+		if (!filters) return logs;
+		return logs.filter((log) => {
+			if (filters.levels && !filters.levels.includes(log.level)) return false;
+			if (filters.services && !filters.services.includes(log.appName)) return false;
+			if (filters.traceIds && log.traceId && !filters.traceIds.includes(log.traceId)) return false;
+			if (filters.timeRange) {
+				const logTime = new Date(log.timestamp).getTime();
+				if (logTime < (typeof filters.timeRange.start === "number" ? filters.timeRange.start : filters.timeRange.start.getTime())) return false;
+				if (filters.timeRange.end) {
+					if (logTime > (typeof filters.timeRange.end === "number" ? filters.timeRange.end : filters.timeRange.end.getTime())) return false;
+				}
+			}
+			if (filters.hasError !== void 0) {
+				const hasError = log.level === "error" || !!log.error;
+				if (filters.hasError !== hasError) return false;
+			}
+			if (filters.contexts && log.context && !filters.contexts.includes(log.context)) return false;
+			return true;
+		});
+	}
+	performTextSearch(logs, query, options) {
+		if (!query) return logs.map((log) => ({
+			log,
+			score: 1
+		}));
+		const queryTerms = query.toLowerCase().split(/\s+/);
+		const results = [];
+		for (const log of logs) {
+			const searchableText = this.getSearchableText(log).toLowerCase();
+			let score = 0;
+			const highlights = [];
+			const matchedTerms = [];
+			for (const term of queryTerms) if (searchableText.includes(term)) {
+				score += 1;
+				matchedTerms.push(term);
+			}
+			if (score > 0) {
+				if (options === null || options === void 0 ? void 0 : options.highlightMatches) highlights.push({
+					field: "message",
+					fragments: this.getHighlightFragments(log.message, matchedTerms),
+					matchedTerms
+				});
+				const result = {
+					log,
+					score: score / queryTerms.length
+				};
+				if (highlights.length > 0) result.highlights = highlights;
+				results.push(result);
+			}
+		}
+		return results;
+	}
+	getSearchableText(log) {
+		const payloadText = log.payload ? require_coerce_utils.safeToString(log.payload) : "";
+		return [
+			log.message,
+			log.level,
+			log.appName,
+			log.context,
+			payloadText
+		].filter(Boolean).join(" ");
+	}
+	getHighlightFragments(text, terms) {
+		const fragments = [];
+		const lowerText = text.toLowerCase();
+		for (const term of terms) {
+			const index = lowerText.indexOf(term);
+			if (index !== -1) {
+				const start = Math.max(0, index - 30);
+				const end = Math.min(text.length, index + term.length + 30);
+				fragments.push(text.slice(start, end));
+			}
+		}
+		return fragments;
+	}
+	applySorting(results, sortBy, sortOrder = "desc") {
+		const sorted = [...results];
+		sorted.sort((a, b) => {
+			let comparison;
+			switch (sortBy) {
+				case "timestamp":
+					comparison = new Date(a.log.timestamp).getTime() - new Date(b.log.timestamp).getTime();
+					break;
+				case "level":
+					comparison = a.log.level.localeCompare(b.log.level);
+					break;
+				case "score":
+				case "relevance":
+				default:
+					comparison = a.score - b.score;
+					break;
+			}
+			return sortOrder === "asc" ? comparison : -comparison;
+		});
+		return sorted;
+	}
+	applyPagination(results, offset = 0, limit = 100) {
+		return results.slice(offset, offset + limit);
+	}
+	async enrichWithContext(results, contextSize = 5) {
+		for (const result of results) {
+			const logIndex = this.logs.indexOf(result.log);
+			if (logIndex !== -1) {
+				const start = Math.max(0, logIndex - contextSize);
+				const end = Math.min(this.logs.length, logIndex + contextSize + 1);
+				result.context = this.logs.slice(start, end).filter((l) => l !== result.log);
+			}
+		}
+	}
+	calculateSimilarity(log1, log2) {
+		let score = 0;
+		let factors = 0;
+		if (log1.level === log2.level) score += .3;
+		factors++;
+		if (log1.appName === log2.appName) score += .2;
+		factors++;
+		if (log1.traceId && log1.traceId === log2.traceId) score += .3;
+		factors++;
+		const messageSimilarity = this.calculateTextSimilarity(log1.message, log2.message);
+		score += messageSimilarity * .2;
+		factors++;
+		return score / factors;
+	}
+	calculateTextSimilarity(text1, text2) {
+		const words1 = new Set(text1.toLowerCase().split(/\s+/));
+		const words2 = new Set(text2.toLowerCase().split(/\s+/));
+		const intersection = new Set([...words1].filter((x) => words2.has(x)));
+		const union = new Set([...words1, ...words2]);
+		return union.size > 0 ? intersection.size / union.size : 0;
+	}
+	findMatchedPatterns(log1, log2) {
+		const patterns = [];
+		if (log1.level === log2.level) patterns.push("same_level");
+		if (log1.appName === log2.appName) patterns.push("same_service");
+		if (log1.traceId === log2.traceId) patterns.push("same_trace");
+		if (log1.context === log2.context) patterns.push("same_context");
+		return patterns;
+	}
+	generateSimilarityReason(log1, log2, similarity) {
+		const reasons = [];
+		if (log1.level === log2.level) reasons.push("same log level");
+		if (log1.appName === log2.appName) reasons.push("same service");
+		if (log1.traceId === log2.traceId) reasons.push("same trace ID");
+		return reasons.length > 0 ? `Similar because: ${reasons.join(", ")}` : `${Math.round(similarity * 100)}% content similarity`;
+	}
+	extractTimeRange(query) {
+		const lowerQuery = query.toLowerCase();
+		if (lowerQuery.includes("last hour") || lowerQuery.includes("past hour")) return { start: /* @__PURE__ */ new Date(Date.now() - 3600 * 1e3) };
+		const hoursMatch = query.match(/last\s+(\d+)\s+hours?/i);
+		if (hoursMatch) return { start: /* @__PURE__ */ new Date(Date.now() - Number.parseInt(hoursMatch[1] ?? "0") * 60 * 60 * 1e3) };
+		if (lowerQuery.includes("today")) {
+			const today = /* @__PURE__ */ new Date();
+			today.setHours(0, 0, 0, 0);
+			return { start: today };
+		}
+	}
+	addToSearchHistory(query) {
+		var _this$options3;
+		this.searchHistory.push(query);
+		const maxSize = ((_this$options3 = this.options) === null || _this$options3 === void 0 ? void 0 : _this$options3.maxHistorySize) || 1e3;
+		if (this.searchHistory.length > maxSize) this.searchHistory = this.searchHistory.slice(-maxSize);
+	}
+	getTopTerms() {
+		const termCounts = /* @__PURE__ */ new Map();
+		for (const log of this.logs.slice(-1e3)) {
+			const words = log.message.toLowerCase().split(/\s+/);
+			for (const word of words) if (word.length > 3) termCounts.set(word, (termCounts.get(word) || 0) + 1);
+		}
+		return Array.from(termCounts.entries()).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([term]) => term);
+	}
+	generateId() {
+		return `preset_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+	}
+};
+
+//#endregion
+//#region src/search/engines/correlation-engine.ts
+/**
+* Correlation engine for log analysis
+*/
+var CorrelationEngine = class {
+	constructor(options) {
+		this.options = options;
+		this.options = {
+			maxCorrelationDistance: 100,
+			temporalWindowMs: 300 * 1e3,
+			minSimilarityScore: .3,
+			...options
+		};
+	}
+	/**
+	* Find logs related to a given log entry
+	*/
+	async findRelatedLogs(log, allLogs, limit = 50) {
+		const related = [];
+		for (const otherLog of allLogs) {
+			if (otherLog === log) continue;
+			const relationships = this.findRelationships(log, otherLog);
+			for (const relationship of relationships) {
+				var _this$options;
+				const score = this.calculateRelationshipScore(relationship, log, otherLog);
+				if (score > (((_this$options = this.options) === null || _this$options === void 0 ? void 0 : _this$options.minSimilarityScore) || .3)) related.push({
+					log: otherLog,
+					relationship,
+					score
+				});
+			}
+		}
+		return this.deduplicateRelatedLogs(related).sort((a, b) => b.score - a.score).slice(0, limit);
+	}
+	/**
+	* Correlate logs by multiple criteria
+	*/
+	async correlateByMultipleCriteria(logs, criteria) {
+		const correlations = /* @__PURE__ */ new Map();
+		if (criteria.traceId) {
+			const traceCorrelations = this.correlateByTraceId(logs);
+			for (const [key, value] of traceCorrelations) correlations.set(`trace_${key}`, value);
+		}
+		if (criteria.userId) {
+			const userCorrelations = this.correlateByUserId(logs);
+			for (const [key, value] of userCorrelations) correlations.set(`user_${key}`, value);
+		}
+		if (criteria.sessionId) {
+			const sessionCorrelations = this.correlateBySessionId(logs);
+			for (const [key, value] of sessionCorrelations) correlations.set(`session_${key}`, value);
+		}
+		if (criteria.temporal) {
+			const temporalCorrelations = this.correlateByTemporalProximity(logs);
+			for (const [key, value] of temporalCorrelations) correlations.set(`temporal_${key}`, value);
+		}
+		if (criteria.errorCascade) {
+			const errorCorrelations = this.correlateErrorCascades(logs);
+			for (const [key, value] of errorCorrelations) correlations.set(`error_${key}`, value);
+		}
+		return correlations;
+	}
+	/**
+	* Build a timeline from correlated logs
+	*/
+	buildTimeline(logs) {
+		const timeline = [];
+		const sortedLogs = [...logs].sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+		for (let i = 0; i < sortedLogs.length; i++) {
+			const log = sortedLogs[i];
+			const eventType = this.determineEventType(log, sortedLogs, i);
+			const event = {
+				timestamp: new Date(log.timestamp),
+				log,
+				eventType
+			};
+			if (eventType === "start" && i < sortedLogs.length - 1) {
+				const endEvent = sortedLogs.slice(i + 1).find((l) => this.determineEventType(l, sortedLogs, sortedLogs.indexOf(l)) === "end");
+				if (endEvent) event.duration = new Date(endEvent.timestamp).getTime() - new Date(log.timestamp).getTime();
+			}
+			timeline.push(event);
+		}
+		return timeline;
+	}
+	/**
+	* Analyze error cascades
+	*/
+	async analyzeErrorCascade(logs) {
+		const errors = logs.filter((log) => log.level === "error");
+		if (errors.length === 0) return {
+			cascade: [],
+			impactedServices: []
+		};
+		const rootCause = errors.reduce((earliest, current) => new Date(current.timestamp) < new Date(earliest.timestamp) ? current : earliest);
+		const cascade = this.buildErrorCascade(rootCause, errors);
+		return {
+			rootCause,
+			cascade,
+			impactedServices: [...new Set(cascade.map((log) => log.appName))]
+		};
+	}
+	correlateByTraceId(logs) {
+		const correlations = /* @__PURE__ */ new Map();
+		for (const log of logs) {
+			if (!log.traceId) continue;
+			if (!correlations.has(log.traceId)) correlations.set(log.traceId, []);
+			correlations.get(log.traceId).push(log);
+		}
+		return this.convertToCorrelatedLogs(correlations, "trace");
+	}
+	correlateByUserId(logs) {
+		const correlations = /* @__PURE__ */ new Map();
+		for (const log of logs) {
+			var _log$payload;
+			const userId = (_log$payload = log.payload) === null || _log$payload === void 0 ? void 0 : _log$payload.userId;
+			if (!userId) continue;
+			if (!correlations.has(userId)) correlations.set(userId, []);
+			correlations.get(userId).push(log);
+		}
+		return this.convertToCorrelatedLogs(correlations, "user");
+	}
+	correlateBySessionId(logs) {
+		const correlations = /* @__PURE__ */ new Map();
+		for (const log of logs) {
+			var _log$payload2;
+			const sessionId = (_log$payload2 = log.payload) === null || _log$payload2 === void 0 ? void 0 : _log$payload2.sessionId;
+			if (!sessionId) continue;
+			if (!correlations.has(sessionId)) correlations.set(sessionId, []);
+			correlations.get(sessionId).push(log);
+		}
+		return this.convertToCorrelatedLogs(correlations, "session");
+	}
+	correlateByTemporalProximity(logs) {
+		const correlations = /* @__PURE__ */ new Map();
+		const sortedLogs = [...logs].sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+		let currentGroup = [];
+		let groupStartTime = null;
+		for (const log of sortedLogs) {
+			var _this$options2;
+			const logTime = new Date(log.timestamp).getTime();
+			if (groupStartTime === null) {
+				groupStartTime = logTime;
+				currentGroup = [log];
+			} else if (logTime - groupStartTime <= (((_this$options2 = this.options) === null || _this$options2 === void 0 ? void 0 : _this$options2.temporalWindowMs) || 3e5)) currentGroup.push(log);
+			else {
+				if (currentGroup.length > 1) {
+					const groupKey = `${groupStartTime}`;
+					correlations.set(groupKey, currentGroup);
+				}
+				groupStartTime = logTime;
+				currentGroup = [log];
+			}
+		}
+		if (currentGroup.length > 1 && groupStartTime !== null) correlations.set(`${groupStartTime}`, currentGroup);
+		return this.convertToCorrelatedLogs(correlations, "temporal");
+	}
+	correlateErrorCascades(logs) {
+		const correlations = /* @__PURE__ */ new Map();
+		const errors = logs.filter((log) => log.level === "error");
+		for (const error of errors) {
+			const cascade = this.buildErrorCascade(error, logs);
+			if (cascade.length > 1) {
+				const key = `${error.timestamp}_${error.message.slice(0, 20)}`;
+				correlations.set(key, cascade);
+			}
+		}
+		return this.convertToCorrelatedLogs(correlations, "error_cascade");
+	}
+	buildErrorCascade(rootError, allLogs) {
+		var _this$options3;
+		const cascade = [rootError];
+		const rootTime = new Date(rootError.timestamp).getTime();
+		const windowMs = ((_this$options3 = this.options) === null || _this$options3 === void 0 ? void 0 : _this$options3.temporalWindowMs) || 3e5;
+		for (const log of allLogs) {
+			if (log === rootError) continue;
+			const timeDiff = new Date(log.timestamp).getTime() - rootTime;
+			if (timeDiff > 0 && timeDiff <= windowMs && (log.level === "error" || log.level === "warn") && (log.traceId === rootError.traceId || log.appName === rootError.appName)) cascade.push(log);
+		}
+		return cascade.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+	}
+	findRelationships(log1, log2) {
+		var _log1$payload, _log2$payload, _log1$payload2, _log2$payload2, _this$options4, _this$options5;
+		const relationships = [];
+		if (log1.traceId && log1.traceId === log2.traceId) relationships.push("same_trace");
+		const user1 = (_log1$payload = log1.payload) === null || _log1$payload === void 0 ? void 0 : _log1$payload.userId;
+		const user2 = (_log2$payload = log2.payload) === null || _log2$payload === void 0 ? void 0 : _log2$payload.userId;
+		if (user1 && user1 === user2) relationships.push("same_user");
+		const session1 = (_log1$payload2 = log1.payload) === null || _log1$payload2 === void 0 ? void 0 : _log1$payload2.sessionId;
+		const session2 = (_log2$payload2 = log2.payload) === null || _log2$payload2 === void 0 ? void 0 : _log2$payload2.sessionId;
+		if (session1 && session1 === session2) relationships.push("same_session");
+		const time1 = new Date(log1.timestamp).getTime();
+		const time2 = new Date(log2.timestamp).getTime();
+		if (Math.abs(time1 - time2) <= (((_this$options4 = this.options) === null || _this$options4 === void 0 ? void 0 : _this$options4.temporalWindowMs) || 3e5)) relationships.push("temporal_proximity");
+		if ((log1.level === "error" || log2.level === "error") && time2 > time1 && time2 - time1 <= (((_this$options5 = this.options) === null || _this$options5 === void 0 ? void 0 : _this$options5.temporalWindowMs) || 3e5)) relationships.push("error_cascade");
+		if (this.haveSimilarPattern(log1, log2)) relationships.push("similar_pattern");
+		return relationships;
+	}
+	calculateRelationshipScore(relationship, log1, log2) {
+		let score = {
+			same_trace: .9,
+			same_user: .7,
+			same_session: .8,
+			temporal_proximity: .4,
+			error_cascade: .8,
+			similar_pattern: .5
+		}[relationship] || .3;
+		if (log1.appName === log2.appName) score += .1;
+		return Math.min(score, 1);
+	}
+	haveSimilarPattern(log1, log2) {
+		return this.normalizeMessage(log1.message) === this.normalizeMessage(log2.message);
+	}
+	normalizeMessage(message) {
+		return message.replace(/\d+/g, "<NUM>").replace(/[a-f0-9-]{36}/gi, "<UUID>").toLowerCase().trim();
+	}
+	determineEventType(log, _allLogs, _index) {
+		const message = log.message.toLowerCase();
+		if (message.includes("start") || message.includes("begin") || message.includes("initiated")) return "start";
+		if (message.includes("end") || message.includes("complete") || message.includes("finished")) return "end";
+		if (log.level === "error") return "error";
+		if (message.includes("milestone") || message.includes("checkpoint")) return "milestone";
+		return "info";
+	}
+	deduplicateRelatedLogs(related) {
+		const seen = /* @__PURE__ */ new Set();
+		const unique = [];
+		for (const item of related) if (!seen.has(item.log)) {
+			seen.add(item.log);
+			unique.push(item);
+		}
+		return unique;
+	}
+	convertToCorrelatedLogs(correlations, type) {
+		const result = /* @__PURE__ */ new Map();
+		for (const [key, logs] of correlations.entries()) {
+			if (logs.length < 2) continue;
+			const timeline = this.buildTimeline(logs);
+			const summary = this.generateSummary(logs);
+			result.set(key, {
+				correlationKey: key,
+				...type === "trace" ? { traceId: key } : {},
+				logs,
+				timeline,
+				summary
+			});
+		}
+		return result;
+	}
+	generateSummary(logs) {
+		const errorCount = logs.filter((l) => l.level === "error").length;
+		const warningCount = logs.filter((l) => l.level === "warn").length;
+		const services = [...new Set(logs.map((l) => l.appName))];
+		let duration;
+		if (logs.length > 1) {
+			const sorted = [...logs].sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+			const start = new Date(sorted[0].timestamp).getTime();
+			duration = new Date(sorted[sorted.length - 1].timestamp).getTime() - start;
+		}
+		return {
+			totalLogs: logs.length,
+			errorCount,
+			warningCount,
+			services,
+			...duration !== void 0 ? { duration } : {}
+		};
+	}
+};
+
+//#endregion
+//#region src/search/engines/nlp-search-engine.ts
+/**
+* NLP-enhanced search engine
+*/
+var NLPSearchEngine = class extends BasicSearchEngine {
+	constructor(options) {
+		super(options);
+		this.initializePatterns();
+	}
+	/**
+	* Enhanced natural language query parsing
+	*/
+	async parseNaturalLanguageQuery(query) {
+		const entities = [];
+		const filters = {};
+		const intent = this.detectIntent(query);
+		const extractedEntities = this.extractEntities(query);
+		entities.push(...extractedEntities);
+		for (const entity of entities) this.applyEntityToFilter(entity, filters);
+		const timeRange = this.extractAdvancedTimeRange(query);
+		if (timeRange) filters.timeRange = timeRange;
+		const confidence = this.calculateConfidence(intent, entities, query);
+		return {
+			originalQuery: query,
+			intent,
+			entities,
+			filters,
+			...timeRange !== void 0 ? { timeRange } : {},
+			confidence
+		};
+	}
+	/**
+	* Enhanced natural language search
+	*/
+	async naturalLanguageSearch(query) {
+		const parsed = await this.parseNaturalLanguageQuery(query);
+		const options = this.getOptionsForIntent(parsed.intent);
+		const cleanQuery = this.extractCleanQuery(query, parsed.entities);
+		return this.search(cleanQuery, parsed.filters, options);
+	}
+	initializePatterns() {
+		this.intentPatterns = new Map([
+			["find_errors", [
+				/show.*errors?/i,
+				/find.*errors?/i,
+				/all.*errors?/i,
+				/errors?\s+(?:in|from|for)/i,
+				/what.*went wrong/i,
+				/failures?/i
+			]],
+			["trace_request", [
+				/trace\s+(?:request|id)/i,
+				/follow\s+request/i,
+				/track\s+request/i,
+				/request\s+(?:flow|path)/i,
+				/trace.*across/i
+			]],
+			["find_user_activity", [
+				/user\s+(?:\w+|id)/i,
+				/activity\s+(?:for|of)\s+user/i,
+				/what\s+did\s+user/i,
+				/user\s+journey/i,
+				/user\s+session/i
+			]],
+			["performance_analysis", [
+				/slow\s+(?:queries?|requests?|operations?)/i,
+				/performance\s+issues?/i,
+				/latency/i,
+				/response\s+time/i,
+				/took\s+(?:too\s+)?long/i
+			]],
+			["time_range_query", [
+				/(?:in|during|from)\s+the\s+last/i,
+				/(?:today|yesterday|this\s+week)/i,
+				/between.*and/i,
+				/in\s+the\s+past/i
+			]],
+			["correlation", [
+				/related\s+to/i,
+				/connected\s+with/i,
+				/caused\s+by/i,
+				/before.*happened/i,
+				/after.*occurred/i
+			]]
+		]);
+		this.entityPatterns = new Map([
+			["level", /(error|warn|warning|info|debug|trace|verbose)/i],
+			["service", /(?:from|in)\s+(?:the\s+)?(\w+)\s+(?:service|app|application)/i],
+			["user_id", /user\s+(?:id\s+)?['"]?(\w+)['"]?/i],
+			["trace_id", /trace\s+(?:id\s+)?['"]?([\w-]+)['"]?/i],
+			["time", /(?:last|past|previous)\s+(\d+)\s+(second|minute|hour|day|week)s?/i],
+			["error_type", /(\w+Error|\w+Exception)/i]
+		]);
+	}
+	detectIntent(query) {
+		let maxScore = 0;
+		let detectedIntent = "general_search";
+		for (const [intent, patterns] of this.intentPatterns.entries()) {
+			let score = 0;
+			for (const pattern of patterns) if (pattern.test(query)) score++;
+			if (score > maxScore) {
+				maxScore = score;
+				detectedIntent = intent;
+			}
+		}
+		return detectedIntent;
+	}
+	extractEntities(query) {
+		const entities = [];
+		for (const [type, pattern] of this.entityPatterns.entries()) {
+			const matches = query.matchAll(new RegExp(pattern, "gi"));
+			for (const match of matches) {
+				const value = match[1] || match[0];
+				entities.push({
+					type,
+					value: value.trim(),
+					confidence: .8
+				});
+			}
+		}
+		return entities;
+	}
+	applyEntityToFilter(entity, filters) {
+		switch (entity.type) {
+			case "level":
+				if (!filters.levels) filters.levels = [];
+				filters.levels.push(entity.value.toLowerCase());
+				break;
+			case "service":
+				if (!filters.services) filters.services = [];
+				filters.services.push(entity.value);
+				break;
+			case "user_id":
+				if (!filters.userIds) filters.userIds = [];
+				filters.userIds.push(entity.value);
+				break;
+			case "trace_id":
+				if (!filters.traceIds) filters.traceIds = [];
+				filters.traceIds.push(entity.value);
+				break;
+			case "error_type": break;
+		}
+	}
+	extractAdvancedTimeRange(query) {
+		const lowerQuery = query.toLowerCase();
+		for (const { pattern, unit } of [
+			{
+				pattern: /last\s+(\d+)\s+second/i,
+				unit: "seconds"
+			},
+			{
+				pattern: /last\s+(\d+)\s+minute/i,
+				unit: "minutes"
+			},
+			{
+				pattern: /last\s+(\d+)\s+hour/i,
+				unit: "hours"
+			},
+			{
+				pattern: /last\s+(\d+)\s+day/i,
+				unit: "days"
+			}
+		]) {
+			const match = query.match(pattern);
+			if (match) {
+				const value = Number.parseInt(match[1] ?? "0");
+				const multiplier = {
+					seconds: 1e3,
+					minutes: 60 * 1e3,
+					hours: 3600 * 1e3,
+					days: 1440 * 60 * 1e3
+				}[unit];
+				return {
+					start: new Date(Date.now() - value * multiplier),
+					relative: {
+						value,
+						unit
+					}
+				};
+			}
+		}
+		if (lowerQuery.includes("today")) {
+			const today = /* @__PURE__ */ new Date();
+			today.setHours(0, 0, 0, 0);
+			return { start: today };
+		}
+		if (lowerQuery.includes("yesterday")) {
+			const yesterday = /* @__PURE__ */ new Date();
+			yesterday.setDate(yesterday.getDate() - 1);
+			yesterday.setHours(0, 0, 0, 0);
+			const endOfYesterday = new Date(yesterday);
+			endOfYesterday.setHours(23, 59, 59, 999);
+			return {
+				start: yesterday,
+				end: endOfYesterday
+			};
+		}
+		if (lowerQuery.includes("this week")) {
+			const now = /* @__PURE__ */ new Date();
+			const startOfWeek = new Date(now);
+			startOfWeek.setDate(now.getDate() - now.getDay());
+			startOfWeek.setHours(0, 0, 0, 0);
+			return { start: startOfWeek };
+		}
+	}
+	calculateConfidence(intent, entities, query) {
+		let confidence = .5;
+		if (intent !== "general_search") confidence += .2;
+		confidence += Math.min(entities.length * .1, .3);
+		const wordCount = query.split(/\s+/).length;
+		if (wordCount < 3 || wordCount > 20) confidence -= .1;
+		return Math.max(0, Math.min(1, confidence));
+	}
+	getOptionsForIntent(intent) {
+		const baseOptions = {
+			limit: 100,
+			highlightMatches: true
+		};
+		switch (intent) {
+			case "find_errors": return {
+				...baseOptions,
+				includeContext: true,
+				contextSize: 3,
+				findSimilar: true
+			};
+			case "trace_request": return {
+				...baseOptions,
+				includeContext: true,
+				contextSize: 10,
+				correlate: true,
+				sortBy: "timestamp",
+				sortOrder: "asc"
+			};
+			case "find_user_activity": return {
+				...baseOptions,
+				includeContext: true,
+				sortBy: "timestamp",
+				sortOrder: "asc",
+				limit: 200
+			};
+			case "performance_analysis": return {
+				...baseOptions,
+				includeContext: true,
+				contextSize: 5,
+				sortBy: "timestamp"
+			};
+			case "correlation": return {
+				...baseOptions,
+				includeContext: true,
+				contextSize: 5,
+				correlate: true,
+				findSimilar: true
+			};
+			default: return baseOptions;
+		}
+	}
+	extractCleanQuery(query, entities) {
+		let cleanQuery = query;
+		for (const entity of entities) cleanQuery = cleanQuery.replace(new RegExp(`\\b${entity.value}\\b`, "gi"), "");
+		for (const word of [
+			"show",
+			"find",
+			"get",
+			"all",
+			"from",
+			"in",
+			"the",
+			"for",
+			"with",
+			"last",
+			"past",
+			"today",
+			"yesterday",
+			"service",
+			"user",
+			"trace",
+			"error",
+			"errors"
+		]) cleanQuery = cleanQuery.replace(new RegExp(`\\b${word}\\b`, "gi"), "");
+		cleanQuery = cleanQuery.replace(/\s+/g, " ").trim();
+		return cleanQuery || query;
+	}
+};
+
+//#endregion
+//#region src/search/engines/pattern-recognition-engine.ts
+/**
+* Pattern recognition engine for log analysis
+*/
+var PatternRecognitionEngine = class {
+	constructor(options) {
+		this.options = options;
+		this.patterns = /* @__PURE__ */ new Map();
+		this.patternFrequencies = /* @__PURE__ */ new Map();
+		this.options = {
+			minFrequency: 3,
+			maxPatterns: 1e3,
+			anomalyThreshold: .3,
+			...options
+		};
+	}
+	/**
+	* Analyze logs and detect patterns
+	*/
+	async analyzePatterns(logs) {
+		var _this$options2;
+		const messagePatterns = this.extractMessagePatterns(logs);
+		const errorPatterns = this.extractErrorPatterns(logs);
+		const timingPatterns = this.extractTimingPatterns(logs);
+		const frequentPatterns = [
+			...messagePatterns,
+			...errorPatterns,
+			...timingPatterns
+		].filter((p) => {
+			var _this$options;
+			return p.frequency >= (((_this$options = this.options) === null || _this$options === void 0 ? void 0 : _this$options.minFrequency) || 3);
+		});
+		frequentPatterns.sort((a, b) => b.frequency - a.frequency);
+		const limitedPatterns = frequentPatterns.slice(0, ((_this$options2 = this.options) === null || _this$options2 === void 0 ? void 0 : _this$options2.maxPatterns) || 1e3);
+		for (const pattern of limitedPatterns) this.patterns.set(pattern.id, pattern);
+		return limitedPatterns;
+	}
+	/**
+	* Detect anomalies in logs
+	*/
+	async detectAnomalies(logs) {
+		const anomalies = [];
+		for (const log of logs) {
+			var _this$options3;
+			const anomalyScore = await this.calculateAnomalyScore(log);
+			if (anomalyScore > (((_this$options3 = this.options) === null || _this$options3 === void 0 ? void 0 : _this$options3.anomalyThreshold) || .3)) anomalies.push({
+				log,
+				anomalyScore,
+				reason: this.generateAnomalyReason(log, anomalyScore),
+				deviations: this.findDeviations(log)
+			});
+		}
+		return anomalies.sort((a, b) => b.anomalyScore - a.anomalyScore);
+	}
+	/**
+	* Find patterns matching a log entry
+	*/
+	findMatchingPatterns(log) {
+		const matching = [];
+		for (const pattern of this.patterns.values()) if (this.doesLogMatchPattern(log, pattern)) matching.push(pattern);
+		return matching;
+	}
+	/**
+	* Get all detected patterns
+	*/
+	getPatterns() {
+		return Array.from(this.patterns.values());
+	}
+	/**
+	* Get pattern by ID
+	*/
+	getPattern(patternId) {
+		return this.patterns.get(patternId);
+	}
+	extractMessagePatterns(logs) {
+		const patternMap = /* @__PURE__ */ new Map();
+		for (const log of logs) {
+			const normalizedMessage = this.normalizeMessage(log.message);
+			if (!patternMap.has(normalizedMessage)) patternMap.set(normalizedMessage, {
+				examples: [],
+				count: 0
+			});
+			const pattern = patternMap.get(normalizedMessage);
+			if (pattern.examples.length < 3) pattern.examples.push(log);
+			pattern.count++;
+		}
+		return Array.from(patternMap.entries()).map(([pattern, data], index) => {
+			var _data$examples;
+			return {
+				id: `msg_pattern_${index}`,
+				pattern,
+				examples: data.examples,
+				frequency: data.count,
+				lastSeen: ((_data$examples = data.examples[data.examples.length - 1]) === null || _data$examples === void 0 ? void 0 : _data$examples.timestamp) ? new Date(data.examples[data.examples.length - 1].timestamp) : /* @__PURE__ */ new Date(),
+				category: "message"
+			};
+		});
+	}
+	extractErrorPatterns(logs) {
+		const errorLogs = logs.filter((log) => log.level === "error" || log.error);
+		const patternMap = /* @__PURE__ */ new Map();
+		for (const log of errorLogs) {
+			const errorPattern = this.extractErrorPattern(log);
+			if (!patternMap.has(errorPattern)) patternMap.set(errorPattern, {
+				examples: [],
+				count: 0
+			});
+			const pattern = patternMap.get(errorPattern);
+			if (pattern.examples.length < 3) pattern.examples.push(log);
+			pattern.count++;
+		}
+		return Array.from(patternMap.entries()).map(([pattern, data], index) => {
+			var _data$examples2;
+			return {
+				id: `error_pattern_${index}`,
+				pattern,
+				examples: data.examples,
+				frequency: data.count,
+				lastSeen: ((_data$examples2 = data.examples[data.examples.length - 1]) === null || _data$examples2 === void 0 ? void 0 : _data$examples2.timestamp) ? new Date(data.examples[data.examples.length - 1].timestamp) : /* @__PURE__ */ new Date(),
+				category: "error",
+				severity: "high"
+			};
+		});
+	}
+	extractTimingPatterns(logs) {
+		const patterns = [];
+		const hourCounts = /* @__PURE__ */ new Map();
+		for (const log of logs) {
+			const hour = new Date(log.timestamp).getHours();
+			hourCounts.set(hour, (hourCounts.get(hour) || 0) + 1);
+		}
+		const peakHour = Array.from(hourCounts.entries()).sort((a, b) => b[1] - a[1])[0];
+		if (peakHour) patterns.push({
+			id: "timing_peak",
+			pattern: `Peak activity at hour ${peakHour[0]}`,
+			examples: logs.slice(0, 3),
+			frequency: peakHour[1],
+			lastSeen: /* @__PURE__ */ new Date(),
+			category: "timing"
+		});
+		return patterns;
+	}
+	normalizeMessage(message) {
+		return message.replace(/\d+/g, "<NUM>").replace(/[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}/gi, "<UUID>").replace(/[a-f0-9]{32}/gi, "<HASH>").replace(/"[^"]*"/g, "<STRING>").replace(/\b\w+@\w+\.\w+\b/g, "<EMAIL>").trim();
+	}
+	extractErrorPattern(log) {
+		if (log.error) return `${log.error.name}: ${this.normalizeMessage(log.error.message || "")}`;
+		return this.normalizeMessage(log.message);
+	}
+	async calculateAnomalyScore(log) {
+		let score = 0;
+		if (this.findMatchingPatterns(log).length === 0) score += .3;
+		if (log.level === "error") {
+			const errorPattern = this.extractErrorPattern(log);
+			if ((this.patternFrequencies.get(errorPattern) || 0) < 2) score += .3;
+		}
+		const hour = new Date(log.timestamp).getHours();
+		if (hour < 6 || hour > 22) score += .2;
+		return Math.min(score, 1);
+	}
+	generateAnomalyReason(log, score) {
+		const reasons = [];
+		if (score > .7) reasons.push("Highly unusual log entry");
+		else if (score > .5) reasons.push("Moderately unusual log entry");
+		else reasons.push("Slightly unusual log entry");
+		if (this.findMatchingPatterns(log).length === 0) reasons.push("does not match any known patterns");
+		if (log.level === "error") reasons.push("rare error type");
+		const hour = new Date(log.timestamp).getHours();
+		if (hour < 6 || hour > 22) reasons.push("occurred during off-hours");
+		return reasons.join(", ");
+	}
+	findDeviations(log) {
+		const deviations = [];
+		if (!log.traceId) deviations.push("Missing trace ID");
+		if (!log.context) deviations.push("Missing context");
+		if (log.payload && Object.keys(log.payload).length > 20) deviations.push("Unusually large payload");
+		if (log.level !== "error" && log.message.includes("at ")) deviations.push("Stack trace in non-error log");
+		return deviations;
+	}
+	doesLogMatchPattern(log, pattern) {
+		const normalizedMessage = this.normalizeMessage(log.message);
+		if (pattern.regex) return pattern.regex.test(log.message);
+		return normalizedMessage === pattern.pattern;
+	}
+};
+
+//#endregion
+//#region src/search/search-manager.ts
+/**
+* Main search manager class
+*/
+var SearchManager = class {
+	constructor(config) {
+		this.config = {
+			enableNLP: true,
+			enablePatternRecognition: true,
+			enableCorrelation: true,
+			maxIndexSize: 1e6,
+			autoOptimize: true,
+			...config
+		};
+		this.searchEngine = this.config.enableNLP ? new NLPSearchEngine() : new BasicSearchEngine();
+		this.indexer = new BasicLogIndexer({
+			maxIndexSize: this.config.maxIndexSize,
+			autoOptimize: this.config.autoOptimize
+		});
+		if (this.config.enablePatternRecognition) this.patternEngine = new PatternRecognitionEngine();
+		if (this.config.enableCorrelation) this.correlationEngine = new CorrelationEngine();
+	}
+	/**
+	* Index new logs
+	*/
+	async indexLogs(logs) {
+		await this.indexer.indexBatch(logs);
+		this.searchEngine.addLogs(logs);
+		if (this.patternEngine && logs.length > 10) await this.patternEngine.analyzePatterns(logs);
+	}
+	/**
+	* Add a single log to the index
+	*/
+	async indexLog(log) {
+		await this.indexer.indexLog(log);
+		this.searchEngine.addLogs([log]);
+	}
+	/**
+	* Perform a search
+	*/
+	async search(query, filters, options) {
+		return this.searchEngine.search(query, filters, options);
+	}
+	/**
+	* Perform a natural language search
+	*/
+	async naturalLanguageSearch(query) {
+		return this.searchEngine.naturalLanguageSearch(query);
+	}
+	/**
+	* Find logs correlated by trace ID
+	*/
+	async correlateByTraceId(traceId) {
+		return this.searchEngine.correlateByTraceId(traceId);
+	}
+	/**
+	* Find similar logs
+	*/
+	async findSimilarLogs(logEntry, limit) {
+		return this.searchEngine.findSimilarLogs(logEntry, limit);
+	}
+	/**
+	* Find logs related to a given log
+	*/
+	async findRelatedLogs(log, limit) {
+		if (!this.correlationEngine) throw new Error("Correlation engine not enabled");
+		const allLogs = this.searchEngine.getLogs();
+		return this.correlationEngine.findRelatedLogs(log, allLogs, limit);
+	}
+	/**
+	* Get search suggestions
+	*/
+	async getSuggestions(partialQuery, limit) {
+		return this.searchEngine.getSuggestions(partialQuery, limit);
+	}
+	/**
+	* Get search statistics
+	*/
+	async getStats() {
+		return this.searchEngine.getStats();
+	}
+	/**
+	* Parse natural language query
+	*/
+	async parseNaturalLanguageQuery(query) {
+		return this.searchEngine.parseNaturalLanguageQuery(query);
+	}
+	/**
+	* Save a search preset
+	*/
+	async savePreset(preset) {
+		return this.searchEngine.savePreset(preset);
+	}
+	/**
+	* Get saved presets
+	*/
+	async getPresets(userId) {
+		return this.searchEngine.getPresets(userId);
+	}
+	/**
+	* Delete a preset
+	*/
+	async deletePreset(presetId) {
+		return this.searchEngine.deletePreset(presetId);
+	}
+	/**
+	* Detect log patterns
+	*/
+	async detectPatterns() {
+		if (!this.patternEngine) throw new Error("Pattern recognition not enabled");
+		const allLogs = this.searchEngine.getLogs();
+		return this.patternEngine.analyzePatterns(allLogs);
+	}
+	/**
+	* Get detected patterns
+	*/
+	getPatterns() {
+		if (!this.patternEngine) return [];
+		return this.patternEngine.getPatterns();
+	}
+	/**
+	* Detect anomalies in logs
+	*/
+	async detectAnomalies() {
+		if (!this.patternEngine) throw new Error("Pattern recognition not enabled");
+		const allLogs = this.searchEngine.getLogs();
+		return this.patternEngine.detectAnomalies(allLogs);
+	}
+	/**
+	* Correlate logs by multiple criteria
+	*/
+	async correlateByMultipleCriteria(criteria) {
+		if (!this.correlationEngine) throw new Error("Correlation engine not enabled");
+		const allLogs = this.searchEngine.getLogs();
+		return this.correlationEngine.correlateByMultipleCriteria(allLogs, criteria);
+	}
+	/**
+	* Analyze error cascades
+	*/
+	async analyzeErrorCascade(traceId) {
+		if (!this.correlationEngine) throw new Error("Correlation engine not enabled");
+		const correlated = await this.correlateByTraceId(traceId);
+		return this.correlationEngine.analyzeErrorCascade(correlated.logs);
+	}
+	/**
+	* Export search results
+	*/
+	async exportResults(results, options) {
+		switch (options.format) {
+			case "json": return this.exportAsJSON(results, options);
+			case "csv": return this.exportAsCSV(results, options);
+			case "text": return this.exportAsText(results, options);
+			default: throw new Error(`Unsupported export format: ${options.format}`);
+		}
+	}
+	/**
+	* Clear all indexed data
+	*/
+	async clearIndex() {
+		await this.indexer.clearIndex();
+		this.searchEngine.clearLogs();
+	}
+	/**
+	* Optimize the index
+	*/
+	async optimizeIndex() {
+		await this.indexer.optimizeIndex();
+	}
+	/**
+	* Get index statistics
+	*/
+	async getIndexStats() {
+		return this.indexer.getIndexStats();
+	}
+	/**
+	* Remove old logs
+	*/
+	async removeOldLogs(olderThan) {
+		const removed = await this.indexer.removeOldLogs(olderThan);
+		const filteredLogs = this.searchEngine.getLogs().filter((log) => new Date(log.timestamp) >= olderThan);
+		this.searchEngine.clearLogs();
+		this.searchEngine.addLogs(filteredLogs);
+		return removed;
+	}
+	exportAsJSON(results, options) {
+		const data = options.includeMetadata ? results : results.map((r) => r.log);
+		if (options.fields) return JSON.stringify(data.map((item) => this.filterFields(item, options.fields)), null, 2);
+		return JSON.stringify(data, null, 2);
+	}
+	exportAsCSV(results, options) {
+		const logs = results.map((r) => r.log);
+		if (logs.length === 0) return "";
+		const fields = options.fields || [
+			"timestamp",
+			"level",
+			"appName",
+			"message"
+		];
+		return [fields.join(","), ...logs.map((log) => {
+			return fields.map((field) => {
+				const value = log[field];
+				return this.escapeCSVValue(value);
+			}).join(",");
+		})].join("\n");
+	}
+	exportAsText(results, options) {
+		return results.map((result) => {
+			const log = result.log;
+			let text = `[${log.timestamp}] [${log.level.toUpperCase()}] ${log.appName}: ${log.message}`;
+			if (options.includeMetadata) {
+				text += `\n  Score: ${result.score.toFixed(2)}`;
+				if (result.highlights) text += `\n  Matches: ${result.highlights.length}`;
+			}
+			return text;
+		}).join("\n\n");
+	}
+	filterFields(obj, fields) {
+		const filtered = {};
+		for (const field of fields) if (obj !== null && typeof obj === "object" && field in obj) filtered[field] = obj[field];
+		else if (field.includes(".")) {
+			const value = this.getNestedValue(obj, field);
+			if (value !== void 0) filtered[field] = value;
+		}
+		return filtered;
+	}
+	getNestedValue(obj, path) {
+		return path.split(".").reduce((current, key) => {
+			if (current !== null && typeof current === "object") return current[key];
+			return current;
+		}, obj);
+	}
+	escapeCSVValue(value) {
+		if (value === null || value === void 0) return "";
+		const str = typeof value === "object" ? JSON.stringify(value) : String(value);
+		if (str.includes(",") || str.includes("\n") || str.includes("\"")) return `"${str.replace(/"/g, "\"\"")}"`;
+		return str;
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'BasicLogIndexer', {
+  enumerable: true,
+  get: function () {
+    return BasicLogIndexer;
+  }
+});
+Object.defineProperty(exports, 'BasicSearchEngine', {
+  enumerable: true,
+  get: function () {
+    return BasicSearchEngine;
+  }
+});
+Object.defineProperty(exports, 'CorrelationEngine', {
+  enumerable: true,
+  get: function () {
+    return CorrelationEngine;
+  }
+});
+Object.defineProperty(exports, 'NLPSearchEngine', {
+  enumerable: true,
+  get: function () {
+    return NLPSearchEngine;
+  }
+});
+Object.defineProperty(exports, 'PatternRecognitionEngine', {
+  enumerable: true,
+  get: function () {
+    return PatternRecognitionEngine;
+  }
+});
+Object.defineProperty(exports, 'SearchManager', {
+  enumerable: true,
+  get: function () {
+    return SearchManager;
+  }
+});
+//# sourceMappingURL=search-njTI2hdo.js.map