@wipcomputer/memory-crystal 0.7.30 → 0.7.32

package/dist/chunk-7IUE7ODU.js

@@ -1,254 +0,0 @@
-// src/llm.ts
-import { existsSync, readFileSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
-import { execSync } from "child_process";
-var samplingServer = null;
-function setSamplingServer(server) {
-  samplingServer = server;
-}
-var expansionCache = /* @__PURE__ */ new Map();
-var detectedProvider = null;
-var detectionDone = false;
-function getOpSecret(itemName, fieldLabel) {
-  try {
-    const saTokenPath = join(homedir(), ".openclaw/secrets/op-sa-token");
-    if (!existsSync(saTokenPath)) return void 0;
-    const saToken = readFileSync(saTokenPath, "utf-8").trim();
-    const result = execSync(
-      `OP_SERVICE_ACCOUNT_TOKEN="${saToken}" op item get "${itemName}" --vault "Agent Secrets" --fields "${fieldLabel}" --reveal`,
-      { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }
-    ).trim();
-    return result || void 0;
-  } catch {
-    return void 0;
-  }
-}
-async function detectProvider() {
-  if (detectionDone && detectedProvider) return detectedProvider;
-  detectionDone = true;
-  if (samplingServer) {
-    detectedProvider = { provider: "sampling", baseURL: "", apiKey: "", model: "client-selected" };
-    process.stderr.write("[memory-crystal] LLM provider: MCP Sampling (via client)\n");
-    return detectedProvider;
-  }
-  try {
-    const resp = await fetch("http://localhost:8080/v1/models", { signal: AbortSignal.timeout(1e3) });
-    if (resp.ok) {
-      const data = await resp.json();
-      const model = data?.data?.[0]?.id || "default";
-      detectedProvider = { provider: "mlx", baseURL: "http://localhost:8080/v1", apiKey: "not-needed", model };
-      process.stderr.write(`[memory-crystal] LLM provider: MLX (${model})
-`);
-      return detectedProvider;
-    }
-  } catch {
-  }
-  try {
-    const resp = await fetch("http://localhost:11434/api/tags", { signal: AbortSignal.timeout(1e3) });
-    if (resp.ok) {
-      const data = await resp.json();
-      const models = data?.models || [];
-      const embeddingOnly = ["nomic-embed-text", "mxbai-embed", "all-minilm", "snowflake-arctic-embed"];
-      const chatModel = models.find((m) => !embeddingOnly.some((e) => m.name.startsWith(e)));
-      if (chatModel) {
-        detectedProvider = { provider: "ollama", baseURL: "http://localhost:11434/v1", apiKey: "ollama", model: chatModel.name };
-        process.stderr.write(`[memory-crystal] LLM provider: Ollama (${chatModel.name})
-`);
-        return detectedProvider;
-      }
-    }
-  } catch {
-  }
-  const openaiKey = process.env.OPENAI_API_KEY || getOpSecret("OpenAI API", "api key");
-  if (openaiKey) {
-    detectedProvider = { provider: "openai", baseURL: "https://api.openai.com/v1", apiKey: openaiKey, model: "gpt-4o-mini" };
-    process.stderr.write("[memory-crystal] LLM provider: OpenAI API\n");
-    return detectedProvider;
-  }
-  const anthropicKey = process.env.ANTHROPIC_API_KEY || getOpSecret("Anthropic Auth Token - remote bunkers", "Auth Token");
-  if (anthropicKey && !anthropicKey.startsWith("sk-ant-oat")) {
-    detectedProvider = { provider: "anthropic", baseURL: "https://api.anthropic.com", apiKey: anthropicKey, model: "claude-haiku-4-5-20251001" };
-    process.stderr.write("[memory-crystal] LLM provider: Anthropic API\n");
-    return detectedProvider;
-  }
-  detectedProvider = { provider: "none", baseURL: "", apiKey: "", model: "" };
-  process.stderr.write("[memory-crystal] LLM provider: none (deep search unavailable)\n");
-  return detectedProvider;
-}
-async function chatComplete(config, messages, maxTokens = 300) {
-  if (config.provider === "sampling") {
-    return samplingComplete(messages, maxTokens);
-  }
-  if (config.provider === "anthropic") {
-    return anthropicComplete(config, messages, maxTokens);
-  }
-  const resp = await fetch(`${config.baseURL}/chat/completions`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "Authorization": `Bearer ${config.apiKey}`
-    },
-    body: JSON.stringify({
-      model: config.model,
-      messages,
-      max_tokens: maxTokens,
-      temperature: 0.7
-    })
-  });
-  if (!resp.ok) throw new Error(`LLM request failed: ${resp.status}`);
-  const data = await resp.json();
-  return data.choices?.[0]?.message?.content || "";
-}
-async function anthropicComplete(config, messages, maxTokens) {
-  const systemMsg = messages.find((m) => m.role === "system");
-  const userMessages = messages.filter((m) => m.role !== "system");
-  const body = {
-    model: config.model,
-    max_tokens: maxTokens,
-    messages: userMessages
-  };
-  if (systemMsg) body.system = systemMsg.content;
-  const resp = await fetch("https://api.anthropic.com/v1/messages", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "x-api-key": config.apiKey,
-      "anthropic-version": "2023-06-01"
-    },
-    body: JSON.stringify(body)
-  });
-  if (!resp.ok) throw new Error(`Anthropic request failed: ${resp.status}`);
-  const data = await resp.json();
-  return data.content?.[0]?.text || "";
-}
-async function samplingComplete(messages, maxTokens) {
-  if (!samplingServer) throw new Error("MCP sampling server not set");
-  const systemMsg = messages.find((m) => m.role === "system");
-  const userMessages = messages.filter((m) => m.role !== "system");
-  const result = await samplingServer.createMessage({
-    messages: userMessages.map((m) => ({
-      role: m.role,
-      content: { type: "text", text: m.content }
-    })),
-    systemPrompt: systemMsg?.content,
-    maxTokens,
-    modelPreferences: {
-      // Request cheap, fast model (Haiku-class). We don't need Opus for query expansion.
-      costPriority: 0.9,
-      speedPriority: 0.8,
-      intelligencePriority: 0.3,
-      hints: [{ name: "haiku" }]
-    }
-  });
-  if (result?.content?.type === "text") return result.content.text;
-  if (typeof result?.content === "string") return result.content;
-  return "";
-}
-var EXPAND_PROMPT = `You are a search query expander. Given a search query, generate exactly 3 variations to improve search recall.
-
-Output exactly 3 lines in this format (no other text):
-lex: <keyword-focused variation for full-text search>
-vec: <semantic variation rephrased for embedding similarity>
-hyde: <hypothetical document snippet that would answer this query>
-
-Rules:
-- Each variation must contain at least one term from the original query
-- Keep variations concise (under 30 words each)
-- lex should use specific keywords and synonyms
-- vec should rephrase the intent naturally
-- hyde should be a short passage as if answering the query`;
-async function expandQuery(query) {
-  const cached = expansionCache.get(query);
-  if (cached) return cached;
-  const config = await detectProvider();
-  if (config.provider === "none") return [];
-  try {
-    const result = await chatComplete(config, [
-      { role: "system", content: EXPAND_PROMPT },
-      { role: "user", content: query }
-    ], 300);
-    const lines = result.trim().split("\n");
-    const queryLower = query.toLowerCase();
-    const queryTerms = queryLower.replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter(Boolean);
-    const hasQueryTerm = (text) => {
-      const lower = text.toLowerCase();
-      if (queryTerms.length === 0) return true;
-      return queryTerms.some((term) => lower.includes(term));
-    };
-    const variations = lines.map((line) => {
-      const colonIdx = line.indexOf(":");
-      if (colonIdx === -1) return null;
-      const type = line.slice(0, colonIdx).trim();
-      if (type !== "lex" && type !== "vec" && type !== "hyde") return null;
-      const text = line.slice(colonIdx + 1).trim();
-      if (!text || !hasQueryTerm(text)) return null;
-      return { type, text };
-    }).filter((v) => v !== null);
-    if (variations.length > 0) {
-      expansionCache.set(query, variations);
-      return variations;
-    }
-  } catch (err) {
-    process.stderr.write(`[memory-crystal] Query expansion failed: ${err.message}
-`);
-  }
-  const fallback = [
-    { type: "lex", text: query },
-    { type: "vec", text: query },
-    { type: "hyde", text: `Information about ${query}` }
-  ];
-  return fallback;
-}
-var RERANK_PROMPT = `You are a search result re-ranker. Given a query and a list of text passages, rate each passage's relevance to the query.
-
-Output one line per passage in this exact format:
-<index>: <score>
-
-Where index is the passage number (0-based) and score is a float from 0.0 to 1.0.
-- 1.0 = perfectly relevant, directly answers the query
-- 0.7 = highly relevant, closely related
-- 0.4 = somewhat relevant, tangentially related
-- 0.1 = barely relevant
-- 0.0 = not relevant at all
-
-Rate ALL passages. Output nothing else.`;
-async function rerankResults(query, passages) {
-  const config = await detectProvider();
-  if (config.provider === "none") {
-    return passages.map((_, i) => ({ index: i, score: 1 - i * 0.01 }));
-  }
-  try {
-    const passageList = passages.map((p, i) => `[${i}] ${p.slice(0, 500)}`).join("\n\n");
-    const result = await chatComplete(config, [
-      { role: "system", content: RERANK_PROMPT },
-      { role: "user", content: `Query: ${query}
-
-Passages:
-${passageList}` }
-    ], 200);
-    const results = [];
-    for (const line of result.trim().split("\n")) {
-      const match = line.match(/^(\d+):\s*([\d.]+)/);
-      if (match) {
-        results.push({ index: parseInt(match[1]), score: parseFloat(match[2]) });
-      }
-    }
-    const scored = new Set(results.map((r) => r.index));
-    for (let i = 0; i < passages.length; i++) {
-      if (!scored.has(i)) results.push({ index: i, score: 0 });
-    }
-    return results.sort((a, b) => b.score - a.score);
-  } catch (err) {
-    process.stderr.write(`[memory-crystal] Reranking failed: ${err.message}
-`);
-    return passages.map((_, i) => ({ index: i, score: 1 - i * 0.01 }));
-  }
-}
-
-export {
-  setSamplingServer,
-  detectProvider,
-  expandQuery,
-  rerankResults
-};

package/dist/chunk-7RMLKZIS.js

@@ -1,108 +0,0 @@
-import {
-  resolveSecretPath
-} from "./chunk-DACSKLY6.js";
-
-// src/crypto.ts
-import { readFileSync, existsSync } from "fs";
-import { createCipheriv, createDecipheriv, createHmac, randomBytes, hkdfSync } from "crypto";
-import { createHash } from "crypto";
-var KEY_PATH = process.env.CRYSTAL_RELAY_KEY_PATH || resolveSecretPath("crystal-relay-key");
-function loadRelayKey() {
-  if (!existsSync(KEY_PATH)) {
-    throw new Error(
-      `Relay key not found at ${KEY_PATH}
-Generate one: mkdir -p ~/.ldm/secrets && openssl rand -base64 32 > ~/.ldm/secrets/crystal-relay-key && chmod 600 ~/.ldm/secrets/crystal-relay-key
-Or run: crystal pair`
-    );
-  }
-  const raw = readFileSync(KEY_PATH, "utf-8").trim();
-  const key = Buffer.from(raw, "base64");
-  if (key.length !== 32) {
-    throw new Error(`Relay key must be 32 bytes (256 bits). Got ${key.length} bytes. Regenerate with: openssl rand -base64 32`);
-  }
-  return key;
-}
-function deriveSigningKey(masterKey) {
-  return Buffer.from(hkdfSync("sha256", masterKey, "", "crystal-relay-sign", 32));
-}
-function encrypt(plaintext, masterKey) {
-  const nonce = randomBytes(12);
-  const cipher = createCipheriv("aes-256-gcm", masterKey, nonce);
-  const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
-  const tag = cipher.getAuthTag();
-  const signingKey = deriveSigningKey(masterKey);
-  const hmacData = Buffer.concat([nonce, ciphertext, tag]);
-  const hmac = createHmac("sha256", signingKey).update(hmacData).digest("hex");
-  return {
-    v: 1,
-    nonce: nonce.toString("base64"),
-    ciphertext: ciphertext.toString("base64"),
-    tag: tag.toString("base64"),
-    hmac
-  };
-}
-function decrypt(payload, masterKey) {
-  if (payload.v !== 1) {
-    throw new Error(`Unknown payload version: ${payload.v}`);
-  }
-  const nonce = Buffer.from(payload.nonce, "base64");
-  const ciphertext = Buffer.from(payload.ciphertext, "base64");
-  const tag = Buffer.from(payload.tag, "base64");
-  const signingKey = deriveSigningKey(masterKey);
-  const hmacData = Buffer.concat([nonce, ciphertext, tag]);
-  const expectedHmac = createHmac("sha256", signingKey).update(hmacData).digest("hex");
-  if (payload.hmac !== expectedHmac) {
-    throw new Error("HMAC verification failed \u2014 blob rejected (tampered or wrong key)");
-  }
-  const decipher = createDecipheriv("aes-256-gcm", masterKey, nonce);
-  decipher.setAuthTag(tag);
-  return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
-}
-function encryptJSON(data, masterKey) {
-  const plaintext = Buffer.from(JSON.stringify(data), "utf-8");
-  return encrypt(plaintext, masterKey);
-}
-function decryptJSON(payload, masterKey) {
-  const plaintext = decrypt(payload, masterKey);
-  return JSON.parse(plaintext.toString("utf-8"));
-}
-function encryptFile(filePath, masterKey) {
-  const plaintext = readFileSync(filePath);
-  return encrypt(plaintext, masterKey);
-}
-var RELAY_KEY_PATH = KEY_PATH;
-function generateRelayKey() {
-  return randomBytes(32);
-}
-function encodePairingString(key) {
-  if (key.length !== 32) throw new Error("Key must be 32 bytes");
-  return `mc1:${key.toString("base64")}`;
-}
-function decodePairingString(str) {
-  const trimmed = str.trim();
-  if (!trimmed.startsWith("mc1:")) {
-    throw new Error("Invalid pairing string (expected mc1: prefix)");
-  }
-  const key = Buffer.from(trimmed.slice(4), "base64");
-  if (key.length !== 32) {
-    throw new Error(`Invalid key length: expected 32 bytes, got ${key.length}`);
-  }
-  return key;
-}
-function hashBuffer(data) {
-  return createHash("sha256").update(data).digest("hex");
-}
-
-export {
-  loadRelayKey,
-  encrypt,
-  decrypt,
-  encryptJSON,
-  decryptJSON,
-  encryptFile,
-  RELAY_KEY_PATH,
-  generateRelayKey,
-  encodePairingString,
-  decodePairingString,
-  hashBuffer
-};