@tensakulabs/memory 0.1.0

package/dist/lib.js

@@ -0,0 +1,171 @@
+// @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 = () => {};
+init_lib();
+
+export {
+  readJsonl,
+  loadConfig,
+  generateId,
+  coldSearch,
+  coldAdd
+};

package/dist/rem-sleep.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env bun
+/**
+ * Memory Module — REM Sleep Batch Processor
+ *
+ * Reads staged facts, classifies (hot/warm/cold), deduplicates against
+ * mem0, and routes to appropriate tier. All config from memory-config.json.
+ *
+ * Usage:
+ *   bun rem-sleep.ts                    # Full run
+ *   bun rem-sleep.ts --dry-run          # Show decisions without executing
+ *   bun rem-sleep.ts --stats            # Show staging stats only
+ */
+export declare function run(args: string[]): Promise<void>;

package/dist/rem-sleep.js

@@ -0,0 +1,337 @@
+#!/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 = () => {};
+
+// rem-sleep.ts
+var exports_rem_sleep = {};
+__export(exports_rem_sleep, {
+  run: () => run
+});
+import { writeFileSync, appendFileSync } from "fs";
+import { join as join2, dirname as dirname2 } from "path";
+function classify(fact) {
+  if (fact.tier_hint !== "auto") {
+    return { ...fact, tier: fact.tier_hint, reason: `explicit: ${fact.tier_hint}` };
+  }
+  const text = `${fact.fact} ${fact.context}`;
+  const hot = HOT_SIGNALS.reduce((s, r) => s + (r.test(text) ? 1 : 0), 0);
+  const warm = WARM_SIGNALS.reduce((s, r) => s + (r.test(text) ? 1 : 0), 0);
+  const cold = COLD_SIGNALS.reduce((s, r) => s + (r.test(text) ? 1 : 0), 0);
+  if (hot > warm && hot > cold)
+    return { ...fact, tier: "hot", reason: `hot signals: ${hot}` };
+  if (warm > cold)
+    return { ...fact, tier: "warm", reason: `warm signals: ${warm}` };
+  if (cold > 0)
+    return { ...fact, tier: "cold", reason: `cold signals: ${cold}` };
+  return { ...fact, tier: "warm", reason: "default (no strong signals)" };
+}
+function appendToWarm(fact) {
+  const entry = {
+    id: fact.id,
+    fact: fact.fact,
+    origin: "new",
+    created: fact.timestamp,
+    last_access: new Date().toISOString(),
+    access_count: 1,
+    context: fact.context
+  };
+  appendFileSync(WARM, JSON.stringify(entry) + `
+`);
+}
+async function run(args) {
+  const dryRun = args.includes("--dry-run");
+  const statsOnly = args.includes("--stats");
+  const allEntries = readJsonl(STAGING);
+  const pending = allEntries.filter((e) => !e.processed);
+  if (statsOnly) {
+    console.log(`Agent: ${config.agent}`);
+    console.log(`Cold mode: ${config.cold.mode}`);
+    console.log(`Total entries: ${allEntries.length}`);
+    console.log(`Pending: ${pending.length}`);
+    console.log(`Processed: ${allEntries.length - pending.length}`);
+    return;
+  }
+  if (pending.length === 0) {
+    console.log("No pending facts. Staging is clean.");
+    return;
+  }
+  console.log(`
+\uD83C\uDF19 REM Sleep [${config.agent}] \u2014 Processing ${pending.length} fact(s)${dryRun ? " [DRY RUN]" : ""}`);
+  console.log(`   Cold mode: ${config.cold.mode} | Max writes: ${config.remSleep.maxColdWrites} | Dedup: ${config.remSleep.dedupThreshold}
+`);
+  const classified = pending.map(classify);
+  const hot = classified.filter((f) => f.tier === "hot");
+  const warm = classified.filter((f) => f.tier === "warm");
+  const cold = classified.filter((f) => f.tier === "cold");
+  console.log(`\uD83D\uDCCA Classification: ${hot.length} hot, ${warm.length} warm, ${cold.length} cold
+`);
+  if (hot.length > 0) {
+    console.log("\uD83D\uDD25 HOT \u2014 Suggested MEMORY.md additions (review manually):");
+    console.log(`   Target: ${config.hot.path}`);
+    for (const f of hot)
+      console.log(`  - ${f.fact}  (${f.reason})`);
+    console.log();
+  }
+  if (warm.length > 0) {
+    console.log("\u2668\uFE0F  WARM \u2014 Cross-agent shared facts:");
+    for (const f of warm) {
+      console.log(`  - ${f.fact}`);
+      if (!dryRun)
+        appendToWarm(f);
+    }
+    console.log(dryRun ? `  \u2192 Would write to ${WARM}
+` : `  \u2192 Written to ${WARM}
+`);
+  }
+  let coldWritten = 0;
+  let coldSkipped = 0;
+  let coldCapped = 0;
+  if (cold.length > 0) {
+    console.log("\uD83E\uDDCA COLD \u2014 Long-tail facts (mem0 candidates):");
+    for (const f of cold) {
+      if (coldWritten >= config.remSleep.maxColdWrites) {
+        console.log(`  \u23F8 ${f.fact}  \u2192 DEFERRED (cap reached)`);
+        coldCapped++;
+        continue;
+      }
+      console.log(`  - ${f.fact}`);
+      if (dryRun) {
+        console.log(`    \u2192 Would search mem0 (${config.cold.mode}) then add if new`);
+        continue;
+      }
+      const match = await coldSearch(config, f.fact);
+      if (match.score >= config.remSleep.dedupThreshold) {
+        console.log(`    \u2192 SKIP (dup: ${(match.score * 100).toFixed(0)}% \u2014 "${match.text.slice(0, 60)}...")`);
+        coldSkipped++;
+      } else {
+        const ok = await coldAdd(config, f.fact);
+        console.log(ok ? `    \u2192 ADDED to mem0` : `    \u2192 FAILED`);
+        if (ok)
+          coldWritten++;
+      }
+    }
+    console.log();
+  }
+  if (!dryRun) {
+    const cappedIds = new Set(cold.slice(config.remSleep.maxColdWrites).map((f) => f.id));
+    const updated = allEntries.map((e) => !e.processed && !cappedIds.has(e.id) ? { ...e, processed: true } : e);
+    writeFileSync(STAGING, updated.map((e) => JSON.stringify(e)).join(`
+`) + `
+`);
+  }
+  const report = {
+    timestamp: new Date().toISOString(),
+    agent: config.agent,
+    coldMode: config.cold.mode,
+    dryRun,
+    staged: pending.length,
+    classified: { hot: hot.length, warm: warm.length, cold: cold.length },
+    written: { cold: coldWritten, warm: dryRun ? 0 : warm.length, hotSuggested: hot.length },
+    skipped: coldSkipped,
+    deferred: coldCapped,
+    cost: `~$${(coldWritten * 0.001).toFixed(4)}`
+  };
+  if (!dryRun)
+    writeFileSync(REPORT, JSON.stringify(report, null, 2));
+  console.log("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  console.log(`\u2705 REM Sleep [${config.agent}] complete${dryRun ? " (dry run)" : ""}`);
+  console.log(`   Hot: ${hot.length} suggested | Warm: ${dryRun ? 0 : warm.length} written | Cold: ${coldWritten} added, ${coldSkipped} dup, ${coldCapped} deferred`);
+  console.log(`   Cost: ${report.cost}`);
+}
+var config, configDir, STAGING, WARM, REPORT, HOT_SIGNALS, WARM_SIGNALS, COLD_SIGNALS;
+var init_rem_sleep = __esm(() => {
+  init_lib();
+  ({ config, configDir } = loadConfig());
+  STAGING = config.remSleep.stagingPath;
+  WARM = config.warm.path;
+  REPORT = join2(dirname2(STAGING), "last-run.json");
+  HOT_SIGNALS = [
+    /\bmy (model|config|cron|path|key|token|port|setup)\b/i,
+    /\b(localhost|127\.0\.0\.1|~\/|\/home\/)/i,
+    /\b(launchd|plist|systemd|crontab)\b/i,
+    /\b(heartbeat) model\b/i
+  ];
+  WARM_SIGNALS = [
+    /\b(we|our|us|together|both agents|cross-agent)\b/i,
+    /\b(prefers|wants|decided|likes|agreed)\b/i,
+    /\b(strategy|approach|decision|convention)\b/i,
+    /\b(project|milestone|roadmap|plan)\b/i
+  ];
+  COLD_SIGNALS = [
+    /\b(PR #\d+|issue #\d+|bug #\d+)\b/i,
+    /\b(benchmark|pricing|per M tokens)\b/i,
+    /\b(workaround|root cause|known issue)\b/i,
+    /\b(research|found|discovered|learned)\b/i
+  ];
+  if (import.meta.main) {
+    run(process.argv.slice(2)).catch((err) => {
+      console.error("REM Sleep failed:", err);
+      process.exit(1);
+    });
+  }
+});
+init_rem_sleep();
+
+export {
+  run
+};

package/dist/stage.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env bun
+/**
+ * Memory Module — Stage
+ *
+ * Appends a fact to rem-staging.jsonl for later batch processing.
+ * All paths from memory-config.json.
+ *
+ * Usage:
+ *   memory stage "fact text" [--context "..."] [--tier hot|warm|cold]
+ *   memory stage --list | --count
+ *   bun stage.ts "fact text"  (standalone mode)
+ */
+export declare function run(args: string[]): Promise<void>;