@bike4mind/cli 0.1.0

package/dist/chunk-ETEFNJEP.js

@@ -0,0 +1,235 @@
+#!/usr/bin/env node
+import {
+  EmbeddingFactory,
+  computeCosineSimilarity,
+  getProviderFromModel,
+  getSettingsByNames,
+  obfuscateApiKey,
+  secureParameters
+} from "./chunk-JVPB6BB5.js";
+import {
+  ApiKeyType,
+  MementoTier,
+  isSupportedEmbeddingModel
+} from "./chunk-MKO2KCCS.js";
+
+// ../../b4m-core/packages/services/dist/src/apiKeyService/get.js
+import { z } from "zod";
+var getApiKeySchema = z.object({
+  type: z.nativeEnum(ApiKeyType),
+  nullIfMissing: z.boolean().optional(),
+  obfuscate: z.boolean().optional(),
+  demoKeyName: z.string().optional()
+});
+var getApiKey = async (userId, params, { db }) => {
+  const { type, obfuscate } = secureParameters(params, getApiKeySchema);
+  const apiKey = await db.apiKeys.findByUserIdAndType(userId, type);
+  if (apiKey && obfuscate) {
+    return {
+      ...apiKey,
+      apiKey: obfuscateApiKey(apiKey.apiKey)
+    };
+  }
+  return apiKey;
+};
+var getMultipleApiKeys = async (userId, types, { db }, options) => {
+  const apiKeys = await db.apiKeys.findByUserIdAndTypes(userId, types);
+  if (options?.obfuscate) {
+    return apiKeys.map((apiKey) => ({
+      ...apiKey,
+      apiKey: obfuscateApiKey(apiKey.apiKey)
+    }));
+  }
+  return apiKeys;
+};
+
+// ../../b4m-core/packages/services/dist/src/apiKeyService/getEffective.js
+var DEMO_KEY_MAP = {
+  [ApiKeyType.openai]: "openaiDemoKey",
+  [ApiKeyType.anthropic]: "anthropicDemoKey",
+  [ApiKeyType.gemini]: "geminiDemoKey",
+  [ApiKeyType.xai]: "xaiApiKey",
+  [ApiKeyType.bfl]: "bflApiKey",
+  [ApiKeyType.voyageai]: "voyageApiKey"
+};
+var getSerperKey = async (adapters) => {
+  const { db } = adapters;
+  const settings = await db.adminSettings.findBySettingName("SerperKey");
+  return settings?.settingValue;
+};
+var getOpenWeatherKey = async (adapters) => {
+  const { db } = adapters;
+  const settings = await db.adminSettings.findBySettingName("OpenWeatherKey");
+  return settings?.settingValue;
+};
+var getEffectiveApiKey = async (userId, params, adapters) => {
+  const { db } = adapters;
+  const apiKey = await getApiKey(userId, params, adapters);
+  let key = apiKey?.apiKey;
+  if (!key) {
+    const demoKeyName = params.demoKeyName || DEMO_KEY_MAP[params.type];
+    if (demoKeyName) {
+      const settings = await db.adminSettings.findBySettingName(demoKeyName);
+      key = settings?.settingValue;
+    }
+  }
+  return key;
+};
+var getEffectiveLLMApiKeys = async (userId, adapters, options) => {
+  const { db } = adapters;
+  const logger = options?.logger;
+  const apiKeyFetchStartTime = Date.now();
+  const userApiKeys = await getMultipleApiKeys(userId, [ApiKeyType.openai, ApiKeyType.anthropic, ApiKeyType.gemini, ApiKeyType.bfl, ApiKeyType.xai, ApiKeyType.voyageai], adapters);
+  const userKeyMap = /* @__PURE__ */ new Map();
+  userApiKeys.forEach((key) => userKeyMap.set(key.type, key));
+  const openaiUserKey = userKeyMap.get(ApiKeyType.openai) || null;
+  const anthropicUserKey = userKeyMap.get(ApiKeyType.anthropic) || null;
+  const geminiUserKey = userKeyMap.get(ApiKeyType.gemini) || null;
+  const bflUserKey = userKeyMap.get(ApiKeyType.bfl) || null;
+  const xaiUserKey = userKeyMap.get(ApiKeyType.xai) || null;
+  const voyageaiUserKey = userKeyMap.get(ApiKeyType.voyageai) || null;
+  const adminSettingNames = [
+    "openaiDemoKey",
+    "anthropicDemoKey",
+    "geminiDemoKey",
+    "bflApiKey",
+    "xaiApiKey",
+    "voyageApiKey",
+    "ollamaBackend",
+    "EnableOllama"
+  ];
+  const adminSettingsStartTime = Date.now();
+  const adminSettings = await getSettingsByNames(adminSettingNames, { adminSettings: db.adminSettings }, { logger });
+  const openaiDemoKey = adminSettings["openaiDemoKey"];
+  const anthropicDemoKey = adminSettings["anthropicDemoKey"];
+  const geminiDemoKey = adminSettings["geminiDemoKey"];
+  const bflDemoKey = adminSettings["bflApiKey"];
+  const xaiDemoKey = adminSettings["xaiApiKey"];
+  const voyageaiDemoKey = adminSettings["voyageApiKey"];
+  const ollamaBackend = adminSettings["ollamaBackend"];
+  const enableOllama = adminSettings["EnableOllama"];
+  const adminSettingsTime = Date.now() - adminSettingsStartTime;
+  const totalTime = Date.now() - apiKeyFetchStartTime;
+  if (logger) {
+    logger.info(`\u{1F4E6} Cached admin settings fetch completed in ${adminSettingsTime}ms (total API key fetch: ${totalTime}ms)`);
+  }
+  const ollamaEnabled = enableOllama === "true" || enableOllama === true;
+  const keyOrExpired = (apiKey) => {
+    if (!apiKey)
+      return null;
+    if (apiKey.expiresAt && apiKey.expiresAt < /* @__PURE__ */ new Date())
+      return "expired";
+    return apiKey.apiKey;
+  };
+  return {
+    openai: keyOrExpired(openaiUserKey) || openaiDemoKey || null,
+    anthropic: keyOrExpired(anthropicUserKey) || anthropicDemoKey || null,
+    gemini: keyOrExpired(geminiUserKey) || geminiDemoKey || null,
+    bfl: keyOrExpired(bflUserKey) || bflDemoKey || null,
+    xai: keyOrExpired(xaiUserKey) || xaiDemoKey || null,
+    voyageai: keyOrExpired(voyageaiUserKey) || voyageaiDemoKey || null,
+    ollama: ollamaEnabled ? ollamaBackend || null : null
+  };
+};
+
+// ../../b4m-core/packages/services/dist/src/mementoService/getRelevantMementos.js
+async function getRelevantMementos(userId, prompt, options = {}, adapters) {
+  const { topK = 5, minSimilarity = 0.7, tier = MementoTier.HOT, embeddingModel: providedEmbeddingModel, apiKeyTable: providedApiKeyTable, logger } = options;
+  logger?.updateMetadata({
+    promptLength: prompt.length
+  });
+  const apiKeyTable = providedApiKeyTable || await getEffectiveLLMApiKeys(userId, {
+    db: {
+      apiKeys: adapters.db.apiKeys,
+      adminSettings: adapters.db.adminSettings
+    }
+  }, { logger });
+  let embeddingModel = providedEmbeddingModel;
+  if (!embeddingModel) {
+    const defaultModel = await adapters.db.adminSettings.getSettingsValue("defaultEmbeddingModel");
+    if (!defaultModel || !isSupportedEmbeddingModel(defaultModel)) {
+      throw new Error("Default embedding model not configured. Please configure it in admin settings.");
+    }
+    embeddingModel = defaultModel;
+  }
+  logger?.debug?.("Using embedding model for memento retrieval:", embeddingModel);
+  const requiredProvider = getProviderFromModel(embeddingModel);
+  const embeddingConfig = {};
+  if (requiredProvider === "openai") {
+    if (!apiKeyTable?.openai) {
+      throw new Error("OpenAI API key is required for memento retrieval but not found.");
+    }
+    embeddingConfig.openaiApiKey = apiKeyTable.openai;
+  } else if (requiredProvider === "voyageai") {
+    if (!apiKeyTable?.voyageai) {
+      throw new Error("VoyageAI API key is required for memento retrieval but not found.");
+    }
+    embeddingConfig.voyageApiKey = apiKeyTable.voyageai;
+  }
+  const embeddingFactory = new EmbeddingFactory(embeddingConfig);
+  const embeddingService = embeddingFactory.createEmbeddingService(embeddingModel);
+  logger?.debug?.("Generating embedding for prompt:", prompt.substring(0, 100));
+  try {
+    const promptEmbedding = await embeddingService.generateEmbedding(prompt);
+    const mementos = await adapters.db.mementos.findByUserId(userId, {
+      tier: tier === "all" ? void 0 : tier,
+      select: "summary embedding weight tags fullContent lastAccessedAt"
+    });
+    logger?.debug?.(`Found ${mementos.length} mementos to search through (tier: ${tier})`);
+    if (mementos.length === 0) {
+      logger?.debug?.("No mementos found for user");
+      return [];
+    }
+    const mementosWithScores = mementos.reduce((acc, memento) => {
+      if (!memento.embedding || memento.embedding.length === 0) {
+        logger?.warn?.(`Memento ${memento.id} missing embedding, skipping`);
+        return acc;
+      }
+      const similarity = computeCosineSimilarity(promptEmbedding, memento.embedding);
+      if (similarity >= minSimilarity) {
+        acc.push({
+          memento,
+          similarity
+        });
+      }
+      return acc;
+    }, []);
+    const sortedMementos = mementosWithScores.sort((a, b) => b.similarity - a.similarity).slice(0, topK);
+    logger?.debug?.(`Returning ${sortedMementos.length} relevant mementos (min similarity: ${minSimilarity}, topK: ${topK})`);
+    if (sortedMementos.length > 0) {
+      logger?.debug?.(`Top memento similarity: ${sortedMementos[0].similarity.toFixed(3)} - "${sortedMementos[0].memento.summary}"`);
+    }
+    return sortedMementos;
+  } catch (error) {
+    logger?.warn?.("Error generating embedding for prompt, returning empty array:", error);
+    return [];
+  }
+}
+
+// ../../b4m-core/packages/services/dist/src/mementoService/findMostSimilarMemento.js
+function findMostSimilarMemento(targetEmbedding, mementos) {
+  let highestSimilarity = 0;
+  let mostSimilarMemento = null;
+  for (const memento of mementos) {
+    if (!memento.embedding || memento.embedding.length === 0) {
+      continue;
+    }
+    const similarity = computeCosineSimilarity(targetEmbedding, memento.embedding);
+    if (similarity > highestSimilarity) {
+      highestSimilarity = similarity;
+      mostSimilarMemento = memento;
+    }
+  }
+  return {
+    memento: mostSimilarMemento,
+    similarity: highestSimilarity
+  };
+}
+
+export {
+  getSerperKey,
+  getOpenWeatherKey,
+  getEffectiveApiKey,
+  getRelevantMementos,
+  findMostSimilarMemento
+};