@jcyamacho/agent-memory 0.0.3 → 0.0.4

package/README.md

@@ -77,8 +77,8 @@ short phrases. Each term is matched independently — more terms cast a wider ne
 and results matching multiple terms rank higher. Stemming is applied
 automatically, so exact word forms are not required.
 
-Use `preferred_workspace` to bias ranking. Use `filter_workspace` and
-`created_*` only for exact scoping. Keep `limit` small.
+Use `workspace` to bias ranking toward the current project. Use `created_*`
+only for exact scoping.
 ```
 
 ## What It Stores
@@ -116,8 +116,7 @@ Inputs:
 - `terms` -> 2-5 distinctive terms or short phrases that should appear in the
   memory content; avoid full natural-language questions
 - `limit` -> maximum results to return
-- `preferred_workspace` -> ranking hint for a workspace
-- `filter_workspace` -> exact workspace filter
+- `workspace` -> workspace or repo path; biases ranking toward this workspace
 - `created_after` -> ISO 8601 lower bound
 - `created_before` -> ISO 8601 upper bound
 

package/dist/index.js

@@ -12464,7 +12464,7 @@ class StdioServerTransport {
   }
 }
 // package.json
-var version2 = "0.0.3";
+var version2 = "0.0.4";
 
 // src/config.ts
 import { homedir } from "node:os";
@@ -19881,6 +19881,9 @@ var EMPTY_COMPLETION_RESULT = {
   }
 };
 
+// src/memory-service.ts
+import { randomUUID } from "node:crypto";
+
 // src/errors.ts
 class MemoryError extends Error {
   code;
@@ -19905,6 +19908,63 @@ class PersistenceError extends MemoryError {
   }
 }
 
+// src/memory-service.ts
+var DEFAULT_LIMIT = 15;
+var MAX_LIMIT = 50;
+
+class MemoryService {
+  repository;
+  constructor(repository) {
+    this.repository = repository;
+  }
+  async save(input) {
+    const content = input.content.trim();
+    if (!content) {
+      throw new ValidationError("Memory content is required.");
+    }
+    const now = new Date;
+    const memory = {
+      id: randomUUID(),
+      content,
+      workspace: normalizeOptionalString(input.workspace),
+      createdAt: now,
+      updatedAt: now
+    };
+    return this.repository.save(memory);
+  }
+  async search(input) {
+    const terms = normalizeTerms(input.terms);
+    if (terms.length === 0) {
+      throw new ValidationError("At least one search term is required.");
+    }
+    const normalizedQuery = {
+      terms,
+      limit: normalizeLimit(input.limit),
+      workspace: normalizeOptionalString(input.workspace),
+      createdAfter: input.createdAfter,
+      createdBefore: input.createdBefore
+    };
+    return this.repository.search(normalizedQuery);
+  }
+}
+var normalizeLimit = (value) => {
+  if (value === undefined) {
+    return DEFAULT_LIMIT;
+  }
+  if (!Number.isInteger(value) || value < 1 || value > MAX_LIMIT) {
+    throw new ValidationError(`Limit must be an integer between 1 and ${MAX_LIMIT}.`);
+  }
+  return value;
+};
+var normalizeOptionalString = (value) => {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : undefined;
+};
+var normalizeTerms = (terms) => {
+  const normalizedTerms = terms.map((term) => term.trim()).filter(Boolean);
+  return [...new Set(normalizedTerms)];
+};
+
 // src/tools/shared.ts
 var toMcpError = (error2) => {
   if (error2 instanceof McpError) {
@@ -19933,9 +19993,8 @@ var parseOptionalDate = (value, fieldName) => {
 // src/tools/recall.ts
 var recallInputSchema = {
   terms: array(string2()).min(1).describe("Search terms to match against remembered content. Use distinctive keywords, IDs, names, file names, or short phrases as separate items."),
-  limit: number2().int().min(1).max(20).optional().describe("Maximum number of memory results to return. Use a small number when you only need the best matches."),
-  preferred_workspace: string2().optional().describe("Preferred workspace or repository path to rank higher when relevant. This does not exclude other workspaces."),
-  filter_workspace: string2().optional().describe("Only return memories from this exact workspace or repository path."),
+  limit: number2().int().min(1).max(MAX_LIMIT).optional().describe("Maximum number of memory results to return. Use a small number when you only need the best matches."),
+  workspace: string2().optional().describe("Workspace or repository path. Memories from this workspace rank higher, but other workspaces are not excluded."),
   created_after: string2().optional().describe("Only return memories created at or after this ISO 8601 timestamp."),
   created_before: string2().optional().describe("Only return memories created at or before this ISO 8601 timestamp.")
 };
@@ -19953,13 +20012,12 @@ var registerRecallTool = (server, memoryService) => {
     description: "Retrieve previously remembered context that may help with the current task. Use it for user preferences, project facts, prior decisions, constraints, or earlier conversation details.",
     inputSchema: recallInputSchema,
     outputSchema: recallOutputSchema
-  }, async ({ terms, limit, preferred_workspace, filter_workspace, created_after, created_before }) => {
+  }, async ({ terms, limit, workspace, created_after, created_before }) => {
     try {
       const results = await memoryService.search({
         terms,
         limit,
-        preferredWorkspace: preferred_workspace,
-        filterWorkspace: filter_workspace,
+        workspace,
         createdAfter: parseOptionalDate(created_after, "created_after"),
         createdBefore: parseOptionalDate(created_before, "created_before")
       });
@@ -20041,66 +20099,6 @@ var createMcpServer = (memoryService, version3) => {
   return server;
 };
 
-// src/memory-service.ts
-import { randomUUID } from "node:crypto";
-var DEFAULT_LIMIT = 5;
-var MAX_LIMIT = 20;
-
-class MemoryService {
-  repository;
-  constructor(repository) {
-    this.repository = repository;
-  }
-  async save(input) {
-    const content = input.content.trim();
-    if (!content) {
-      throw new ValidationError("Memory content is required.");
-    }
-    const now = new Date;
-    const memory = {
-      id: randomUUID(),
-      content,
-      workspace: normalizeOptionalString(input.workspace),
-      createdAt: now,
-      updatedAt: now
-    };
-    return this.repository.save(memory);
-  }
-  async search(input) {
-    const terms = normalizeTerms(input.terms);
-    if (terms.length === 0) {
-      throw new ValidationError("At least one search term is required.");
-    }
-    const normalizedQuery = {
-      terms,
-      limit: normalizeLimit(input.limit),
-      preferredWorkspace: normalizeOptionalString(input.preferredWorkspace),
-      filterWorkspace: normalizeOptionalString(input.filterWorkspace),
-      createdAfter: input.createdAfter,
-      createdBefore: input.createdBefore
-    };
-    const results = await this.repository.search(normalizedQuery);
-    return results.slice(0, normalizedQuery.limit);
-  }
-}
-var normalizeLimit = (value) => {
-  if (value === undefined) {
-    return DEFAULT_LIMIT;
-  }
-  if (!Number.isInteger(value) || value < 1 || value > MAX_LIMIT) {
-    throw new ValidationError(`Limit must be an integer between 1 and ${MAX_LIMIT}.`);
-  }
-  return value;
-};
-var normalizeOptionalString = (value) => {
-  const trimmed = value?.trim();
-  return trimmed ? trimmed : undefined;
-};
-var normalizeTerms = (terms) => {
-  const normalizedTerms = terms.map((term) => term.trim()).filter(Boolean);
-  return [...new Set(normalizedTerms)];
-};
-
 // src/sqlite-db.ts
 import { mkdirSync } from "node:fs";
 import { dirname } from "node:path";
@@ -20167,9 +20165,6 @@ var initializeMemoryDatabase = (database) => {
 };
 
 // src/sqlite-repository.ts
-var CANDIDATE_MULTIPLIER = 5;
-var MIN_CANDIDATES = 25;
-var MAX_CANDIDATES = 100;
 var WORKSPACE_BIAS = 0.1;
 
 class SqliteMemoryRepository {
@@ -20206,17 +20201,13 @@ class SqliteMemoryRepository {
       const selectParams = [];
       const whereParams = [toFtsQuery(query.terms)];
       let scoreExpr;
-      if (query.preferredWorkspace) {
+      if (query.workspace) {
         scoreExpr = "MAX(0, -bm25(memories_fts) + CASE WHEN m.workspace = ? THEN ? ELSE 0.0 END)";
-        selectParams.push(query.preferredWorkspace, WORKSPACE_BIAS);
+        selectParams.push(query.workspace, WORKSPACE_BIAS);
       } else {
         scoreExpr = "MAX(0, -bm25(memories_fts))";
       }
       const whereClauses = ["memories_fts MATCH ?"];
-      if (query.filterWorkspace) {
-        whereClauses.push("m.workspace = ?");
-        whereParams.push(query.filterWorkspace);
-      }
       if (query.createdAfter) {
         whereClauses.push("m.created_at >= ?");
         whereParams.push(query.createdAfter.getTime());
@@ -20225,7 +20216,7 @@ class SqliteMemoryRepository {
         whereClauses.push("m.created_at <= ?");
         whereParams.push(query.createdBefore.getTime());
       }
-      const params = [...selectParams, ...whereParams, toCandidateLimit(query.limit)];
+      const params = [...selectParams, ...whereParams, query.limit];
       const statement = this.database.prepare(`
         SELECT
           m.id,
@@ -20254,7 +20245,6 @@ class SqliteMemoryRepository {
     }
   }
 }
-var toCandidateLimit = (limit) => Math.min(Math.max(limit * CANDIDATE_MULTIPLIER, MIN_CANDIDATES), MAX_CANDIDATES);
 var toFtsQuery = (terms) => terms.map(toFtsTerm).join(" OR ");
 var toFtsTerm = (term) => {
   const escaped = term.replaceAll('"', '""');

package/package.json

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