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

package/dist/dist-OPDCWARF.js

@@ -0,0 +1,727 @@
+import {
+  __commonJS,
+  __require
+} from "./chunk-2ESYSVXG.js";
+
+// ../../node_modules/@terminals-tech/embeddings/dist/types.js
+var require_types = __commonJS({
+  "../../node_modules/@terminals-tech/embeddings/dist/types.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/@terminals-tech/embeddings/dist/cache.js
+var require_cache = __commonJS({
+  "../../node_modules/@terminals-tech/embeddings/dist/cache.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.EmbeddingCache = void 0;
+    var EmbeddingCache = class {
+      constructor(options = {}) {
+        this.cache = /* @__PURE__ */ new Map();
+        this.lru = [];
+        this.timestamps = /* @__PURE__ */ new Map();
+        this.hitCount = 0;
+        this.missCount = 0;
+        this.maxSize = options.maxSize || 1e3;
+        this.ttlMs = options.ttlMs;
+        this.quantize = options.quantize || false;
+      }
+      /**
+       * Get an embedding from cache
+       */
+      get(key) {
+        if (!this.cache.has(key)) {
+          return null;
+        }
+        if (this.ttlMs) {
+          const timestamp = this.timestamps.get(key);
+          if (timestamp && Date.now() - timestamp > this.ttlMs) {
+            this.delete(key);
+            return null;
+          }
+        }
+        this.updateLRU(key);
+        const cached = this.cache.get(key);
+        if (this.quantize) {
+          return this.dequantizeVector(cached);
+        }
+        return cached;
+      }
+      /**
+       * Set an embedding in cache
+       */
+      set(key, embedding) {
+        if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
+          const oldest = this.lru.shift();
+          if (oldest) {
+            this.cache.delete(oldest);
+            this.timestamps.delete(oldest);
+          }
+        }
+        const toStore = this.quantize ? this.quantizeVector(embedding) : embedding;
+        this.cache.set(key, toStore);
+        this.timestamps.set(key, Date.now());
+        this.updateLRU(key);
+      }
+      /**
+       * Delete an entry from cache
+       */
+      delete(key) {
+        this.cache.delete(key);
+        this.timestamps.delete(key);
+        const index = this.lru.indexOf(key);
+        if (index > -1) {
+          this.lru.splice(index, 1);
+        }
+      }
+      /**
+       * Clear the entire cache
+       */
+      clear() {
+        this.cache.clear();
+        this.timestamps.clear();
+        this.lru = [];
+      }
+      /**
+       * Get cache statistics
+       */
+      stats() {
+        const size = this.cache.size;
+        const bytesPerVector = this.quantize ? 1 : 4;
+        const avgDimensions = 384;
+        const memoryUsage = size * avgDimensions * bytesPerVector;
+        return {
+          size,
+          maxSize: this.maxSize,
+          hitRate: this.hitCount / Math.max(1, this.hitCount + this.missCount),
+          memoryUsage
+        };
+      }
+      /**
+       * Update LRU order
+       */
+      updateLRU(key) {
+        const index = this.lru.indexOf(key);
+        if (index > -1) {
+          this.lru.splice(index, 1);
+        }
+        this.lru.push(key);
+      }
+      /**
+       * Quantize to int8 (saves 75% memory)
+       */
+      quantizeVector(vector) {
+        const { values, dimensions, normalized } = vector;
+        let min = Infinity;
+        let max = -Infinity;
+        for (let i = 0; i < dimensions; i++) {
+          min = Math.min(min, values[i]);
+          max = Math.max(max, values[i]);
+        }
+        const scale = 255 / (max - min);
+        const quantized = new Int8Array(dimensions);
+        for (let i = 0; i < dimensions; i++) {
+          quantized[i] = Math.round((values[i] - min) * scale - 128);
+        }
+        const metadata = new Float32Array(dimensions);
+        metadata[0] = min;
+        metadata[1] = max;
+        for (let i = 0; i < dimensions; i++) {
+          metadata[i + 2] = quantized[i];
+        }
+        return { values: metadata, dimensions, normalized };
+      }
+      /**
+       * Dequantize from int8 back to float32
+       */
+      dequantizeVector(vector) {
+        const { values, dimensions, normalized } = vector;
+        const min = values[0];
+        const max = values[1];
+        const scale = 255 / (max - min);
+        const dequantized = new Float32Array(dimensions);
+        for (let i = 0; i < dimensions; i++) {
+          const quantized = values[i + 2];
+          dequantized[i] = (quantized + 128) / scale + min;
+        }
+        return { values: dequantized, dimensions, normalized };
+      }
+    };
+    exports.EmbeddingCache = EmbeddingCache;
+  }
+});
+
+// ../../node_modules/@terminals-tech/embeddings/dist/providers/base.js
+var require_base = __commonJS({
+  "../../node_modules/@terminals-tech/embeddings/dist/providers/base.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.BaseEmbeddingProvider = void 0;
+    var cache_1 = require_cache();
+    var BaseEmbeddingProvider = class {
+      get ready() {
+        return this._ready;
+      }
+      constructor(options = {}) {
+        this.options = options;
+        this._ready = false;
+        if (options.cache !== false) {
+          this.cache = new cache_1.EmbeddingCache({
+            maxSize: options.cacheSize || 1e3,
+            ttlMs: options.cacheTTL,
+            quantize: options.quantizeCache || false
+          });
+        }
+      }
+      /**
+       * Generate embedding with caching
+       */
+      async embed(text) {
+        if (this.cache) {
+          const cached = this.cache.get(text);
+          if (cached)
+            return cached;
+        }
+        const embedding = await this.embedInternal(text);
+        if (this.cache) {
+          this.cache.set(text, embedding);
+        }
+        return embedding;
+      }
+      /**
+       * Batch embedding with optimal processing
+       */
+      async embedBatch(texts) {
+        const results = new Array(texts.length);
+        const toProcess = [];
+        for (let i = 0; i < texts.length; i++) {
+          if (this.cache) {
+            const cached = this.cache.get(texts[i]);
+            if (cached) {
+              results[i] = cached;
+              continue;
+            }
+          }
+          toProcess.push({ index: i, text: texts[i] });
+        }
+        if (toProcess.length > 0) {
+          const embeddings = await this.embedBatchInternal(toProcess.map((item) => item.text));
+          for (let i = 0; i < toProcess.length; i++) {
+            const { index, text } = toProcess[i];
+            results[index] = embeddings[i];
+            if (this.cache) {
+              this.cache.set(text, embeddings[i]);
+            }
+          }
+        }
+        return results;
+      }
+      /**
+       * Calculate cosine similarity between two vectors
+       */
+      similarity(a, b) {
+        if (a.dimensions !== b.dimensions) {
+          throw new Error("Vectors must have same dimensions");
+        }
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.dimensions; i++) {
+          dotProduct += a.values[i] * b.values[i];
+          normA += a.values[i] * a.values[i];
+          normB += b.values[i] * b.values[i];
+        }
+        if (a.normalized && b.normalized) {
+          return dotProduct;
+        }
+        return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+      }
+      /**
+       * Normalize a vector
+       */
+      normalize(vector) {
+        let norm = 0;
+        for (let i = 0; i < vector.length; i++) {
+          norm += vector[i] * vector[i];
+        }
+        norm = Math.sqrt(norm);
+        const normalized = new Float32Array(vector.length);
+        for (let i = 0; i < vector.length; i++) {
+          normalized[i] = vector[i] / norm;
+        }
+        return normalized;
+      }
+      /**
+       * Clean up resources
+       */
+      dispose() {
+        this.cache?.clear();
+        this._ready = false;
+      }
+    };
+    exports.BaseEmbeddingProvider = BaseEmbeddingProvider;
+  }
+});
+
+// ../../node_modules/@terminals-tech/embeddings/dist/providers/mock.js
+var require_mock = __commonJS({
+  "../../node_modules/@terminals-tech/embeddings/dist/providers/mock.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.MockEmbeddingProvider = void 0;
+    var base_1 = require_base();
+    var MockEmbeddingProvider = class extends base_1.BaseEmbeddingProvider {
+      constructor() {
+        super(...arguments);
+        this.name = "mock";
+        this.dimensions = 64;
+        this.maxTokens = 512;
+      }
+      async initialize() {
+        this._ready = true;
+      }
+      async embedInternal(text) {
+        const values = this.generateMockEmbedding(text);
+        return {
+          values,
+          dimensions: this.dimensions,
+          normalized: true
+        };
+      }
+      async embedBatchInternal(texts) {
+        return texts.map((text) => ({
+          values: this.generateMockEmbedding(text),
+          dimensions: this.dimensions,
+          normalized: true
+        }));
+      }
+      /**
+       * Generate a deterministic mock embedding from text
+       */
+      generateMockEmbedding(text) {
+        const embedding = new Float32Array(this.dimensions);
+        let hash = 0;
+        for (let i = 0; i < text.length; i++) {
+          hash = (hash << 5) - hash + text.charCodeAt(i);
+          hash = hash & hash;
+        }
+        for (let i = 0; i < this.dimensions; i++) {
+          const seed = hash + i * 31;
+          const x = Math.sin(seed) * 1e4;
+          embedding[i] = x - Math.floor(x);
+          if (i < 10) {
+            embedding[i] += text.length / 1e3;
+          } else if (i < 20) {
+            const words = text.split(/\s+/).length;
+            embedding[i] += words / 100;
+          } else if (i < 30) {
+            const punctuation = (text.match(/[.,!?;:]/g) || []).length;
+            embedding[i] += punctuation / 50;
+          }
+        }
+        return this.normalize(embedding);
+      }
+    };
+    exports.MockEmbeddingProvider = MockEmbeddingProvider;
+  }
+});
+
+// ../../node_modules/@terminals-tech/embeddings/dist/providers/transformers.js
+var require_transformers = __commonJS({
+  "../../node_modules/@terminals-tech/embeddings/dist/providers/transformers.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TransformersEmbeddingProvider = void 0;
+    var base_1 = require_base();
+    var pipeline = null;
+    var TransformersEmbeddingProvider = class extends base_1.BaseEmbeddingProvider {
+      constructor(options = {}) {
+        super(options);
+        this.name = "transformers-minilm";
+        this.dimensions = 384;
+        this.maxTokens = 256;
+        this.extractor = null;
+        this.modelId = options.modelId || "Xenova/all-MiniLM-L6-v2";
+      }
+      async initialize() {
+        if (this._ready)
+          return;
+        try {
+          if (typeof window !== "undefined") {
+            const transformers = await Promise.resolve().then(() => __importStar(__require("@huggingface/transformers")));
+            pipeline = transformers.pipeline;
+          } else {
+            const transformers = __require("@huggingface/transformers");
+            pipeline = transformers.pipeline;
+          }
+          this.extractor = await pipeline("feature-extraction", this.modelId);
+          this._ready = true;
+        } catch (error) {
+          console.warn("Transformers.js not available, falling back to mock provider");
+          throw error;
+        }
+      }
+      async embedInternal(text) {
+        if (!this._ready || !this.extractor) {
+          throw new Error("Provider not initialized. Call initialize() first.");
+        }
+        const truncated = this.truncateText(text);
+        const output = await this.extractor(truncated, {
+          pooling: "mean",
+          normalize: true
+        });
+        const values = new Float32Array(output.data);
+        return {
+          values,
+          dimensions: this.dimensions,
+          normalized: true
+        };
+      }
+      async embedBatchInternal(texts) {
+        if (!this._ready || !this.extractor) {
+          throw new Error("Provider not initialized. Call initialize() first.");
+        }
+        const truncated = texts.map((text) => this.truncateText(text));
+        const batchSize = 16;
+        const results = [];
+        for (let i = 0; i < truncated.length; i += batchSize) {
+          const batch = truncated.slice(i, i + batchSize);
+          const outputs = await this.extractor(batch, {
+            pooling: "mean",
+            normalize: true
+          });
+          for (let j = 0; j < outputs.length; j++) {
+            const values = new Float32Array(outputs[j].data);
+            results.push({
+              values,
+              dimensions: this.dimensions,
+              normalized: true
+            });
+          }
+        }
+        return results;
+      }
+      /**
+       * Truncate text to fit within token limit
+       */
+      truncateText(text) {
+        const maxChars = this.maxTokens * 4;
+        if (text.length <= maxChars)
+          return text;
+        return text.substring(0, maxChars - 3) + "...";
+      }
+      dispose() {
+        super.dispose();
+        this.extractor = null;
+      }
+    };
+    exports.TransformersEmbeddingProvider = TransformersEmbeddingProvider;
+  }
+});
+
+// ../../node_modules/@terminals-tech/embeddings/dist/search.js
+var require_search = __commonJS({
+  "../../node_modules/@terminals-tech/embeddings/dist/search.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SemanticSearch = void 0;
+    var SemanticSearch = class {
+      constructor(provider) {
+        this.provider = provider;
+        this.embeddings = /* @__PURE__ */ new Map();
+        this.texts = [];
+        this.metadata = /* @__PURE__ */ new Map();
+      }
+      /**
+       * Add documents to the search index
+       */
+      async addDocuments(documents) {
+        const texts = documents.map((d) => d.text);
+        const embeddings = await this.provider.embedBatch(texts);
+        for (let i = 0; i < documents.length; i++) {
+          const { text, metadata } = documents[i];
+          this.texts.push(text);
+          this.embeddings.set(text, embeddings[i]);
+          if (metadata) {
+            this.metadata.set(text, metadata);
+          }
+        }
+      }
+      /**
+       * Search for similar documents
+       */
+      async search(query, options = {}) {
+        const { topK = 10, threshold = 0 } = options;
+        const queryEmbedding = await this.provider.embed(query);
+        const results = [];
+        for (const text of this.texts) {
+          const embedding = this.embeddings.get(text);
+          const score = this.provider.similarity(queryEmbedding, embedding);
+          if (score >= threshold) {
+            results.push({
+              text,
+              score,
+              embedding,
+              metadata: this.metadata.get(text)
+            });
+          }
+        }
+        results.sort((a, b) => b.score - a.score);
+        return results.slice(0, topK);
+      }
+      /**
+       * Find clusters in the documents
+       */
+      async findClusters(options = {}) {
+        const { minClusterSize = 2, similarityThreshold = 0.7 } = options;
+        const clusters = [];
+        const assigned = /* @__PURE__ */ new Set();
+        for (const text of this.texts) {
+          if (assigned.has(text))
+            continue;
+          const cluster = /* @__PURE__ */ new Set([text]);
+          const embedding = this.embeddings.get(text);
+          for (const other of this.texts) {
+            if (other === text || assigned.has(other))
+              continue;
+            const otherEmbedding = this.embeddings.get(other);
+            const similarity = this.provider.similarity(embedding, otherEmbedding);
+            if (similarity >= similarityThreshold) {
+              cluster.add(other);
+              assigned.add(other);
+            }
+          }
+          if (cluster.size >= minClusterSize) {
+            clusters.push(cluster);
+            assigned.add(text);
+          }
+        }
+        return clusters.map((cluster) => ({
+          members: Array.from(cluster),
+          centroid: Array.from(cluster)[0]
+          // Simple: use first member as centroid
+        }));
+      }
+      /**
+       * Clear the search index
+       */
+      clear() {
+        this.embeddings.clear();
+        this.texts = [];
+        this.metadata.clear();
+      }
+      /**
+       * Get index statistics
+       */
+      stats() {
+        const documentCount = this.texts.length;
+        const dimensions = this.provider.dimensions;
+        const memoryUsage = documentCount * dimensions * 4;
+        return {
+          documentCount,
+          dimensions,
+          memoryUsage
+        };
+      }
+    };
+    exports.SemanticSearch = SemanticSearch;
+  }
+});
+
+// ../../node_modules/@terminals-tech/embeddings/dist/index.js
+var require_dist = __commonJS({
+  "../../node_modules/@terminals-tech/embeddings/dist/index.js"(exports) {
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.VERSION = exports.EmbeddingProviderFactory = exports.SemanticSearch = exports.TransformersEmbeddingProvider = exports.MockEmbeddingProvider = exports.BaseEmbeddingProvider = exports.EmbeddingCache = void 0;
+    exports.enhanceGraphWithSemantics = enhanceGraphWithSemantics;
+    __exportStar(require_types(), exports);
+    var cache_1 = require_cache();
+    Object.defineProperty(exports, "EmbeddingCache", { enumerable: true, get: function() {
+      return cache_1.EmbeddingCache;
+    } });
+    var base_1 = require_base();
+    Object.defineProperty(exports, "BaseEmbeddingProvider", { enumerable: true, get: function() {
+      return base_1.BaseEmbeddingProvider;
+    } });
+    var mock_1 = require_mock();
+    Object.defineProperty(exports, "MockEmbeddingProvider", { enumerable: true, get: function() {
+      return mock_1.MockEmbeddingProvider;
+    } });
+    var transformers_1 = require_transformers();
+    Object.defineProperty(exports, "TransformersEmbeddingProvider", { enumerable: true, get: function() {
+      return transformers_1.TransformersEmbeddingProvider;
+    } });
+    var search_1 = require_search();
+    Object.defineProperty(exports, "SemanticSearch", { enumerable: true, get: function() {
+      return search_1.SemanticSearch;
+    } });
+    var EmbeddingProviderFactory = class {
+      /**
+       * Create the best available provider
+       */
+      static async createBest(options = {}) {
+        const { preferredProvider = "transformers" } = options;
+        if (preferredProvider === "transformers") {
+          try {
+            const { TransformersEmbeddingProvider } = await Promise.resolve().then(() => __importStar(require_transformers()));
+            const provider2 = new TransformersEmbeddingProvider(options);
+            await provider2.initialize();
+            return provider2;
+          } catch (error) {
+            console.warn("Transformers.js not available, falling back to mock provider");
+          }
+        }
+        const { MockEmbeddingProvider } = await Promise.resolve().then(() => __importStar(require_mock()));
+        const provider = new MockEmbeddingProvider(options);
+        await provider.initialize();
+        return provider;
+      }
+      /**
+       * Create a specific provider
+       */
+      static async create(type, options = {}) {
+        switch (type) {
+          case "transformers": {
+            const { TransformersEmbeddingProvider } = await Promise.resolve().then(() => __importStar(require_transformers()));
+            const provider = new TransformersEmbeddingProvider(options);
+            await provider.initialize();
+            return provider;
+          }
+          case "mock": {
+            const { MockEmbeddingProvider } = await Promise.resolve().then(() => __importStar(require_mock()));
+            const provider = new MockEmbeddingProvider(options);
+            await provider.initialize();
+            return provider;
+          }
+          default:
+            throw new Error(`Unknown provider type: ${type}`);
+        }
+      }
+    };
+    exports.EmbeddingProviderFactory = EmbeddingProviderFactory;
+    async function enhanceGraphWithSemantics(graph, provider) {
+      const embeddingProvider = provider || await EmbeddingProviderFactory.createBest();
+      graph.extractSemanticRelations = async function(text) {
+        const sentences = text.split(/[.!?]+/).filter((s) => s.trim());
+        const embeddings = await embeddingProvider.embedBatch(sentences);
+        const relations = [];
+        const patterns = {
+          causal: await embeddingProvider.embed("X causes Y"),
+          temporal: await embeddingProvider.embed("X happens before Y"),
+          dependency: await embeddingProvider.embed("X depends on Y")
+        };
+        for (let i = 0; i < sentences.length - 1; i++) {
+          for (let j = i + 1; j < sentences.length; j++) {
+            const similarity = embeddingProvider.similarity(embeddings[i], embeddings[j]);
+            for (const [type, pattern] of Object.entries(patterns)) {
+              const patternSimilarity = embeddingProvider.similarity(embeddings[i], pattern);
+              if (patternSimilarity > 0.7) {
+                relations.push({
+                  type,
+                  from: sentences[i],
+                  to: sentences[j],
+                  weight: similarity,
+                  semantic: true
+                });
+              }
+            }
+          }
+        }
+        return relations;
+      };
+      graph.findSemanticClusters = async function(events) {
+        const { SemanticSearch } = await Promise.resolve().then(() => __importStar(require_search()));
+        const search = new SemanticSearch(embeddingProvider);
+        await search.addDocuments(events.map((e) => ({
+          text: e.description || e.type || "",
+          metadata: { id: e.id, type: e.type }
+        })));
+        return search.findClusters({
+          minClusterSize: 3,
+          similarityThreshold: 0.8
+        });
+      };
+    }
+    exports.VERSION = "0.1.0";
+  }
+});
+export default require_dist();