@stackmemoryai/stackmemory 1.2.2 → 1.2.6

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

@@ -31,7 +31,6 @@ import { LLMContextRetrieval } from "../../core/retrieval/index.js";
 import { DiscoveryHandlers } from "./handlers/discovery-handlers.js";
 import { DiffMemHandlers } from "./handlers/diffmem-handlers.js";
 import { GreptileHandlers } from "./handlers/greptile-handlers.js";
-import { GraphitiClient } from "../graphiti/client.js";
 import { fuzzyEdit } from "../../utils/fuzzy-edit.js";
 import { v4 as uuidv4 } from "uuid";
 import {
@@ -67,7 +66,6 @@ class LocalStackMemoryMCP {
   diffMemHandlers;
   greptileHandlers;
   providerHandlers = null;
-  graphitiClient = null;
   pendingPlans = /* @__PURE__ */ new Map();
   constructor() {
     this.projectRoot = this.findProjectRoot();
@@ -142,15 +140,6 @@ class LocalStackMemoryMCP {
     this.diffMemHandlers = new DiffMemHandlers();
     this.greptileHandlers = new GreptileHandlers();
     this.initProviderHandlers();
-    if (process.env.GRAPHITI_ENDPOINT) {
-      this.graphitiClient = new GraphitiClient({
-        endpoint: process.env.GRAPHITI_ENDPOINT,
-        projectNamespace: process.env.STACKMEMORY_PROJECT_ID || this.projectId
-      });
-      logger.info("Graphiti client initialized", {
-        endpoint: process.env.GRAPHITI_ENDPOINT
-      });
-    }
     this.setupHandlers();
     this.loadInitialContext();
     this.loadPendingPlans();
@@ -711,24 +700,6 @@ ${summary}...`, 0.8);
                 properties: {}
               }
             },
-            {
-              name: "add_task_dependency",
-              description: "Add dependency relationship between tasks",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  taskId: {
-                    type: "string",
-                    description: "Task that depends on another"
-                  },
-                  dependsOnId: {
-                    type: "string",
-                    description: "Task ID that this depends on"
-                  }
-                },
-                required: ["taskId", "dependsOnId"]
-              }
-            },
             {
               name: "linear_sync",
               description: "Sync tasks with Linear",
@@ -1087,51 +1058,6 @@ ${summary}...`, 0.8);
                 properties: {}
               }
             },
-            // Graphiti tools (only active when GRAPHITI_ENDPOINT is set)
-            ...this.graphitiClient ? [
-              {
-                name: "graphiti_status",
-                description: "Check Graphiti temporal knowledge graph connection status",
-                inputSchema: {
-                  type: "object",
-                  properties: {}
-                }
-              },
-              {
-                name: "graphiti_query",
-                description: "Query the Graphiti temporal knowledge graph for entities, relations, and episodes",
-                inputSchema: {
-                  type: "object",
-                  properties: {
-                    query: {
-                      type: "string",
-                      description: "Semantic text query"
-                    },
-                    entityTypes: {
-                      type: "array",
-                      items: { type: "string" },
-                      description: 'Entity types to filter (e.g., ["Person", "File", "Issue"])'
-                    },
-                    validFrom: {
-                      type: "number",
-                      description: "Start of time window (epoch ms)"
-                    },
-                    validTo: {
-                      type: "number",
-                      description: "End of time window (epoch ms)"
-                    },
-                    maxHops: {
-                      type: "number",
-                      description: "Graph traversal depth (default 2)"
-                    },
-                    k: {
-                      type: "number",
-                      description: "Top-k results (default 20)"
-                    }
-                  }
-                }
-              }
-            ] : [],
             // Greptile tools (only active when GREPTILE_API_KEY is set)
             ...process.env.GREPTILE_API_KEY ? this.greptileHandlers.getToolDefinitions() : [],
             // Provider tools (only active when STACKMEMORY_MULTI_PROVIDER=true)
@@ -1299,9 +1225,6 @@ ${summary}...`, 0.8);
             case "get_task_metrics":
               result = await this.handleGetTaskMetrics(args);
               break;
-            case "add_task_dependency":
-              result = await this.handleAddTaskDependency(args);
-              break;
             case "linear_sync":
               result = await this.handleLinearSync(args);
               break;
@@ -1456,59 +1379,6 @@ ${summary}...`, 0.8);
                 );
               }
               break;
-            // Graphiti tools
-            case "graphiti_status":
-              if (!this.graphitiClient) {
-                result = {
-                  content: [
-                    {
-                      type: "text",
-                      text: JSON.stringify({
-                        connected: false,
-                        message: "Graphiti integration disabled (GRAPHITI_ENDPOINT not set)"
-                      })
-                    }
-                  ]
-                };
-              } else {
-                const status = await this.graphitiClient.getStatus();
-                result = {
-                  content: [
-                    { type: "text", text: JSON.stringify(status, null, 2) }
-                  ]
-                };
-              }
-              break;
-            case "graphiti_query":
-              if (!this.graphitiClient) {
-                result = {
-                  content: [
-                    {
-                      type: "text",
-                      text: "Graphiti integration disabled (GRAPHITI_ENDPOINT not set)"
-                    }
-                  ]
-                };
-              } else {
-                const gCtx = await this.graphitiClient.queryTemporal({
-                  query: args.query,
-                  entityTypes: args.entityTypes,
-                  validFrom: args.validFrom,
-                  validTo: args.validTo,
-                  maxHops: args.maxHops,
-                  k: args.k
-                });
-                const text = gCtx.chunks.map((c) => c.text).join("\n\n");
-                result = {
-                  content: [
-                    {
-                      type: "text",
-                      text: text || `No results found (${gCtx.totalTokens} tokens searched)`
-                    }
-                  ]
-                };
-              }
-              break;
             default:
               throw new Error(`Unknown tool: ${name}`);
           }

package/dist/src/integrations/mcp/tool-definitions.js

@@ -14,7 +14,8 @@ class MCPToolDefinitions {
       ...this.getTraceTools(),
       ...this.getDiscoveryTools(),
       ...this.getEditTools(),
-      ...this.getGraphitiTools()
+      ...this.getTeamTools(),
+      ...this.getCordTools()
     ];
   }
   /**
@@ -281,30 +282,6 @@ class MCPToolDefinitions {
           type: "object",
           properties: {}
         }
-      },
-      {
-        name: "add_task_dependency",
-        description: "Add dependency between tasks",
-        inputSchema: {
-          type: "object",
-          properties: {
-            task_id: {
-              type: "string",
-              description: "Task that depends on another"
-            },
-            depends_on: {
-              type: "string",
-              description: "Task that must be completed first"
-            },
-            dependency_type: {
-              type: "string",
-              enum: ["blocks", "related", "subtask"],
-              default: "blocks",
-              description: "Type of dependency"
-            }
-          },
-          required: ["task_id", "depends_on"]
-        }
       }
     ];
   }
@@ -415,7 +392,7 @@ class MCPToolDefinitions {
     return [
       {
         name: "get_traces",
-        description: "Get execution traces with optional filtering",
+        description: "Get execution traces with optional filtering. Set analyze=true to run pattern analysis instead of listing traces.",
         inputSchema: {
           type: "object",
           properties: {
@@ -442,30 +419,21 @@ class MCPToolDefinitions {
               type: "boolean",
               default: false,
               description: "Include full trace context"
-            }
-          }
-        }
-      },
-      {
-        name: "analyze_traces",
-        description: "Analyze trace patterns for insights",
-        inputSchema: {
-          type: "object",
-          properties: {
+            },
+            analyze: {
+              type: "boolean",
+              default: false,
+              description: "Run analysis on traces instead of listing them"
+            },
             trace_id: {
               type: "string",
-              description: "Specific trace to analyze"
+              description: "Specific trace to analyze (requires analyze=true)"
             },
             analysis_type: {
               type: "string",
               enum: ["performance", "patterns", "errors"],
               default: "performance",
-              description: "Type of analysis to perform"
-            },
-            include_recommendations: {
-              type: "boolean",
-              default: true,
-              description: "Include optimization recommendations"
+              description: "Type of analysis (requires analyze=true)"
             }
           }
         }
@@ -707,48 +675,207 @@ class MCPToolDefinitions {
     ];
   }
   /**
-   * Graphiti knowledge graph tools
+   * Multi-agent team collaboration tools
    */
-  getGraphitiTools() {
+  getTeamTools() {
     return [
       {
-        name: "graphiti_status",
-        description: "Check Graphiti temporal knowledge graph connection status",
+        name: "team_context_get",
+        description: "Get context from other agents working on the same project. Returns recent frames and shared anchors from other sessions.",
         inputSchema: {
           type: "object",
-          properties: {}
+          properties: {
+            limit: {
+              type: "number",
+              default: 10,
+              description: "Max frames to return"
+            },
+            types: {
+              type: "array",
+              items: { type: "string" },
+              description: "Filter by frame types"
+            },
+            since: {
+              type: "number",
+              description: "Only frames created after this timestamp (epoch ms)"
+            }
+          }
+        }
+      },
+      {
+        name: "team_context_share",
+        description: "Share a piece of context with other agents working on the same project. Creates a high-priority anchor visible to team_context_get.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            content: {
+              type: "string",
+              description: "The context to share"
+            },
+            type: {
+              type: "string",
+              enum: [
+                "FACT",
+                "DECISION",
+                "CONSTRAINT",
+                "INTERFACE_CONTRACT",
+                "TODO",
+                "RISK"
+              ],
+              default: "FACT",
+              description: "Type of context"
+            },
+            priority: {
+              type: "number",
+              minimum: 1,
+              maximum: 10,
+              default: 8,
+              description: "Priority level (1-10)"
+            }
+          },
+          required: ["content"]
         }
       },
       {
-        name: "graphiti_query",
-        description: "Query the Graphiti temporal knowledge graph for entities, relations, and episodes",
+        name: "team_search",
+        description: "Search across all agents' context in the project. Uses full-text search across all sessions.",
         inputSchema: {
           type: "object",
           properties: {
             query: {
               type: "string",
-              description: "Semantic text query"
+              description: "Search query"
             },
-            entityTypes: {
+            limit: {
+              type: "number",
+              default: 20,
+              description: "Maximum results to return"
+            },
+            include_events: {
+              type: "boolean",
+              default: false,
+              description: "Include events in results"
+            }
+          },
+          required: ["query"]
+        }
+      }
+    ];
+  }
+  /**
+   * Cord task orchestration tools
+   */
+  getCordTools() {
+    return [
+      {
+        name: "cord_spawn",
+        description: "Create a subtask with clean context (spawn). Child sees only its prompt and completed blocker results.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            goal: {
+              type: "string",
+              description: "What this task should accomplish"
+            },
+            prompt: {
+              type: "string",
+              description: "Detailed instructions for the task"
+            },
+            blocked_by: {
               type: "array",
               items: { type: "string" },
-              description: 'Entity types to filter (e.g., ["Person", "File", "Issue"])'
+              description: "Task IDs that must complete before this can start"
             },
-            validFrom: {
-              type: "number",
-              description: "Start of time window (epoch ms)"
+            parent_id: {
+              type: "string",
+              description: "Parent task ID"
+            }
+          },
+          required: ["goal"]
+        }
+      },
+      {
+        name: "cord_fork",
+        description: "Create a subtask with full sibling context (fork). Child sees its prompt, blocker results, AND completed sibling results.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            goal: {
+              type: "string",
+              description: "What this task should accomplish"
             },
-            validTo: {
-              type: "number",
-              description: "End of time window (epoch ms)"
+            prompt: {
+              type: "string",
+              description: "Detailed instructions for the task"
             },
-            maxHops: {
-              type: "number",
-              description: "Graph traversal depth (default 2)"
+            blocked_by: {
+              type: "array",
+              items: { type: "string" },
+              description: "Task IDs that must complete before this can start"
             },
-            k: {
-              type: "number",
-              description: "Top-k results (default 20)"
+            parent_id: {
+              type: "string",
+              description: "Parent task ID"
+            }
+          },
+          required: ["goal"]
+        }
+      },
+      {
+        name: "cord_complete",
+        description: "Mark a cord task as completed with a result. Automatically unblocks dependent tasks.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            task_id: {
+              type: "string",
+              description: "Task ID to complete"
+            },
+            result: {
+              type: "string",
+              description: "The result/output of this task"
+            }
+          },
+          required: ["task_id", "result"]
+        }
+      },
+      {
+        name: "cord_ask",
+        description: "Create an ask task \u2014 a question that needs an answer before dependent tasks can proceed.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            question: {
+              type: "string",
+              description: "The question to ask"
+            },
+            options: {
+              type: "array",
+              items: { type: "string" },
+              description: "Optional list of answer choices"
+            },
+            parent_id: {
+              type: "string",
+              description: "Parent task ID"
+            }
+          },
+          required: ["question"]
+        }
+      },
+      {
+        name: "cord_tree",
+        description: "View the cord task tree with context scoping. Shows which tasks are active, blocked, or completed.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            task_id: {
+              type: "string",
+              description: "Root task ID to show subtree (omit for full project tree)"
+            },
+            include_results: {
+              type: "boolean",
+              default: false,
+              description: "Include task results in output"
             }
           }
         }
@@ -778,8 +905,10 @@ class MCPToolDefinitions {
         return this.getDiscoveryTools();
       case "edit":
         return this.getEditTools();
-      case "graphiti":
-        return this.getGraphitiTools();
+      case "team":
+        return this.getTeamTools();
+      case "cord":
+        return this.getCordTools();
       default:
         return [];
     }

package/dist/src/integrations/ralph/context/context-budget-manager.js

@@ -115,14 +115,22 @@ class ContextBudgetManager {
     const reductionRatio = this.config.maxTokens / currentTokens;
     const phase = this.determinePhase(context.task.currentIteration);
     const adjustedWeights = this.getPhaseAdjustedWeights(phase);
-    return this.applyWeightedReduction(context, reductionRatio, adjustedWeights);
+    return this.applyWeightedReduction(
+      context,
+      reductionRatio,
+      adjustedWeights
+    );
   }
   /**
    * Priority-based allocation using fixed weights
    */
   priorityBasedAllocation(context, currentTokens) {
     const reductionRatio = this.config.maxTokens / currentTokens;
-    return this.applyWeightedReduction(context, reductionRatio, this.config.priorityWeights);
+    return this.applyWeightedReduction(
+      context,
+      reductionRatio,
+      this.config.priorityWeights
+    );
   }
   /**
    * Apply weighted reduction to context

package/dist/src/integrations/ralph/context/stackmemory-context-loader.js

@@ -46,7 +46,10 @@ class StackMemoryContextLoader {
       await sharedContextLayer.initialize();
       const session = await sessionManager.getOrCreateSession({});
       if (session.database) {
-        this.frameManager = new FrameManager(session.database, session.projectId);
+        this.frameManager = new FrameManager(
+          session.database,
+          session.projectId
+        );
         this.contextRetriever = new ContextRetriever(session.database);
       }
       logger.info("Context loader initialized successfully");
@@ -115,17 +118,25 @@ class StackMemoryContextLoader {
         totalTokens += sources[sources.length - 1].tokens;
       }
       const budgetedSources = this.budgetManager.allocateBudget({ sources });
-      const synthesizedContext = this.synthesizeContext(budgetedSources.sources);
+      const synthesizedContext = this.synthesizeContext(
+        budgetedSources.sources
+      );
       logger.info("Context loaded successfully", {
         totalSources: sources.length,
         totalTokens,
-        budgetedTokens: budgetedSources.sources.reduce((sum, s) => sum + s.tokens, 0)
+        budgetedTokens: budgetedSources.sources.reduce(
+          (sum, s) => sum + s.tokens,
+          0
+        )
       });
       return {
         context: synthesizedContext,
         sources: budgetedSources.sources,
         metadata: {
-          totalTokens: budgetedSources.sources.reduce((sum, s) => sum + s.tokens, 0),
+          totalTokens: budgetedSources.sources.reduce(
+            (sum, s) => sum + s.tokens,
+            0
+          ),
           sourcesCount: budgetedSources.sources.length,
           patterns: request.usePatterns ? patterns : [],
           similarTasks: request.useSimilarTasks ? similarTasks : []
@@ -144,16 +155,22 @@ class StackMemoryContextLoader {
       return [];
     }
     try {
-      const searchResults = await this.contextRetriever.search(taskDescription, {
-        maxResults: 10,
-        types: ["task", "subtask"],
-        timeFilter: {
-          days: this.config.lookbackDays
+      const searchResults = await this.contextRetriever.search(
+        taskDescription,
+        {
+          maxResults: 10,
+          types: ["task", "subtask"],
+          timeFilter: {
+            days: this.config.lookbackDays
+          }
         }
-      });
+      );
       const similarities = [];
       for (const result of searchResults) {
-        const similarity = this.calculateTaskSimilarity(taskDescription, result.content);
+        const similarity = this.calculateTaskSimilarity(
+          taskDescription,
+          result.content
+        );
         if (similarity >= this.config.similarityThreshold) {
           similarities.push({
             frameId: result.frameId,
@@ -184,7 +201,10 @@ class StackMemoryContextLoader {
       if (!context) return [];
       const relevantPatterns = [];
       for (const pattern of context.globalPatterns) {
-        const relevance = this.calculatePatternRelevance(taskDescription, pattern.pattern);
+        const relevance = this.calculatePatternRelevance(
+          taskDescription,
+          pattern.pattern
+        );
         if (relevance >= 0.5) {
           relevantPatterns.push({
             pattern: pattern.pattern,
@@ -197,7 +217,9 @@ class StackMemoryContextLoader {
           });
         }
       }
-      return relevantPatterns.sort((a, b) => b.relevance * Math.log(b.frequency + 1) - a.relevance * Math.log(a.frequency + 1)).slice(0, 8);
+      return relevantPatterns.sort(
+        (a, b) => b.relevance * Math.log(b.frequency + 1) - a.relevance * Math.log(a.frequency + 1)
+      ).slice(0, 8);
     } catch (error) {
       logger.error("Failed to extract patterns", error);
       return [];
@@ -270,12 +292,14 @@ class StackMemoryContextLoader {
     const contextParts = [];
     contextParts.push("Similar tasks from history:");
     for (const sim of similarities) {
-      contextParts.push(`
+      contextParts.push(
+        `
 Task: ${sim.task}
 Outcome: ${sim.outcome}
 Similarity: ${Math.round(sim.similarity * 100)}%
 ${sim.outcome === "success" ? "\u2705 Successfully completed" : "\u274C Had issues"}
-      `.trim());
+      `.trim()
+      );
     }
     return contextParts.join("\n\n");
   }
@@ -286,13 +310,15 @@ ${sim.outcome === "success" ? "\u2705 Successfully completed" : "\u274C Had issu
     const contextParts = [];
     contextParts.push("Relevant patterns from experience:");
     for (const pattern of patterns2) {
-      contextParts.push(`
+      contextParts.push(
+        `
 Pattern: ${pattern.pattern}
 Type: ${pattern.type}
 Frequency: ${pattern.frequency} occurrences
 ${pattern.resolution ? `Resolution: ${pattern.resolution}` : ""}
 Relevance: ${Math.round(pattern.relevance * 100)}%
-      `.trim());
+      `.trim()
+      );
     }
     return contextParts.join("\n\n");
   }
@@ -303,11 +329,13 @@ Relevance: ${Math.round(pattern.relevance * 100)}%
     const contextParts = [];
     contextParts.push("Recent successful decisions:");
     for (const decision of decisions) {
-      contextParts.push(`
+      contextParts.push(
+        `
 Decision: ${decision.decision}
 Reasoning: ${decision.reasoning}
 Date: ${new Date(decision.timestamp).toLocaleDateString()}
-      `.trim());
+      `.trim()
+      );
     }
     return contextParts.join("\n\n");
   }
@@ -322,11 +350,15 @@ Date: ${new Date(decision.timestamp).toLocaleDateString()}
     contextParts.push("Context from StackMemory:");
     const sortedSources = sources.sort((a, b) => b.weight - a.weight);
     for (const source of sortedSources) {
-      contextParts.push(`
---- ${source.type.replace("_", " ").toUpperCase()} ---`);
+      contextParts.push(
+        `
+--- ${source.type.replace("_", " ").toUpperCase()} ---`
+      );
       contextParts.push(source.content);
     }
-    contextParts.push("\nUse this context to inform your approach to the current task.");
+    contextParts.push(
+      "\nUse this context to inform your approach to the current task."
+    );
     return contextParts.join("\n");
   }
   /**