@tensakulabs/memory 0.1.0

package/dist/stage.js

@@ -0,0 +1,236 @@
+#!/usr/bin/env bun
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// lib.ts
+var exports_lib = {};
+__export(exports_lib, {
+  readJsonl: () => readJsonl,
+  loadConfig: () => loadConfig,
+  generateId: () => generateId,
+  coldSearch: () => coldSearch,
+  coldAdd: () => coldAdd
+});
+import { readFileSync, existsSync } from "fs";
+import { join, resolve, dirname } from "path";
+var {$ } = globalThis.Bun;
+function loadConfig(explicitPath) {
+  const home = process.env.HOME || "~";
+  const candidates = [];
+  if (explicitPath) {
+    candidates.push(resolve(explicitPath));
+  }
+  if (process.env.MEMORY_CONFIG) {
+    candidates.push(resolve(process.env.MEMORY_CONFIG));
+  }
+  candidates.push(join(home, ".pai", "memory", CONFIG_FILENAME));
+  candidates.push(join(dirname(Bun.main), CONFIG_FILENAME));
+  candidates.push(resolve(CONFIG_FILENAME));
+  const configPath = candidates.find((p) => existsSync(p));
+  if (!configPath) {
+    console.error(`Config not found. Searched:`);
+    for (const c of candidates)
+      console.error(`  - ${c}`);
+    console.error(`
+Run: memory init`);
+    process.exit(1);
+  }
+  const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+  const configDir = dirname(configPath);
+  const config = {
+    agent: raw.agent || "unknown",
+    hot: {
+      path: resolvePath(configDir, raw.hot?.path || "./MEMORY.md")
+    },
+    warm: {
+      path: resolvePath(configDir, raw.warm?.path || "./warm.jsonl"),
+      ttlDays: raw.warm?.ttlDays ?? 7
+    },
+    cold: {
+      mode: raw.cold?.mode || "mcp",
+      endpoint: raw.cold?.endpoint,
+      userId: raw.cold?.userId || "justin"
+    },
+    remSleep: {
+      maxColdWrites: raw.remSleep?.maxColdWrites ?? 5,
+      dedupThreshold: raw.remSleep?.dedupThreshold ?? 0.85,
+      stagingPath: resolvePath(configDir, raw.remSleep?.stagingPath || "./rem-staging.jsonl")
+    }
+  };
+  if (config.cold.mode === "http" && !config.cold.endpoint) {
+    console.error("cold.mode is 'http' but no cold.endpoint specified.");
+    process.exit(1);
+  }
+  return { config, configDir };
+}
+function resolvePath(base, p) {
+  if (p.startsWith("/") || p.startsWith("~"))
+    return p.replace(/^~/, process.env.HOME || "~");
+  return resolve(base, p);
+}
+async function coldSearch(config, query) {
+  if (config.cold.mode === "mcp") {
+    return coldSearchMcp(query, config.cold.userId);
+  } else {
+    return coldSearchHttp(config.cold.endpoint, query, config.cold.userId);
+  }
+}
+async function coldAdd(config, fact) {
+  if (config.cold.mode === "mcp") {
+    return coldAddMcp(fact, config.cold.userId);
+  } else {
+    return coldAddHttp(config.cold.endpoint, fact, config.cold.userId);
+  }
+}
+async function coldSearchMcp(query, userId) {
+  try {
+    const escaped = query.replace(/"/g, "\\\"");
+    const prompt = `Search mem0 for this fact and report if it already exists. Use search_memories with query: "${escaped}" and user_id "${userId}". If results exist with high relevance, respond ONLY with: FOUND|<score>|<matching text>. If no close match, respond ONLY with: NOT_FOUND|0|none. Do not explain.`;
+    const result = await $`claude -p ${prompt} --allowedTools "mcp__mem0__search_memories" 2>/dev/null`.text();
+    const line = result.trim().split(`
+`).pop() || "";
+    if (line.startsWith("FOUND|")) {
+      const parts = line.split("|");
+      return { score: parseFloat(parts[1]) || 0, text: parts[2] || "" };
+    }
+    return { score: 0, text: "" };
+  } catch {
+    return { score: 0, text: "" };
+  }
+}
+async function coldAddMcp(fact, userId) {
+  try {
+    const escaped = fact.replace(/"/g, "\\\"");
+    const prompt = `Add this fact to mem0. Use add_memory with text: "${escaped}" and user_id "${userId}". Respond ONLY with: DONE or FAILED.`;
+    const result = await $`claude -p ${prompt} --allowedTools "mcp__mem0__add_memory" 2>/dev/null`.text();
+    return result.trim().includes("DONE");
+  } catch {
+    return false;
+  }
+}
+async function coldSearchHttp(endpoint, query, userId) {
+  try {
+    const res = await fetch(`${endpoint}/v1/memories/search/`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ query, user_id: userId })
+    });
+    if (!res.ok)
+      return { score: 0, text: "" };
+    const data = await res.json();
+    const top = data.results?.[0];
+    if (top) {
+      return { score: top.score ?? 0, text: top.memory ?? "" };
+    }
+    return { score: 0, text: "" };
+  } catch {
+    return { score: 0, text: "" };
+  }
+}
+async function coldAddHttp(endpoint, fact, userId) {
+  try {
+    const res = await fetch(`${endpoint}/v1/memories/`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ text: fact, user_id: userId })
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+function generateId() {
+  return `rem-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+}
+function readJsonl(path) {
+  if (!existsSync(path))
+    return [];
+  return readFileSync(path, "utf-8").trim().split(`
+`).filter(Boolean).map((line) => JSON.parse(line));
+}
+var CONFIG_FILENAME = "memory-config.json";
+var init_lib = () => {};
+
+// stage.ts
+var exports_stage = {};
+__export(exports_stage, {
+  run: () => run
+});
+import { appendFileSync } from "fs";
+function parseArgs(args) {
+  if (args.includes("--list"))
+    return { command: "list" };
+  if (args.includes("--count"))
+    return { command: "count" };
+  const fact = args.find((a) => !a.startsWith("--"));
+  if (!fact) {
+    console.error('Usage: memory stage "fact text" [--context "..."] [--tier hot|warm|cold]');
+    process.exit(1);
+  }
+  let context = "";
+  const ctxIdx = args.indexOf("--context");
+  if (ctxIdx !== -1 && args[ctxIdx + 1])
+    context = args[ctxIdx + 1];
+  let tierHint = "auto";
+  const tierIdx = args.indexOf("--tier");
+  if (tierIdx !== -1 && args[tierIdx + 1]) {
+    const t = args[tierIdx + 1];
+    if (t === "hot" || t === "warm" || t === "cold")
+      tierHint = t;
+  }
+  return { command: "stage", fact, context, tierHint };
+}
+async function run(args) {
+  const { config } = loadConfig();
+  const STAGING = config.remSleep.stagingPath;
+  const parsed = parseArgs(args);
+  if (parsed.command === "list") {
+    const entries = readJsonl(STAGING).filter((e) => !e.processed);
+    if (entries.length === 0) {
+      console.log("No staged facts.");
+    } else {
+      for (const e of entries) {
+        const hint = e.tier_hint === "auto" ? "" : ` [${e.tier_hint}]`;
+        console.log(`${e.id}: ${e.fact}${hint}`);
+      }
+      console.log(`
+${entries.length} fact(s) pending.`);
+    }
+  } else if (parsed.command === "count") {
+    console.log(readJsonl(STAGING).filter((e) => !e.processed).length);
+  } else {
+    const entry = {
+      id: generateId(),
+      fact: parsed.fact,
+      timestamp: new Date().toISOString(),
+      context: parsed.context || "",
+      tier_hint: parsed.tierHint || "auto",
+      processed: false
+    };
+    appendFileSync(STAGING, JSON.stringify(entry) + `
+`);
+    console.log(`Staged: ${entry.id}`);
+  }
+}
+var init_stage = __esm(() => {
+  init_lib();
+  if (import.meta.main) {
+    run(process.argv.slice(2));
+  }
+});
+init_stage();
+
+export {
+  run
+};

package/examples/atlas.config.json

@@ -0,0 +1,19 @@
+{
+  "agent": "atlas",
+  "hot": {
+    "path": "/home/openclaw/memory/MEMORY.md"
+  },
+  "warm": {
+    "path": "/home/openclaw/memory/warm.jsonl"
+  },
+  "cold": {
+    "mode": "http",
+    "endpoint": "http://localhost:8080",
+    "userId": "justin"
+  },
+  "remSleep": {
+    "maxColdWrites": 5,
+    "dedupThreshold": 0.85,
+    "stagingPath": "/home/openclaw/memory/rem-staging.jsonl"
+  }
+}

package/examples/sage.config.json

@@ -0,0 +1,18 @@
+{
+  "agent": "sage",
+  "hot": {
+    "path": "../MEMORY.md"
+  },
+  "warm": {
+    "path": "./warm.jsonl"
+  },
+  "cold": {
+    "mode": "mcp",
+    "userId": "justin"
+  },
+  "remSleep": {
+    "maxColdWrites": 5,
+    "dedupThreshold": 0.85,
+    "stagingPath": "./rem-staging.jsonl"
+  }
+}

package/memory-config.example.json

@@ -0,0 +1,19 @@
+{
+  "agent": "your-agent-name",
+  "hot": {
+    "path": "./MEMORY.md"
+  },
+  "warm": {
+    "path": "./warm.jsonl"
+  },
+  "cold": {
+    "mode": "mcp",
+    "endpoint": "http://localhost:8080",
+    "userId": "your-user-id"
+  },
+  "remSleep": {
+    "maxColdWrites": 5,
+    "dedupThreshold": 0.85,
+    "stagingPath": "./rem-staging.jsonl"
+  }
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@tensakulabs/memory",
+  "version": "0.1.0",
+  "description": "Three-tier memory system (hot/warm/cold) with REM Sleep batch consolidation for AI agents",
+  "type": "module",
+  "main": "./dist/lib.js",
+  "types": "./dist/lib.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/lib.js",
+      "types": "./dist/lib.d.ts"
+    },
+    "./stage": {
+      "import": "./dist/stage.js",
+      "types": "./dist/stage.d.ts"
+    },
+    "./rem-sleep": {
+      "import": "./dist/rem-sleep.js",
+      "types": "./dist/rem-sleep.d.ts"
+    }
+  },
+  "bin": {
+    "memory": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "bun build cli.ts lib.ts stage.ts rem-sleep.ts --outdir dist --target bun && tsc --emitDeclarationOnly",
+    "prepublishOnly": "bun run build",
+    "typecheck": "tsc --noEmit"
+  },
+  "files": [
+    "dist/",
+    "memory-config.example.json",
+    "examples/",
+    "README.md"
+  ],
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "keywords": ["memory", "ai", "agent", "mem0", "batch", "three-tier", "rem-sleep"],
+  "author": "Tensaku Labs",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tensakulabs/memory.git"
+  },
+  "bugs": {
+    "url": "https://github.com/tensakulabs/memory/issues"
+  },
+  "homepage": "https://github.com/tensakulabs/memory#readme",
+  "devDependencies": {
+    "bun-types": "^1.3.9",
+    "typescript": "^5.9.3"
+  }
+}