@terminals-tech/sdk 1.0.0-rc.1 → 1.0.0

package/dist/dist-VYGJXGUS.js

@@ -0,0 +1,1008 @@
+import {
+  __commonJS
+} from "./chunk-2ESYSVXG.js";
+
+// ../../node_modules/@terminals-tech/graph/dist/TextGraph.js
+var require_TextGraph = __commonJS({
+  "../../node_modules/@terminals-tech/graph/dist/TextGraph.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TextGraph = void 0;
+    var TextGraph = class {
+      constructor() {
+        this.patterns = {
+          // Causal relationships
+          causal: /(?:caused?|led to|resulted in|triggered|because of|due to|therefore|hence|thus|so)/i,
+          // Temporal relationships
+          temporal: /(?:before|after|then|when|while|during|followed by|subsequently|prior to|next)/i,
+          // Dependency relationships
+          dependency: /(?:requires?|depends? on|needs?|uses?|based on|relies on|built on)/i,
+          // Named entities (capitalized words)
+          entity: /(?:[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)/g,
+          // References to previous context
+          reference: /(?:this|that|it|they|them|the \w+)/gi,
+          // Actions/verbs that indicate relationships
+          action: /(?:clicked|opened|closed|created|deleted|updated|modified|viewed|downloaded|uploaded)/i
+        };
+      }
+      /**
+       * Extract relationships from text using linguistic patterns
+       */
+      extractRelations(text) {
+        if (!text)
+          return [];
+        const relations = [];
+        const sentences = text.split(/[.!?]+/).filter((s) => s.trim());
+        sentences.forEach((sentence, idx) => {
+          const trimmed = sentence.trim();
+          const causalMatch = trimmed.match(this.patterns.causal);
+          if (causalMatch) {
+            const parts = trimmed.split(causalMatch[0]);
+            if (parts.length === 2) {
+              relations.push({
+                type: "causal",
+                from: this.normalize(parts[0]),
+                to: this.normalize(parts[1]),
+                weight: 0.8,
+                context: causalMatch[0]
+              });
+            }
+          }
+          const temporalMatch = trimmed.match(this.patterns.temporal);
+          if (temporalMatch) {
+            const parts = trimmed.split(temporalMatch[0]);
+            if (parts.length === 2) {
+              relations.push({
+                type: "temporal",
+                from: this.normalize(parts[0]),
+                to: this.normalize(parts[1]),
+                weight: 0.6,
+                context: temporalMatch[0]
+              });
+            }
+          }
+          const dependencyMatch = trimmed.match(this.patterns.dependency);
+          if (dependencyMatch) {
+            const parts = trimmed.split(dependencyMatch[0]);
+            if (parts.length === 2) {
+              relations.push({
+                type: "dependency",
+                from: this.normalize(parts[0]),
+                to: this.normalize(parts[1]),
+                weight: 0.7,
+                context: dependencyMatch[0]
+              });
+            }
+          }
+          const entities = trimmed.match(this.patterns.entity) || [];
+          entities.forEach((entity) => {
+            if (entity.length > 2) {
+              relations.push({
+                type: "mention",
+                from: `sentence_${idx}`,
+                to: entity,
+                weight: 0.3
+              });
+            }
+          });
+        });
+        return relations;
+      }
+      /**
+       * Build a graph from events
+       */
+      buildGraph(events) {
+        const nodes = /* @__PURE__ */ new Map();
+        const edges = [];
+        const entityMap = /* @__PURE__ */ new Map();
+        events.forEach((event, idx) => {
+          nodes.set(event.id, {
+            id: event.id,
+            label: event.type,
+            data: event,
+            timestamp: event.timestamp
+          });
+          if (idx > 0) {
+            edges.push({
+              from: events[idx - 1].id,
+              to: event.id,
+              type: "temporal",
+              weight: 0.5
+            });
+          }
+          if (event.description) {
+            const relations = this.extractRelations(event.description);
+            relations.forEach((rel) => {
+              if (rel.type === "mention") {
+                entityMap.set(rel.to, event.id);
+                if (!nodes.has(rel.to)) {
+                  nodes.set(rel.to, {
+                    id: rel.to,
+                    label: rel.to,
+                    data: { type: "entity", name: rel.to },
+                    timestamp: event.timestamp
+                  });
+                }
+                edges.push({
+                  from: event.id,
+                  to: rel.to,
+                  type: "mention",
+                  weight: rel.weight
+                });
+              } else {
+                const fromId = this.resolveReference(rel.from, event.id, entityMap);
+                const toId = this.resolveReference(rel.to, event.id, entityMap);
+                edges.push({
+                  from: fromId,
+                  to: toId,
+                  type: rel.type,
+                  weight: rel.weight
+                });
+              }
+            });
+          }
+        });
+        return { nodes, edges };
+      }
+      /**
+       * Find events that caused a given event
+       */
+      findCauses(graph, eventId) {
+        return graph.edges.filter((e) => e.to === eventId && e.type === "causal").map((e) => graph.nodes.get(e.from)).filter((node) => node !== void 0);
+      }
+      /**
+       * Find events that were caused by a given event
+       */
+      findEffects(graph, eventId) {
+        return graph.edges.filter((e) => e.from === eventId && e.type === "causal").map((e) => graph.nodes.get(e.to)).filter((node) => node !== void 0);
+      }
+      /**
+       * Find temporal sequence around an event
+       */
+      findTemporalContext(graph, eventId, windowSize = 5) {
+        const result = [];
+        const visited = /* @__PURE__ */ new Set();
+        let current = eventId;
+        for (let i = 0; i < windowSize; i++) {
+          const prev = graph.edges.find((e) => e.to === current && e.type === "temporal");
+          if (!prev || visited.has(prev.from))
+            break;
+          const node = graph.nodes.get(prev.from);
+          if (node) {
+            result.unshift(node);
+            visited.add(prev.from);
+            current = prev.from;
+          }
+        }
+        const currentNode = graph.nodes.get(eventId);
+        if (currentNode)
+          result.push(currentNode);
+        current = eventId;
+        visited.clear();
+        for (let i = 0; i < windowSize; i++) {
+          const next = graph.edges.find((e) => e.from === current && e.type === "temporal");
+          if (!next || visited.has(next.to))
+            break;
+          const node = graph.nodes.get(next.to);
+          if (node) {
+            result.push(node);
+            visited.add(next.to);
+            current = next.to;
+          }
+        }
+        return result;
+      }
+      /**
+       * Find all related entities for an event
+       */
+      findRelatedEntities(graph, eventId) {
+        return graph.edges.filter((e) => e.from === eventId && e.type === "mention").map((e) => graph.nodes.get(e.to)).filter((node) => node !== void 0 && node.data.type === "entity");
+      }
+      /**
+       * Export graph to DOT format for visualization
+       */
+      toDot(graph) {
+        const lines = ["digraph G {"];
+        graph.nodes.forEach((node) => {
+          const label = node.label.replace(/"/g, '\\"');
+          lines.push(`  "${node.id}" [label="${label}"];`);
+        });
+        graph.edges.forEach((edge) => {
+          const style = this.getEdgeStyle(edge.type);
+          lines.push(`  "${edge.from}" -> "${edge.to}" [${style}];`);
+        });
+        lines.push("}");
+        return lines.join("\n");
+      }
+      /**
+       * Export graph to JSON for D3.js or other visualization libraries
+       */
+      toJSON(graph) {
+        return {
+          nodes: Array.from(graph.nodes.values()),
+          links: graph.edges.map((e) => ({
+            source: e.from,
+            target: e.to,
+            type: e.type,
+            value: e.weight
+          }))
+        };
+      }
+      // Private helper methods
+      normalize(text) {
+        return text.trim().toLowerCase().replace(/[^\w\s]/g, "");
+      }
+      resolveReference(ref, currentEventId, entityMap) {
+        const entityEvent = entityMap.get(ref);
+        if (entityEvent)
+          return entityEvent;
+        if (/^(this|that|it)/.test(ref.toLowerCase())) {
+          return currentEventId;
+        }
+        return ref;
+      }
+      getEdgeStyle(type) {
+        switch (type) {
+          case "causal":
+            return 'style="bold", color="red", label="causes"';
+          case "temporal":
+            return 'style="dashed", color="blue", label="then"';
+          case "dependency":
+            return 'style="dotted", color="green", label="depends"';
+          case "mention":
+            return 'style="dotted", color="gray", label="mentions"';
+          default:
+            return 'color="black"';
+        }
+      }
+    };
+    exports.TextGraph = TextGraph;
+  }
+});
+
+// ../../node_modules/@terminals-tech/graph/dist/PatternMatcher.js
+var require_PatternMatcher = __commonJS({
+  "../../node_modules/@terminals-tech/graph/dist/PatternMatcher.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.PatternMatcher = void 0;
+    var PatternMatcher = class {
+      constructor() {
+        this.sequenceCache = /* @__PURE__ */ new Map();
+        this.transitionMatrix = /* @__PURE__ */ new Map();
+        this.eventTypeFrequency = /* @__PURE__ */ new Map();
+      }
+      /**
+       * Extract n-gram patterns from event sequences
+       */
+      extractPatterns(events, n = 3) {
+        this.sequenceCache.clear();
+        for (let i = 0; i <= events.length - n; i++) {
+          const sequence = events.slice(i, i + n);
+          const key = sequence.map((e) => e.type).join("\u2192");
+          if (!this.sequenceCache.has(key)) {
+            this.sequenceCache.set(key, {
+              sequence: sequence.map((e) => e.type),
+              frequency: 0,
+              avgDuration: 0,
+              instances: []
+            });
+          }
+          const pattern = this.sequenceCache.get(key);
+          pattern.frequency++;
+          const instance = {
+            events: sequence,
+            timestamp: sequence[0].timestamp
+          };
+          if (sequence[n - 1].timestamp && sequence[0].timestamp) {
+            instance.duration = sequence[n - 1].timestamp - sequence[0].timestamp;
+          }
+          pattern.instances.push(instance);
+        }
+        this.sequenceCache.forEach((pattern) => {
+          const durations = pattern.instances.map((i) => i.duration).filter((d) => d !== void 0);
+          if (durations.length > 0) {
+            pattern.avgDuration = durations.reduce((a, b) => a + b, 0) / durations.length;
+          }
+        });
+        this.buildTransitionMatrix(events);
+        return Array.from(this.sequenceCache.values()).filter((p) => p.frequency > 1).sort((a, b) => b.frequency - a.frequency);
+      }
+      /**
+       * Detect anomalies using statistical analysis
+       */
+      detectAnomalies(events, threshold = 0.1) {
+        if (events.length < 2)
+          return [];
+        const anomalies = [];
+        const patterns = this.extractPatterns(events, 2);
+        const totalPairs = events.length - 1;
+        const avgFrequency = patterns.reduce((sum, p) => sum + p.frequency, 0) / patterns.length;
+        for (let i = 1; i < events.length; i++) {
+          const prevEvent = events[i - 1];
+          const currEvent = events[i];
+          const pair = `${prevEvent.type}\u2192${currEvent.type}`;
+          const pattern = patterns.find((p) => p.sequence.join("\u2192") === pair);
+          const frequency = pattern ? pattern.frequency : 0;
+          const relativeFreq = frequency / totalPairs;
+          if (relativeFreq < threshold) {
+            anomalies.push({
+              event: currEvent,
+              score: relativeFreq,
+              reason: `Rare transition: ${prevEvent.type} \u2192 ${currEvent.type}`,
+              context: [prevEvent, currEvent]
+            });
+          }
+          if (pattern && pattern.avgDuration > 0 && currEvent.timestamp && prevEvent.timestamp) {
+            const actualDuration = currEvent.timestamp - prevEvent.timestamp;
+            const expectedDuration = pattern.avgDuration;
+            const deviation = Math.abs(actualDuration - expectedDuration) / expectedDuration;
+            if (deviation > 2) {
+              anomalies.push({
+                event: currEvent,
+                score: 1 / (1 + deviation),
+                reason: `Unusual timing: expected ~${Math.round(expectedDuration)}ms, got ${actualDuration}ms`,
+                context: [prevEvent, currEvent]
+              });
+            }
+          }
+        }
+        this.calculateEventTypeFrequency(events);
+        const avgTypeFreq = Array.from(this.eventTypeFrequency.values()).reduce((a, b) => a + b, 0) / this.eventTypeFrequency.size;
+        events.forEach((event) => {
+          const typeFreq = this.eventTypeFrequency.get(event.type) || 0;
+          if (typeFreq < avgTypeFreq * threshold) {
+            anomalies.push({
+              event,
+              score: typeFreq / avgTypeFreq,
+              reason: `Rare event type: ${event.type} (${typeFreq} occurrences)`,
+              context: []
+            });
+          }
+        });
+        return anomalies.sort((a, b) => a.score - b.score);
+      }
+      /**
+       * Predict next event based on Markov chain
+       */
+      predictNext(events, lookback = 3) {
+        if (events.length === 0)
+          return [];
+        const recent = events.slice(-lookback).map((e) => e.type);
+        const predictions = /* @__PURE__ */ new Map();
+        this.sequenceCache.forEach((pattern) => {
+          const patternPrefix = pattern.sequence.slice(0, lookback);
+          if (this.arraysEqual(patternPrefix, recent) && pattern.sequence.length > lookback) {
+            const nextEvent = pattern.sequence[lookback];
+            predictions.set(nextEvent, (predictions.get(nextEvent) || 0) + pattern.frequency);
+          }
+        });
+        if (predictions.size === 0 && this.transitionMatrix.size > 0) {
+          const lastEvent = events[events.length - 1].type;
+          const transitions = this.transitionMatrix.get(lastEvent);
+          if (transitions) {
+            transitions.forEach((count, nextType) => {
+              predictions.set(nextType, count);
+            });
+          }
+        }
+        const total = Array.from(predictions.values()).reduce((a, b) => a + b, 0);
+        if (total === 0) {
+          return this.getMostCommonEventTypes(events, 3);
+        }
+        return Array.from(predictions.entries()).map(([type, count]) => ({
+          type,
+          probability: count / total,
+          confidence: Math.min(count / 10, 1),
+          // Confidence based on sample size
+          basedOn: this.findPatternsContaining(type, recent)
+        })).sort((a, b) => b.probability - a.probability).slice(0, 5);
+      }
+      /**
+       * Find cyclic patterns (loops in behavior)
+       */
+      findCycles(events, minLength = 3, maxLength = 10) {
+        const cycles = [];
+        for (let len = minLength; len <= maxLength && len <= events.length / 2; len++) {
+          for (let start = 0; start <= events.length - len * 2; start++) {
+            const candidate = events.slice(start, start + len).map((e) => e.type);
+            for (let next = start + len; next <= events.length - len; next++) {
+              const comparison = events.slice(next, next + len).map((e) => e.type);
+              if (this.arraysEqual(candidate, comparison)) {
+                const key = candidate.join("\u2192");
+                if (!cycles.find((c) => c.sequence.join("\u2192") === key)) {
+                  cycles.push({
+                    sequence: candidate,
+                    frequency: 2,
+                    // Found at least twice
+                    avgDuration: 0,
+                    instances: [
+                      { events: events.slice(start, start + len), timestamp: events[start].timestamp },
+                      { events: events.slice(next, next + len), timestamp: events[next].timestamp }
+                    ]
+                  });
+                }
+              }
+            }
+          }
+        }
+        return cycles;
+      }
+      /**
+       * Calculate pattern complexity (entropy)
+       */
+      calculateComplexity(events) {
+        if (events.length === 0)
+          return 0;
+        this.calculateEventTypeFrequency(events);
+        const total = events.length;
+        let entropy = 0;
+        this.eventTypeFrequency.forEach((count) => {
+          const probability = count / total;
+          if (probability > 0) {
+            entropy -= probability * Math.log2(probability);
+          }
+        });
+        return entropy;
+      }
+      /**
+       * Find patterns that deviate from the norm
+       */
+      findDeviations(events, windowSize = 20) {
+        const deviations = [];
+        if (events.length < windowSize * 2)
+          return deviations;
+        const baseline = events.slice(0, Math.floor(events.length / 2));
+        const baselinePatterns = this.extractPatterns(baseline, 2);
+        const baselineTransitions = /* @__PURE__ */ new Map();
+        baselinePatterns.forEach((p) => {
+          const key = p.sequence.join("\u2192");
+          baselineTransitions.set(key, p.frequency);
+        });
+        for (let i = 0; i <= events.length - windowSize; i++) {
+          const window = events.slice(i, i + windowSize);
+          const windowPatterns = this.extractPatterns(window, 2);
+          let deviationScore = 0;
+          windowPatterns.forEach((p) => {
+            const key = p.sequence.join("\u2192");
+            const baselineFreq = baselineTransitions.get(key) || 0;
+            const expectedFreq = baselineFreq / baseline.length * window.length;
+            const actualFreq = p.frequency;
+            if (expectedFreq > 0) {
+              deviationScore += Math.abs(actualFreq - expectedFreq) / expectedFreq;
+            }
+          });
+          if (deviationScore > 1) {
+            deviations.push({
+              event: window[0],
+              score: deviationScore,
+              reason: `Pattern deviation in window starting at index ${i}`,
+              context: window
+            });
+          }
+        }
+        return deviations;
+      }
+      // Private helper methods
+      buildTransitionMatrix(events) {
+        this.transitionMatrix.clear();
+        for (let i = 0; i < events.length - 1; i++) {
+          const current = events[i].type;
+          const next = events[i + 1].type;
+          if (!this.transitionMatrix.has(current)) {
+            this.transitionMatrix.set(current, /* @__PURE__ */ new Map());
+          }
+          const transitions = this.transitionMatrix.get(current);
+          transitions.set(next, (transitions.get(next) || 0) + 1);
+        }
+      }
+      calculateEventTypeFrequency(events) {
+        this.eventTypeFrequency.clear();
+        events.forEach((event) => {
+          this.eventTypeFrequency.set(event.type, (this.eventTypeFrequency.get(event.type) || 0) + 1);
+        });
+      }
+      arraysEqual(a, b) {
+        if (a.length !== b.length)
+          return false;
+        return a.every((val, idx) => val === b[idx]);
+      }
+      findPatternsContaining(eventType, prefix) {
+        return Array.from(this.sequenceCache.values()).filter((p) => {
+          const prefixMatch = prefix.every((type, idx) => p.sequence[idx] === type);
+          const containsType = p.sequence.includes(eventType);
+          return prefixMatch && containsType;
+        });
+      }
+      getMostCommonEventTypes(events, n) {
+        this.calculateEventTypeFrequency(events);
+        const total = events.length;
+        return Array.from(this.eventTypeFrequency.entries()).sort((a, b) => b[1] - a[1]).slice(0, n).map(([type, count]) => ({
+          type,
+          probability: count / total,
+          confidence: 0.3
+          // Low confidence for fallback predictions
+        }));
+      }
+    };
+    exports.PatternMatcher = PatternMatcher;
+  }
+});
+
+// ../../node_modules/@terminals-tech/graph/dist/GraphProcessor.js
+var require_GraphProcessor = __commonJS({
+  "../../node_modules/@terminals-tech/graph/dist/GraphProcessor.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.GraphProcessor = void 0;
+    var GraphProcessor = class {
+      constructor() {
+        this.adjacencyList = /* @__PURE__ */ new Map();
+        this.reverseIndex = /* @__PURE__ */ new Map();
+        this.edgeWeights = /* @__PURE__ */ new Map();
+        this.nodeData = /* @__PURE__ */ new Map();
+        this.pageRankCache = /* @__PURE__ */ new Map();
+        this.clusters = /* @__PURE__ */ new Map();
+        this.isDirty = false;
+        this.nodeCount = 0;
+        this.edgeCount = 0;
+        this.processedEvents = /* @__PURE__ */ new Set();
+        this.edgeHashes = /* @__PURE__ */ new Set();
+      }
+      /**
+       * Add event to graph incrementally (idempotent)
+       */
+      addEvent(event, relations) {
+        if (this.processedEvents.has(event.id)) {
+          return;
+        }
+        const snapshot = this.createSnapshot();
+        try {
+          if (!this.adjacencyList.has(event.id)) {
+            this.adjacencyList.set(event.id, /* @__PURE__ */ new Set());
+            this.nodeData.set(event.id, event);
+            this.nodeCount++;
+          }
+          relations.forEach((rel) => {
+            this.addEdge(event.id, rel.to, rel.weight, rel.type);
+          });
+          this.processedEvents.add(event.id);
+          this.isDirty = true;
+        } catch (error) {
+          this.restoreSnapshot(snapshot);
+          throw error;
+        }
+      }
+      /**
+       * Add edge between nodes (idempotent)
+       */
+      addEdge(from, to, weight = 1, type) {
+        const edgeHash = `${from}->${to}:${type || "default"}`;
+        if (this.edgeHashes.has(edgeHash)) {
+          const existingWeight = this.edgeWeights.get(from)?.get(to) || 0;
+          if (weight > existingWeight) {
+            this.edgeWeights.get(from).set(to, weight);
+          }
+          return;
+        }
+        if (!this.adjacencyList.has(from)) {
+          this.adjacencyList.set(from, /* @__PURE__ */ new Set());
+          this.nodeCount++;
+        }
+        if (!this.adjacencyList.has(to)) {
+          this.adjacencyList.set(to, /* @__PURE__ */ new Set());
+          this.nodeCount++;
+        }
+        this.adjacencyList.get(from).add(to);
+        if (!this.reverseIndex.has(to)) {
+          this.reverseIndex.set(to, /* @__PURE__ */ new Set());
+        }
+        this.reverseIndex.get(to).add(from);
+        if (!this.edgeWeights.has(from)) {
+          this.edgeWeights.set(from, /* @__PURE__ */ new Map());
+        }
+        this.edgeWeights.get(from).set(to, weight);
+        this.edgeHashes.add(edgeHash);
+        this.edgeCount++;
+        this.isDirty = true;
+      }
+      /**
+       * Calculate PageRank scores using power iteration
+       */
+      calculatePageRank(iterations = 20, damping = 0.85) {
+        if (!this.isDirty && this.pageRankCache.size > 0) {
+          return this.formatPageRankResults();
+        }
+        const nodes = Array.from(this.adjacencyList.keys());
+        const n = nodes.length;
+        if (n === 0)
+          return [];
+        const scores = /* @__PURE__ */ new Map();
+        const newScores = /* @__PURE__ */ new Map();
+        nodes.forEach((node) => scores.set(node, 1 / n));
+        for (let iter = 0; iter < iterations; iter++) {
+          newScores.clear();
+          nodes.forEach((node) => {
+            let score = (1 - damping) / n;
+            const incoming = this.reverseIndex.get(node) || /* @__PURE__ */ new Set();
+            incoming.forEach((source) => {
+              const outDegree = this.adjacencyList.get(source)?.size || 1;
+              const sourceScore = scores.get(source) || 0;
+              const edgeWeight = this.edgeWeights.get(source)?.get(node) || 1;
+              score += damping * sourceScore * edgeWeight / outDegree;
+            });
+            newScores.set(node, score);
+          });
+          scores.clear();
+          newScores.forEach((score, node) => scores.set(node, score));
+        }
+        this.pageRankCache = scores;
+        this.isDirty = false;
+        return this.formatPageRankResults();
+      }
+      /**
+       * Find connected components (clusters)
+       */
+      findClusters() {
+        this.clusters.clear();
+        const visited = /* @__PURE__ */ new Set();
+        const clusterList = [];
+        let clusterId = 0;
+        this.adjacencyList.forEach((_, startNode) => {
+          if (!visited.has(startNode)) {
+            const cluster = /* @__PURE__ */ new Set();
+            const queue = [startNode];
+            visited.add(startNode);
+            while (queue.length > 0) {
+              const node = queue.shift();
+              cluster.add(node);
+              this.clusters.set(node, clusterId);
+              const outgoing = this.adjacencyList.get(node) || /* @__PURE__ */ new Set();
+              const incoming = this.reverseIndex.get(node) || /* @__PURE__ */ new Set();
+              const neighbors = /* @__PURE__ */ new Set([...outgoing, ...incoming]);
+              neighbors.forEach((neighbor) => {
+                if (!visited.has(neighbor)) {
+                  visited.add(neighbor);
+                  queue.push(neighbor);
+                }
+              });
+            }
+            const density = this.calculateClusterDensity(cluster);
+            const center = this.findClusterCenter(cluster);
+            clusterList.push({
+              id: clusterId++,
+              nodes: cluster,
+              center,
+              density
+            });
+          }
+        });
+        return clusterList.sort((a, b) => b.nodes.size - a.nodes.size);
+      }
+      /**
+       * Find shortest path using BFS
+       */
+      findPath(from, to) {
+        if (!this.adjacencyList.has(from) || !this.adjacencyList.has(to)) {
+          return null;
+        }
+        const queue = [
+          { node: from, path: [from], weight: 0 }
+        ];
+        const visited = /* @__PURE__ */ new Set([from]);
+        while (queue.length > 0) {
+          const { node, path, weight } = queue.shift();
+          if (node === to) {
+            return {
+              nodes: path,
+              totalWeight: weight,
+              length: path.length - 1
+            };
+          }
+          const neighbors = this.adjacencyList.get(node) || /* @__PURE__ */ new Set();
+          neighbors.forEach((neighbor) => {
+            if (!visited.has(neighbor)) {
+              visited.add(neighbor);
+              const edgeWeight = this.edgeWeights.get(node)?.get(neighbor) || 1;
+              queue.push({
+                node: neighbor,
+                path: [...path, neighbor],
+                weight: weight + edgeWeight
+              });
+            }
+          });
+        }
+        return null;
+      }
+      /**
+       * Find all paths between two nodes (limited depth)
+       */
+      findAllPaths(from, to, maxDepth = 5) {
+        if (!this.adjacencyList.has(from) || !this.adjacencyList.has(to)) {
+          return [];
+        }
+        const paths = [];
+        const stack = [
+          { node: from, path: [from], weight: 0, visited: /* @__PURE__ */ new Set([from]) }
+        ];
+        while (stack.length > 0) {
+          const { node, path, weight, visited } = stack.pop();
+          if (path.length > maxDepth)
+            continue;
+          if (node === to) {
+            paths.push({
+              nodes: path,
+              totalWeight: weight,
+              length: path.length - 1
+            });
+            continue;
+          }
+          const neighbors = this.adjacencyList.get(node) || /* @__PURE__ */ new Set();
+          neighbors.forEach((neighbor) => {
+            if (!visited.has(neighbor)) {
+              const newVisited = new Set(visited);
+              newVisited.add(neighbor);
+              const edgeWeight = this.edgeWeights.get(node)?.get(neighbor) || 1;
+              stack.push({
+                node: neighbor,
+                path: [...path, neighbor],
+                weight: weight + edgeWeight,
+                visited: newVisited
+              });
+            }
+          });
+        }
+        return paths.sort((a, b) => a.totalWeight - b.totalWeight);
+      }
+      /**
+       * Get subgraph around a node
+       */
+      getSubgraph(nodeId, depth = 2) {
+        if (!this.adjacencyList.has(nodeId)) {
+          return { nodes: /* @__PURE__ */ new Set(), edges: [] };
+        }
+        const subgraphNodes = /* @__PURE__ */ new Set();
+        const subgraphEdges = [];
+        const queue = [{ node: nodeId, d: 0 }];
+        const visited = /* @__PURE__ */ new Set();
+        while (queue.length > 0) {
+          const { node, d } = queue.shift();
+          if (visited.has(node) || d > depth)
+            continue;
+          visited.add(node);
+          subgraphNodes.add(node);
+          const neighbors = this.adjacencyList.get(node) || /* @__PURE__ */ new Set();
+          neighbors.forEach((neighbor) => {
+            if (d < depth) {
+              const weight = this.edgeWeights.get(node)?.get(neighbor) || 1;
+              subgraphEdges.push({
+                from: node,
+                to: neighbor,
+                weight
+              });
+              queue.push({ node: neighbor, d: d + 1 });
+            }
+          });
+          const incoming = this.reverseIndex.get(node) || /* @__PURE__ */ new Set();
+          incoming.forEach((source) => {
+            if (d < depth && !visited.has(source)) {
+              queue.push({ node: source, d: d + 1 });
+            }
+          });
+        }
+        return { nodes: subgraphNodes, edges: subgraphEdges };
+      }
+      /**
+       * Detect cycles in the graph
+       */
+      detectCycles() {
+        const cycles = [];
+        const visited = /* @__PURE__ */ new Set();
+        const recursionStack = /* @__PURE__ */ new Set();
+        const dfs = (node, path) => {
+          visited.add(node);
+          recursionStack.add(node);
+          path.push(node);
+          const neighbors = this.adjacencyList.get(node) || /* @__PURE__ */ new Set();
+          neighbors.forEach((neighbor) => {
+            if (!visited.has(neighbor)) {
+              dfs(neighbor, [...path]);
+            } else if (recursionStack.has(neighbor)) {
+              const cycleStart = path.indexOf(neighbor);
+              if (cycleStart !== -1) {
+                cycles.push(path.slice(cycleStart));
+              }
+            }
+          });
+          recursionStack.delete(node);
+        };
+        this.adjacencyList.forEach((_, node) => {
+          if (!visited.has(node)) {
+            dfs(node, []);
+          }
+        });
+        return cycles;
+      }
+      /**
+       * Calculate graph statistics
+       */
+      getStatistics() {
+        const degrees = Array.from(this.adjacencyList.values()).map((neighbors) => neighbors.size);
+        const maxDegree = Math.max(...degrees, 0);
+        const avgDegree = degrees.length > 0 ? degrees.reduce((a, b) => a + b, 0) / degrees.length : 0;
+        const maxPossibleEdges = this.nodeCount * (this.nodeCount - 1);
+        const density = maxPossibleEdges > 0 ? this.edgeCount / maxPossibleEdges : 0;
+        const clusters = this.findClusters();
+        const connected = clusters.length === 1;
+        const cycles = this.detectCycles();
+        const cyclic = cycles.length > 0;
+        return {
+          nodes: this.nodeCount,
+          edges: this.edgeCount,
+          density,
+          avgDegree,
+          maxDegree,
+          connected,
+          cyclic
+        };
+      }
+      /**
+       * Clear the graph
+       */
+      clear() {
+        this.adjacencyList.clear();
+        this.reverseIndex.clear();
+        this.edgeWeights.clear();
+        this.nodeData.clear();
+        this.pageRankCache.clear();
+        this.clusters.clear();
+        this.processedEvents.clear();
+        this.edgeHashes.clear();
+        this.nodeCount = 0;
+        this.edgeCount = 0;
+        this.isDirty = false;
+      }
+      /**
+       * Create a snapshot for rollback
+       */
+      createSnapshot() {
+        return {
+          nodeCount: this.nodeCount,
+          edgeCount: this.edgeCount,
+          processedEvents: new Set(this.processedEvents),
+          edgeHashes: new Set(this.edgeHashes)
+        };
+      }
+      /**
+       * Restore from snapshot
+       */
+      restoreSnapshot(snapshot) {
+        this.nodeCount = snapshot.nodeCount;
+        this.edgeCount = snapshot.edgeCount;
+        this.processedEvents = snapshot.processedEvents;
+        this.edgeHashes = snapshot.edgeHashes;
+        this.isDirty = true;
+      }
+      // Private helper methods
+      formatPageRankResults() {
+        const results = Array.from(this.pageRankCache.entries()).map(([node, score]) => ({ node, score, rank: 0 })).sort((a, b) => b.score - a.score);
+        results.forEach((result, idx) => {
+          result.rank = idx + 1;
+        });
+        return results;
+      }
+      calculateClusterDensity(cluster) {
+        if (cluster.size <= 1)
+          return 0;
+        let internalEdges = 0;
+        cluster.forEach((node) => {
+          const neighbors = this.adjacencyList.get(node) || /* @__PURE__ */ new Set();
+          neighbors.forEach((neighbor) => {
+            if (cluster.has(neighbor)) {
+              internalEdges++;
+            }
+          });
+        });
+        const maxPossibleEdges = cluster.size * (cluster.size - 1);
+        return maxPossibleEdges > 0 ? internalEdges / maxPossibleEdges : 0;
+      }
+      findClusterCenter(cluster) {
+        let maxDegree = 0;
+        let center;
+        cluster.forEach((node) => {
+          const outDegree = (this.adjacencyList.get(node) || /* @__PURE__ */ new Set()).size;
+          const inDegree = (this.reverseIndex.get(node) || /* @__PURE__ */ new Set()).size;
+          const totalDegree = outDegree + inDegree;
+          if (totalDegree > maxDegree) {
+            maxDegree = totalDegree;
+            center = node;
+          }
+        });
+        return center;
+      }
+    };
+    exports.GraphProcessor = GraphProcessor;
+  }
+});
+
+// ../../node_modules/@terminals-tech/graph/dist/index.js
+var require_dist = __commonJS({
+  "../../node_modules/@terminals-tech/graph/dist/index.js"(exports) {
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.EventGraph = exports.GraphProcessor = exports.PatternMatcher = exports.TextGraph = void 0;
+    var TextGraph_1 = require_TextGraph();
+    var PatternMatcher_1 = require_PatternMatcher();
+    var GraphProcessor_1 = require_GraphProcessor();
+    var TextGraph_2 = require_TextGraph();
+    Object.defineProperty(exports, "TextGraph", { enumerable: true, get: function() {
+      return TextGraph_2.TextGraph;
+    } });
+    var PatternMatcher_2 = require_PatternMatcher();
+    Object.defineProperty(exports, "PatternMatcher", { enumerable: true, get: function() {
+      return PatternMatcher_2.PatternMatcher;
+    } });
+    var GraphProcessor_2 = require_GraphProcessor();
+    Object.defineProperty(exports, "GraphProcessor", { enumerable: true, get: function() {
+      return GraphProcessor_2.GraphProcessor;
+    } });
+    var EventGraph = class {
+      constructor() {
+        this.textGraph = new TextGraph_1.TextGraph();
+        this.patternMatcher = new PatternMatcher_1.PatternMatcher();
+        this.processor = new GraphProcessor_1.GraphProcessor();
+      }
+      /**
+       * Process events and build graph
+       */
+      processEvents(events) {
+        const graph = this.textGraph.buildGraph(events);
+        events.forEach((event) => {
+          if (event.description) {
+            const relations = this.textGraph.extractRelations(event.description);
+            this.processor.addEvent(event, relations);
+          }
+        });
+        this.patternMatcher.extractPatterns(events);
+      }
+      /**
+       * Find what caused an event
+       */
+      findCauses(eventId) {
+        const graph = this.textGraph.buildGraph([]);
+        return this.textGraph.findCauses(graph, eventId);
+      }
+      /**
+       * Detect anomalies
+       */
+      detectAnomalies(events) {
+        return this.patternMatcher.detectAnomalies(events);
+      }
+      /**
+       * Predict next event
+       */
+      predictNext(events) {
+        return this.patternMatcher.predictNext(events);
+      }
+      /**
+       * Find important events
+       */
+      findImportantEvents(limit = 10) {
+        return this.processor.calculatePageRank().slice(0, limit);
+      }
+      /**
+       * Find clusters
+       */
+      findClusters() {
+        return this.processor.findClusters();
+      }
+      /**
+       * Find path between events
+       */
+      findPath(from, to) {
+        return this.processor.findPath(from, to);
+      }
+    };
+    exports.EventGraph = EventGraph;
+  }
+});
+export default require_dist();