memento-mcp 0.3.6 → 0.3.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memento-mcp",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "mcpName": "io.github.myrakrusemark/memento-protocol",
   "description": "The Memento Protocol — persistent memory for AI agents",
   "type": "module",

package/scripts/memento-stop-recall.sh

@@ -42,7 +42,7 @@ print('true' if hook.get('enabled', True) else 'false')
     MEMENTO_WORKSPACE="${MEMENTO_WORKSPACE:-$(echo "$CONFIG_JSON" | python3 -c "import json,sys; print(json.load(sys.stdin).get('workspace',''))" 2>/dev/null)}"
 
     RECALL_LIMIT=$(echo "$CONFIG_JSON" | python3 -c "import json,sys; print(json.load(sys.stdin).get('hooks',{}).get('$HOOK_NAME',{}).get('limit',5))" 2>/dev/null)
-    RECALL_MAX_LENGTH=$(echo "$CONFIG_JSON" | python3 -c "import json,sys; print(json.load(sys.stdin).get('hooks',{}).get('$HOOK_NAME',{}).get('maxLength',200))" 2>/dev/null)
+    RECALL_MAX_LENGTH=$(echo "$CONFIG_JSON" | python3 -c "import json,sys; print(json.load(sys.stdin).get('hooks',{}).get('$HOOK_NAME',{}).get('maxLength',120))" 2>/dev/null)
 fi
 # --- End config block ---
 
@@ -92,34 +92,24 @@ try:
     data = json.load(sys.stdin)
     lines = []
     count = 0
+    abbrev = {'instruction':'instr','observation':'obs','decision':'dec','preference':'pref'}
 
     memories = data.get('memories', {}).get('matches', [])
     if memories:
         for m in memories[:${RECALL_LIMIT:-5}]:
-            tags = m.get('tags', [])
-            tag_str = f' [{\", \".join(tags)}]' if tags else ''
-            content = m['content'][:${RECALL_MAX_LENGTH:-200}]
-            score = m.get('score', '?')
-            date_str = f' {m[\"created_at\"][:10]}' if m.get('created_at') else ''
-            lines.append(f'  {m[\"id\"]} ({m[\"type\"]}, {score}{date_str}){tag_str} — {content}')
+            content = m['content'][:${RECALL_MAX_LENGTH:-120}]
+            t = abbrev.get(m['type'], m['type'])
+            lines.append(f'  · {content} [{m[\"id\"]} {t}]')
             count += 1
 
     skip_matches = data.get('skip_matches', [])
     if skip_matches:
-        lines.append('')
-        lines.append('SKIP LIST WARNINGS:')
         for s in skip_matches:
-            lines.append(f'  ⚠ SKIP: {s[\"item\"]} — {s[\"reason\"]} (expires: {s[\"expires\"]})')
+            lines.append(f'  Skip: {s[\"item\"]} — {s[\"reason\"]} (expires {s[\"expires\"]})')
 
-    # Auto-extracted memories
     extracted = data.get('extracted', [])
     if extracted:
-        lines.append('')
-        lines.append('MEMORIES STORED:')
-        for e in extracted:
-            etags = [t for t in e.get('tags', []) if t != 'source:auto-extract']
-            etag_str = f' [{\", \".join(etags)}]' if etags else ''
-            lines.append(f'  {e[\"id\"]} ({e.get(\"type\", \"observation\")}){etag_str} — {e[\"content\"]}')
+        lines.append(f'  Stored: {len(extracted)} new memories')
 
     # Output: recall_count \t extracted_count \t detail
     extracted_count = len(extracted)
@@ -143,9 +133,11 @@ if [ -z "$SAAS_COUNT" ] || [ "$SAAS_COUNT" = "0" ]; then
         "$TOAST" memento "✓ ${EXTRACTED_COUNT} memories stored" &>/dev/null
     else
         "$TOAST" memento "✓ No memories matched" &>/dev/null
-        exit 0
     fi
-else
+    exit 0
+fi
+
+if [ "$SAAS_COUNT" != "0" ]; then
     if [ -n "$EXTRACTED_COUNT" ] && [ "$EXTRACTED_COUNT" != "0" ]; then
         "$TOAST" memento "✓ ${SAAS_COUNT} recalled, ${EXTRACTED_COUNT} stored" &>/dev/null
     else
@@ -154,16 +146,16 @@ else
 fi
 
 # Build summary line
-SUMMARY="Autonomous Recall: ${SAAS_COUNT} memories"
+SUMMARY="Recall (${SAAS_COUNT})"
 if [ -n "$EXTRACTED_COUNT" ] && [ "$EXTRACTED_COUNT" != "0" ]; then
-    SUMMARY="${SUMMARY}, ${EXTRACTED_COUNT} memories stored"
+    SUMMARY="Recall (${SAAS_COUNT}), stored ${EXTRACTED_COUNT}"
 fi
 
-# Block the Stop so Claude continues — the reason becomes Claude's next instruction.
-REASON="${SUMMARY} surfaced from your last response.
+# Block the Stop so recalled memories are injected into context.
+# If no memories are relevant, respond with <...> to signal active silence.
+REASON="${SUMMARY}:
 ${SAAS_DETAIL}
-
-You have absorbed these memories into context. If any recalled memory is stale, wrong, or overlaps with others — update, delete, or consolidate it now. Otherwise continue naturally."
+Stale or wrong? Update or consolidate."
 
 python3 -c "
 import json, sys

package/src/index.js

@@ -433,6 +433,72 @@ This is reconsolidation — like how the brain rebuilds memories on recall. Freq
   }
 );
 
+// ---------------------------------------------------------------------------
+// Tool: memento_extract
+// ---------------------------------------------------------------------------
+
+server.tool(
+  "memento_extract",
+  `Extract memories from a conversation transcript or the conversation buffer using LLM. Use this to manually trigger memory extraction — e.g., to flush the buffer before ending a session, or to extract from a pasted transcript.
+
+Two modes:
+- "distill" (default): Full extraction — facts, decisions, instructions, observations. Up to 20 memories.
+- "seeds": Relational/experiential texture — preferences, emotions, sensory details. Up to 3 memories.
+
+If no transcript is provided, reads from the conversation buffer (auto-populated by the context hook). Buffer is cleared after extraction unless keep_buffer is true.`,
+  {
+    transcript: z.string().optional().describe("Raw conversation text. If omitted, reads from the conversation buffer."),
+    mode: z.enum(["distill", "seeds"]).optional().describe("Extraction mode (default: distill)"),
+    max_memories: z.number().optional().describe("Override max memories to extract"),
+    keep_buffer: z.boolean().optional().describe("If true, don't clear the buffer after reading it"),
+  },
+  async ({ transcript, mode, max_memories, keep_buffer }) => {
+    const result = await storage.extractMemories(null, {
+      transcript,
+      mode,
+      max_memories,
+      keep_buffer,
+    });
+
+    if (result.error && !result.stored) {
+      return {
+        content: [{ type: "text", text: `Error: ${result.error}` }],
+        isError: true,
+      };
+    }
+
+    if (result.error) {
+      // Partial success — extraction ran but had issues
+      const summary = result.stored?.length > 0
+        ? result.stored.map((m) => `- **${m.id}** (${m.type}): ${m.content}`).join("\n")
+        : "No memories extracted.";
+      return {
+        content: [{
+          type: "text",
+          text: `Extraction completed with warning: ${result.error}\n\n${summary}`,
+        }],
+      };
+    }
+
+    if (!result.stored || result.stored.length === 0) {
+      return {
+        content: [{
+          type: "text",
+          text: `No novel memories found (mode: ${result.mode || mode || "distill"}, source: ${result.source || "unknown"}).`,
+        }],
+      };
+    }
+
+    const summary = result.stored.map((m) => `- **${m.id}** (${m.type}): ${m.content}`).join("\n");
+    return {
+      content: [{
+        type: "text",
+        text: `Extracted ${result.count} memor${result.count === 1 ? "y" : "ies"} (mode: ${result.mode}, source: ${result.source}):\n\n${summary}`,
+      }],
+    };
+  }
+);
+
 // ---------------------------------------------------------------------------
 // Tool: memento_skip_add
 // ---------------------------------------------------------------------------

package/src/storage/hosted.js

@@ -261,6 +261,19 @@ export class HostedStorageAdapter extends StorageInterface {
     return res;
   }
 
+  async extractMemories(_wsPath, { transcript, mode, max_memories, source_tag, keep_buffer }) {
+    const body = {};
+    if (transcript) body.transcript = transcript;
+    if (mode) body.mode = mode;
+    if (max_memories) body.max_memories = max_memories;
+    if (source_tag) body.source_tag = source_tag;
+    if (keep_buffer !== undefined) body.keep_buffer = keep_buffer;
+
+    const res = await this._fetchJson("POST", "/v1/extract", body);
+    if (res.error && !res.stored) return { error: res.error };
+    return res;
+  }
+
   async getIdentity(_wsPath) {
     const { text, isError } = await this._fetch("GET", "/v1/identity");
     if (isError) return { error: text };