@horribleprogram/sdk 0.1.5 → 0.1.7

package/dist/chunk-4TRAHT2X.js

@@ -0,0 +1,577 @@
+// src/index.ts
+import { pipeline as pipeline2 } from "@xenova/transformers";
+
+// src/intents.ts
+var INTENTS_TAXONOMY = {
+  "GIFTMINDER": {
+    "view_events": [
+      "I want to see events coming up"
+    ],
+    "view_wishlists": [
+      "I want to see wishlists"
+    ],
+    "buy_gifts": [
+      "I want to buy gifts for my loved ones"
+    ]
+  },
+  "REMEMBOT": {
+    "remember": [
+      "I want to remember something"
+    ],
+    "recall": [
+      "I want to recall something"
+    ]
+  },
+  "RESCUEBIDS": {
+    "avoid_fee": [
+      "I want to avoid a bank fee"
+    ],
+    "request_loan": [
+      "I need a small loan"
+    ]
+  },
+  "FOODLINK": {
+    "request_food": [
+      "I'm hungry",
+      "I am hungry"
+    ],
+    "share_food": [
+      "I have food to share",
+      "I want to share some food"
+    ]
+  },
+  "BILLBRIDGE": {
+    "request_bill_help": [
+      "I need help with a bill"
+    ]
+  },
+  "BLOODSHARE": {
+    "request_blood": [
+      "I need blood"
+    ],
+    "share_blood": [
+      "I have blood to share"
+    ]
+  },
+  "MATH": {
+    "compute_expression": [
+      "compute xplusonesquared",
+      "compute xsquaredplusone",
+      "Compute x squared plus one",
+      "Compute x plus one squared"
+    ]
+  },
+  "SHOP_SAVVY": {
+    "add_item": [
+      "Add an item to my shopping list",
+      "I want to add items to my shopping list"
+    ],
+    "remove_item": [
+      "Remove an item from my shopping list"
+    ],
+    "view_list": [
+      "What's on my shopping list",
+      "I want to see my shopping list"
+    ],
+    "edit_list": [
+      "I want to change my shopping list"
+    ],
+    "mark_purchased": [
+      "I've purchased some items on my shopping list",
+      "I have purchased some items on my shopping list"
+    ]
+  },
+  "BOT_STORE": {
+    "add_package": [
+      "I want to buy a package",
+      "I want to add a package"
+    ],
+    "remove_package": [
+      "I want to stop using a package",
+      "I want to remove a package"
+    ]
+  },
+  "TASKMASTERAI": {
+    "add_task": [
+      "I want to add a to do list item to my list",
+      "Add a to do list item",
+      "I want to add a to do list item"
+    ],
+    "view_tasks": [
+      "I want to see my to do list",
+      "Show to do list",
+      "Show my to do list"
+    ],
+    "edit_tasks": [
+      "I want to change my to do list",
+      "I want to edit my to do list"
+    ],
+    "remove_task": [
+      "I want to remove items from my to do list"
+    ]
+  },
+  "FLOWPLANNER": {
+    "create_flow_plan": [
+      "Create a flow plan for tomorrow"
+    ]
+  },
+  "CGM": {
+    "find_company": [
+      "I need a company that...",
+      "I want a company that..."
+    ]
+  },
+  "TIFFANY": {
+    "process_dental_patient": [
+      "I want to process the patient visit for <patient-name>"
+    ]
+  },
+  "CAREMEDIC": {
+    "process_medical_patient": [
+      "I want to process the patient visit for <patient-name>"
+    ]
+  },
+  "DISCRETION": {
+    "retrieval_augmented_generation": [
+      "I need to retrieve information from my documents"
+    ]
+  }
+};
+
+// src/companyEmbeddings.ts
+import * as fs from "fs";
+import { MongoClient } from "mongodb";
+import { pipeline } from "@xenova/transformers";
+function parseCSV(content) {
+  const lines = [];
+  let currentLine = "";
+  let insideQuote = false;
+  for (let i = 0; i < content.length; i++) {
+    const char = content[i];
+    const nextChar = content[i + 1];
+    if (char === '"') {
+      insideQuote = !insideQuote;
+    } else if (char === "\r" || char === "\n") {
+      if (!insideQuote) {
+        if (currentLine || i === 0 || content[i - 1] === "\n" || content[i - 1] === "\r") {
+          lines.push(currentLine);
+          currentLine = "";
+        }
+        if (char === "\r" && nextChar === "\n") {
+          i++;
+        }
+      } else {
+        currentLine += char;
+      }
+    } else {
+      currentLine += char;
+    }
+  }
+  if (currentLine) {
+    lines.push(currentLine);
+  }
+  if (lines.length === 0) return [];
+  const parseLine = (line) => {
+    const result = [];
+    let cell = "";
+    let inside = false;
+    for (let i = 0; i < line.length; i++) {
+      const char = line[i];
+      if (char === '"') {
+        if (inside && line[i + 1] === '"') {
+          cell += '"';
+          i++;
+        } else {
+          inside = !inside;
+        }
+      } else if (char === "," && !inside) {
+        result.push(cell.trim());
+        cell = "";
+      } else {
+        cell += char;
+      }
+    }
+    result.push(cell.trim());
+    return result;
+  };
+  const headers = parseLine(lines[0]);
+  const records = [];
+  for (let i = 1; i < lines.length; i++) {
+    const cells = parseLine(lines[i]);
+    if (cells.length === 1 && cells[0] === "") continue;
+    const record = {};
+    for (let j = 0; j < headers.length; j++) {
+      record[headers[j]] = cells[j] || "";
+    }
+    records.push(record);
+  }
+  return records;
+}
+function companyToText(company) {
+  const parts = [];
+  const keys = [
+    "company_name",
+    "website",
+    "short_description",
+    "product_description",
+    "mapped_function",
+    "mapped_industry",
+    "match_keywords",
+    "aliases",
+    "active",
+    "priority",
+    "source",
+    "zone"
+  ];
+  for (const key of keys) {
+    if (key in company) {
+      const val = String(company[key]).trim();
+      if (val) {
+        parts.push(`${key}: ${val}`);
+      }
+    }
+  }
+  for (const [key, value] of Object.entries(company)) {
+    if (keys.includes(key) || key === "_id" || key === "embedding") continue;
+    const val = String(value).trim();
+    if (val) {
+      parts.push(`${key}: ${val}`);
+    }
+  }
+  return parts.join(" | ");
+}
+function cosineSimilarity(v1, v2) {
+  let dotProduct = 0;
+  let norm1 = 0;
+  let norm2 = 0;
+  for (let i = 0; i < v1.length; i++) {
+    dotProduct += v1[i] * v2[i];
+    norm1 += v1[i] * v1[i];
+    norm2 += v2[i] * v2[i];
+  }
+  if (norm1 === 0 || norm2 === 0) return 0;
+  return dotProduct / (Math.sqrt(norm1) * Math.sqrt(norm2));
+}
+var CompanyEmbeddingManager = class {
+  client = null;
+  config;
+  extractorPromise = null;
+  constructor(config = {}) {
+    this.config = {
+      uri: config.uri || process.env.MONGODB_URI || "mongodb://localhost:27017",
+      dbName: config.dbName || process.env.MONGODB_DB_NAME || "distance_metrics",
+      collectionName: config.collectionName || "companies",
+      openAIApiKey: config.openAIApiKey || process.env.OPENAI_API_KEY || "",
+      preferOpenAI: config.preferOpenAI ?? !!(config.openAIApiKey || process.env.OPENAI_API_KEY)
+    };
+  }
+  async getExtractor() {
+    if (!this.extractorPromise) {
+      this.extractorPromise = (async () => {
+        console.log("Loading local embedding model 'Xenova/all-MiniLM-L12-v2'...");
+        const extractor = await pipeline("feature-extraction", "Xenova/all-MiniLM-L12-v2");
+        console.log("Local embedding model loaded successfully.");
+        return extractor;
+      })();
+    }
+    return this.extractorPromise;
+  }
+  async connect() {
+    if (!this.client) {
+      this.client = new MongoClient(this.config.uri);
+      await this.client.connect();
+    }
+    return this.client;
+  }
+  async getCollection() {
+    const client = await this.connect();
+    return client.db(this.config.dbName).collection(this.config.collectionName);
+  }
+  async disconnect() {
+    if (this.client) {
+      await this.client.close();
+      this.client = null;
+    }
+  }
+  async getEmbedding(text) {
+    if (this.config.preferOpenAI && this.config.openAIApiKey) {
+      const embeddings = await this.getOpenAIBatchEmbeddings([text]);
+      return embeddings[0];
+    }
+    const extractor = await this.getExtractor();
+    const output = await extractor(text, { pooling: "mean", normalize: true });
+    return Array.from(output.data);
+  }
+  async getEmbeddings(texts) {
+    if (texts.length === 0) return [];
+    if (this.config.preferOpenAI && this.config.openAIApiKey) {
+      return this.getOpenAIBatchEmbeddings(texts);
+    }
+    const extractor = await this.getExtractor();
+    const output = await extractor(texts, { pooling: "mean", normalize: true });
+    const dim = output.dims[1];
+    const data = output.data;
+    const embeddings = [];
+    for (let i = 0; i < texts.length; i++) {
+      const startIndex = i * dim;
+      const vector = Array.from(data.subarray(startIndex, startIndex + dim));
+      embeddings.push(vector);
+    }
+    return embeddings;
+  }
+  async getOpenAIBatchEmbeddings(texts) {
+    const batchSize = 50;
+    const results = [];
+    for (let i = 0; i < texts.length; i += batchSize) {
+      const chunk = texts.slice(i, i + batchSize);
+      const response = await fetch("https://api.openai.com/v1/embeddings", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${this.config.openAIApiKey}`
+        },
+        body: JSON.stringify({
+          input: chunk,
+          model: "text-embedding-3-small"
+        })
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`OpenAI API error: ${response.status} - ${errorText}`);
+      }
+      const json = await response.json();
+      results.push(...json.data.map((item) => item.embedding));
+    }
+    return results;
+  }
+  async addCompany(company) {
+    const col = await this.getCollection();
+    let active = company.active;
+    if (typeof active === "string") {
+      const activeStr = active.toLowerCase().trim();
+      active = activeStr === "true" || activeStr === "yes" || activeStr === "1";
+    }
+    const cleanCompany = {
+      ...company,
+      active: !!active
+    };
+    if (!cleanCompany.embedding) {
+      const text = companyToText(cleanCompany);
+      cleanCompany.embedding = await this.getEmbedding(text);
+    }
+    await col.updateOne(
+      { company_name: cleanCompany.company_name },
+      { $set: cleanCompany },
+      { upsert: true }
+    );
+  }
+  async removeCompany(companyName) {
+    const col = await this.getCollection();
+    const result = await col.deleteOne({
+      company_name: { $regex: new RegExp(`^${this.escapeRegExp(companyName)}$`, "i") }
+    });
+    return (result.deletedCount ?? 0) > 0;
+  }
+  async queryCompanies(prompt, limit = 10) {
+    const col = await this.getCollection();
+    const queryVector = await this.getEmbedding(prompt);
+    const allDocs = await col.find({}).toArray();
+    const results = allDocs.filter((doc) => doc.embedding && Array.isArray(doc.embedding)).map((doc) => {
+      const similarity = cosineSimilarity(queryVector, doc.embedding);
+      return {
+        ...doc,
+        similarity
+      };
+    });
+    results.sort((a, b) => b.similarity - a.similarity);
+    return results.slice(0, limit);
+  }
+  async seedFromCSV(csvPath) {
+    const csvContent = fs.readFileSync(csvPath, "utf8");
+    const records = parseCSV(csvContent);
+    if (records.length === 0) return 0;
+    const companies = records.map((rec) => {
+      const activeStr = String(rec.active).toLowerCase().trim();
+      const active = activeStr === "true" || activeStr === "yes" || activeStr === "1";
+      return {
+        company_name: rec.company_name || "",
+        website: rec.website || "",
+        short_description: rec.short_description || "",
+        product_description: rec.product_description || "",
+        mapped_function: rec.mapped_function || "",
+        mapped_industry: rec.mapped_industry || "",
+        match_keywords: rec.match_keywords || "",
+        aliases: rec.aliases || "",
+        active,
+        priority: rec.priority || "",
+        source: rec.source || "",
+        zone: rec.zone || ""
+      };
+    }).filter((c) => c.company_name);
+    const texts = companies.map((c) => companyToText(c));
+    console.log(`Generating embeddings for ${companies.length} companies...`);
+    const embeddings = await this.getEmbeddings(texts);
+    for (let i = 0; i < companies.length; i++) {
+      companies[i].embedding = embeddings[i];
+    }
+    const col = await this.getCollection();
+    await col.deleteMany({});
+    const batchSize = 100;
+    for (let i = 0; i < companies.length; i += batchSize) {
+      const batch = companies.slice(i, i + batchSize);
+      await col.insertMany(batch);
+    }
+    return companies.length;
+  }
+  escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+};
+var defaultManager = null;
+function getDefaultManager(config) {
+  if (!defaultManager || config) {
+    defaultManager = new CompanyEmbeddingManager(config);
+  }
+  return defaultManager;
+}
+async function seedCompanies(csvPath, config) {
+  const manager = getDefaultManager(config);
+  return manager.seedFromCSV(csvPath);
+}
+async function addCompany(company, config) {
+  const manager = getDefaultManager(config);
+  return manager.addCompany(company);
+}
+async function removeCompany(companyName, config) {
+  const manager = getDefaultManager(config);
+  return manager.removeCompany(companyName);
+}
+async function queryCompanies(prompt, limit, config) {
+  const manager = getDefaultManager(config);
+  return manager.queryCompanies(prompt, limit);
+}
+async function closeConnection() {
+  if (defaultManager) {
+    await defaultManager.disconnect();
+    defaultManager = null;
+  }
+}
+
+// src/index.ts
+var extractorPromise = null;
+function getExtractor() {
+  if (!extractorPromise) {
+    extractorPromise = (async () => {
+      console.log("Loading local embedding model 'Xenova/all-MiniLM-L12-v2'...");
+      console.log("Note: On first run, this will download the model files (approx. 120MB).");
+      const extractor = await pipeline2("feature-extraction", "Xenova/all-MiniLM-L12-v2");
+      console.log("Local embedding model loaded successfully.");
+      return extractor;
+    })();
+  }
+  return extractorPromise;
+}
+var cachedTaxonomyEmbeddingsPromise = null;
+async function getTaxonomyEmbeddings() {
+  if (cachedTaxonomyEmbeddingsPromise) {
+    return cachedTaxonomyEmbeddingsPromise;
+  }
+  cachedTaxonomyEmbeddingsPromise = (async () => {
+    const extractor = await getExtractor();
+    const items = [];
+    for (const [domain, intents] of Object.entries(INTENTS_TAXONOMY)) {
+      for (const [intent, utterances] of Object.entries(intents)) {
+        for (const utterance of utterances) {
+          if (utterance.trim()) {
+            items.push({ domain, intent, utterance });
+          }
+        }
+      }
+    }
+    const texts = items.map((item) => item.utterance);
+    const output = await extractor(texts, { pooling: "mean", normalize: true });
+    const dim = output.dims[1];
+    const data = output.data;
+    const embeddings = [];
+    for (let i = 0; i < items.length; i++) {
+      const startIndex = i * dim;
+      const vector = Array.from(data.subarray(startIndex, startIndex + dim));
+      embeddings.push({
+        ...items[i],
+        vector
+      });
+    }
+    return embeddings;
+  })();
+  return cachedTaxonomyEmbeddingsPromise;
+}
+function cosineSimilarity2(v1, v2) {
+  let dotProduct = 0;
+  let norm1 = 0;
+  let norm2 = 0;
+  for (let i = 0; i < v1.length; i++) {
+    dotProduct += v1[i] * v2[i];
+    norm1 += v1[i] * v1[i];
+    norm2 += v2[i] * v2[i];
+  }
+  if (norm1 === 0 || norm2 === 0) return 0;
+  return dotProduct / (Math.sqrt(norm1) * Math.sqrt(norm2));
+}
+var Botcierge = class {
+  constructor(config = {}) {
+  }
+  async query_intent(utterance) {
+    const extractor = await getExtractor();
+    const output = await extractor(utterance, { pooling: "mean", normalize: true });
+    const queryVector = Array.from(output.data);
+    const taxEmbeddings = await getTaxonomyEmbeddings();
+    let bestSim = -1;
+    let bestItem = null;
+    for (const item of taxEmbeddings) {
+      const sim = cosineSimilarity2(queryVector, item.vector);
+      if (sim > bestSim) {
+        bestSim = sim;
+        bestItem = item;
+      }
+    }
+    if (!bestItem || bestSim < 0.35) {
+      return {
+        domain: "unknown",
+        intent: "unknown",
+        confidence: "low",
+        scores: {}
+      };
+    }
+    let confidence = "low";
+    if (bestSim >= 0.7) {
+      confidence = "high";
+    } else if (bestSim >= 0.5) {
+      confidence = "medium";
+    }
+    return {
+      domain: bestItem.domain,
+      intent: bestItem.intent,
+      confidence,
+      scores: {
+        [bestItem.intent]: bestSim
+      }
+    };
+  }
+};
+var defaultClient = new Botcierge();
+async function query_intent(utterance) {
+  return defaultClient.query_intent(utterance);
+}
+
+export {
+  parseCSV,
+  companyToText,
+  CompanyEmbeddingManager,
+  seedCompanies,
+  addCompany,
+  removeCompany,
+  queryCompanies,
+  closeConnection,
+  Botcierge,
+  query_intent
+};