memento-mcp 0.3.13 → 0.3.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memento-mcp",
-  "version": "0.3.13",
+  "version": "0.3.14",
   "mcpName": "io.github.myrakrusemark/memento-protocol",
   "description": "The Memento Protocol — persistent memory for AI agents",
   "type": "module",
@@ -22,6 +22,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.26.0",
     "dotenv": "^16.6.1",
+    "sharp": "^0.34.5",
     "zod": "^3.24.2"
   },
   "files": [

package/scripts/memento-userprompt-recall.sh

@@ -3,6 +3,8 @@
 # JSON output: systemMessage (user sees count) + additionalContext (model sees details).
 #
 # Calls /v1/context endpoint for memories + skip list matches.
+# Supports image search: detects pasted images (Claude Code image cache) and
+# file paths in the message, downscales to 224x224, sends to /v1/context.
 
 set -o pipefail
 
@@ -60,6 +62,7 @@ MEMENTO_WS="${MEMENTO_WORKSPACE:-default}"
 
 INPUT=$(cat)
 USER_MESSAGE=$(echo "$INPUT" | jq -r '.prompt // empty' 2>/dev/null)
+SESSION_ID=$(echo "$INPUT" | jq -r '.session_id // empty' 2>/dev/null)
 
 if [ -z "$USER_MESSAGE" ] || [ ${#USER_MESSAGE} -lt 10 ]; then
     exit 0
@@ -67,16 +70,97 @@ fi
 
 QUERY="${USER_MESSAGE:0:500}"
 
+# --- Image detection ---
+# Collect up to 3 images from two sources:
+#   1. Claude Code image cache (pasted/dropped images, recent only)
+#   2. File paths mentioned in the message text
+IMAGE_PATHS=()
+
+# Prong 1: Claude Code image cache — pasted images cached in ~/.claude/image-cache/{session_id}/
+if [ -n "$SESSION_ID" ]; then
+    IMAGE_CACHE="$HOME/.claude/image-cache/$SESSION_ID"
+    if [ -d "$IMAGE_CACHE" ]; then
+        while IFS= read -r img; do
+            IMAGE_PATHS+=("$img")
+        done < <(find "$IMAGE_CACHE" -maxdepth 1 -name "*.png" -newermt '5 seconds ago' 2>/dev/null | head -3)
+    fi
+fi
+
+# Prong 2: File paths in message text (explicit image references)
+if [ ${#IMAGE_PATHS[@]} -lt 3 ]; then
+    REMAINING_SLOTS=$(( 3 - ${#IMAGE_PATHS[@]} ))
+    while IFS= read -r img; do
+        if [ -f "$img" ]; then
+            IMAGE_PATHS+=("$img")
+        fi
+    done < <(echo "$USER_MESSAGE" | grep -oE '(/[^ ]+\.(jpg|jpeg|png|gif|webp))' | head -"$REMAINING_SLOTS")
+fi
+
+# Build images JSON array (base64-encoded, downscaled to 224x224)
+IMAGES_JSON=""
+if [ ${#IMAGE_PATHS[@]} -gt 0 ] && command -v convert &>/dev/null; then
+    IMAGES_JSON=$(python3 -c "
+import subprocess, base64, json, sys, os
+
+paths = sys.argv[1:]
+images = []
+for p in paths:
+    if not os.path.isfile(p):
+        continue
+    ext = os.path.splitext(p)[1].lower()
+    mime_map = {'.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.png': 'image/png', '.gif': 'image/gif', '.webp': 'image/webp'}
+    mimetype = mime_map.get(ext, 'image/jpeg')
+    try:
+        result = subprocess.run(
+            ['convert', p, '-resize', '224x224^', '-gravity', 'center', '-extent', '224x224', '-quality', '80', 'jpeg:-'],
+            capture_output=True, timeout=5
+        )
+        if result.returncode == 0 and len(result.stdout) > 0:
+            b64 = base64.b64encode(result.stdout).decode()
+            images.append({'data': b64, 'mimetype': 'image/jpeg'})
+    except Exception:
+        pass
+
+if images:
+    print(json.dumps(images))
+else:
+    print('')
+" "${IMAGE_PATHS[@]}" 2>/dev/null)
+fi
+
 # Toast: start retrieving
 "$TOAST" memento "⏳ Retrieving memories..." &>/dev/null
 
+# Build request body with optional images
+REQUEST_BODY=$(python3 -c "
+import json, sys
+
+message = sys.argv[1]
+images_json = sys.argv[2] if len(sys.argv) > 2 else ''
+
+body = {
+    'message': message,
+    'include': ['memories', 'skip_list']
+}
+
+if images_json:
+    try:
+        images = json.loads(images_json)
+        if images:
+            body['images'] = images
+    except Exception:
+        pass
+
+print(json.dumps(body))
+" "$QUERY" "$IMAGES_JSON")
+
 # Call Memento SaaS /v1/context
 SAAS_OUTPUT=$(curl -s --max-time 8 \
     -X POST \
     -H "Authorization: Bearer $MEMENTO_KEY" \
     -H "X-Memento-Workspace: $MEMENTO_WS" \
     -H "Content-Type: application/json" \
-    -d "{\"message\": $(echo "$QUERY" | python3 -c 'import json,sys; print(json.dumps(sys.stdin.read()))'), \"include\": [\"memories\", \"skip_list\"]}" \
+    -d "$REQUEST_BODY" \
     "$MEMENTO_API/v1/context" 2>/dev/null \
 | python3 -c "
 import json, sys

package/src/index.js

@@ -257,11 +257,13 @@ Use tags generously — they power recall. Set expiration for time-sensitive fac
 
 server.tool(
   "memento_recall",
-  `Search stored memories by keyword, tag, or type. Use this before starting work on any topic — someone may have already figured it out.
+  `Search stored memories by keyword, tag, type, or image similarity. Use this before starting work on any topic — someone may have already figured it out.
 
-Results are ranked by relevance (keyword match + recency + access frequency). Each recall increments the memory's access count, reinforcing important memories and letting unused ones decay naturally.`,
+Results are ranked by relevance (keyword match + semantic similarity + recency + access frequency). Each recall increments the memory's access count, reinforcing important memories and letting unused ones decay naturally.
+
+Supports image search: provide image_path to find visually similar memories. Can combine text query + image for multi-modal search.`,
   {
-    query: z.string().describe("Search query (matched against memory content)"),
+    query: z.string().optional().describe("Search query (matched against memory content). Required unless image_path is provided."),
     tags: z.array(z.string()).optional().describe("Filter by tags (matches any)"),
     type: z
       .string()
@@ -269,9 +271,57 @@ Results are ranked by relevance (keyword match + recency + access frequency). Ea
       .describe("Filter by type: fact, decision, observation, instruction"),
     limit: z.number().optional().describe("Max results (default: 10)"),
     workspace: z.string().optional().describe('Omit to search your own workspace. Set to a workspace name (e.g. "fathom") to search that workspace instead.'),
+    image_path: z.string().optional().describe(
+      "Path to an image file to search by visual similarity. Can combine with query for multi-modal search."
+    ),
   },
-  async ({ query, tags, type, limit, workspace }) => {
-    const result = await storage.recallMemories(null, { query, tags, type, limit, workspace });
+  async ({ query, tags, type, limit, workspace, image_path }) => {
+    if (!query && !image_path) {
+      return {
+        content: [{ type: "text", text: 'At least one of "query" or "image_path" is required.' }],
+        isError: true,
+      };
+    }
+
+    // Process image if provided
+    let images;
+    if (image_path) {
+      const MIME_MAP = { ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".png": "image/png", ".gif": "image/gif", ".webp": "image/webp" };
+      const ext = path.extname(image_path).toLowerCase();
+      const mimetype = MIME_MAP[ext];
+      if (!mimetype) {
+        return {
+          content: [{ type: "text", text: `Unsupported image format: ${ext}. Allowed: .jpg, .jpeg, .png, .gif, .webp` }],
+          isError: true,
+        };
+      }
+
+      let buffer;
+      try {
+        buffer = fs.readFileSync(image_path);
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Cannot read image: ${err.message}` }],
+          isError: true,
+        };
+      }
+
+      // Downscale to 224x224 via sharp for efficient embedding
+      try {
+        const sharp = (await import("sharp")).default;
+        buffer = await sharp(buffer)
+          .resize(224, 224, { fit: "cover" })
+          .jpeg({ quality: 80 })
+          .toBuffer();
+      } catch {
+        // If sharp fails, send the original — Nomic resizes internally anyway
+      }
+
+      const data = buffer.toString("base64");
+      images = [{ data, mimetype: "image/jpeg" }];
+    }
+
+    const result = await storage.recallMemories(null, { query, tags, type, limit, workspace, images });
 
     if (result._raw) {
       return {

package/src/storage/hosted.js

@@ -108,7 +108,22 @@ export class HostedStorageAdapter extends StorageInterface {
     return { _raw: true, text, isError: false };
   }
 
-  async recallMemories(_wsPath, { query, tags, type, limit, workspace }) {
+  async recallMemories(_wsPath, { query, tags, type, limit, workspace, images }) {
+    // Use POST when images are present (GET can't carry binary data)
+    if (images?.length > 0) {
+      const body = { images };
+      if (query) body.query = query;
+      if (tags?.length) body.tags = tags;
+      if (type) body.type = type;
+      if (limit) body.limit = limit;
+      // Note: cross-workspace peek not supported for image search
+
+      const json = await this._fetchJson("POST", "/v1/memories/recall", body);
+      if (json.error) return { error: json.error };
+      return { _raw: true, text: json.text, memories: json.memories || [], isError: false };
+    }
+
+    // Existing GET path for text-only recall
     const params = new URLSearchParams({ query, format: "json" });
     if (tags?.length) params.set("tags", tags.join(","));
     if (type) params.set("type", type);