@wipcomputer/memory-crystal 0.7.30 → 0.7.32

package/dist/chunk-J7MRSZIO.js

@@ -1,167 +0,0 @@
-// src/cloud-crystal.ts
-async function embed(text, apiKey) {
-  const resp = await fetch("https://api.openai.com/v1/embeddings", {
-    method: "POST",
-    headers: {
-      "Authorization": `Bearer ${apiKey}`,
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({
-      model: "text-embedding-3-small",
-      input: text,
-      dimensions: 1024
-    })
-  });
-  if (!resp.ok) {
-    const err = await resp.text();
-    throw new Error(`Embedding failed: ${resp.status} ${err}`);
-  }
-  const data = await resp.json();
-  return data.data[0].embedding;
-}
-var CloudCrystal = class {
-  constructor(db, vectorize, apiKey) {
-    this.db = db;
-    this.vectorize = vectorize;
-    this.apiKey = apiKey;
-  }
-  // Hybrid search: BM25 (FTS5) + vector (Vectorize) + RRF fusion + recency
-  async search(userId, query, limit = 5, agentId) {
-    const agentFilter = agentId ? "AND c.agent_id = ?" : "";
-    const bm25Params = [userId, query];
-    if (agentId) bm25Params.push(agentId);
-    const bm25Results = await this.db.prepare(`
-      SELECT c.id, c.text, c.role, c.agent_id, c.created_at, c.source_type,
-             rank AS bm25_score
-      FROM chunks_fts f
-      JOIN chunks c ON c.id = f.rowid
-      WHERE f.text MATCH ? AND c.user_id = ? ${agentFilter}
-      ORDER BY rank
-      LIMIT ?
-    `).bind(query, userId, ...agentId ? [agentId] : [], limit * 3).all();
-    const queryVec = await embed(query, this.apiKey);
-    const vecResults = await this.vectorize.query(queryVec, {
-      topK: limit * 3,
-      filter: { user_id: userId, ...agentId ? { agent_id: agentId } : {} },
-      returnMetadata: "all"
-    });
-    const k = 60;
-    const scores = /* @__PURE__ */ new Map();
-    const bm25Rows = bm25Results.results || [];
-    for (let i = 0; i < bm25Rows.length; i++) {
-      const id = bm25Rows[i].id;
-      const existing = scores.get(id) || { score: 0, data: bm25Rows[i] };
-      existing.score += 1 / (k + i + 1);
-      scores.set(id, existing);
-    }
-    for (let i = 0; i < vecResults.matches.length; i++) {
-      const match = vecResults.matches[i];
-      const id = parseInt(match.id, 10);
-      const existing = scores.get(id) || { score: 0 };
-      existing.score += 1 / (k + i + 1);
-      scores.set(id, existing);
-    }
-    const now = Date.now();
-    for (const [id, entry] of scores) {
-      if (entry.data?.created_at) {
-        const age = now - new Date(entry.data.created_at).getTime();
-        const dayAge = age / (1e3 * 60 * 60 * 24);
-        const recencyBoost = Math.max(0, 1 - dayAge / 90) * 0.15;
-        entry.score += recencyBoost;
-      }
-    }
-    const ranked = [...scores.entries()].sort((a, b) => b[1].score - a[1].score).slice(0, limit);
-    const needFetch = ranked.filter(([_, v]) => !v.data).map(([id]) => id);
-    if (needFetch.length > 0) {
-      const placeholders = needFetch.map(() => "?").join(",");
-      const rows = await this.db.prepare(
-        `SELECT id, text, role, agent_id, created_at, source_type FROM chunks WHERE id IN (${placeholders})`
-      ).bind(...needFetch).all();
-      const rowMap = new Map(rows.results.map((r) => [r.id, r]));
-      for (const [id, entry] of scores) {
-        if (!entry.data && rowMap.has(id)) {
-          entry.data = rowMap.get(id);
-        }
-      }
-    }
-    return ranked.map(([id, entry]) => ({
-      id,
-      text: entry.data?.text || "",
-      score: entry.score,
-      role: entry.data?.role || "unknown",
-      agent_id: entry.data?.agent_id || "unknown",
-      created_at: entry.data?.created_at || "",
-      source_type: entry.data?.source_type || "unknown"
-    }));
-  }
-  // Ingest chunks (conversation turns)
-  async ingest(userId, chunks) {
-    let ingested = 0;
-    for (const chunk of chunks) {
-      const result = await this.db.prepare(`
-        INSERT INTO chunks (user_id, text, role, agent_id, source_type, token_count)
-        VALUES (?, ?, ?, ?, ?, ?)
-      `).bind(
-        userId,
-        chunk.text,
-        chunk.role,
-        chunk.agent_id,
-        chunk.source_type || "chatgpt",
-        Math.ceil(chunk.text.length / 4)
-        // rough token estimate
-      ).run();
-      const chunkId = result.meta.last_row_id;
-      const vec = await embed(chunk.text, this.apiKey);
-      await this.vectorize.upsert([{
-        id: String(chunkId),
-        values: vec,
-        metadata: {
-          user_id: userId,
-          agent_id: chunk.agent_id,
-          role: chunk.role,
-          source_type: chunk.source_type || "chatgpt"
-        }
-      }]);
-      ingested++;
-    }
-    return ingested;
-  }
-  // Remember a fact/preference/event
-  async remember(userId, text, category = "fact") {
-    const result = await this.db.prepare(`
-      INSERT INTO memories (user_id, text, category) VALUES (?, ?, ?)
-    `).bind(userId, text, category).run();
-    return result.meta.last_row_id;
-  }
-  // Forget (deprecate) a memory
-  async forget(userId, memoryId) {
-    const result = await this.db.prepare(`
-      UPDATE memories SET status = 'deprecated', updated_at = datetime('now')
-      WHERE id = ? AND user_id = ? AND status = 'active'
-    `).bind(memoryId, userId).run();
-    return (result.meta.changes || 0) > 0;
-  }
-  // Status
-  async status(userId) {
-    const chunkCount = await this.db.prepare(
-      "SELECT COUNT(*) as count FROM chunks WHERE user_id = ?"
-    ).bind(userId).first();
-    const memoryCount = await this.db.prepare(
-      "SELECT COUNT(*) as count FROM memories WHERE user_id = ? AND status = ?"
-    ).bind(userId, "active").first();
-    const agents = await this.db.prepare(
-      "SELECT DISTINCT agent_id FROM chunks WHERE user_id = ?"
-    ).bind(userId).all();
-    return {
-      chunks: chunkCount?.count || 0,
-      memories: memoryCount?.count || 0,
-      agents: (agents.results || []).map((r) => r.agent_id),
-      tier: "convenience"
-      // Tier 2 users only
-    };
-  }
-};
-
-export {
-  CloudCrystal
-};

package/dist/chunk-JITKI2OI.js

@@ -1,106 +0,0 @@
-// src/crypto.ts
-import { readFileSync, existsSync } from "fs";
-import { createCipheriv, createDecipheriv, createHmac, randomBytes, hkdfSync } from "crypto";
-import { join } from "path";
-import { createHash } from "crypto";
-var HOME = process.env.HOME || "";
-var KEY_PATH = process.env.CRYSTAL_RELAY_KEY_PATH || join(HOME, ".openclaw", "secrets", "crystal-relay-key");
-function loadRelayKey() {
-  if (!existsSync(KEY_PATH)) {
-    throw new Error(
-      `Relay key not found at ${KEY_PATH}
-Generate one: openssl rand -base64 32 > ${KEY_PATH} && chmod 600 ${KEY_PATH}
-Copy the same key to all trusted machines.`
-    );
-  }
-  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
-};