@stackmemoryai/stackmemory 0.5.61 → 0.5.62

package/dist/src/integrations/mcp/server.js

@@ -27,6 +27,7 @@ import { BrowserMCPIntegration } from "../../features/browser/browser-mcp.js";
 import { TraceDetector } from "../../core/trace/trace-detector.js";
 import { LLMContextRetrieval } from "../../core/retrieval/index.js";
 import { DiscoveryHandlers } from "./handlers/discovery-handlers.js";
+import { DiffMemHandlers } from "./handlers/diffmem-handlers.js";
 import { v4 as uuidv4 } from "uuid";
 function getEnv(key, defaultValue) {
   const value = process.env[key];
@@ -53,6 +54,7 @@ class LocalStackMemoryMCP {
   traceDetector;
   contextRetrieval;
   discoveryHandlers;
+  diffMemHandlers;
   constructor() {
     this.projectRoot = this.findProjectRoot();
     this.projectId = this.getProjectId();
@@ -92,6 +94,7 @@ class LocalStackMemoryMCP {
       db: this.db,
       projectRoot: this.projectRoot
     });
+    this.diffMemHandlers = new DiffMemHandlers();
     this.setupHandlers();
     this.loadInitialContext();
     this.browserMCP.initialize(this.server).catch((error) => {
@@ -740,6 +743,111 @@ ${summary}...`, 0.8);
                 },
                 required: ["query"]
               }
+            },
+            // DiffMem tools for user memory management
+            {
+              name: "diffmem_get_user_context",
+              description: "Fetch user knowledge and preferences from memory. Use to personalize responses based on learned user patterns.",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  categories: {
+                    type: "array",
+                    items: {
+                      type: "string",
+                      enum: [
+                        "preference",
+                        "expertise",
+                        "project_knowledge",
+                        "pattern",
+                        "correction"
+                      ]
+                    },
+                    description: "Filter by memory categories"
+                  },
+                  limit: {
+                    type: "number",
+                    default: 10,
+                    description: "Maximum memories to return"
+                  }
+                }
+              }
+            },
+            {
+              name: "diffmem_store_learning",
+              description: "Store a new insight about the user (preference, expertise, pattern, or correction)",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  content: {
+                    type: "string",
+                    description: "The insight to store"
+                  },
+                  category: {
+                    type: "string",
+                    enum: [
+                      "preference",
+                      "expertise",
+                      "project_knowledge",
+                      "pattern",
+                      "correction"
+                    ],
+                    description: "Category of the insight"
+                  },
+                  confidence: {
+                    type: "number",
+                    minimum: 0,
+                    maximum: 1,
+                    default: 0.7,
+                    description: "Confidence level (0-1)"
+                  },
+                  context: {
+                    type: "object",
+                    description: "Additional context for the insight"
+                  }
+                },
+                required: ["content", "category"]
+              }
+            },
+            {
+              name: "diffmem_search",
+              description: "Semantic search across user memories. Find relevant past insights and preferences.",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  query: {
+                    type: "string",
+                    description: "Search query"
+                  },
+                  timeRange: {
+                    type: "string",
+                    enum: ["day", "week", "month", "all"],
+                    default: "all",
+                    description: "Time range filter"
+                  },
+                  minConfidence: {
+                    type: "number",
+                    minimum: 0,
+                    maximum: 1,
+                    default: 0.5,
+                    description: "Minimum confidence threshold"
+                  },
+                  limit: {
+                    type: "number",
+                    default: 10,
+                    description: "Maximum results"
+                  }
+                },
+                required: ["query"]
+              }
+            },
+            {
+              name: "diffmem_status",
+              description: "Check DiffMem connection status and memory statistics",
+              inputSchema: {
+                type: "object",
+                properties: {}
+              }
             }
           ]
         };
@@ -851,6 +959,19 @@ ${summary}...`, 0.8);
             case "sm_search":
               result = await this.handleSmSearch(args);
               break;
+            // DiffMem handlers
+            case "diffmem_get_user_context":
+              result = await this.diffMemHandlers.handleGetUserContext(args);
+              break;
+            case "diffmem_store_learning":
+              result = await this.diffMemHandlers.handleStoreLearning(args);
+              break;
+            case "diffmem_search":
+              result = await this.diffMemHandlers.handleSearch(args);
+              break;
+            case "diffmem_status":
+              result = await this.diffMemHandlers.handleStatus();
+              break;
             default:
               throw new Error(`Unknown tool: ${name}`);
           }