logixia 1.12.4 → 1.12.6

package/dist/search-DujhR94O.d.ts

@@ -0,0 +1,816 @@
+import { h as LogEntry } from "./index-C1X-TE5I.js";
+
+//#region src/search/types/search.types.d.ts
+
+/**
+ * Search filter options
+ */
+interface SearchFilters {
+  levels?: string[];
+  services?: string[];
+  traceIds?: string[];
+  timeRange?: TimeRange;
+  userIds?: string[];
+  sessionIds?: string[];
+  contexts?: string[];
+  excludePatterns?: string[];
+  minSeverity?: number;
+  hasError?: boolean;
+  customFields?: Record<string, unknown>;
+}
+/**
+ * Time range for filtering logs
+ */
+interface TimeRange {
+  start: Date | number;
+  end?: Date | number;
+  relative?: RelativeTime;
+}
+/**
+ * Relative time specification
+ */
+interface RelativeTime {
+  value: number;
+  unit: 'seconds' | 'minutes' | 'hours' | 'days';
+}
+/**
+ * Search result with metadata
+ */
+interface SearchResult {
+  log: LogEntry;
+  score: number;
+  highlights?: SearchHighlight[];
+  matches?: SearchMatch[];
+  context?: LogEntry[];
+  relatedLogs?: RelatedLog[];
+}
+/**
+ * Search highlight information
+ */
+interface SearchHighlight {
+  field: string;
+  fragments: string[];
+  matchedTerms: string[];
+}
+/**
+ * Search match details
+ */
+interface SearchMatch {
+  field: string;
+  value: string;
+  position: number;
+  length: number;
+}
+/**
+ * Related log entry
+ */
+interface RelatedLog {
+  log: LogEntry;
+  relationship: RelationshipType;
+  score: number;
+}
+/**
+ * Type of relationship between logs
+ */
+type RelationshipType = 'same_trace' | 'same_user' | 'same_session' | 'temporal_proximity' | 'error_cascade' | 'similar_pattern';
+/**
+ * Correlated logs grouped by trace ID or other criteria
+ */
+interface CorrelatedLogs {
+  traceId?: string;
+  correlationKey: string;
+  logs: LogEntry[];
+  timeline: TimelineEvent[];
+  summary?: LogCorrelationSummary;
+}
+/**
+ * Timeline event for correlated logs
+ */
+interface TimelineEvent {
+  timestamp: Date;
+  log: LogEntry;
+  eventType: 'start' | 'end' | 'error' | 'milestone' | 'info';
+  duration?: number;
+}
+/**
+ * Summary of correlated logs
+ */
+interface LogCorrelationSummary {
+  totalLogs: number;
+  errorCount: number;
+  warningCount: number;
+  duration?: number;
+  services: string[];
+  criticalPath?: LogEntry[];
+}
+/**
+ * Similar log entry
+ */
+interface SimilarLog {
+  log: LogEntry;
+  similarity: number;
+  matchedPatterns: string[];
+  reason: string;
+}
+/**
+ * Search query with metadata
+ */
+interface SearchQuery {
+  query: string;
+  filters?: SearchFilters;
+  options?: SearchOptions;
+  timestamp: Date;
+  userId?: string;
+}
+/**
+ * Search options
+ */
+interface SearchOptions {
+  limit?: number;
+  offset?: number;
+  sortBy?: SortField;
+  sortOrder?: 'asc' | 'desc';
+  includeContext?: boolean;
+  contextSize?: number;
+  highlightMatches?: boolean;
+  findSimilar?: boolean;
+  correlate?: boolean;
+  semanticSearch?: boolean;
+}
+/**
+ * Sort field options
+ */
+type SortField = 'timestamp' | 'level' | 'score' | 'relevance';
+/**
+ * Search suggestion
+ */
+interface SearchSuggestion {
+  text: string;
+  type: SuggestionType;
+  category?: string;
+  frequency?: number;
+  lastUsed?: Date;
+}
+/**
+ * Suggestion type
+ */
+type SuggestionType = 'field' | 'value' | 'operator' | 'query_history' | 'pattern' | 'filter';
+/**
+ * Search statistics
+ */
+interface SearchStats {
+  totalResults: number;
+  executionTime: number;
+  indexSize: number;
+  cacheHitRate?: number;
+  topTerms?: string[];
+}
+/**
+ * Semantic index for intelligent search
+ */
+interface SemanticIndex {
+  version: string;
+  indexedCount: number;
+  lastUpdated: Date;
+  embeddings?: Map<string, number[]>;
+  clusters?: LogCluster[];
+}
+/**
+ * Log cluster for grouping similar logs
+ */
+interface LogCluster {
+  id: string;
+  centroid: number[];
+  logs: LogEntry[];
+  pattern: string;
+  frequency: number;
+  labels?: string[];
+}
+/**
+ * Log pattern for pattern recognition
+ */
+interface LogPattern {
+  id: string;
+  pattern: string;
+  regex?: RegExp;
+  examples: LogEntry[];
+  frequency: number;
+  lastSeen: Date;
+  category?: string;
+  severity?: string;
+}
+/**
+ * Anomaly detection result
+ */
+interface AnomalyDetection {
+  log: LogEntry;
+  anomalyScore: number;
+  reason: string;
+  expectedPattern?: string;
+  deviations: string[];
+}
+/**
+ * Natural language query parsed result
+ */
+interface ParsedNLQuery {
+  originalQuery: string;
+  intent: QueryIntent;
+  entities: QueryEntity[];
+  filters: SearchFilters;
+  timeRange?: TimeRange;
+  confidence: number;
+}
+/**
+ * Query intent
+ */
+type QueryIntent = 'find_errors' | 'trace_request' | 'find_user_activity' | 'performance_analysis' | 'find_similar' | 'time_range_query' | 'correlation' | 'general_search';
+/**
+ * Query entity extracted from natural language
+ */
+interface QueryEntity {
+  type: EntityType;
+  value: string;
+  field?: string;
+  confidence: number;
+}
+/**
+ * Entity type
+ */
+type EntityType = 'level' | 'service' | 'user_id' | 'trace_id' | 'time' | 'error_type' | 'field_value';
+/**
+ * Search preset for saving common searches
+ */
+interface SearchPreset {
+  id: string;
+  name: string;
+  description?: string;
+  query: string;
+  filters: SearchFilters;
+  options: SearchOptions;
+  createdAt: Date;
+  updatedAt: Date;
+  userId?: string;
+  shared?: boolean;
+}
+/**
+ * Export options for search results
+ */
+interface ExportOptions {
+  format: 'json' | 'csv' | 'text';
+  includeMetadata?: boolean;
+  filename?: string;
+  fields?: string[];
+}
+//#endregion
+//#region src/search/search-manager.d.ts
+/**
+ * Configuration for search manager
+ */
+interface SearchManagerConfig {
+  enableNLP?: boolean;
+  enablePatternRecognition?: boolean;
+  enableCorrelation?: boolean;
+  maxIndexSize?: number;
+  autoOptimize?: boolean;
+}
+/**
+ * Main search manager class
+ */
+declare class SearchManager {
+  private searchEngine;
+  private indexer;
+  private patternEngine?;
+  private correlationEngine?;
+  private config;
+  constructor(config?: SearchManagerConfig);
+  /**
+   * Index new logs
+   */
+  indexLogs(logs: LogEntry[]): Promise<void>;
+  /**
+   * Add a single log to the index
+   */
+  indexLog(log: LogEntry): Promise<void>;
+  /**
+   * Perform a search
+   */
+  search(query: string, filters?: SearchFilters, options?: SearchOptions): Promise<SearchResult[]>;
+  /**
+   * Perform a natural language search
+   */
+  naturalLanguageSearch(query: string): Promise<SearchResult[]>;
+  /**
+   * Find logs correlated by trace ID
+   */
+  correlateByTraceId(traceId: string): Promise<CorrelatedLogs>;
+  /**
+   * Find similar logs
+   */
+  findSimilarLogs(logEntry: LogEntry, limit?: number): Promise<SimilarLog[]>;
+  /**
+   * Find logs related to a given log
+   */
+  findRelatedLogs(log: LogEntry, limit?: number): Promise<RelatedLog[]>;
+  /**
+   * Get search suggestions
+   */
+  getSuggestions(partialQuery: string, limit?: number): Promise<SearchSuggestion[]>;
+  /**
+   * Get search statistics
+   */
+  getStats(): Promise<SearchStats>;
+  /**
+   * Parse natural language query
+   */
+  parseNaturalLanguageQuery(query: string): Promise<ParsedNLQuery>;
+  /**
+   * Save a search preset
+   */
+  savePreset(preset: Omit<SearchPreset, 'id' | 'createdAt' | 'updatedAt'>): Promise<SearchPreset>;
+  /**
+   * Get saved presets
+   */
+  getPresets(userId?: string): Promise<SearchPreset[]>;
+  /**
+   * Delete a preset
+   */
+  deletePreset(presetId: string): Promise<void>;
+  /**
+   * Detect log patterns
+   */
+  detectPatterns(): Promise<LogPattern[]>;
+  /**
+   * Get detected patterns
+   */
+  getPatterns(): LogPattern[];
+  /**
+   * Detect anomalies in logs
+   */
+  detectAnomalies(): Promise<AnomalyDetection[]>;
+  /**
+   * Correlate logs by multiple criteria
+   */
+  correlateByMultipleCriteria(criteria: {
+    traceId?: boolean;
+    userId?: boolean;
+    sessionId?: boolean;
+    temporal?: boolean;
+    errorCascade?: boolean;
+  }): Promise<Map<string, CorrelatedLogs>>;
+  /**
+   * Analyze error cascades
+   */
+  analyzeErrorCascade(traceId: string): Promise<{
+    rootCause?: LogEntry;
+    cascade: LogEntry[];
+    impactedServices: string[];
+  }>;
+  /**
+   * Export search results
+   */
+  exportResults(results: SearchResult[], options: ExportOptions): Promise<string>;
+  /**
+   * Clear all indexed data
+   */
+  clearIndex(): Promise<void>;
+  /**
+   * Optimize the index
+   */
+  optimizeIndex(): Promise<void>;
+  /**
+   * Get index statistics
+   */
+  getIndexStats(): Promise<{
+    totalDocuments: number;
+    indexSize: number;
+    lastOptimized?: Date;
+  }>;
+  /**
+   * Remove old logs
+   */
+  removeOldLogs(olderThan: Date): Promise<number>;
+  private exportAsJSON;
+  private exportAsCSV;
+  private exportAsText;
+  private filterFields;
+  private getNestedValue;
+  private escapeCSVValue;
+}
+//#endregion
+//#region src/search/core/log-indexer.interface.d.ts
+/**
+ * Log indexer interface
+ */
+interface ILogIndexer {
+  /**
+   * Index a single log entry
+   * @param log - Log entry to index
+   */
+  indexLog(log: LogEntry): Promise<void>;
+  /**
+   * Index multiple log entries in batch
+   * @param logs - Array of log entries to index
+   */
+  indexBatch(logs: LogEntry[]): Promise<void>;
+  /**
+   * Build semantic index for intelligent search
+   * @param logs - Array of log entries to build index from
+   * @returns Semantic index
+   */
+  buildSemanticIndex(logs: LogEntry[]): Promise<SemanticIndex>;
+  /**
+   * Update search suggestions based on search history
+   * @param searchHistory - Array of past search queries
+   */
+  updateSearchSuggestions(searchHistory: SearchQuery[]): Promise<void>;
+  /**
+   * Optimize the index for better performance
+   */
+  optimizeIndex(): Promise<void>;
+  /**
+   * Clear the index
+   */
+  clearIndex(): Promise<void>;
+  /**
+   * Get index statistics
+   * @returns Index statistics
+   */
+  getIndexStats(): Promise<{
+    totalDocuments: number;
+    indexSize: number;
+    lastOptimized?: Date;
+  }>;
+  /**
+   * Remove logs older than specified time
+   * @param olderThan - Remove logs older than this date
+   * @returns Number of logs removed
+   */
+  removeOldLogs(olderThan: Date): Promise<number>;
+}
+//#endregion
+//#region src/search/core/basic-log-indexer.d.ts
+/**
+ * Basic log indexer implementation
+ */
+declare class BasicLogIndexer implements ILogIndexer {
+  private options?;
+  private index;
+  private fieldIndices;
+  private semanticIndex;
+  private lastOptimized?;
+  /**
+   * Running estimate of the serialized index size in bytes, maintained
+   * incrementally. The previous implementation JSON.stringify'd EVERY log on
+   * each getIndexStats() call — O(n) per call, which for the default 1M-entry
+   * cap means stringifying a million objects and blocking the event loop.
+   * We keep a per-log byte estimate so the lookup is O(1).
+   */
+  private indexSizeBytes;
+  private readonly logSizeById;
+  constructor(options?: {
+    maxIndexSize?: number;
+    autoOptimize?: boolean;
+    optimizeThreshold?: number;
+  } | undefined);
+  /**
+   * Index a single log entry
+   */
+  indexLog(log: LogEntry): Promise<void>;
+  /**
+   * Index multiple log entries in batch
+   */
+  indexBatch(logs: LogEntry[]): Promise<void>;
+  /**
+   * Build semantic index for intelligent search
+   */
+  buildSemanticIndex(logs: LogEntry[]): Promise<SemanticIndex>;
+  /**
+   * Update search suggestions based on search history
+   */
+  updateSearchSuggestions(searchHistory: SearchQuery[]): Promise<void>;
+  /**
+   * Optimize the index for better performance
+   */
+  optimizeIndex(): Promise<void>;
+  /**
+   * Clear the index
+   */
+  clearIndex(): Promise<void>;
+  /**
+   * Get index statistics
+   */
+  getIndexStats(): Promise<{
+    totalDocuments: number;
+    indexSize: number;
+    lastOptimized?: Date;
+  }>;
+  /**
+   * Remove logs older than specified time
+   */
+  removeOldLogs(olderThan: Date): Promise<number>;
+  /**
+   * Search logs by field
+   */
+  searchByField(field: string, value: string): LogEntry[];
+  /**
+   * Get all indexed logs
+   */
+  getAllLogs(): LogEntry[];
+  private initializeFieldIndices;
+  private updateFieldIndices;
+  private addToFieldIndex;
+  private removeFromFieldIndices;
+  private generateLogId;
+  private calculateIndexSize;
+  /** Insert into the main index and update the running size estimate. */
+  private trackInsert;
+  /** Delete from the main index and update the running size estimate. */
+  private trackDelete;
+  private removeOldestLogs;
+  private clusterLogs;
+}
+//#endregion
+//#region src/search/core/search-engine.interface.d.ts
+/**
+ * Main search engine interface
+ */
+interface ILogSearchEngine {
+  /**
+   * Perform a full-text search across logs
+   * @param query - Search query string
+   * @param filters - Optional filters to narrow down results
+   * @param options - Search options
+   * @returns Array of search results
+   */
+  search(query: string, filters?: SearchFilters, options?: SearchOptions): Promise<SearchResult[]>;
+  /**
+   * Perform a natural language search
+   * @param query - Natural language query
+   * @returns Array of search results
+   */
+  naturalLanguageSearch(query: string): Promise<SearchResult[]>;
+  /**
+   * Find logs correlated by trace ID
+   * @param traceId - Trace ID to correlate logs
+   * @returns Correlated logs
+   */
+  correlateByTraceId(traceId: string): Promise<CorrelatedLogs>;
+  /**
+   * Find logs similar to a given log entry
+   * @param logEntry - Log entry to find similar logs for
+   * @param limit - Maximum number of similar logs to return
+   * @returns Array of similar logs
+   */
+  findSimilarLogs(logEntry: LogEntry, limit?: number): Promise<SimilarLog[]>;
+  /**
+   * Get search suggestions based on partial query
+   * @param partialQuery - Partial query string
+   * @param limit - Maximum number of suggestions
+   * @returns Array of suggestions
+   */
+  getSuggestions(partialQuery: string, limit?: number): Promise<SearchSuggestion[]>;
+  /**
+   * Get search statistics
+   * @returns Search statistics
+   */
+  getStats(): Promise<SearchStats>;
+  /**
+   * Parse natural language query
+   * @param query - Natural language query
+   * @returns Parsed query with intent and entities
+   */
+  parseNaturalLanguageQuery(query: string): Promise<ParsedNLQuery>;
+  /**
+   * Save a search preset
+   * @param preset - Search preset to save
+   * @returns Saved preset with ID
+   */
+  savePreset(preset: Omit<SearchPreset, 'id' | 'createdAt' | 'updatedAt'>): Promise<SearchPreset>;
+  /**
+   * Get saved presets
+   * @param userId - Optional user ID to filter presets
+   * @returns Array of presets
+   */
+  getPresets(userId?: string): Promise<SearchPreset[]>;
+  /**
+   * Delete a preset
+   * @param presetId - ID of preset to delete
+   */
+  deletePreset(presetId: string): Promise<void>;
+}
+//#endregion
+//#region src/search/core/basic-search-engine.d.ts
+/**
+ * Basic search engine implementation
+ */
+declare class BasicSearchEngine implements ILogSearchEngine {
+  private options?;
+  private logs;
+  private presets;
+  private searchHistory;
+  private suggestionCache;
+  constructor(options?: {
+    maxHistorySize?: number;
+    cacheSize?: number;
+    maxLogs?: number;
+  } | undefined);
+  /**
+   * 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: LogEntry[]): void;
+  /**
+   * Clear all logs from the index
+   */
+  clearLogs(): void;
+  /**
+   * Get all indexed logs
+   */
+  getLogs(): LogEntry[];
+  /**
+   * Perform a full-text search across logs
+   */
+  search(query: string, filters?: SearchFilters, options?: SearchOptions): Promise<SearchResult[]>;
+  /**
+   * Natural language search (basic implementation)
+   */
+  naturalLanguageSearch(query: string): Promise<SearchResult[]>;
+  /**
+   * Find logs correlated by trace ID
+   */
+  correlateByTraceId(traceId: string): Promise<CorrelatedLogs>;
+  /**
+   * Find similar logs based on content similarity
+   */
+  findSimilarLogs(logEntry: LogEntry, limit?: number): Promise<SimilarLog[]>;
+  /**
+   * Get search suggestions
+   */
+  getSuggestions(partialQuery: string, limit?: number): Promise<SearchSuggestion[]>;
+  /**
+   * Get search statistics
+   */
+  getStats(): Promise<SearchStats>;
+  /**
+   * Parse natural language query
+   */
+  parseNaturalLanguageQuery(query: string): Promise<ParsedNLQuery>;
+  /**
+   * Save a search preset
+   */
+  savePreset(preset: Omit<SearchPreset, 'id' | 'createdAt' | 'updatedAt'>): Promise<SearchPreset>;
+  /**
+   * Get saved presets
+   */
+  getPresets(userId?: string): Promise<SearchPreset[]>;
+  /**
+   * Delete a preset
+   */
+  deletePreset(presetId: string): Promise<void>;
+  private applyFilters;
+  private performTextSearch;
+  private getSearchableText;
+  private getHighlightFragments;
+  private applySorting;
+  private applyPagination;
+  private enrichWithContext;
+  private calculateSimilarity;
+  private calculateTextSimilarity;
+  private findMatchedPatterns;
+  private generateSimilarityReason;
+  private extractTimeRange;
+  private addToSearchHistory;
+  private getTopTerms;
+  private generateId;
+}
+//#endregion
+//#region src/search/engines/correlation-engine.d.ts
+/**
+ * Correlation engine for log analysis
+ */
+declare class CorrelationEngine {
+  private options?;
+  constructor(options?: {
+    maxCorrelationDistance?: number;
+    temporalWindowMs?: number;
+    minSimilarityScore?: number;
+  } | undefined);
+  /**
+   * Find logs related to a given log entry
+   */
+  findRelatedLogs(log: LogEntry, allLogs: LogEntry[], limit?: number): Promise<RelatedLog[]>;
+  /**
+   * Correlate logs by multiple criteria
+   */
+  correlateByMultipleCriteria(logs: LogEntry[], criteria: {
+    traceId?: boolean;
+    userId?: boolean;
+    sessionId?: boolean;
+    temporal?: boolean;
+    errorCascade?: boolean;
+  }): Promise<Map<string, CorrelatedLogs>>;
+  /**
+   * Build a timeline from correlated logs
+   */
+  buildTimeline(logs: LogEntry[]): TimelineEvent[];
+  /**
+   * Analyze error cascades
+   */
+  analyzeErrorCascade(logs: LogEntry[]): Promise<{
+    rootCause?: LogEntry;
+    cascade: LogEntry[];
+    impactedServices: string[];
+  }>;
+  private correlateByTraceId;
+  private correlateByUserId;
+  private correlateBySessionId;
+  private correlateByTemporalProximity;
+  private correlateErrorCascades;
+  private buildErrorCascade;
+  private findRelationships;
+  private calculateRelationshipScore;
+  private haveSimilarPattern;
+  private normalizeMessage;
+  private determineEventType;
+  private deduplicateRelatedLogs;
+  private convertToCorrelatedLogs;
+  private generateSummary;
+}
+//#endregion
+//#region src/search/engines/nlp-search-engine.d.ts
+/**
+ * NLP-enhanced search engine
+ */
+declare class NLPSearchEngine extends BasicSearchEngine {
+  private intentPatterns;
+  private entityPatterns;
+  constructor(options?: Record<string, unknown>);
+  /**
+   * Enhanced natural language query parsing
+   */
+  parseNaturalLanguageQuery(query: string): Promise<ParsedNLQuery>;
+  /**
+   * Enhanced natural language search
+   */
+  naturalLanguageSearch(query: string): Promise<SearchResult[]>;
+  private initializePatterns;
+  private detectIntent;
+  private extractEntities;
+  private applyEntityToFilter;
+  private extractAdvancedTimeRange;
+  private calculateConfidence;
+  private getOptionsForIntent;
+  private extractCleanQuery;
+}
+//#endregion
+//#region src/search/engines/pattern-recognition-engine.d.ts
+/**
+ * Pattern recognition engine for log analysis
+ */
+declare class PatternRecognitionEngine {
+  private options?;
+  private patterns;
+  private patternFrequencies;
+  constructor(options?: {
+    minFrequency?: number;
+    maxPatterns?: number;
+    anomalyThreshold?: number;
+  } | undefined);
+  /**
+   * Analyze logs and detect patterns
+   */
+  analyzePatterns(logs: LogEntry[]): Promise<LogPattern[]>;
+  /**
+   * Detect anomalies in logs
+   */
+  detectAnomalies(logs: LogEntry[]): Promise<AnomalyDetection[]>;
+  /**
+   * Find patterns matching a log entry
+   */
+  findMatchingPatterns(log: LogEntry): LogPattern[];
+  /**
+   * Get all detected patterns
+   */
+  getPatterns(): LogPattern[];
+  /**
+   * Get pattern by ID
+   */
+  getPattern(patternId: string): LogPattern | undefined;
+  private extractMessagePatterns;
+  private extractErrorPatterns;
+  private extractTimingPatterns;
+  private normalizeMessage;
+  private extractErrorPattern;
+  private calculateAnomalyScore;
+  private generateAnomalyReason;
+  private findDeviations;
+  private doesLogMatchPattern;
+}
+//#endregion
+export { SearchStats as A, SearchFilters as C, SearchPreset as D, SearchOptions as E, SuggestionType as F, TimeRange as I, TimelineEvent as L, SemanticIndex as M, SimilarLog as N, SearchQuery as O, SortField as P, RelativeTime as S, SearchMatch as T, ParsedNLQuery as _, ILogSearchEngine as a, RelatedLog as b, SearchManager as c, CorrelatedLogs as d, EntityType as f, LogPattern as g, LogCorrelationSummary as h, BasicSearchEngine as i, SearchSuggestion as j, SearchResult as k, SearchManagerConfig as l, LogCluster as m, NLPSearchEngine as n, BasicLogIndexer as o, ExportOptions as p, CorrelationEngine as r, ILogIndexer as s, PatternRecognitionEngine as t, AnomalyDetection as u, QueryEntity as v, SearchHighlight as w, RelationshipType as x, QueryIntent as y };
+//# sourceMappingURL=search-DujhR94O.d.ts.map