alvin-bot 4.10.0 → 4.12.0

package/test/memory-extractor.test.ts

@@ -0,0 +1,151 @@
+/**
+ * v4.11.0 — Auto-fact-extraction.
+ *
+ * When compaction archives messages, instead of just dumping prose into
+ * the daily log, run a structured extraction pass that pulls user_facts,
+ * preferences, and decisions out of the chunk and appends them to MEMORY.md
+ * (de-duplicated by exact-string match).
+ *
+ * Marked experimental in v4.11.0. Opt out via MEMORY_EXTRACTION_DISABLED=1.
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import fs from "fs";
+import os from "os";
+import { resolve } from "path";
+
+const TEST_DATA_DIR = resolve(os.tmpdir(), `alvin-mem-extract-${process.pid}-${Date.now()}`);
+
+beforeEach(() => {
+  if (fs.existsSync(TEST_DATA_DIR)) fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
+  fs.mkdirSync(resolve(TEST_DATA_DIR, "memory"), { recursive: true });
+  process.env.ALVIN_DATA_DIR = TEST_DATA_DIR;
+  delete process.env.MEMORY_EXTRACTION_DISABLED;
+  vi.resetModules();
+});
+
+describe("memory-extractor (v4.11.0)", () => {
+  it("parseExtractedFacts handles a clean JSON response", async () => {
+    const { parseExtractedFacts } = await import("../src/services/memory-extractor.js");
+    const json = JSON.stringify({
+      user_facts: ["User Ali lives in Berlin"],
+      preferences: ["Replies in German"],
+      decisions: ["Use Hostinger VPS for production"],
+    });
+    const facts = parseExtractedFacts(json);
+    expect(facts.user_facts).toEqual(["User Ali lives in Berlin"]);
+    expect(facts.preferences).toEqual(["Replies in German"]);
+    expect(facts.decisions).toEqual(["Use Hostinger VPS for production"]);
+  });
+
+  it("parseExtractedFacts handles JSON wrapped in markdown code fences", async () => {
+    const { parseExtractedFacts } = await import("../src/services/memory-extractor.js");
+    const wrapped = "```json\n" + JSON.stringify({
+      user_facts: ["fact 1"],
+    }) + "\n```";
+    const facts = parseExtractedFacts(wrapped);
+    expect(facts.user_facts).toEqual(["fact 1"]);
+  });
+
+  it("parseExtractedFacts handles JSON with surrounding prose", async () => {
+    const { parseExtractedFacts } = await import("../src/services/memory-extractor.js");
+    const messy = `Sure, here are the extracted facts:
+${JSON.stringify({ user_facts: ["x"], preferences: [], decisions: [] })}
+Hope this helps!`;
+    const facts = parseExtractedFacts(messy);
+    expect(facts.user_facts).toEqual(["x"]);
+  });
+
+  it("parseExtractedFacts returns empty arrays on garbage input", async () => {
+    const { parseExtractedFacts } = await import("../src/services/memory-extractor.js");
+    const facts = parseExtractedFacts("not json at all");
+    expect(facts.user_facts).toEqual([]);
+    expect(facts.preferences).toEqual([]);
+    expect(facts.decisions).toEqual([]);
+  });
+
+  it("parseExtractedFacts filters non-string entries from arrays", async () => {
+    const { parseExtractedFacts } = await import("../src/services/memory-extractor.js");
+    const messy = JSON.stringify({
+      user_facts: ["good", 42, null, "good2"],
+      preferences: [],
+      decisions: [],
+    });
+    const facts = parseExtractedFacts(messy);
+    expect(facts.user_facts).toEqual(["good", "good2"]);
+  });
+
+  it("appendFactsToMemoryFile writes new facts under structured headers", async () => {
+    const { appendFactsToMemoryFile } = await import("../src/services/memory-extractor.js");
+    await appendFactsToMemoryFile({
+      user_facts: ["Ali uses launchd for the bot"],
+      preferences: [],
+      decisions: ["v4.11.0 ships memory persistence"],
+    });
+    const memFile = resolve(TEST_DATA_DIR, "memory", "MEMORY.md");
+    expect(fs.existsSync(memFile)).toBe(true);
+    const content = fs.readFileSync(memFile, "utf-8");
+    expect(content).toMatch(/Ali uses launchd for the bot/);
+    expect(content).toMatch(/v4\.11\.0 ships memory persistence/);
+  });
+
+  it("appendFactsToMemoryFile dedupes on exact-string match", async () => {
+    const { appendFactsToMemoryFile } = await import("../src/services/memory-extractor.js");
+    await appendFactsToMemoryFile({
+      user_facts: ["Ali uses launchd for the bot"],
+      preferences: [],
+      decisions: [],
+    });
+    await appendFactsToMemoryFile({
+      user_facts: ["Ali uses launchd for the bot", "Ali drinks coffee"],
+      preferences: [],
+      decisions: [],
+    });
+    const content = fs.readFileSync(resolve(TEST_DATA_DIR, "memory", "MEMORY.md"), "utf-8");
+    const matches = content.match(/Ali uses launchd for the bot/g);
+    expect(matches).toHaveLength(1); // not duplicated
+    expect(content).toMatch(/Ali drinks coffee/);
+  });
+
+  it("appendFactsToMemoryFile returns 0 when all facts are duplicates", async () => {
+    const { appendFactsToMemoryFile } = await import("../src/services/memory-extractor.js");
+    await appendFactsToMemoryFile({
+      user_facts: ["unique fact"],
+      preferences: [],
+      decisions: [],
+    });
+    const stored = await appendFactsToMemoryFile({
+      user_facts: ["unique fact"],
+      preferences: [],
+      decisions: [],
+    });
+    expect(stored).toBe(0);
+  });
+
+  it("extractAndStoreFacts is a no-op when MEMORY_EXTRACTION_DISABLED=1", async () => {
+    process.env.MEMORY_EXTRACTION_DISABLED = "1";
+    vi.resetModules();
+    const { extractAndStoreFacts } = await import("../src/services/memory-extractor.js");
+    const result = await extractAndStoreFacts("some conversation text");
+    expect(result.disabled).toBe(true);
+    expect(result.factsStored).toBe(0);
+  });
+
+  it("extractAndStoreFacts returns 0 stored on too-short input", async () => {
+    const { extractAndStoreFacts } = await import("../src/services/memory-extractor.js");
+    const result = await extractAndStoreFacts("hi");
+    expect(result.disabled).toBe(false);
+    expect(result.factsStored).toBe(0);
+  });
+
+  it("extractAndStoreFacts gracefully handles AI provider failure", async () => {
+    // No API keys in test env — provider will fail, extractor should swallow
+    const { extractAndStoreFacts } = await import("../src/services/memory-extractor.js");
+    const result = await extractAndStoreFacts(
+      "This is a long enough conversation about Berlin, Postgres databases, " +
+      "and how to set up nginx properly. Should be more than 50 characters easily.",
+    );
+    expect(result.disabled).toBe(false);
+    expect(result).toHaveProperty("factsStored");
+    // Either succeeded or failed silently — but didn't throw
+  });
+});

package/test/memory-layers.test.ts

@@ -0,0 +1,169 @@
+/**
+ * v4.11.0 — Layered memory loader.
+ *
+ * Replaces the monolithic MEMORY.md → System Prompt with a structured
+ * 4-layer architecture (inspired by mempalace's L0–L3 stack):
+ *
+ *   L0 identity.md      — always loaded, ~200 tokens (who the user is)
+ *   L1 preferences.md   — always loaded (how to communicate)
+ *   L1 MEMORY.md        — backwards-compat: existing curated knowledge
+ *   L2 projects/*.md    — loaded on topic match
+ *   L3 daily logs       — only via vector search (existing embeddings.ts)
+ *
+ * If the new files don't exist, this falls back to the monolithic MEMORY.md
+ * so existing setups keep working without migration.
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import fs from "fs";
+import os from "os";
+import { resolve } from "path";
+
+const TEST_DATA_DIR = resolve(os.tmpdir(), `alvin-mem-layers-${process.pid}-${Date.now()}`);
+
+beforeEach(() => {
+  if (fs.existsSync(TEST_DATA_DIR)) fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
+  fs.mkdirSync(resolve(TEST_DATA_DIR, "memory"), { recursive: true });
+  process.env.ALVIN_DATA_DIR = TEST_DATA_DIR;
+  vi.resetModules();
+});
+
+describe("memory-layers (v4.11.0)", () => {
+  it("returns empty when nothing exists", async () => {
+    const { loadMemoryLayers } = await import("../src/services/memory-layers.js");
+    const layered = loadMemoryLayers();
+    expect(layered.identity).toBe("");
+    expect(layered.preferences).toBe("");
+    expect(layered.longTerm).toBe("");
+    expect(layered.projects).toEqual([]);
+  });
+
+  it("loads identity.md as L0 always", async () => {
+    fs.writeFileSync(
+      resolve(TEST_DATA_DIR, "memory", "identity.md"),
+      "# Identity\n\nName: Ali Levin\nLocation: Berlin",
+    );
+    const { loadMemoryLayers } = await import("../src/services/memory-layers.js");
+    const layered = loadMemoryLayers();
+    expect(layered.identity).toMatch(/Ali Levin/);
+  });
+
+  it("loads preferences.md as L1 always", async () => {
+    fs.writeFileSync(
+      resolve(TEST_DATA_DIR, "memory", "preferences.md"),
+      "- Reply in German\n- No 'Gerne' in responses",
+    );
+    const { loadMemoryLayers } = await import("../src/services/memory-layers.js");
+    const layered = loadMemoryLayers();
+    expect(layered.preferences).toMatch(/Reply in German/);
+  });
+
+  it("falls back to monolithic MEMORY.md when split files are missing", async () => {
+    fs.writeFileSync(
+      resolve(TEST_DATA_DIR, "memory", "MEMORY.md"),
+      "# Old monolithic\n\n- Some legacy fact",
+    );
+    const { loadMemoryLayers } = await import("../src/services/memory-layers.js");
+    const layered = loadMemoryLayers();
+    expect(layered.longTerm).toMatch(/legacy fact/);
+  });
+
+  it("loads projects/*.md and exposes them with their filename as topic", async () => {
+    fs.mkdirSync(resolve(TEST_DATA_DIR, "memory", "projects"), { recursive: true });
+    fs.writeFileSync(
+      resolve(TEST_DATA_DIR, "memory", "projects", "alev-b.md"),
+      "# Alev-B\nVPS: 72.62.34.230, runs nginx + pm2",
+    );
+    fs.writeFileSync(
+      resolve(TEST_DATA_DIR, "memory", "projects", "homes.md"),
+      "# HOMES\nDB: homes_production (Postgres)",
+    );
+    const { loadMemoryLayers } = await import("../src/services/memory-layers.js");
+    const layered = loadMemoryLayers();
+    expect(layered.projects).toHaveLength(2);
+    const topics = layered.projects.map(p => p.topic).sort();
+    expect(topics).toEqual(["alev-b", "homes"]);
+    expect(layered.projects.find(p => p.topic === "homes")?.content).toMatch(/homes_production/);
+  });
+
+  it("buildLayeredContext returns all L0+L1 plus matching L2 by topic keyword", async () => {
+    fs.writeFileSync(
+      resolve(TEST_DATA_DIR, "memory", "identity.md"),
+      "Name: Ali",
+    );
+    fs.writeFileSync(
+      resolve(TEST_DATA_DIR, "memory", "preferences.md"),
+      "Be terse.",
+    );
+    fs.mkdirSync(resolve(TEST_DATA_DIR, "memory", "projects"), { recursive: true });
+    fs.writeFileSync(
+      resolve(TEST_DATA_DIR, "memory", "projects", "homes.md"),
+      "HOMES uses Postgres",
+    );
+    fs.writeFileSync(
+      resolve(TEST_DATA_DIR, "memory", "projects", "alev-b.md"),
+      "Alev-B uses MySQL",
+    );
+
+    const { buildLayeredContext } = await import("../src/services/memory-layers.js");
+
+    // Query mentions HOMES → only the homes project should be loaded
+    const ctx = buildLayeredContext("Tell me about HOMES backups");
+    expect(ctx).toMatch(/Name: Ali/); // L0
+    expect(ctx).toMatch(/Be terse/); // L1
+    expect(ctx).toMatch(/HOMES uses Postgres/); // L2 matched
+    expect(ctx).not.toMatch(/Alev-B uses MySQL/); // L2 not matched
+  });
+
+  it("buildLayeredContext without a query returns L0+L1 only (boot-up brief)", async () => {
+    fs.writeFileSync(
+      resolve(TEST_DATA_DIR, "memory", "identity.md"),
+      "Name: Ali",
+    );
+    fs.writeFileSync(
+      resolve(TEST_DATA_DIR, "memory", "preferences.md"),
+      "Be terse.",
+    );
+    fs.mkdirSync(resolve(TEST_DATA_DIR, "memory", "projects"), { recursive: true });
+    fs.writeFileSync(
+      resolve(TEST_DATA_DIR, "memory", "projects", "homes.md"),
+      "HOMES uses Postgres",
+    );
+
+    const { buildLayeredContext } = await import("../src/services/memory-layers.js");
+    const ctx = buildLayeredContext();
+    expect(ctx).toMatch(/Name: Ali/);
+    expect(ctx).not.toMatch(/Postgres/); // L2 only loaded with a query
+  });
+
+  it("token budget: layered context truncates long projects to fit budget", async () => {
+    fs.writeFileSync(
+      resolve(TEST_DATA_DIR, "memory", "identity.md"),
+      "Name: Ali",
+    );
+    fs.mkdirSync(resolve(TEST_DATA_DIR, "memory", "projects"), { recursive: true });
+    const longContent = "homes ".repeat(2000); // ~10000 chars
+    fs.writeFileSync(
+      resolve(TEST_DATA_DIR, "memory", "projects", "homes.md"),
+      longContent,
+    );
+    const { buildLayeredContext } = await import("../src/services/memory-layers.js");
+    const ctx = buildLayeredContext("HOMES");
+    // Total context should be capped (~6000 chars max for L0+L1+L2)
+    expect(ctx.length).toBeLessThan(8000);
+  });
+
+  it("monolithic MEMORY.md and split files coexist (split takes priority, mono is secondary)", async () => {
+    fs.writeFileSync(
+      resolve(TEST_DATA_DIR, "memory", "identity.md"),
+      "Name: Ali",
+    );
+    fs.writeFileSync(
+      resolve(TEST_DATA_DIR, "memory", "MEMORY.md"),
+      "# Legacy\n\n- Old fact still there",
+    );
+    const { buildLayeredContext } = await import("../src/services/memory-layers.js");
+    const ctx = buildLayeredContext("anything");
+    expect(ctx).toMatch(/Name: Ali/); // L0
+    expect(ctx).toMatch(/Old fact still there/); // legacy still included
+  });
+});

package/test/memory-sdk-injection.test.ts

@@ -0,0 +1,146 @@
+/**
+ * v4.11.0 — SDK system prompts now receive MEMORY.md context.
+ *
+ * Before v4.11.0, only non-SDK providers (Groq, Gemini, NVIDIA) got
+ * buildMemoryContext() injected into their system prompt — the SDK was
+ * expected to read memory files via tools. In practice it rarely did,
+ * resulting in "frickelig" memory after restart even with persisted
+ * sessions. v4.11.0 closes this gap.
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import fs from "fs";
+import os from "os";
+import { resolve } from "path";
+
+const TEST_DATA_DIR = resolve(os.tmpdir(), `alvin-sdk-mem-inject-${process.pid}-${Date.now()}`);
+
+beforeEach(() => {
+  if (fs.existsSync(TEST_DATA_DIR)) fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
+  fs.mkdirSync(TEST_DATA_DIR, { recursive: true });
+  fs.mkdirSync(resolve(TEST_DATA_DIR, "memory"), { recursive: true });
+  fs.writeFileSync(
+    resolve(TEST_DATA_DIR, "memory", "MEMORY.md"),
+    "# Long-term Memory\n\n- User Ali prefers terse answers.\n- HOMES uses Postgres `homes_production`.\n",
+  );
+  process.env.ALVIN_DATA_DIR = TEST_DATA_DIR;
+  vi.resetModules();
+});
+
+describe("SDK memory injection (v4.11.0)", () => {
+  it("buildSystemPrompt(isSDK=true) now includes MEMORY.md content", async () => {
+    const { buildSystemPrompt } = await import("../src/services/personality.js");
+    const prompt = buildSystemPrompt(true, "en", "1234");
+    expect(prompt).toMatch(/User Ali prefers terse answers/);
+    expect(prompt).toMatch(/HOMES uses Postgres/);
+  });
+
+  it("non-SDK still gets memory injection (regression check)", async () => {
+    const { buildSystemPrompt } = await import("../src/services/personality.js");
+    const prompt = buildSystemPrompt(false, "en", "1234");
+    expect(prompt).toMatch(/User Ali prefers terse answers/);
+  });
+
+  it("no MEMORY.md → SDK prompt builds without crash and without memory section", async () => {
+    fs.unlinkSync(resolve(TEST_DATA_DIR, "memory", "MEMORY.md"));
+    vi.resetModules();
+    const { buildSystemPrompt } = await import("../src/services/personality.js");
+    const prompt = buildSystemPrompt(true, "en", "1234");
+    expect(prompt).toBeTruthy();
+    expect(prompt).not.toMatch(/Your Memory \(auto-loaded\)/);
+  });
+});
+
+describe("SDK smart prompt (semantic recall) on first turn (v4.11.0)", () => {
+  it("buildSmartSystemPrompt for SDK with isFirstTurn=false does NOT call searchMemory", async () => {
+    let searchCalls = 0;
+    vi.doMock("../src/services/embeddings.js", () => ({
+      searchMemory: async () => {
+        searchCalls++;
+        return [];
+      },
+      reindexMemory: async () => ({ indexed: 0, total: 0 }),
+      initEmbeddings: async () => {},
+      getIndexStats: () => ({ entries: 0, files: 0, lastReindex: 0, sizeBytes: 0 }),
+    }));
+    vi.resetModules();
+    const { buildSmartSystemPrompt } = await import("../src/services/personality.js");
+
+    await buildSmartSystemPrompt(true, "en", "tell me about HOMES", "1234", false);
+    expect(searchCalls).toBe(0);
+  });
+
+  it("buildSmartSystemPrompt for SDK with isFirstTurn=true CALLS searchMemory", async () => {
+    let searchCalls = 0;
+    vi.doMock("../src/services/embeddings.js", () => ({
+      searchMemory: async () => {
+        searchCalls++;
+        return [
+          { text: "HOMES uses homes_production database", source: "MEMORY.md", score: 0.9 },
+        ];
+      },
+      reindexMemory: async () => ({ indexed: 0, total: 0 }),
+      initEmbeddings: async () => {},
+      getIndexStats: () => ({ entries: 0, files: 0, lastReindex: 0, sizeBytes: 0 }),
+    }));
+    vi.resetModules();
+    const { buildSmartSystemPrompt } = await import("../src/services/personality.js");
+
+    const prompt = await buildSmartSystemPrompt(true, "en", "tell me about HOMES", "1234", true);
+    expect(searchCalls).toBe(1);
+    expect(prompt).toMatch(/Relevant Memories \(auto-retrieved\)/);
+    expect(prompt).toMatch(/homes_production/);
+  });
+
+  it("non-SDK calls searchMemory regardless of isFirstTurn flag", async () => {
+    let searchCalls = 0;
+    vi.doMock("../src/services/embeddings.js", () => ({
+      searchMemory: async () => {
+        searchCalls++;
+        return [];
+      },
+      reindexMemory: async () => ({ indexed: 0, total: 0 }),
+      initEmbeddings: async () => {},
+      getIndexStats: () => ({ entries: 0, files: 0, lastReindex: 0, sizeBytes: 0 }),
+    }));
+    vi.resetModules();
+    const { buildSmartSystemPrompt } = await import("../src/services/personality.js");
+
+    await buildSmartSystemPrompt(false, "en", "HOMES backup question", "1234", false);
+    expect(searchCalls).toBe(1);
+  });
+
+  it("buildSmartSystemPrompt for SDK with no userMessage skips search even when isFirstTurn=true", async () => {
+    let searchCalls = 0;
+    vi.doMock("../src/services/embeddings.js", () => ({
+      searchMemory: async () => {
+        searchCalls++;
+        return [];
+      },
+      reindexMemory: async () => ({ indexed: 0, total: 0 }),
+      initEmbeddings: async () => {},
+      getIndexStats: () => ({ entries: 0, files: 0, lastReindex: 0, sizeBytes: 0 }),
+    }));
+    vi.resetModules();
+    const { buildSmartSystemPrompt } = await import("../src/services/personality.js");
+
+    await buildSmartSystemPrompt(true, "en", undefined, "1234", true);
+    expect(searchCalls).toBe(0);
+  });
+
+  it("graceful failure: SDK first turn search throws → returns base prompt without crashing", async () => {
+    vi.doMock("../src/services/embeddings.js", () => ({
+      searchMemory: async () => {
+        throw new Error("Embedding API down");
+      },
+      reindexMemory: async () => ({ indexed: 0, total: 0 }),
+      initEmbeddings: async () => {},
+      getIndexStats: () => ({ entries: 0, files: 0, lastReindex: 0, sizeBytes: 0 }),
+    }));
+    vi.resetModules();
+    const { buildSmartSystemPrompt } = await import("../src/services/personality.js");
+
+    const prompt = await buildSmartSystemPrompt(true, "en", "test query", "1234", true);
+    expect(prompt).toBeTruthy();
+    expect(prompt).toMatch(/User Ali prefers terse answers/); // base still works
+  });
+});