@clude/sdk 3.0.1

package/dist/mcp/local-store.js

@@ -0,0 +1,268 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/brain/src/mcp/local-store.ts
+var local_store_exports = {};
+__export(local_store_exports, {
+  localClinamen: () => localClinamen,
+  localDelete: () => localDelete,
+  localList: () => localList,
+  localRecall: () => localRecall,
+  localStats: () => localStats,
+  localStore: () => localStore,
+  localUpdate: () => localUpdate
+});
+module.exports = __toCommonJS(local_store_exports);
+var import_fs = require("fs");
+var import_path = require("path");
+var CLUDE_DIR = (0, import_path.join)(process.env.HOME || process.env.USERPROFILE || ".", ".clude");
+var MEMORIES_FILE = (0, import_path.join)(CLUDE_DIR, "memories.json");
+function ensureDir() {
+  if (!(0, import_fs.existsSync)(CLUDE_DIR)) {
+    (0, import_fs.mkdirSync)(CLUDE_DIR, { recursive: true });
+  }
+}
+function loadStore() {
+  ensureDir();
+  if (!(0, import_fs.existsSync)(MEMORIES_FILE)) {
+    return { version: 1, next_id: 1, memories: [] };
+  }
+  try {
+    const raw = (0, import_fs.readFileSync)(MEMORIES_FILE, "utf-8");
+    const data = JSON.parse(raw);
+    if (!data || !Array.isArray(data.memories)) {
+      console.error("[clude-local] Warning: memories.json has invalid structure, starting fresh. Backup saved.");
+      try {
+        (0, import_fs.writeFileSync)(MEMORIES_FILE + ".bak", raw);
+      } catch {
+      }
+      return { version: 1, next_id: 1, memories: [] };
+    }
+    return data;
+  } catch (err) {
+    console.error("[clude-local] Warning: failed to parse memories.json:", err.message);
+    try {
+      const raw = (0, import_fs.readFileSync)(MEMORIES_FILE, "utf-8");
+      (0, import_fs.writeFileSync)(MEMORIES_FILE + ".bak", raw);
+      console.error("[clude-local] Backup saved to memories.json.bak");
+    } catch {
+    }
+    return { version: 1, next_id: 1, memories: [] };
+  }
+}
+function saveStore(store) {
+  ensureDir();
+  const tmpFile = MEMORIES_FILE + ".tmp";
+  (0, import_fs.writeFileSync)(tmpFile, JSON.stringify(store, null, 2));
+  (0, import_fs.renameSync)(tmpFile, MEMORIES_FILE);
+}
+function scoreRelevance(query, memory) {
+  const queryTerms = query.toLowerCase().split(/\s+/).filter((t) => t.length > 2);
+  if (queryTerms.length === 0) return 0.5;
+  const text = `${memory.summary} ${memory.content} ${memory.tags.join(" ")}`.toLowerCase();
+  let matches = 0;
+  for (const term of queryTerms) {
+    if (text.includes(term)) matches++;
+  }
+  const termScore = queryTerms.length > 0 ? matches / queryTerms.length : 0;
+  const recency = Math.max(0, 1 - (Date.now() - new Date(memory.created_at).getTime()) / (30 * 864e5));
+  const score = termScore * 0.6 + memory.importance * 0.2 + memory.decay_factor * 0.1 + recency * 0.1;
+  return Math.min(1, score);
+}
+function localRecall(opts) {
+  const store = loadStore();
+  let results = store.memories;
+  if (opts.memory_types?.length) {
+    results = results.filter((m) => opts.memory_types.includes(m.memory_type));
+  }
+  if (opts.tags?.length) {
+    results = results.filter((m) => m.tags.some((t) => opts.tags.includes(t)));
+  }
+  if (opts.min_importance !== void 0) {
+    results = results.filter((m) => m.importance >= opts.min_importance);
+  }
+  if (opts.min_decay !== void 0) {
+    results = results.filter((m) => m.decay_factor >= opts.min_decay);
+  }
+  if (opts.related_user) {
+    results = results.filter((m) => m.related_user === opts.related_user);
+  }
+  if (opts.related_wallet) {
+    results = results.filter((m) => m.related_wallet === opts.related_wallet);
+  }
+  if (opts.query) {
+    results = results.map((m) => ({ ...m, _score: scoreRelevance(opts.query, m) })).filter((m) => m._score > 0.1).sort((a, b) => b._score - a._score);
+  } else {
+    results = results.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
+  }
+  const limit = opts.limit || 5;
+  const returned = results.slice(0, limit);
+  for (const r of returned) {
+    const mem = store.memories.find((m) => m.id === r.id);
+    if (mem) {
+      mem.access_count++;
+      mem.last_accessed = (/* @__PURE__ */ new Date()).toISOString();
+      mem.importance = Math.min(1, mem.importance + 0.01);
+    }
+  }
+  saveStore(store);
+  return returned;
+}
+function localStore(opts) {
+  const store = loadStore();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const id = store.next_id++;
+  store.memories.push({
+    id,
+    memory_type: opts.type,
+    content: opts.content,
+    summary: opts.summary,
+    tags: opts.tags || [],
+    concepts: opts.concepts || [],
+    importance: opts.importance ?? 0.5,
+    decay_factor: 1,
+    access_count: 0,
+    emotional_valence: opts.emotional_valence ?? 0,
+    source: opts.source,
+    source_id: opts.source_id,
+    related_user: opts.related_user,
+    related_wallet: opts.related_wallet,
+    metadata: opts.metadata || {},
+    created_at: now,
+    last_accessed: now
+  });
+  saveStore(store);
+  return id;
+}
+function localStats() {
+  const store = loadStore();
+  const memories = store.memories;
+  const byType = {};
+  let totalImportance = 0;
+  let totalDecay = 0;
+  const tagCounts = {};
+  const sourceCounts = {};
+  let oldest = "";
+  let newest = "";
+  let mostAccessed = null;
+  for (const m of memories) {
+    byType[m.memory_type] = (byType[m.memory_type] || 0) + 1;
+    totalImportance += m.importance;
+    totalDecay += m.decay_factor;
+    for (const t of m.tags) {
+      tagCounts[t] = (tagCounts[t] || 0) + 1;
+    }
+    if (m.source) {
+      sourceCounts[m.source] = (sourceCounts[m.source] || 0) + 1;
+    }
+    if (!oldest || m.created_at < oldest) oldest = m.created_at;
+    if (!newest || m.created_at > newest) newest = m.created_at;
+    if (!mostAccessed || m.access_count > mostAccessed.access_count) {
+      mostAccessed = { summary: m.summary, access_count: m.access_count };
+    }
+  }
+  const topTags = Object.entries(tagCounts).sort(([, a], [, b]) => b - a).slice(0, 10).map(([tag, count]) => ({ tag, count }));
+  return {
+    status: "active",
+    mode: "local",
+    storage: MEMORIES_FILE,
+    total_memories: memories.length,
+    by_type: byType,
+    avg_importance: memories.length > 0 ? +(totalImportance / memories.length).toFixed(3) : 0,
+    avg_decay: memories.length > 0 ? +(totalDecay / memories.length).toFixed(3) : 0,
+    top_tags: topTags,
+    sources: sourceCounts,
+    oldest_memory: oldest || null,
+    newest_memory: newest || null,
+    most_accessed: mostAccessed
+  };
+}
+function localClinamen(opts) {
+  const store = loadStore();
+  const minImp = opts.min_importance ?? 0.6;
+  const maxRel = opts.max_relevance ?? 0.35;
+  const limit = opts.limit ?? 3;
+  let candidates = store.memories.filter((m) => m.importance >= minImp);
+  if (opts.memory_types?.length) {
+    candidates = candidates.filter((m) => opts.memory_types.includes(m.memory_type));
+  }
+  const contextTerms = opts.context.toLowerCase().split(/\s+/).filter((t) => t.length > 2);
+  const scored = candidates.map((m) => {
+    const text = `${m.summary} ${m.content}`.toLowerCase();
+    let matches = 0;
+    for (const term of contextTerms) {
+      if (text.includes(term)) matches++;
+    }
+    const relevance = contextTerms.length > 0 ? matches / contextTerms.length : 0;
+    const divergence = m.importance * (1 - relevance);
+    return { ...m, _divergence: divergence, _relevanceSim: relevance };
+  });
+  return scored.filter((m) => m._relevanceSim < maxRel).sort((a, b) => b._divergence - a._divergence).slice(0, limit);
+}
+function localDelete(id) {
+  const store = loadStore();
+  const idx = store.memories.findIndex((m) => m.id === id);
+  if (idx === -1) return false;
+  store.memories.splice(idx, 1);
+  saveStore(store);
+  return true;
+}
+function localUpdate(id, patches) {
+  const store = loadStore();
+  const mem = store.memories.find((m) => m.id === id);
+  if (!mem) return false;
+  if (patches.summary !== void 0) mem.summary = patches.summary;
+  if (patches.content !== void 0) mem.content = patches.content;
+  if (patches.tags !== void 0) mem.tags = patches.tags;
+  if (patches.importance !== void 0) mem.importance = Math.max(0, Math.min(1, patches.importance));
+  if (patches.memory_type !== void 0) mem.memory_type = patches.memory_type;
+  saveStore(store);
+  return true;
+}
+function localList(opts) {
+  const store = loadStore();
+  let memories = [...store.memories];
+  if (opts.memory_type) {
+    memories = memories.filter((m) => m.memory_type === opts.memory_type);
+  }
+  if (opts.min_importance !== void 0) {
+    memories = memories.filter((m) => m.importance >= opts.min_importance);
+  }
+  const order = opts.order ?? "created_at";
+  memories.sort((a, b) => {
+    if (order === "importance") return b.importance - a.importance;
+    if (order === "last_accessed") return b.last_accessed.localeCompare(a.last_accessed);
+    return b.created_at.localeCompare(a.created_at);
+  });
+  const total = memories.length;
+  const pageSize = Math.min(opts.page_size ?? 20, 100);
+  const page = Math.max(opts.page ?? 1, 1);
+  const start = (page - 1) * pageSize;
+  return { memories: memories.slice(start, start + pageSize), total };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  localClinamen,
+  localDelete,
+  localList,
+  localRecall,
+  localStats,
+  localStore,
+  localUpdate
+});