@vellumai/assistant 0.6.0 → 0.6.2

package/src/memory/graph/store.test.ts

@@ -7,6 +7,7 @@ import {
   createEdge,
   createNode,
   createTrigger,
+  deduplicateParagraphs,
   deleteEdge,
   deleteNode,
   deleteTrigger,
@@ -1048,3 +1049,50 @@ describe("updateNode event trigger sync", () => {
     expect(triggers[0].eventDate).toBe(eventDate);
   });
 });
+
+// ---------------------------------------------------------------------------
+// Paragraph deduplication
+// ---------------------------------------------------------------------------
+
+describe("deduplicateParagraphs", () => {
+  test("content with no duplicates passes through unchanged", () => {
+    const input = "First paragraph.\n\nSecond paragraph.\n\nThird paragraph.";
+    expect(deduplicateParagraphs(input)).toBe(input);
+  });
+
+  test("two identical paragraphs separated by \\n\\n collapses to one", () => {
+    const input = "Hello world.\n\nHello world.";
+    expect(deduplicateParagraphs(input)).toBe("Hello world.");
+  });
+
+  test("paragraphs that differ only in trailing whitespace are treated as duplicates", () => {
+    const input = "Hello world.  \n\nHello world.";
+    expect(deduplicateParagraphs(input)).toBe("Hello world.  ");
+  });
+
+  test("bullet lists with repeated items are deduped", () => {
+    const input = "- item one\n- item two\n- item one\n- item three";
+    expect(deduplicateParagraphs(input)).toBe(
+      "- item one\n- item two\n- item three",
+    );
+  });
+
+  test("empty content returns empty string", () => {
+    expect(deduplicateParagraphs("")).toBe("");
+  });
+
+  test("multiple duplicate paragraphs with different content", () => {
+    const input = "Alpha.\n\nBeta.\n\nAlpha.\n\nGamma.\n\nBeta.";
+    expect(deduplicateParagraphs(input)).toBe("Alpha.\n\nBeta.\n\nGamma.");
+  });
+
+  test("bullet dedup within a paragraph preserves non-bullet lines", () => {
+    const input = "Header:\n- item A\n- item B\n- item A";
+    expect(deduplicateParagraphs(input)).toBe("Header:\n- item A\n- item B");
+  });
+
+  test("paragraphs differing only in internal whitespace are treated as duplicates", () => {
+    const input = "hello   world\n\nhello world";
+    expect(deduplicateParagraphs(input)).toBe("hello   world");
+  });
+});

package/src/memory/graph/store.ts

@@ -2,12 +2,13 @@
 // Memory Graph — Data access layer
 // ---------------------------------------------------------------------------
 
-import { and, eq, inArray, sql } from "drizzle-orm";
+import { and, desc, eq, inArray, sql } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
 import { getDb } from "../db.js";
 import {
   memoryGraphEdges,
+  memoryGraphNodeEdits,
   memoryGraphNodes,
   memoryGraphTriggers,
 } from "../schema.js";
@@ -115,6 +116,60 @@ function rowToTrigger(
   };
 }
 
+// ---------------------------------------------------------------------------
+// Paragraph deduplication
+// ---------------------------------------------------------------------------
+
+/**
+ * Remove repeated paragraphs and bullet items from memory node content.
+ * Paragraphs are separated by `\n\n`. Within each paragraph, lines starting
+ * with `- ` are treated as bullet items and individually deduplicated.
+ */
+export function deduplicateParagraphs(content: string): string {
+  if (!content) return content;
+
+  const paragraphs = content.split("\n\n");
+  const seen = new Set<string>();
+  const unique: string[] = [];
+
+  for (const paragraph of paragraphs) {
+    // Deduplicate bullet items within the paragraph
+    const lines = paragraph.split("\n");
+    const isBulletList = lines.some((l) => l.trimStart().startsWith("- "));
+
+    let processed: string;
+    if (isBulletList) {
+      const seenBullets = new Set<string>();
+      const uniqueLines: string[] = [];
+      for (const line of lines) {
+        if (line.trimStart().startsWith("- ")) {
+          const normalized = line.trim().replace(/\s+/g, " ");
+          if (!seenBullets.has(normalized)) {
+            seenBullets.add(normalized);
+            uniqueLines.push(line);
+          }
+        } else {
+          uniqueLines.push(line);
+        }
+      }
+      processed = uniqueLines.join("\n");
+    } else {
+      processed = paragraph;
+    }
+
+    const normalized = processed.trim().replace(/\s+/g, " ");
+    if (normalized === "") {
+      // Preserve empty paragraphs (whitespace-only) as separators
+      unique.push(processed);
+    } else if (!seen.has(normalized)) {
+      seen.add(normalized);
+      unique.push(processed);
+    }
+  }
+
+  return unique.join("\n\n");
+}
+
 // ---------------------------------------------------------------------------
 // Node CRUD
 // ---------------------------------------------------------------------------
@@ -122,8 +177,11 @@ function rowToTrigger(
 export function createNode(node: NewNode): MemoryNode {
   const db = getDb();
   const id = uuid();
-  db.insert(memoryGraphNodes).values(nodeToInsertValues(node, id)).run();
-  return { ...node, id };
+  const cleanContent = deduplicateParagraphs(node.content);
+  db.insert(memoryGraphNodes)
+    .values(nodeToInsertValues({ ...node, content: cleanContent }, id))
+    .run();
+  return { ...node, content: cleanContent, id };
 }
 
 export function getNode(id: string): MemoryNode | null {
@@ -154,7 +212,8 @@ export function updateNode(
   const db = getDb();
   const updates: Record<string, unknown> = {};
 
-  if (changes.content !== undefined) updates.content = changes.content;
+  if (changes.content !== undefined)
+    updates.content = deduplicateParagraphs(changes.content);
   if (changes.type !== undefined) updates.type = changes.type;
   if (changes.created !== undefined) updates.created = changes.created;
   if (changes.lastAccessed !== undefined)
@@ -180,7 +239,9 @@ export function updateNode(
   if (changes.partOfStory !== undefined)
     updates.partOfStory = changes.partOfStory;
   if (changes.imageRefs !== undefined)
-    updates.imageRefs = changes.imageRefs ? JSON.stringify(changes.imageRefs) : null;
+    updates.imageRefs = changes.imageRefs
+      ? JSON.stringify(changes.imageRefs)
+      : null;
   if (changes.scopeId !== undefined) updates.scopeId = changes.scopeId;
   if (changes.eventDate !== undefined) updates.eventDate = changes.eventDate;
 
@@ -382,9 +443,7 @@ export function createTrigger(trigger: NewTrigger): MemoryTrigger {
 
 export function deleteTrigger(id: string): void {
   const db = getDb();
-  db.delete(memoryGraphTriggers)
-    .where(eq(memoryGraphTriggers.id, id))
-    .run();
+  db.delete(memoryGraphTriggers).where(eq(memoryGraphTriggers.id, id)).run();
 }
 
 export function updateTrigger(
@@ -534,7 +593,13 @@ export function supersedeNode(
 /**
  * Apply a MemoryDiff atomically. All operations run in a single transaction.
  */
-export function applyDiff(diff: MemoryDiff): ApplyDiffResult {
+export function applyDiff(
+  diff: MemoryDiff,
+  opts?: {
+    conversationId?: string;
+    source?: "extraction" | "consolidation" | "manual";
+  },
+): ApplyDiffResult {
   const db = getDb();
   const result: ApplyDiffResult = {
     nodesCreated: 0,
@@ -558,7 +623,10 @@ export function applyDiff(diff: MemoryDiff): ApplyDiffResult {
     // Create nodes
     for (const node of diff.createNodes) {
       const id = uuid();
-      tx.insert(memoryGraphNodes).values(nodeToInsertValues(node, id)).run();
+      const cleanContent = deduplicateParagraphs(node.content);
+      tx.insert(memoryGraphNodes)
+        .values(nodeToInsertValues({ ...node, content: cleanContent }, id))
+        .run();
       result.nodesCreated++;
       result.createdNodeIds.push(id);
     }
@@ -567,7 +635,8 @@ export function applyDiff(diff: MemoryDiff): ApplyDiffResult {
     for (const update of diff.updateNodes) {
       const updates: Record<string, unknown> = {};
       const c = update.changes;
-      if (c.content !== undefined) updates.content = c.content;
+      if (c.content !== undefined)
+        updates.content = deduplicateParagraphs(c.content as string);
       if (c.type !== undefined) updates.type = c.type;
       if (c.emotionalCharge !== undefined)
         updates.emotionalCharge = JSON.stringify(c.emotionalCharge);
@@ -584,6 +653,28 @@ export function applyDiff(diff: MemoryDiff): ApplyDiffResult {
         updates.sourceConversations = JSON.stringify(c.sourceConversations);
       if (c.eventDate !== undefined) updates.eventDate = c.eventDate;
 
+      // Record edit history when content changes
+      if (updates.content !== undefined) {
+        const current = tx
+          .select({ content: memoryGraphNodes.content })
+          .from(memoryGraphNodes)
+          .where(eq(memoryGraphNodes.id, update.id))
+          .get();
+        if (current && current.content !== updates.content) {
+          tx.insert(memoryGraphNodeEdits)
+            .values({
+              id: uuid(),
+              nodeId: update.id,
+              previousContent: current.content,
+              newContent: updates.content as string,
+              source: opts?.source ?? "extraction",
+              conversationId: opts?.conversationId ?? null,
+              created: Date.now(),
+            })
+            .run();
+        }
+      }
+
       if (Object.keys(updates).length > 0) {
         tx.update(memoryGraphNodes)
           .set(updates)
@@ -697,3 +788,51 @@ export function applyDiff(diff: MemoryDiff): ApplyDiffResult {
 
   return result;
 }
+
+// ---------------------------------------------------------------------------
+// Node edit history
+// ---------------------------------------------------------------------------
+
+/** Record a content change to a memory node for edit chain tracking. */
+export function recordNodeEdit(opts: {
+  nodeId: string;
+  previousContent: string;
+  newContent: string;
+  source: "extraction" | "consolidation" | "manual";
+  conversationId?: string;
+}): void {
+  const db = getDb();
+  db.insert(memoryGraphNodeEdits)
+    .values({
+      id: uuid(),
+      nodeId: opts.nodeId,
+      previousContent: opts.previousContent,
+      newContent: opts.newContent,
+      source: opts.source,
+      conversationId: opts.conversationId ?? null,
+      created: Date.now(),
+    })
+    .run();
+}
+
+/** Retrieve the edit history for a memory node, newest first. */
+export function getNodeEditHistory(
+  nodeId: string,
+  limit = 20,
+): Array<{
+  id: string;
+  previousContent: string;
+  newContent: string;
+  source: string;
+  conversationId: string | null;
+  created: number;
+}> {
+  const db = getDb();
+  return db
+    .select()
+    .from(memoryGraphNodeEdits)
+    .where(eq(memoryGraphNodeEdits.nodeId, nodeId))
+    .orderBy(desc(memoryGraphNodeEdits.created))
+    .limit(limit)
+    .all();
+}

package/src/memory/graph/tool-handlers.ts

@@ -1,32 +1,21 @@
 // ---------------------------------------------------------------------------
 // Memory Graph — Tool handlers for recall and remember
 //
-// These are the implementations behind the recall/remember tool definitions.
 // recall: search the living graph or raw archive
-// remember: immediate CRUD on graph nodes (replaces NOW.md)
+// remember: save facts to the PKB (buffer.md + daily archive)
 // ---------------------------------------------------------------------------
 
+import { appendFileSync, existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+
 import type { AssistantConfig } from "../../config/types.js";
 import { getLogger } from "../../util/logger.js";
+import { getWorkspaceDir } from "../../util/platform.js";
 import { buildExcerpt, buildFtsMatchQuery } from "../conversation-queries.js";
 import { embedWithRetry } from "../embed.js";
 import { generateSparseEmbedding } from "../embedding-backend.js";
-import { enqueueGraphNodeEmbed, searchGraphNodes } from "./graph-search.js";
-import {
-  createNode,
-  deleteNode,
-  getNode,
-  getNodesByIds,
-  updateNode,
-} from "./store.js";
-import type {
-  DecayCurve,
-  EmotionalCharge,
-  Fidelity,
-  MemoryType,
-  NewNode,
-  SourceType,
-} from "./types.js";
+import { searchGraphNodes } from "./graph-search.js";
+import { getNodesByIds } from "./store.js";
 
 const log = getLogger("graph-tool-handlers");
 
@@ -95,6 +84,17 @@ async function handleMemoryRecall(
   // Generate sparse embedding for hybrid search (dense + sparse with RRF fusion)
   const sparseVector = generateSparseEmbedding(input.query);
 
+  // Build date range filter for Qdrant-level filtering
+  const dateRange: { afterMs?: number; beforeMs?: number } = {};
+  if (input.filters?.after) {
+    const afterMs = new Date(input.filters.after).getTime();
+    if (!isNaN(afterMs)) dateRange.afterMs = afterMs;
+  }
+  if (input.filters?.before) {
+    const beforeMs = new Date(input.filters.before).getTime();
+    if (!isNaN(beforeMs)) dateRange.beforeMs = beforeMs;
+  }
+
   // Search graph nodes
   const limit = Math.max(1, Math.min(input.num_results ?? 20, 50));
   const searchResults = await searchGraphNodes(
@@ -102,6 +102,9 @@ async function handleMemoryRecall(
     limit,
     [scopeId],
     sparseVector,
+    dateRange.afterMs != null || dateRange.beforeMs != null
+      ? dateRange
+      : undefined,
   );
   if (searchResults.length === 0) {
     return { results: [], mode: "memory", query: input.query };
@@ -121,16 +124,6 @@ async function handleMemoryRecall(
       if (!input.filters.types.includes(node.type)) return [];
     }
 
-    // Date filters
-    if (input.filters?.after) {
-      const afterMs = new Date(input.filters.after).getTime();
-      if (!isNaN(afterMs) && node.created < afterMs) return [];
-    }
-    if (input.filters?.before) {
-      const beforeMs = new Date(input.filters.before).getTime();
-      if (!isNaN(beforeMs) && node.created > beforeMs) return [];
-    }
-
     return [
       {
         id: node.id,
@@ -157,7 +150,28 @@ async function handleArchiveRecall(
 
   try {
     const limit = Math.max(1, Math.min(input.num_results ?? 20, 50));
-    const ftsMatch = buildFtsMatchQuery(input.query.trim());
+    const ftsMatch = buildFtsMatchQuery(input.query.trim(), {
+      allowFts5Syntax: true,
+    });
+
+    const afterMs = input.filters?.after
+      ? new Date(input.filters.after).getTime()
+      : NaN;
+    const beforeMs = input.filters?.before
+      ? new Date(input.filters.before).getTime()
+      : NaN;
+    const dateConditions: string[] = [];
+    const dateParams: number[] = [];
+    if (!isNaN(afterMs)) {
+      dateConditions.push("m.created_at >= ?");
+      dateParams.push(afterMs);
+    }
+    if (!isNaN(beforeMs)) {
+      dateConditions.push("m.created_at <= ?");
+      dateParams.push(beforeMs);
+    }
+    const dateClause =
+      dateConditions.length > 0 ? " AND " + dateConditions.join(" AND ") : "";
 
     type ArchiveRow = {
       id: string;
@@ -177,11 +191,12 @@ async function handleArchiveRecall(
          JOIN messages m ON m.id = fts.message_id
          JOIN conversations c ON c.id = m.conversation_id
          WHERE messages_fts MATCH ?
-           AND c.memory_scope_id = ?
+           AND c.memory_scope_id = ?${dateClause}
          ORDER BY rank
          LIMIT ?`,
         ftsMatch,
         scopeId,
+        ...dateParams,
         limit,
       );
     } else if (!input.query.trim()) {
@@ -199,11 +214,12 @@ async function handleArchiveRecall(
         `SELECT m.id, m.content, m.role, m.created_at, c.id as conversation_id
          FROM messages m
          JOIN conversations c ON c.id = m.conversation_id
-         WHERE m.content LIKE ? ESCAPE '\\' AND c.memory_scope_id = ?
+         WHERE m.content LIKE ? ESCAPE '\\' AND c.memory_scope_id = ?${dateClause}
          ORDER BY m.created_at DESC
          LIMIT ?`,
         likePattern,
         scopeId,
+        ...dateParams,
         limit,
       );
     }
@@ -228,199 +244,58 @@ async function handleArchiveRecall(
 }
 
 // ---------------------------------------------------------------------------
-// remember handler
+// remember handler — writes to PKB buffer + daily archive
 // ---------------------------------------------------------------------------
 
 export interface RememberInput {
-  op: "save" | "update" | "delete";
-  memory_id?: string;
-  content?: string;
-  type?: string;
-  significance?: number;
-  emotional_charge?: {
-    valence?: number;
-    intensity?: number;
-  };
+  content: string;
 }
 
 export interface RememberResult {
   success: boolean;
-  op: string;
-  memory_id?: string;
   message: string;
 }
 
-const VALID_TYPES = new Set<MemoryType>([
-  "episodic",
-  "semantic",
-  "procedural",
-  "emotional",
-  "prospective",
-  "behavioral",
-  "narrative",
-  "shared",
-]);
-
 export function handleRemember(
   input: RememberInput,
-  conversationId: string,
-  scopeId: string,
+  _conversationId: string,
+  _scopeId: string,
 ): RememberResult {
-  switch (input.op) {
-    case "save":
-      return handleSave(input, conversationId, scopeId);
-    case "update":
-      return handleUpdate(input);
-    case "delete":
-      return handleDelete(input);
-    default:
-      return {
-        success: false,
-        op: input.op,
-        message: `Unknown operation: ${input.op}`,
-      };
+  if (!input.content || input.content.trim().length === 0) {
+    return { success: false, message: "content is required" };
   }
-}
 
-function handleSave(
-  input: RememberInput,
-  conversationId: string,
-  scopeId: string,
-): RememberResult {
-  if (!input.content) {
-    return {
-      success: false,
-      op: "save",
-      message: "content is required for save",
-    };
-  }
-  if (!input.type || !VALID_TYPES.has(input.type as MemoryType)) {
-    return {
-      success: false,
-      op: "save",
-      message: `type is required and must be one of: ${[...VALID_TYPES].join(", ")}`,
-    };
+  const workspaceDir = getWorkspaceDir();
+  const pkbDir = join(workspaceDir, "pkb");
+  const archiveDir = join(pkbDir, "archive");
+
+  // Ensure directories exist
+  mkdirSync(pkbDir, { recursive: true });
+  mkdirSync(archiveDir, { recursive: true });
+
+  // Build timestamped entry
+  const now = new Date();
+  const month = now.toLocaleString("en-US", { month: "short" });
+  const day = now.getDate();
+  const hours = now.getHours();
+  const minutes = String(now.getMinutes()).padStart(2, "0");
+  const ampm = hours >= 12 ? "PM" : "AM";
+  const displayHour = hours % 12 || 12;
+  const entry = `- [${month} ${day}, ${displayHour}:${minutes} ${ampm}] ${input.content.trim()}\n`;
+
+  // Append to buffer.md
+  const bufferPath = join(pkbDir, "buffer.md");
+  appendFileSync(bufferPath, entry, "utf-8");
+
+  // Append to daily archive
+  const yyyy = now.getFullYear();
+  const mm = String(now.getMonth() + 1).padStart(2, "0");
+  const dd = String(now.getDate()).padStart(2, "0");
+  const archivePath = join(archiveDir, `${yyyy}-${mm}-${dd}.md`);
+  if (!existsSync(archivePath)) {
+    appendFileSync(archivePath, `# ${month} ${day}, ${yyyy}\n\n`, "utf-8");
   }
+  appendFileSync(archivePath, entry, "utf-8");
 
-  const now = Date.now();
-  const emotionalCharge: EmotionalCharge = {
-    valence: clamp(input.emotional_charge?.valence ?? 0, -1, 1),
-    intensity: clamp(input.emotional_charge?.intensity ?? 0, 0, 1),
-    decayCurve: "linear" as DecayCurve,
-    decayRate: 0.05,
-    originalIntensity: clamp(input.emotional_charge?.intensity ?? 0, 0, 1),
-  };
-
-  const node: NewNode = {
-    content: input.content,
-    type: input.type as MemoryType,
-    created: now,
-    lastAccessed: now,
-    lastConsolidated: now,
-    eventDate: null,
-    emotionalCharge,
-    fidelity: "vivid" as Fidelity,
-    confidence: 0.95, // Explicitly saved = high confidence
-    significance: clamp(input.significance ?? 0.5, 0, 1),
-    stability: 14,
-    reinforcementCount: 0,
-    lastReinforced: now,
-    sourceConversations: [conversationId],
-    sourceType: "direct" as SourceType,
-    narrativeRole: null,
-    partOfStory: null,
-    imageRefs: null,
-    scopeId,
-  };
-
-  const created = createNode(node);
-
-  // Enqueue embedding job immediately
-  enqueueGraphNodeEmbed(created.id);
-
-  return {
-    success: true,
-    op: "save",
-    memory_id: created.id,
-    message: "Memory saved.",
-  };
-}
-
-function handleUpdate(input: RememberInput): RememberResult {
-  if (!input.memory_id) {
-    return {
-      success: false,
-      op: "update",
-      message: "memory_id is required for update",
-    };
-  }
-
-  const existing = getNode(input.memory_id);
-  if (!existing) {
-    return {
-      success: false,
-      op: "update",
-      memory_id: input.memory_id,
-      message: "Memory not found",
-    };
-  }
-
-  const changes: Record<string, unknown> = {};
-  if (input.content) changes.content = input.content;
-  if (input.significance != null)
-    changes.significance = clamp(input.significance, 0, 1);
-  if (input.type && VALID_TYPES.has(input.type as MemoryType))
-    changes.type = input.type;
-
-  if (Object.keys(changes).length > 0) {
-    updateNode(input.memory_id, changes);
-    // Re-embed if content changed
-    if (input.content) {
-      enqueueGraphNodeEmbed(input.memory_id);
-    }
-  }
-
-  return {
-    success: true,
-    op: "update",
-    memory_id: input.memory_id,
-    message: "Memory updated.",
-  };
-}
-
-function handleDelete(input: RememberInput): RememberResult {
-  if (!input.memory_id) {
-    return {
-      success: false,
-      op: "delete",
-      message: "memory_id is required for delete",
-    };
-  }
-
-  const existing = getNode(input.memory_id);
-  if (!existing) {
-    return {
-      success: false,
-      op: "delete",
-      memory_id: input.memory_id,
-      message: "Memory not found",
-    };
-  }
-
-  deleteNode(input.memory_id);
-
-  return {
-    success: true,
-    op: "delete",
-    memory_id: input.memory_id,
-    message: "Memory deleted.",
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function clamp(v: number, min: number, max: number): number {
-  return Math.max(min, Math.min(max, v));
+  return { success: true, message: "Saved to knowledge base." };
 }