@jcyamacho/agent-memory 0.0.15 → 0.0.17

package/README.md

@@ -27,69 +27,17 @@ Codex CLI:
 codex mcp add memory -- npx -y @jcyamacho/agent-memory
 ```
 
-Example MCP server config:
-
-```json
-{
-  "mcpServers": {
-    "memory": {
-      "command": "npx",
-      "args": [
-        "-y",
-        "@jcyamacho/agent-memory"
-      ]
-    }
-  }
-}
-```
-
-With a custom database path:
-
-```json
-{
-  "mcpServers": {
-    "memory": {
-      "command": "npx",
-      "args": [
-        "-y",
-        "@jcyamacho/agent-memory"
-      ],
-      "env": {
-        "AGENT_MEMORY_DB_PATH": "/absolute/path/to/memory.db"
-      }
-    }
-  }
-}
-```
-
-With a custom model cache path:
-
-```json
-{
-  "mcpServers": {
-    "memory": {
-      "command": "npx",
-      "args": [
-        "-y",
-        "@jcyamacho/agent-memory"
-      ],
-      "env": {
-        "AGENT_MEMORY_MODELS_CACHE_PATH": "/absolute/path/to/models"
-      }
-    }
-  }
-}
-```
-
 Optional LLM instructions to reinforce the MCP's built-in guidance:
 
 ```text
-Use `recall` at conversation start and before design choices, conventions, or
-edge cases. Query with 2-5 short anchor-heavy terms or exact phrases, not
-questions or sentences. `recall` is lexical-first; if it misses, retry once
-with overlapping alternate terms. Use `remember` for one durable fact, then
-use `revise` instead of duplicates and `forget` for wrong or obsolete
-memories. Always pass workspace unless the memory is truly global.
+Use `memory_recall` at conversation start and before design choices,
+conventions, or edge cases. Query with 2-5 short anchor-heavy terms or exact
+phrases, not
+questions or sentences. `memory_recall` is lexical-first; if it misses, retry once
+with overlapping alternate terms. Use `memory_remember` for one durable fact, then
+use `memory_revise` instead of duplicates and `memory_forget` for wrong or obsolete
+memories. Always pass workspace unless the memory is truly global. Git worktree
+paths are canonicalized to the main repo root on save and recall.
 ```
 
 ## What It Stores
@@ -147,6 +95,10 @@ If you omit `workspace`, recall still uses text relevance, embedding similarity,
 and recency. For best results, pass `workspace` whenever you have one. Save
 memories without a workspace only when they apply across all projects.
 
+When you save a memory from a git worktree, `agent-memory` stores the main repo
+root as the workspace. `recall` applies the same normalization to incoming
+workspace queries so linked worktrees still match repo-scoped memories exactly.
+
 ## Database location
 
 By default, the SQLite database is created at:
@@ -187,8 +139,8 @@ Set `AGENT_MEMORY_MODELS_CACHE_PATH` when you want to:
 - share the model cache across reinstalls or multiple clients
 - store model downloads somewhere easier to inspect or manage
 
-Beta note: schema changes are not migrated. If you are upgrading from an older
-beta, delete the existing memory DB and let the server create a new one.
+Schema changes are migrated automatically, including workspace normalization for
+existing git worktree memories when the original path can still be resolved.
 
 ## Development
 

package/dist/index.js

@@ -12464,7 +12464,7 @@ class StdioServerTransport {
   }
 }
 // package.json
-var version2 = "0.0.15";
+var version2 = "0.0.17";
 
 // src/config.ts
 import { homedir } from "node:os";
@@ -20146,19 +20146,22 @@ var MAX_LIST_LIMIT = 100;
 class MemoryService {
   repository;
   embeddingService;
-  constructor(repository, embeddingService) {
+  workspaceResolver;
+  constructor(repository, embeddingService, workspaceResolver) {
     this.repository = repository;
     this.embeddingService = embeddingService;
+    this.workspaceResolver = workspaceResolver;
   }
   async create(input) {
     const content = input.content.trim();
     if (!content) {
       throw new ValidationError("Memory content is required.");
     }
+    const workspace = await this.workspaceResolver.resolve(input.workspace);
     const memory = await this.repository.create({
       content,
       embedding: await this.embeddingService.createVector(content),
-      workspace: normalizeOptionalString(input.workspace)
+      workspace
     });
     return toPublicMemoryRecord(memory);
   }
@@ -20184,7 +20187,7 @@ class MemoryService {
     return memory ? toPublicMemoryRecord(memory) : undefined;
   }
   async list(input) {
-    const workspace = normalizeOptionalString(input.workspace);
+    const workspace = await this.workspaceResolver.resolve(input.workspace);
     const page = await this.repository.list({
       workspace,
       workspaceIsNull: workspace ? false : Boolean(input.workspaceIsNull),
@@ -20202,7 +20205,7 @@ class MemoryService {
       throw new ValidationError("At least one search term is required.");
     }
     const requestedLimit = normalizeLimit(input.limit);
-    const workspace = normalizeOptionalString(input.workspace);
+    const workspace = await this.workspaceResolver.resolve(input.workspace);
     const normalizedQuery = {
       terms,
       limit: requestedLimit * RECALL_CANDIDATE_LIMIT_MULTIPLIER,
@@ -20259,10 +20262,6 @@ function normalizeListLimit(value) {
   }
   return Math.min(Math.max(value, 1), MAX_LIST_LIMIT);
 }
-function normalizeOptionalString(value) {
-  const trimmed = value?.trim();
-  return trimmed ? trimmed : undefined;
-}
 function normalizeTerms(terms) {
   const normalizedTerms = terms.map((term) => term.trim()).filter(Boolean);
   return [...new Set(normalizedTerms)];
@@ -20272,7 +20271,7 @@ function normalizeTerms(terms) {
 var recallInputSchema = {
   terms: array(string2()).min(1).describe("Search terms for lexical memory lookup. Pass 2-5 short anchor-heavy terms or exact phrases as separate entries. Prefer identifiers, commands, file paths, package names, and conventions likely to appear verbatim in the memory. Avoid vague words, full sentences, and repeating the workspace name. If recall misses, retry once with overlapping alternate terms."),
   limit: number2().int().min(1).max(MAX_RECALL_LIMIT).optional().describe("Maximum matches to return. Keep this small when you only need the strongest hits."),
-  workspace: string2().optional().describe("Pass the current working directory. This strongly boosts memories from the active project while still allowing global and cross-workspace matches."),
+  workspace: string2().optional().describe("Pass the current working directory. Git worktree paths are normalized to the main repo root for matching. This strongly boosts memories from the active project while still allowing global and cross-workspace matches."),
   updated_after: string2().optional().describe("Only return memories updated at or after this ISO 8601 timestamp."),
   updated_before: string2().optional().describe("Only return memories updated at or before this ISO 8601 timestamp.")
 };
@@ -20286,7 +20285,7 @@ ${content}
 }
 function registerRecallTool(server, memory) {
   server.registerTool("recall", {
-    description: "Retrieve relevant memories for the current task. Use at conversation start and before design choices, conventions, or edge cases. Query with 2-5 short anchor-heavy terms or exact phrases, not questions or full sentences. `recall` is lexical-first; semantic reranking only reorders lexical matches. If it misses, retry once with overlapping alternate terms. Pass workspace. Returns `<memories>...</memories>` or a no-match hint.",
+    description: "Retrieve relevant memories for the current task. Use at conversation start and before design choices, conventions, or edge cases. Query with 2-5 short anchor-heavy terms or exact phrases, not questions or full sentences. `recall` is lexical-first; semantic reranking only reorders lexical matches. If it misses, retry once with overlapping alternate terms. Pass workspace; git worktree paths are normalized to the main repo root for matching. Returns `<memories>...</memories>` or a no-match hint.",
     inputSchema: recallInputSchema
   }, async ({ terms, limit, workspace, updated_after, updated_before }) => {
     try {
@@ -20313,7 +20312,7 @@ ${results.map(toMemoryXml).join(`
 // src/mcp/tools/remember.ts
 var rememberInputSchema = {
   content: string2().describe("One durable fact to save. Use a single self-contained sentence or short note with concrete nouns, identifiers, commands, file paths, or exact phrases the agent is likely to reuse."),
-  workspace: string2().optional().describe("Pass the current working directory for project-specific memories. Omit only for truly global memories.")
+  workspace: string2().optional().describe("Pass the current working directory for project-specific memories. Git worktree paths are saved as the main repo root automatically. Omit only for truly global memories.")
 };
 function registerRememberTool(server, memory) {
   server.registerTool("remember", {
@@ -20370,7 +20369,7 @@ var SERVER_INSTRUCTIONS = [
   "Use `remember` for one durable fact when the user states a preference, corrects you, or a reusable project decision becomes clear.",
   "Call `recall` before `remember`; if the fact already exists, use `revise` instead of creating a duplicate.",
   "Use `revise` to correct an existing memory and `forget` to remove a wrong or obsolete one.",
-  "Pass workspace for project-scoped calls. Omit it only for truly global memories."
+  "Pass workspace for project-scoped calls. Git worktree paths are canonicalized to the main repo root on save and recall. Omit workspace only for truly global memories."
 ].join(" ");
 function createMcpServer(memory, version3) {
   const server = new McpServer({
@@ -20502,7 +20501,7 @@ function toUint8Array(value) {
 }
 
 // src/sqlite/migrations/002-add-memory-embedding.ts
-function createAddMemoryEmbeddingMigration(embeddingService = new EmbeddingService) {
+function createAddMemoryEmbeddingMigration(embeddingService) {
   return {
     version: 2,
     async up(database) {
@@ -20531,13 +20530,33 @@ function createAddMemoryEmbeddingMigration(embeddingService = new EmbeddingServi
     }
   };
 }
-var addMemoryEmbeddingMigration = createAddMemoryEmbeddingMigration();
+
+// src/sqlite/migrations/003-normalize-workspaces.ts
+function createNormalizeWorkspaceMigration(workspaceResolver) {
+  return {
+    version: 3,
+    async up(database) {
+      const rows = database.prepare("SELECT DISTINCT workspace FROM memories WHERE workspace IS NOT NULL ORDER BY workspace").all();
+      const updateStatement = database.prepare("UPDATE memories SET workspace = ? WHERE workspace = ?");
+      for (const row of rows) {
+        const normalizedWorkspace = await workspaceResolver.resolve(row.workspace);
+        if (!normalizedWorkspace || normalizedWorkspace === row.workspace) {
+          continue;
+        }
+        updateStatement.run(normalizedWorkspace, row.workspace);
+      }
+    }
+  };
+}
 
 // src/sqlite/migrations/index.ts
-function createMemoryMigrations(embeddingService = new EmbeddingService) {
-  return [createMemorySchemaMigration, createAddMemoryEmbeddingMigration(embeddingService)];
+function createMemoryMigrations(options) {
+  return [
+    createMemorySchemaMigration,
+    createAddMemoryEmbeddingMigration(options.embeddingService),
+    createNormalizeWorkspaceMigration(options.workspaceResolver)
+  ];
 }
-var MEMORY_MIGRATIONS = createMemoryMigrations();
 
 // src/sqlite/db.ts
 var PRAGMA_STATEMENTS = [
@@ -20546,12 +20565,12 @@ var PRAGMA_STATEMENTS = [
   "foreign_keys = ON",
   "busy_timeout = 5000"
 ];
-async function openMemoryDatabase(databasePath, options = {}) {
+async function openMemoryDatabase(databasePath, options) {
   let database;
   try {
     mkdirSync2(dirname(databasePath), { recursive: true });
     database = new Database(databasePath);
-    await initializeMemoryDatabase(database, createMemoryMigrations(options.embeddingService));
+    await initializeMemoryDatabase(database, createMemoryMigrations(options));
     return database;
   } catch (error2) {
     database?.close();
@@ -20563,7 +20582,7 @@ async function openMemoryDatabase(databasePath, options = {}) {
     });
   }
 }
-async function initializeMemoryDatabase(database, migrations = MEMORY_MIGRATIONS) {
+async function initializeMemoryDatabase(database, migrations) {
   try {
     applyPragmas(database);
     await runSqliteMigrations(database, migrations);
@@ -24195,12 +24214,59 @@ function startWebServer(memory, options) {
   return serve({ fetch: app.fetch, port: options.port });
 }
 
+// src/workspace-resolver.ts
+import { execFile } from "node:child_process";
+import { basename, dirname as dirname2 } from "node:path";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+function createGitWorkspaceResolver(options = {}) {
+  const getGitCommonDir = options.getGitCommonDir ?? defaultGetGitCommonDir;
+  const cache = new Map;
+  return {
+    async resolve(workspace) {
+      const trimmed = normalizeOptionalString(workspace);
+      if (!trimmed) {
+        return;
+      }
+      const cached2 = cache.get(trimmed);
+      if (cached2) {
+        return cached2;
+      }
+      const pending = resolveWorkspace(trimmed, getGitCommonDir);
+      cache.set(trimmed, pending);
+      return pending;
+    }
+  };
+}
+async function resolveWorkspace(workspace, getGitCommonDir) {
+  try {
+    const gitCommonDir = (await getGitCommonDir(workspace)).trim();
+    if (basename(gitCommonDir) !== ".git") {
+      return workspace;
+    }
+    return dirname2(gitCommonDir);
+  } catch {
+    return workspace;
+  }
+}
+async function defaultGetGitCommonDir(cwd) {
+  const { stdout } = await execFileAsync("git", ["rev-parse", "--path-format=absolute", "--git-common-dir"], {
+    cwd
+  });
+  return stdout.trim();
+}
+function normalizeOptionalString(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : undefined;
+}
+
 // src/index.ts
 var config2 = resolveConfig();
 var embeddingService = new EmbeddingService({ modelsCachePath: config2.modelsCachePath });
-var database = await openMemoryDatabase(config2.databasePath, { embeddingService });
+var workspaceResolver = createGitWorkspaceResolver();
+var database = await openMemoryDatabase(config2.databasePath, { embeddingService, workspaceResolver });
 var repository2 = new SqliteMemoryRepository(database);
-var memoryService = new MemoryService(repository2, embeddingService);
+var memoryService = new MemoryService(repository2, embeddingService, workspaceResolver);
 if (config2.uiMode) {
   let shutdown = function() {
     server.close();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@jcyamacho/agent-memory",
   "main": "dist/index.js",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "bin": {
     "agent-memory": "dist/index.js"
   },