@vellumai/assistant 0.5.2 → 0.5.4

package/src/__tests__/memory-regressions.test.ts

@@ -540,13 +540,23 @@ describe("Memory regressions", () => {
 
   test("memory_save sets verificationState to user_confirmed", async () => {
     const { handleMemorySave } = await import("../tools/memory/handlers.js");
+    const legacyConfig = {
+      ...DEFAULT_CONFIG,
+      memory: {
+        ...DEFAULT_CONFIG.memory,
+        simplified: {
+          ...DEFAULT_CONFIG.memory.simplified,
+          enabled: false,
+        },
+      },
+    };
 
     const result = await handleMemorySave(
       {
         statement: "User explicitly saved this preference",
         kind: "preference",
       },
-      DEFAULT_CONFIG,
+      legacyConfig,
       "conv-verify-save",
       "msg-verify-save",
     );
@@ -563,13 +573,23 @@ describe("Memory regressions", () => {
 
   test("memory_save in different scopes creates separate items", async () => {
     const { handleMemorySave } = await import("../tools/memory/handlers.js");
+    const legacyConfig = {
+      ...DEFAULT_CONFIG,
+      memory: {
+        ...DEFAULT_CONFIG.memory,
+        simplified: {
+          ...DEFAULT_CONFIG.memory.simplified,
+          enabled: false,
+        },
+      },
+    };
 
     const sharedArgs = { statement: "I prefer dark mode", kind: "preference" };
 
     // Save in the default scope
     const r1 = await handleMemorySave(
       sharedArgs,
-      DEFAULT_CONFIG,
+      legacyConfig,
       "conv-scope-1",
       "msg-scope-1",
       "default",
@@ -580,7 +600,7 @@ describe("Memory regressions", () => {
     // Save the identical statement in a private scope
     const r2 = await handleMemorySave(
       sharedArgs,
-      DEFAULT_CONFIG,
+      legacyConfig,
       "conv-scope-2",
       "msg-scope-2",
       "private-abc",
@@ -604,7 +624,7 @@ describe("Memory regressions", () => {
     // Saving the same statement again in default scope should dedup (not create a third)
     const r3 = await handleMemorySave(
       sharedArgs,
-      DEFAULT_CONFIG,
+      legacyConfig,
       "conv-scope-3",
       "msg-scope-3",
       "default",
@@ -3207,8 +3227,9 @@ describe("Memory regressions", () => {
       .filter((j) => JSON.parse(j.payload).messageId === "msg-untrusted-gate");
     expect(extractJobs.length).toBe(0);
 
-    // enqueuedJobs should reflect: embed jobs + summary (1), no extract (0)
-    const expectedJobs = result.indexedSegments + 1; // embed per segment + summary
+    // enqueuedJobs reflects legacy embed_segment + archive embed_chunk per
+    // segment, plus the summary job, with extract_items gated off.
+    const expectedJobs = result.indexedSegments * 2 + 1;
     expect(result.enqueuedJobs).toBe(expectedJobs);
   });
 
@@ -3389,8 +3410,9 @@ describe("Memory regressions", () => {
       .filter((j) => JSON.parse(j.payload).messageId === "msg-unverified-gate");
     expect(extractJobs.length).toBe(0);
 
-    // enqueuedJobs should reflect: embed jobs + summary (1), no extract (0)
-    const expectedJobs = result.indexedSegments + 1; // embed per segment + summary
+    // enqueuedJobs reflects legacy embed_segment + archive embed_chunk per
+    // segment, plus the summary job, with extract_items gated off.
+    const expectedJobs = result.indexedSegments * 2 + 1;
     expect(result.enqueuedJobs).toBe(expectedJobs);
   });
 

package/src/__tests__/memory-simplified-config.test.ts

@@ -0,0 +1,281 @@
+import { randomBytes } from "node:crypto";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Mocks — declared before imports that depend on platform/logger
+// ---------------------------------------------------------------------------
+
+const TEST_DIR = join(
+  tmpdir(),
+  `vellum-simplified-mem-test-${randomBytes(4).toString("hex")}`,
+);
+const WORKSPACE_DIR = join(TEST_DIR, "workspace");
+const CONFIG_PATH = join(WORKSPACE_DIR, "config.json");
+
+function ensureTestDir(): void {
+  const dirs = [
+    TEST_DIR,
+    WORKSPACE_DIR,
+    join(TEST_DIR, "data"),
+    join(TEST_DIR, "memory"),
+    join(TEST_DIR, "memory", "knowledge"),
+    join(TEST_DIR, "logs"),
+  ];
+  for (const dir of dirs) {
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  }
+}
+
+function makeLoggerStub(): Record<string, unknown> {
+  const stub: Record<string, unknown> = {};
+  for (const m of [
+    "info",
+    "warn",
+    "error",
+    "debug",
+    "trace",
+    "fatal",
+    "silent",
+    "child",
+  ]) {
+    stub[m] = m === "child" ? () => makeLoggerStub() : () => {};
+  }
+  return stub;
+}
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeLoggerStub(),
+}));
+
+mock.module("../util/platform.js", () => ({
+  getRootDir: () => TEST_DIR,
+  getWorkspaceDir: () => WORKSPACE_DIR,
+  getWorkspaceConfigPath: () => CONFIG_PATH,
+  getDataDir: () => join(TEST_DIR, "data"),
+  getLogPath: () => join(TEST_DIR, "logs", "vellum.log"),
+  ensureDataDir: () => ensureTestDir(),
+  isMacOS: () => false,
+  isLinux: () => false,
+  isWindows: () => false,
+}));
+
+import { invalidateConfigCache, loadConfig } from "../config/loader.js";
+import { AssistantConfigSchema } from "../config/schema.js";
+import { MemorySimplifiedConfigSchema } from "../config/schemas/memory-simplified.js";
+import { _setStorePath } from "../security/encrypted-store.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function writeConfig(obj: unknown): void {
+  writeFileSync(CONFIG_PATH, JSON.stringify(obj));
+}
+
+// ---------------------------------------------------------------------------
+// Tests: MemorySimplifiedConfigSchema (unit)
+// ---------------------------------------------------------------------------
+
+describe("MemorySimplifiedConfigSchema", () => {
+  test("parses empty object with all defaults", () => {
+    const result = MemorySimplifiedConfigSchema.parse({});
+    expect(result).toEqual({
+      enabled: true,
+      brief: { maxTokens: 4000 },
+      reducer: { idleDelayMs: 30_000, switchWaitMs: 5_000 },
+      archiveRecall: { maxSnippets: 10 },
+    });
+  });
+
+  test("accepts explicit enabled=true", () => {
+    const result = MemorySimplifiedConfigSchema.parse({ enabled: true });
+    expect(result.enabled).toBe(true);
+  });
+
+  test("accepts custom brief.maxTokens", () => {
+    const result = MemorySimplifiedConfigSchema.parse({
+      brief: { maxTokens: 8000 },
+    });
+    expect(result.brief.maxTokens).toBe(8000);
+  });
+
+  test("accepts custom reducer values", () => {
+    const result = MemorySimplifiedConfigSchema.parse({
+      reducer: { idleDelayMs: 60_000, switchWaitMs: 10_000 },
+    });
+    expect(result.reducer.idleDelayMs).toBe(60_000);
+    expect(result.reducer.switchWaitMs).toBe(10_000);
+  });
+
+  test("accepts custom archiveRecall.maxSnippets", () => {
+    const result = MemorySimplifiedConfigSchema.parse({
+      archiveRecall: { maxSnippets: 20 },
+    });
+    expect(result.archiveRecall.maxSnippets).toBe(20);
+  });
+
+  test("rejects non-boolean enabled", () => {
+    const result = MemorySimplifiedConfigSchema.safeParse({
+      enabled: "yes",
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects non-positive brief.maxTokens", () => {
+    const result = MemorySimplifiedConfigSchema.safeParse({
+      brief: { maxTokens: 0 },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects non-integer brief.maxTokens", () => {
+    const result = MemorySimplifiedConfigSchema.safeParse({
+      brief: { maxTokens: 3.5 },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects non-positive reducer.idleDelayMs", () => {
+    const result = MemorySimplifiedConfigSchema.safeParse({
+      reducer: { idleDelayMs: 0 },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects non-positive reducer.switchWaitMs", () => {
+    const result = MemorySimplifiedConfigSchema.safeParse({
+      reducer: { switchWaitMs: -1 },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects non-positive archiveRecall.maxSnippets", () => {
+    const result = MemorySimplifiedConfigSchema.safeParse({
+      archiveRecall: { maxSnippets: 0 },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects non-integer archiveRecall.maxSnippets", () => {
+    const result = MemorySimplifiedConfigSchema.safeParse({
+      archiveRecall: { maxSnippets: 2.5 },
+    });
+    expect(result.success).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: Wired into AssistantConfigSchema
+// ---------------------------------------------------------------------------
+
+describe("AssistantConfigSchema memory.simplified", () => {
+  test("empty config exposes memory.simplified with defaults", () => {
+    const result = AssistantConfigSchema.parse({});
+    expect(result.memory.simplified).toEqual({
+      enabled: true,
+      brief: { maxTokens: 4000 },
+      reducer: { idleDelayMs: 30_000, switchWaitMs: 5_000 },
+      archiveRecall: { maxSnippets: 10 },
+    });
+  });
+
+  test("memory.simplified does not disturb legacy memory config", () => {
+    const result = AssistantConfigSchema.parse({});
+    // Legacy fields still present with their defaults
+    expect(result.memory.enabled).toBe(true);
+    expect(result.memory.retrieval).toBeDefined();
+    expect(result.memory.jobs).toBeDefined();
+    expect(result.memory.cleanup).toBeDefined();
+    expect(result.memory.extraction).toBeDefined();
+    expect(result.memory.summarization).toBeDefined();
+    expect(result.memory.segmentation).toBeDefined();
+    expect(result.memory.embeddings).toBeDefined();
+    expect(result.memory.qdrant).toBeDefined();
+    expect(result.memory.retention).toBeDefined();
+  });
+
+  test("accepts memory.simplified overrides alongside legacy config", () => {
+    const result = AssistantConfigSchema.parse({
+      memory: {
+        enabled: true,
+        simplified: {
+          enabled: true,
+          brief: { maxTokens: 6000 },
+        },
+      },
+    });
+    expect(result.memory.enabled).toBe(true);
+    expect(result.memory.simplified.enabled).toBe(true);
+    expect(result.memory.simplified.brief.maxTokens).toBe(6000);
+    // Defaults preserved for unset simplified fields
+    expect(result.memory.simplified.reducer.idleDelayMs).toBe(30_000);
+    expect(result.memory.simplified.archiveRecall.maxSnippets).toBe(10);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: loadConfig integration (empty config file loads cleanly)
+// ---------------------------------------------------------------------------
+
+describe("loadConfig with memory.simplified", () => {
+  beforeEach(() => {
+    ensureTestDir();
+    const resetPaths = [
+      CONFIG_PATH,
+      join(TEST_DIR, "keys.enc"),
+      join(TEST_DIR, "data"),
+      join(TEST_DIR, "memory"),
+    ];
+    for (const path of resetPaths) {
+      if (existsSync(path)) {
+        rmSync(path, { recursive: true, force: true });
+      }
+    }
+    ensureTestDir();
+    _setStorePath(join(TEST_DIR, "keys.enc"));
+    invalidateConfigCache();
+  });
+
+  afterEach(() => {
+    _setStorePath(null);
+    invalidateConfigCache();
+  });
+
+  test("empty config file loads cleanly with simplified defaults", () => {
+    writeConfig({});
+    const config = loadConfig();
+    expect(config.memory.simplified).toEqual({
+      enabled: true,
+      brief: { maxTokens: 4000 },
+      reducer: { idleDelayMs: 30_000, switchWaitMs: 5_000 },
+      archiveRecall: { maxSnippets: 10 },
+    });
+  });
+
+  test("no config file loads cleanly with simplified defaults", () => {
+    const config = loadConfig();
+    expect(config.memory.simplified).toEqual({
+      enabled: true,
+      brief: { maxTokens: 4000 },
+      reducer: { idleDelayMs: 30_000, switchWaitMs: 5_000 },
+      archiveRecall: { maxSnippets: 10 },
+    });
+  });
+
+  test("existing memory config with simplified addition loads cleanly", () => {
+    writeConfig({
+      memory: {
+        enabled: true,
+        simplified: { enabled: true, brief: { maxTokens: 2000 } },
+      },
+    });
+    const config = loadConfig();
+    expect(config.memory.enabled).toBe(true);
+    expect(config.memory.simplified.enabled).toBe(true);
+    expect(config.memory.simplified.brief.maxTokens).toBe(2000);
+    expect(config.memory.simplified.reducer.idleDelayMs).toBe(30_000);
+  });
+});

package/src/__tests__/parse-identity-fields.test.ts

@@ -0,0 +1,129 @@
+/**
+ * Unit tests for identity field parsing and template placeholder filtering.
+ *
+ * Validates that parseIdentityFields correctly extracts real values from
+ * IDENTITY.md content while treating template placeholders (e.g.
+ * `_(not yet chosen)_`) as empty/unset.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import {
+  isTemplatePlaceholder,
+  parseIdentityFields,
+} from "../daemon/handlers/identity.js";
+
+// ---------------------------------------------------------------------------
+// isTemplatePlaceholder
+// ---------------------------------------------------------------------------
+
+describe("isTemplatePlaceholder", () => {
+  test("returns true for _(not yet chosen)_", () => {
+    expect(isTemplatePlaceholder("_(not yet chosen)_")).toBe(true);
+  });
+
+  test("returns true for _(not yet established)_", () => {
+    expect(isTemplatePlaceholder("_(not yet established)_")).toBe(true);
+  });
+
+  test("returns true for any value matching _(…)_ pattern", () => {
+    expect(isTemplatePlaceholder("_(something else)_")).toBe(true);
+  });
+
+  test("returns false for normal values", () => {
+    expect(isTemplatePlaceholder("Your helpful coding assistant")).toBe(false);
+    expect(isTemplatePlaceholder("Jarvis")).toBe(false);
+    expect(isTemplatePlaceholder("")).toBe(false);
+  });
+
+  test("returns false for partial matches", () => {
+    expect(isTemplatePlaceholder("_(incomplete")).toBe(false);
+    expect(isTemplatePlaceholder("incomplete)_")).toBe(false);
+    expect(isTemplatePlaceholder("_(")).toBe(false);
+    expect(isTemplatePlaceholder(")_")).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// parseIdentityFields — placeholder filtering
+// ---------------------------------------------------------------------------
+
+describe("parseIdentityFields", () => {
+  test("returns empty strings for all template placeholder values", () => {
+    const content = [
+      "- **Name:** _(not yet chosen)_",
+      "- **Role:** _(not yet established)_",
+      "- **Personality:** _(not yet chosen)_",
+      "- **Emoji:** _(not yet chosen)_",
+      "- **Home:** _(not yet chosen)_",
+    ].join("\n");
+
+    const fields = parseIdentityFields(content);
+    expect(fields.name).toBe("");
+    expect(fields.role).toBe("");
+    expect(fields.personality).toBe("");
+    expect(fields.emoji).toBe("");
+    expect(fields.home).toBe("");
+  });
+
+  test("preserves real user-provided values", () => {
+    const content = [
+      "- **Name:** Jarvis",
+      "- **Role:** Coding assistant",
+      "- **Personality:** Friendly and helpful",
+      "- **Emoji:** 🤖",
+      "- **Home:** ~/projects",
+    ].join("\n");
+
+    const fields = parseIdentityFields(content);
+    expect(fields.name).toBe("Jarvis");
+    expect(fields.role).toBe("Coding assistant");
+    expect(fields.personality).toBe("Friendly and helpful");
+    expect(fields.emoji).toBe("🤖");
+    expect(fields.home).toBe("~/projects");
+  });
+
+  test("handles a mix of real and placeholder values", () => {
+    const content = [
+      "- **Name:** Jarvis",
+      "- **Role:** _(not yet established)_",
+      "- **Personality:** Friendly",
+      "- **Emoji:** _(not yet chosen)_",
+      "- **Home:** ~/dev",
+    ].join("\n");
+
+    const fields = parseIdentityFields(content);
+    expect(fields.name).toBe("Jarvis");
+    expect(fields.role).toBe("");
+    expect(fields.personality).toBe("Friendly");
+    expect(fields.emoji).toBe("");
+    expect(fields.home).toBe("~/dev");
+  });
+
+  test("returns role: '' when IDENTITY.md contains placeholder role", () => {
+    const content = "- **Role:** _(not yet established)_";
+    const fields = parseIdentityFields(content);
+    expect(fields.role).toBe("");
+  });
+
+  test("returns name: '' when IDENTITY.md contains placeholder name", () => {
+    const content = "- **Name:** _(not yet chosen)_";
+    const fields = parseIdentityFields(content);
+    expect(fields.name).toBe("");
+  });
+
+  test('parses role: "Coding assistant" for real values', () => {
+    const content = "- **Role:** Coding assistant";
+    const fields = parseIdentityFields(content);
+    expect(fields.role).toBe("Coding assistant");
+  });
+
+  test("returns empty strings when content has no identity fields", () => {
+    const fields = parseIdentityFields("# Some other content\nHello world");
+    expect(fields.name).toBe("");
+    expect(fields.role).toBe("");
+    expect(fields.personality).toBe("");
+    expect(fields.emoji).toBe("");
+    expect(fields.home).toBe("");
+  });
+});