open-research 0.1.10 → 0.1.12

package/dist/cli.js

@@ -811,7 +811,7 @@ function formatDateTime(value) {
 }
 
 // src/lib/cli/version.ts
-var PACKAGE_VERSION = "0.1.10";
+var PACKAGE_VERSION = "0.1.12";
 function getPackageVersion() {
   return PACKAGE_VERSION;
 }
@@ -4761,131 +4761,283 @@ async function manualCompact(messages, model, provider, usage, customInstruction
 // src/lib/memory/store.ts
 import fs14 from "fs/promises";
 import path13 from "path";
-function getMemoryFile(options) {
+function getGlobalMemoryFile(options) {
   return path13.join(getOpenResearchRoot(options), "memory.json");
 }
-async function loadMemories(options) {
-  const file = getMemoryFile(options);
+function getProjectMemoryFile(workspaceDir) {
+  return path13.join(workspaceDir, ".open-research", "memory.json");
+}
+async function loadMemoryFile(filePath) {
   try {
-    const raw = await fs14.readFile(file, "utf8");
+    const raw = await fs14.readFile(filePath, "utf8");
     const store = JSON.parse(raw);
     return store.memories ?? [];
   } catch {
     return [];
   }
 }
-async function saveMemories(memories, options) {
-  const file = getMemoryFile(options);
-  await fs14.mkdir(path13.dirname(file), { recursive: true });
-  const store = { version: 1, memories };
-  await fs14.writeFile(file, JSON.stringify(store, null, 2), "utf8");
+async function saveMemoryFile(filePath, memories) {
+  await fs14.mkdir(path13.dirname(filePath), { recursive: true });
+  const store = { version: 2, memories };
+  await fs14.writeFile(filePath, JSON.stringify(store, null, 2), "utf8");
 }
-var MAX_MEMORIES = 100;
-async function addMemory(memory, options) {
-  const memories = await loadMemories(options);
-  const existing = memories.find((m) => {
+async function loadGlobalMemories(options) {
+  const mems = await loadMemoryFile(getGlobalMemoryFile(options));
+  return mems.map((m) => ({ ...m, scope: "global" }));
+}
+async function loadProjectMemories(workspaceDir) {
+  const mems = await loadMemoryFile(getProjectMemoryFile(workspaceDir));
+  return mems.map((m) => ({ ...m, scope: "project" }));
+}
+async function loadAllMemories(options) {
+  const global = await loadGlobalMemories(options);
+  const project = options?.workspaceDir ? await loadProjectMemories(options.workspaceDir) : [];
+  return [...global, ...project];
+}
+var MAX_MEMORIES_PER_STORE = 100;
+function findDuplicate(memories, content) {
+  const b = content.toLowerCase().replace(/\s+/g, " ");
+  const wordsB = new Set(b.split(" ").filter((w) => w.length > 2));
+  return memories.find((m) => {
     const a = m.content.toLowerCase().replace(/\s+/g, " ");
-    const b = memory.content.toLowerCase().replace(/\s+/g, " ");
-    const wordsA = new Set(a.split(" "));
-    const wordsB = new Set(b.split(" "));
+    const wordsA = new Set(a.split(" ").filter((w) => w.length > 2));
     const intersection = [...wordsA].filter((w) => wordsB.has(w));
-    const similarity = intersection.length / Math.max(wordsA.size, wordsB.size);
-    return similarity > 0.7;
+    return intersection.length / Math.max(wordsA.size, wordsB.size) > 0.7;
   });
+}
+function evictIfNeeded(memories) {
+  if (memories.length <= MAX_MEMORIES_PER_STORE) return;
+  memories.sort((a, b) => {
+    const aScore = new Date(a.lastRelevantAt).getTime() + a.relevanceCount * 864e5;
+    const bScore = new Date(b.lastRelevantAt).getTime() + b.relevanceCount * 864e5;
+    return bScore - aScore;
+  });
+  memories.length = MAX_MEMORIES_PER_STORE;
+}
+async function addMemory(memory, options) {
+  const scope = memory.scope ?? (memory.category === "project" || memory.category === "context" ? "project" : "global");
+  const filePath = scope === "project" && options?.workspaceDir ? getProjectMemoryFile(options.workspaceDir) : getGlobalMemoryFile(options);
+  const memories = await loadMemoryFile(filePath);
+  const existing = findDuplicate(memories, memory.content);
   if (existing) {
     existing.lastRelevantAt = (/* @__PURE__ */ new Date()).toISOString();
     existing.relevanceCount++;
     if (memory.content.length > existing.content.length) {
       existing.content = memory.content;
     }
-    await saveMemories(memories, options);
-    return existing;
+    await saveMemoryFile(filePath, memories);
+    return { ...existing, scope };
   }
   const newMemory = {
     id: crypto.randomUUID(),
     content: memory.content,
     category: memory.category,
+    scope,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     lastRelevantAt: (/* @__PURE__ */ new Date()).toISOString(),
     relevanceCount: 1
   };
   memories.push(newMemory);
-  if (memories.length > MAX_MEMORIES) {
-    memories.sort((a, b) => {
-      const aScore = new Date(a.lastRelevantAt).getTime() + a.relevanceCount * 864e5;
-      const bScore = new Date(b.lastRelevantAt).getTime() + b.relevanceCount * 864e5;
-      return bScore - aScore;
-    });
-    memories.length = MAX_MEMORIES;
-  }
-  await saveMemories(memories, options);
+  evictIfNeeded(memories);
+  await saveMemoryFile(filePath, memories);
   return newMemory;
 }
 async function deleteMemory(id, options) {
-  const memories = await loadMemories(options);
-  const idx = memories.findIndex((m) => m.id === id);
-  if (idx === -1) return false;
-  memories.splice(idx, 1);
-  await saveMemories(memories, options);
-  return true;
+  const globalFile = getGlobalMemoryFile(options);
+  const global = await loadMemoryFile(globalFile);
+  const gIdx = global.findIndex((m) => m.id === id);
+  if (gIdx !== -1) {
+    global.splice(gIdx, 1);
+    await saveMemoryFile(globalFile, global);
+    return true;
+  }
+  if (options?.workspaceDir) {
+    const projectFile = getProjectMemoryFile(options.workspaceDir);
+    const project = await loadMemoryFile(projectFile);
+    const pIdx = project.findIndex((m) => m.id === id);
+    if (pIdx !== -1) {
+      project.splice(pIdx, 1);
+      await saveMemoryFile(projectFile, project);
+      return true;
+    }
+  }
+  return false;
 }
 async function clearMemories(options) {
-  await saveMemories([], options);
+  if (!options?.scope || options.scope === "global") {
+    await saveMemoryFile(getGlobalMemoryFile(options), []);
+  }
+  if (options?.workspaceDir && (!options?.scope || options.scope === "project")) {
+    await saveMemoryFile(getProjectMemoryFile(options.workspaceDir), []);
+  }
+}
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "can",
+  "shall",
+  "to",
+  "of",
+  "in",
+  "for",
+  "on",
+  "with",
+  "at",
+  "by",
+  "from",
+  "as",
+  "into",
+  "through",
+  "about",
+  "and",
+  "but",
+  "or",
+  "not",
+  "no",
+  "if",
+  "then",
+  "than",
+  "so",
+  "that",
+  "this",
+  "it",
+  "its",
+  "i",
+  "me",
+  "my",
+  "we",
+  "our",
+  "you",
+  "your",
+  "what",
+  "which",
+  "who",
+  "how",
+  "when",
+  "where",
+  "why"
+]);
+function tokenize(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w) => w.length > 2 && !STOP_WORDS.has(w));
+}
+function scoreRelevance(memory, queryTokens) {
+  const memTokens = tokenize(memory.content);
+  if (memTokens.length === 0) return 0;
+  let matches = 0;
+  for (const token of memTokens) {
+    if (queryTokens.has(token)) matches++;
+  }
+  const overlapScore = matches / memTokens.length;
+  const categoryBoost = memory.category === "user" ? 0.3 : memory.category === "preference" ? 0.2 : memory.category === "methodology" ? 0.15 : 0;
+  const ageMs = Date.now() - new Date(memory.lastRelevantAt).getTime();
+  const ageDays = ageMs / 864e5;
+  const recencyBoost = Math.max(0, 0.1 - ageDays * 1e-3);
+  const freqBoost = Math.min(0.1, memory.relevanceCount * 0.02);
+  return overlapScore + categoryBoost + recencyBoost + freqBoost;
+}
+var MIN_RELEVANCE_SCORE = 0.15;
+var MAX_INJECTED_MEMORIES = 15;
+var ALWAYS_INCLUDE_CATEGORIES = ["user", "preference"];
+function selectRelevantMemories(allMemories, userQuery) {
+  if (allMemories.length === 0) return [];
+  const queryTokens = new Set(tokenize(userQuery));
+  const alwaysInclude = allMemories.filter(
+    (m) => ALWAYS_INCLUDE_CATEGORIES.includes(m.category)
+  );
+  const candidates = allMemories.filter((m) => !ALWAYS_INCLUDE_CATEGORIES.includes(m.category)).map((m) => ({ memory: m, score: scoreRelevance(m, queryTokens) })).filter((c) => c.score >= MIN_RELEVANCE_SCORE).sort((a, b) => b.score - a.score);
+  const selected = [
+    ...alwaysInclude.slice(0, 5),
+    // Max 5 identity memories
+    ...candidates.slice(0, MAX_INJECTED_MEMORIES - Math.min(alwaysInclude.length, 5)).map((c) => c.memory)
+  ];
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const m of selected) {
+    m.lastRelevantAt = now;
+  }
+  return selected;
 }
 function formatMemoriesForPrompt(memories) {
   if (memories.length === 0) return "";
-  const grouped = {};
-  for (const m of memories) {
-    (grouped[m.category] ??= []).push(m);
-  }
-  const sections = ["## What I Remember About You"];
-  const categoryLabels = {
-    user: "About you",
-    preference: "Your preferences",
-    project: "Your projects",
-    methodology: "Methodology preferences",
-    context: "Context"
-  };
-  for (const [cat, mems] of Object.entries(grouped)) {
-    sections.push(`**${categoryLabels[cat] ?? cat}:**`);
-    for (const m of mems) {
-      sections.push(`- ${m.content}`);
-    }
+  const global = memories.filter((m) => m.scope === "global");
+  const project = memories.filter((m) => m.scope === "project");
+  const sections = ["## Relevant Context"];
+  if (global.length > 0) {
+    sections.push("**About you:**");
+    for (const m of global) sections.push(`- ${m.content}`);
+  }
+  if (project.length > 0) {
+    sections.push("**This project:**");
+    for (const m of project) sections.push(`- ${m.content}`);
   }
   return sections.join("\n");
 }
 
 // src/lib/memory/extractor.ts
-var EXTRACTION_PROMPT = `You are a memory extraction system. Your job is to identify facts worth remembering about the user from a conversation exchange.
+var EXTRACTION_PROMPT = `You are a memory management system. You decide what to remember about the user across sessions.
 
-Focus on:
-- Who they are (role, field, institution, expertise level)
-- What they're working on (current research projects, topics, deadlines)
-- How they prefer to work (preferred tools, languages, writing style, methodologies)
-- Methodological preferences (statistical approaches, theoretical frameworks, citation style)
-- Important context (collaborators, advisors, publication targets, funding constraints)
+You will receive:
+1. The current conversation exchange
+2. ALL existing memories (both global and project-level)
 
-Rules:
-- Only extract facts that would be useful in FUTURE conversations
-- Be specific and concise \u2014 each memory should be one clear fact
-- Do NOT extract task-specific details that only matter for the current conversation
-- Do NOT extract obvious things ("user asked about papers" is not useful)
-- If there is nothing meaningful to remember, return an empty array
-- Maximum 3 new memories per exchange
-
-Existing memories (do not duplicate these):
+Your job: decide if any NEW memories should be created OR if any existing memories need updating.
+
+CRITICAL RULES:
+- Do NOT create a memory if an existing memory already covers the same fact
+- If a fact has CHANGED (e.g., user switched from Python to R), output an UPDATE to the existing memory instead of creating a new one
+- Only create memories for facts useful in FUTURE sessions, not task-specific details
+- Maximum 3 actions per exchange
+- If nothing meaningful to remember, return an empty array
+
+Categories:
+- "user" \u2014 identity, role, field, institution (\u2192 stored globally)
+- "preference" \u2014 tools, style, methodology preferences (\u2192 stored globally)
+- "project" \u2014 current research topics, findings, hypotheses (\u2192 stored per-project)
+- "methodology" \u2014 statistical approaches, frameworks (\u2192 stored globally)
+- "context" \u2014 deadlines, collaborators, constraints (\u2192 stored per-project)
+
+Existing memories:
 {EXISTING_MEMORIES}
 
-Respond with a JSON array of objects, each with "content" (string) and "category" (one of: "user", "preference", "project", "methodology", "context"). If nothing worth remembering, respond with [].
+Respond with a JSON array. Each item has:
+- "action": "create" or "update"
+- "content": the memory text (for create: new content; for update: the updated content)
+- "category": one of the categories above
+- "updateId": (only for "update") the ID of the existing memory to update
 
-Example response:
-[{"content": "PhD student in computational neuroscience at MIT", "category": "user"}, {"content": "Prefers Python with statsmodels for statistical analysis over R", "category": "preference"}]`;
+If nothing to do, respond with [].
+
+Example:
+[{"action": "create", "content": "PhD student in neuroscience at MIT", "category": "user"}]
+[{"action": "update", "updateId": "abc123", "content": "Now using R instead of Python for analysis", "category": "preference"}]`;
 async function extractMemories(input2) {
-  const existing = await loadMemories({ homeDir: input2.homeDir });
+  const existing = await loadAllMemories({
+    homeDir: input2.homeDir,
+    workspaceDir: input2.workspaceDir
+  });
   if (input2.userMessage.startsWith("/") || input2.userMessage.length < 20) {
     return [];
   }
-  const existingList = existing.length > 0 ? existing.map((m) => `- [${m.category}] ${m.content}`).join("\n") : "(none)";
+  const existingList = existing.length > 0 ? existing.map((m) => `- [${m.scope}/${m.category}] (id: ${m.id.slice(0, 8)}) ${m.content}`).join("\n") : "(none)";
   const prompt2 = EXTRACTION_PROMPT.replace("{EXISTING_MEMORIES}", existingList);
   const conversationSnippet = [
     `User: ${input2.userMessage.slice(0, 2e3)}`,
@@ -4907,10 +5059,12 @@ async function extractMemories(input2) {
     if (!Array.isArray(parsed)) return [];
     const valid = [];
     for (const item of parsed) {
-      if (typeof item.content === "string" && item.content.length > 5 && ["user", "preference", "project", "methodology", "context"].includes(item.category)) {
+      if (typeof item.content === "string" && item.content.length > 5 && ["user", "preference", "project", "methodology", "context"].includes(item.category) && ["create", "update"].includes(item.action)) {
         valid.push({
+          action: item.action,
           content: item.content,
-          category: item.category
+          category: item.category,
+          updateId: typeof item.updateId === "string" ? item.updateId : void 0
         });
       }
     }
@@ -4920,13 +5074,35 @@ async function extractMemories(input2) {
   }
 }
 async function extractAndStoreMemories(input2) {
-  const extracted = await extractMemories(input2);
-  const stored = [];
-  for (const mem of extracted) {
-    const saved = await addMemory(mem, { homeDir: input2.homeDir });
-    stored.push(saved);
+  const actions = await extractMemories(input2);
+  const results = [];
+  const existing = await loadAllMemories({
+    homeDir: input2.homeDir,
+    workspaceDir: input2.workspaceDir
+  });
+  for (const action of actions) {
+    if (action.action === "update" && action.updateId) {
+      const target = existing.find((m) => m.id.startsWith(action.updateId));
+      if (target) {
+        target.content = action.content;
+        target.lastRelevantAt = (/* @__PURE__ */ new Date()).toISOString();
+        target.relevanceCount++;
+        const saved = await addMemory(
+          { content: action.content, category: action.category, scope: target.scope },
+          { homeDir: input2.homeDir, workspaceDir: input2.workspaceDir }
+        );
+        results.push(saved);
+      }
+    } else {
+      const scope = action.category === "project" || action.category === "context" ? "project" : "global";
+      const saved = await addMemory(
+        { content: action.content, category: action.category, scope },
+        { homeDir: input2.homeDir, workspaceDir: input2.workspaceDir }
+      );
+      results.push(saved);
+    }
   }
-  return stored;
+  return results;
 }
 
 // src/lib/workspace/agents-md.ts
@@ -5083,16 +5259,19 @@ async function runAgentTurn(input2) {
   const systemPrompt = isPlanning ? buildPlanningSystemPrompt(input2.workspace, activeSkills) : buildSystemPrompt(input2.workspace, activeSkills);
   const model = input2.model ?? "gpt-5.4";
   const usage = input2.sessionUsage ?? createSessionUsage();
-  const memories = await loadMemories({ homeDir: input2.homeDir });
-  const memoryBlock = formatMemoriesForPrompt(memories);
+  const allMemories = await loadAllMemories({
+    homeDir: input2.homeDir,
+    workspaceDir: input2.workspace.workspaceDir
+  });
+  const relevantMemories = selectRelevantMemories(allMemories, input2.message);
+  const memoryBlock = formatMemoriesForPrompt(relevantMemories);
   const agentsMd = input2.workspace.workspaceDir ? await readAgentsMd(input2.workspace.workspaceDir).catch(() => "") : "";
-  const contextBlocks = [
+  const fullSystemPrompt = [
     systemPrompt,
-    memoryBlock ? memoryBlock : null,
+    memoryBlock || null,
     agentsMd ? `## Project Context (from AGENTS.md)
 ${agentsMd}` : null
   ].filter(Boolean).join("\n\n");
-  const fullSystemPrompt = contextBlocks;
   let messages = [
     { role: "system", content: fullSystemPrompt },
     ...input2.history,
@@ -5152,7 +5331,8 @@ ${agentsMd}` : null
         agentResponse: fullText,
         provider: input2.provider,
         model: "gpt-5.4-mini",
-        homeDir: input2.homeDir
+        homeDir: input2.homeDir,
+        workspaceDir: input2.workspace.workspaceDir
       }).then((stored) => {
         if (stored.length > 0) {
           input2.onMemoryExtracted?.(stored.map((m) => m.content));
@@ -7006,7 +7186,7 @@ ${msg.text}
         addSystemMessage(`  Workspace: ${workspacePath ? workspacePath : "none"}`);
         addSystemMessage(`  Files: ${workspaceFiles.length}`);
         addSystemMessage(`  Skills: ${skills2.length} loaded`);
-        const mems = await loadMemories({ homeDir });
+        const mems = await loadAllMemories({ homeDir });
         addSystemMessage(`  Memories: ${mems.length} stored`);
         addSystemMessage(`  Node: ${process.version}`);
         const toolChecks = ["python3 --version", "pdflatex --version", "git --version"];
@@ -7057,7 +7237,7 @@ ${msg.text}
           addSystemMessage(deleted ? `Deleted memory ${memId.slice(0, 8)}...` : "Memory not found.");
           break;
         }
-        const mems = await loadMemories({ homeDir });
+        const mems = await loadAllMemories({ homeDir });
         if (mems.length === 0) {
           addSystemMessage("No memories stored yet. I'll learn about you as we talk.");
         } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-research",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "Local-first research CLI agent — discover papers, synthesize notes, run analysis, and draft artifacts from your terminal.",
   "type": "module",
   "license": "MIT",