@crowley/rag-mcp 1.3.0 → 1.5.0

package/dist/context-enrichment.d.ts

@@ -19,7 +19,13 @@ export declare const DEFAULT_ENRICHABLE_TOOLS: Set<string>;
 export declare const DEFAULT_SKIP_TOOLS: Set<string>;
 export declare class ContextEnricher {
     private config;
+    private cache;
+    private static CACHE_TTL_MS;
     constructor(config?: Partial<EnrichmentConfig>);
+    /**
+     * Clear enrichment cache (call on session end).
+     */
+    clearCache(): void;
     /**
      * Before hook: auto-recall relevant memories/patterns/ADRs.
      * Returns a context prefix string or null if nothing relevant found.

package/dist/context-enrichment.js

@@ -45,6 +45,8 @@ export const DEFAULT_SKIP_TOOLS = new Set([
 ]);
 export class ContextEnricher {
     config;
+    cache = new Map();
+    static CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
     constructor(config = {}) {
         this.config = {
             enrichableTools: config.enrichableTools ?? DEFAULT_ENRICHABLE_TOOLS,
@@ -54,6 +56,12 @@ export class ContextEnricher {
             timeoutMs: config.timeoutMs ?? 2000,
         };
     }
+    /**
+     * Clear enrichment cache (call on session end).
+     */
+    clearCache() {
+        this.cache.clear();
+    }
     /**
      * Before hook: auto-recall relevant memories/patterns/ADRs.
      * Returns a context prefix string or null if nothing relevant found.
@@ -68,11 +76,29 @@ export class ContextEnricher {
         const query = this.extractQuery(args);
         if (!query)
             return null;
+        // Check per-session cache
+        const cacheKey = `${ctx.activeSessionId || 'no-session'}:${query.slice(0, 100)}`;
+        const cached = this.cache.get(cacheKey);
+        if (cached && Date.now() < cached.expiresAt) {
+            return cached.result;
+        }
         try {
             const memories = await this.recallWithTimeout(query, ctx);
-            if (memories.length === 0)
-                return null;
-            return this.formatContext(memories);
+            const result = memories.length === 0 ? null : this.formatContext(memories);
+            // Store in cache
+            this.cache.set(cacheKey, {
+                result,
+                expiresAt: Date.now() + ContextEnricher.CACHE_TTL_MS,
+            });
+            // Evict expired entries lazily (every 50 calls)
+            if (this.cache.size > 100) {
+                const now = Date.now();
+                for (const [key, entry] of this.cache) {
+                    if (now > entry.expiresAt)
+                        this.cache.delete(key);
+                }
+            }
+            return result;
         }
         catch {
             // Enrichment should never break tool calls
@@ -150,8 +176,10 @@ export class ContextEnricher {
         const controller = new AbortController();
         const timeout = setTimeout(() => controller.abort(), this.config.timeoutMs);
         try {
-            // Parallel recall: general memories + decisions/ADRs
-            const [memoriesRes, decisionsRes] = await Promise.all([
+            // Parallel recall: general memories + decisions/ADRs + LTM (when enabled)
+            const graphRecallEnabled = process.env.GRAPH_RECALL_ENABLED === "true";
+            const consolidationEnabled = process.env.CONSOLIDATION_ENABLED === "true";
+            const recalls = [
                 ctx.api
                     .post("/api/memory/recall-durable", {
                     projectName: ctx.projectName,
@@ -168,7 +196,19 @@ export class ContextEnricher {
                     type: "decision",
                 }, { signal: controller.signal })
                     .catch(() => null),
-            ]);
+            ];
+            // Phase 2+4: also recall from LTM (episodic+semantic with Ebbinghaus decay)
+            if (consolidationEnabled) {
+                recalls.push(ctx.api
+                    .post("/api/memory/recall-ltm", {
+                    projectName: ctx.projectName,
+                    query,
+                    limit: this.config.maxAutoRecall,
+                    graphRecall: graphRecallEnabled,
+                }, { signal: controller.signal })
+                    .catch(() => null));
+            }
+            const [memoriesRes, decisionsRes, ltmRes] = await Promise.all(recalls);
             const memories = [];
             const seenIds = new Set();
             // Process general memories
@@ -197,6 +237,23 @@ export class ContextEnricher {
                     }
                 }
             }
+            // Process LTM results (episodic + semantic)
+            if (ltmRes?.data?.results) {
+                for (const r of ltmRes.data.results) {
+                    const mem = r.memory;
+                    const id = mem?.id;
+                    if (r.score >= this.config.minRelevance && id && !seenIds.has(id)) {
+                        seenIds.add(id);
+                        memories.push({
+                            type: mem?.subtype || mem?.type || "insight",
+                            content: mem?.content || "",
+                            score: r.score,
+                        });
+                    }
+                }
+            }
+            // Sort by score and limit
+            memories.sort((a, b) => b.score - a.score);
             return memories.slice(0, this.config.maxAutoRecall + 2);
         }
         finally {

package/dist/tool-middleware.js

@@ -155,6 +155,43 @@ export function trackUsage(name, args, startTime, success, result, errorMessage,
     })
         .catch(() => { });
 }
+// ── Sensory buffer ─────────────────────────────────────────
+/** Extract file paths from tool args */
+function extractFiles(args) {
+    const files = [];
+    for (const key of ['file', 'filePath', 'currentFile', 'path']) {
+        const v = args[key];
+        if (typeof v === 'string' && v.length > 0)
+            files.push(v);
+    }
+    const arr = args.affectedFiles || args.files;
+    if (Array.isArray(arr)) {
+        for (const f of arr) {
+            if (typeof f === 'string')
+                files.push(f);
+        }
+    }
+    return files.slice(0, 20);
+}
+/** Fire-and-forget: capture tool event in sensory buffer */
+function appendToSensoryBuffer(name, args, startTime, success, resultText, ctx) {
+    if (!ctx.activeSessionId)
+        return;
+    if (TRACKING_EXCLUDE.has(name))
+        return;
+    ctx.api
+        .post("/api/sensory/append", {
+        projectName: ctx.projectName,
+        sessionId: ctx.activeSessionId,
+        toolName: name,
+        inputSummary: summarizeInput(name, args).slice(0, 500),
+        outputSummary: (resultText || "").slice(0, 500),
+        filesTouched: extractFiles(args),
+        success,
+        durationMs: Date.now() - startTime,
+    })
+        .catch(() => { });
+}
 // ── Error formatting ────────────────────────────────────────
 /** Format an error caught during tool execution */
 export function formatToolError(error, ctx) {
@@ -207,6 +244,8 @@ export function wrapHandler(name, handler, deps) {
             }
             // Track usage (fire-and-forget)
             trackUsage(name, args, startTime, true, text, undefined, ctx);
+            // Capture in sensory buffer (fire-and-forget)
+            appendToSensoryBuffer(name, args, startTime, true, text, ctx);
             // Prepend context/warnings if available
             const prefix = [warningPrefix, contextPrefix].filter(Boolean).join('');
             if (prefix) {
@@ -221,6 +260,8 @@ export function wrapHandler(name, handler, deps) {
             const errorMessage = formatToolError(error, ctx);
             // Track failed usage (fire-and-forget)
             trackUsage(name, args, startTime, false, "", errorMessage, ctx);
+            // Capture failure in sensory buffer (fire-and-forget)
+            appendToSensoryBuffer(name, args, startTime, false, errorMessage, ctx);
             return errorMessage;
         }
     };

package/dist/tools/memory.js

@@ -61,19 +61,22 @@ export function createMemoryTools(projectName) {
             description: "Retrieve relevant memories based on context. Searches agent memory for past decisions, insights, and notes related to the query.",
             schema: z.object({
                 query: z.string().describe("What to recall (semantic search)"),
-                type: z.enum(["decision", "insight", "context", "todo", "conversation", "note", "all"]).optional().describe("Filter by memory type (default: all)"),
+                type: z.enum(["decision", "insight", "context", "todo", "conversation", "note", "procedure", "all"]).optional().describe("Filter by memory type (default: all)"),
                 limit: z.coerce.number().optional().describe("Max memories to retrieve (default: 5)"),
+                graphRecall: z.boolean().optional().describe("Enable graph-aware recall with spreading activation (default: false)"),
             }),
             annotations: TOOL_ANNOTATIONS["recall"],
             handler: async (args, ctx) => {
                 const query = args.query;
                 const type = args.type || "all";
                 const limit = args.limit || 5;
+                const graphRecall = args.graphRecall || false;
                 const response = await ctx.api.post("/api/memory/recall", {
                     projectName: ctx.projectName,
                     query,
                     type,
                     limit,
+                    graphRecall,
                 });
                 const results = response.data.results || [];
                 if (results.length === 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crowley/rag-mcp",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "description": "Universal RAG MCP Server for any project",
   "type": "module",
   "main": "dist/index.js",