coolmem 1.0.0 → 1.0.1

package/package.json

@@ -1,13 +1,18 @@
 {
   "name": "coolmem",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Cross-Agent Memory Fabric — a privacy-first MCP server for shared AI memory with local vector embeddings.",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
     "coolmem": "./dist/index.js"
   },
+  "files": [
+    "dist",
+    "prisma"
+  ],
   "scripts": {
+    "postinstall": "prisma generate",
     "build": "tsc && chmod +x dist/index.js",
     "start": "node dist/index.js",
     "dev": "node --loader ts-node/esm src/index.ts",
@@ -18,11 +23,11 @@
     "@modelcontextprotocol/sdk": "^1.6.1",
     "@prisma/client": "^5.22.0",
     "@xenova/transformers": "^2.17.2",
+    "prisma": "^5.22.0",
     "zod": "^3.23.8"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
-    "prisma": "^5.22.0",
     "ts-node": "^10.9.2",
     "typescript": "^5.7.2"
   }

package/seed.mjs

@@ -1,69 +0,0 @@
-/**
- * seed.mjs — stores architectural decisions about coolmem into coolmem itself.
- * Run once: node seed.mjs
- */
-import { PrismaClient } from "@prisma/client";
-import { pipeline, env } from "@xenova/transformers";
-
-const prisma = new PrismaClient();
-env.cacheDir = "./models";
-
-function encodeEmbedding(vector) {
-    return Buffer.from(new Float32Array(vector).buffer);
-}
-function decodeEmbedding(buf) {
-    return Array.from(new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4));
-}
-function dotProduct(a, b) {
-    let dot = 0;
-    for (let i = 0; i < a.length; i++) dot += a[i] * b[i];
-    return dot;
-}
-
-const DEDUP = 0.88;
-
-process.stdout.write("⏳ Loading model…\n");
-const extractor = await pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2");
-process.stdout.write("✅ Model ready.\n\n");
-
-async function embed(text) {
-    const out = await extractor(text, { pooling: "mean", normalize: true });
-    return Array.from(out.data);
-}
-
-async function store(content, category, project = "coolmem") {
-    const vec = await embed(content);
-    const existing = await prisma.memory.findMany({ where: { project }, select: { id: true, embedding: true } });
-    for (const m of existing) {
-        if (dotProduct(vec, decodeEmbedding(m.embedding)) >= DEDUP) {
-            await prisma.memory.update({ where: { id: m.id }, data: { content, category, embedding: encodeEmbedding(vec) } });
-            process.stdout.write(`♻️  Updated #${m.id} (duplicate)\n`);
-            return;
-        }
-    }
-    const r = await prisma.memory.create({ data: { content, category, project, embedding: encodeEmbedding(vec) } });
-    process.stdout.write(`✅ Stored #${r.id} [${category}]\n`);
-}
-
-await store(
-    "cosineSimilarity in similarity.ts is implemented as a pure dot product, not full cosine. This is correct and optimal because embeddings.ts always uses { normalize: true } with all-MiniLM-L6-v2, making every vector a unit vector (magnitude = 1). For unit vectors, cosine similarity = dot product. This saves ~60% of operations per comparison: removes 2 magnitude accumulators and 2 Math.sqrt calls across all 384 dimensions. If normalize is ever changed to false, full cosine must be restored.",
-    "architecture"
-);
-
-await store(
-    "Similarity search is brute-force O(n): all embeddings are loaded into RAM and scored per query. This is fine up to ~1,000 memories. Beyond that, switch to sqlite-vss (ANN index inside SQLite) or ChromaDB. Each embedding costs 1,536 bytes as Float32 BLOB.",
-    "architecture"
-);
-
-await store(
-    "DEDUP_THRESHOLD = 0.88 for store_memory deduplication. 0.95 was too strict (missed paraphrased rewrites of the same fact). 0.88 catches semantic duplicates without false-positives on genuinely different memories. MIN_SCORE_THRESHOLD = 0.30 for search (below this, results are irrelevant noise).",
-    "decision"
-);
-
-await store(
-    "all-MiniLM-L6-v2 (Xenova) is loaded lazily on first tool call and cached in ./models/. First-run downloads ~22 MB. It produces 384-dimensional L2-normalized float32 sentence embeddings. The pipeline instance is a module-level singleton — only one load per server process regardless of how many tool calls arrive.",
-    "architecture"
-);
-
-await prisma.$disconnect();
-process.stdout.write("\n🎉 coolmem seeded with its own architecture decisions.\n");

package/test.mjs

@@ -1,185 +0,0 @@
-/**
- * test.mjs — Integration test for coolmem v2 (all optimizations)
- * Run with:  node test.mjs
- */
-
-import { PrismaClient } from "@prisma/client";
-import { pipeline, env } from "@xenova/transformers";
-
-// ── color helpers ─────────────────────────────────────────────────────────────
-const bold = (s) => `\x1b[1m${s}\x1b[0m`;
-const dim = (s) => `\x1b[2m${s}\x1b[0m`;
-const green = (s) => `\x1b[32m${s}\x1b[0m`;
-const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
-const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
-const red = (s) => `\x1b[31m${s}\x1b[0m`;
-const hr = (c = "─", n = 60) => c.repeat(n);
-
-// ── binary codec (mirrors src/index.ts) ───────────────────────────────────────
-function encodeEmbedding(vector) {
-    return Buffer.from(new Float32Array(vector).buffer);
-}
-function decodeEmbedding(buf) {
-    return Array.from(new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4));
-}
-function cosineSimilarity(a, b) {
-    let dot = 0, magA = 0, magB = 0;
-    for (let i = 0; i < a.length; i++) { dot += a[i] * b[i]; magA += a[i] * a[i]; magB += b[i] * b[i]; }
-    return dot / (Math.sqrt(magA) * Math.sqrt(magB));
-}
-
-// ── setup ─────────────────────────────────────────────────────────────────────
-const prisma = new PrismaClient();
-env.cacheDir = "./models";
-let extractor;
-
-async function loadModel() {
-    process.stdout.write(yellow("⏳ Loading model…\n"));
-    extractor = await pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2");
-    process.stdout.write(green("✅ Model ready.\n\n"));
-}
-async function embed(text) {
-    const out = await extractor(text, { pooling: "mean", normalize: true });
-    return Array.from(out.data);
-}
-
-// ── tool simulations ──────────────────────────────────────────────────────────
-const DEDUP_THRESHOLD = 0.95;
-const MIN_SCORE = 0.30;
-
-async function storeMemory(content, category, project = "default") {
-    const vector = await embed(content);
-    const existing = await prisma.memory.findMany({ where: { project }, select: { id: true, embedding: true } });
-    for (const m of existing) {
-        const score = cosineSimilarity(vector, decodeEmbedding(m.embedding));
-        if (score >= DEDUP_THRESHOLD) {
-            await prisma.memory.update({ where: { id: m.id }, data: { content, category, embedding: encodeEmbedding(vector) } });
-            return { id: m.id, duplicate: true, score };
-        }
-    }
-    const r = await prisma.memory.create({ data: { content, category, project, embedding: encodeEmbedding(vector) } });
-    return { id: r.id, duplicate: false };
-}
-
-async function searchMemories(query, project, limit = 3) {
-    const qVec = await embed(query);
-    const all = await prisma.memory.findMany({
-        where: project ? { project } : undefined,
-        select: { id: true, content: true, category: true, project: true, embedding: true }
-    });
-    return all
-        .map(m => ({ ...m, score: cosineSimilarity(qVec, decodeEmbedding(m.embedding)) }))
-        .filter(m => m.score >= MIN_SCORE)
-        .sort((a, b) => b.score - a.score)
-        .slice(0, limit);
-}
-
-async function deleteMemory(id) {
-    return prisma.memory.delete({ where: { id } });
-}
-
-async function updateMemory(id, content, category) {
-    const newEmbed = content ? encodeEmbedding(await embed(content)) : undefined;
-    return prisma.memory.update({
-        where: { id }, data: {
-            ...(content && { content }), ...(category && { category }), ...(newEmbed && { embedding: newEmbed }),
-        }
-    });
-}
-
-// ── test runner ───────────────────────────────────────────────────────────────
-async function main() {
-    console.log("\n" + bold("🧠 coolmem v2 — Integration Test"));
-    console.log(hr("═") + "\n");
-    await loadModel();
-
-    // PHASE 1 — Store (two projects)
-    console.log(bold("PHASE 1 — store_memory (with project scoping)"));
-    console.log(hr() + "\n");
-    const toStore = [
-        { content: "We use SQLite with Prisma ORM. Embeddings stored as binary BLOBs (Float32Array).", category: "architecture", project: "coolmem" },
-        { content: "all-MiniLM-L6-v2 runs locally on CPU: 22 MB, 384-dim, zero API cost.", category: "decision", project: "coolmem" },
-        { content: "MCP server uses stdio transport — never write to stdout or you corrupt the protocol.", category: "architecture", project: "coolmem" },
-        { content: "The admin dashboard uses MongoDB with Next.js API routes for the revenue KPI endpoint.", category: "architecture", project: "admin-dashboard" },
-    ];
-    for (const m of toStore) {
-        const r = await storeMemory(m.content, m.category, m.project);
-        const tag = r.duplicate ? yellow(`♻️  Deduplicated → updated #${r.id} (score ${r.score?.toFixed(4)})`) : green(`✅ Stored as #${r.id}`);
-        console.log(`   [${m.project}] ${tag}`);
-        console.log(dim(`   "${m.content.slice(0, 80)}…"\n`));
-    }
-
-    // PHASE 2 — Deduplication
-    console.log(bold("PHASE 2 — Deduplication (store near-identical content)"));
-    console.log(hr() + "\n");
-    const dupResult = await storeMemory(
-        "all-MiniLM-L6-v2 runs on CPU locally: 22 MB model, produces 384-dimensional embeddings, no API key needed.",
-        "decision", "coolmem"
-    );
-    if (dupResult.duplicate) {
-        console.log(yellow(`   ♻️  Correctly detected duplicate! Updated #${dupResult.id} (score: ${dupResult.score.toFixed(4)})\n`));
-    } else {
-        console.log(red(`   ❌ Duplicate NOT detected — threshold may need tuning.\n`));
-    }
-
-    // PHASE 3 — Search (project-scoped + score threshold)
-    console.log(bold("PHASE 3 — search_memories (scoped + score threshold 0.30)"));
-    console.log(hr() + "\n");
-    const queries = [
-        { q: "how are embeddings stored?", project: "coolmem" },
-        { q: "what AI model do we use?", project: "coolmem" },
-        { q: "what database does admin dashboard use?", project: "admin-dashboard" },
-        { q: "quantum physics lecture notes", project: undefined }, // should return nothing
-    ];
-    for (const { q, project } of queries) {
-        console.log(cyan(`   🔍 "${q}"${project ? ` [project: ${project}]` : " [all projects]"}`));
-        const results = await searchMemories(q, project);
-        if (results.length === 0) {
-            console.log(dim(`   → No results above threshold (correct for irrelevant query)\n`));
-        } else {
-            results.forEach((r, i) =>
-                console.log(`   #${i + 1} score=${r.score.toFixed(4)} [${r.project}/${r.category}]\n   ${dim(r.content.slice(0, 90) + "…")}`)
-            );
-            console.log();
-        }
-    }
-
-    // PHASE 4 — Update
-    console.log(bold("PHASE 4 — update_memory"));
-    console.log(hr() + "\n");
-    const all = await prisma.memory.findMany({ take: 1, orderBy: { id: "asc" }, select: { id: true, content: true } });
-    if (all.length > 0) {
-        const { id } = all[0];
-        await updateMemory(id, undefined, "architecture-v2"); // only category changed
-        console.log(green(`   ✅ Updated category of Memory #${id} to "architecture-v2" (no re-embed needed)\n`));
-    }
-
-    // PHASE 5 — Delete
-    console.log(bold("PHASE 5 — delete_memory"));
-    console.log(hr() + "\n");
-    const last = await prisma.memory.findFirst({ orderBy: { id: "desc" }, select: { id: true } });
-    if (last) {
-        await deleteMemory(last.id);
-        console.log(green(`   ✅ Deleted Memory #${last.id}\n`));
-    }
-
-    // PHASE 6 — Timeline
-    console.log(bold("PHASE 6 — project_timeline resource"));
-    console.log(hr() + "\n");
-    const timeline = await prisma.memory.findMany({
-        orderBy: { createdAt: "desc" }, take: 10,
-        select: { id: true, content: true, category: true, project: true, createdAt: true },
-    });
-    for (const m of timeline) {
-        const ts = m.createdAt.toISOString().replace("T", " ").slice(0, 19);
-        console.log(`   [${ts}] #${m.id} | ${m.project} | ${m.category}`);
-        console.log(dim(`   ${m.content.slice(0, 90)}…\n`));
-    }
-
-    console.log(hr("═"));
-    console.log(green(bold("🎉 All phases passed!")));
-
-    await prisma.$disconnect();
-}
-
-main().catch(e => { console.error(red("FATAL:"), e); prisma.$disconnect(); process.exit(1); });