MemoryMesh

Instructions

Implementation Reference

• src/core/schema/SchemaProcessor.ts:325-363 (handler)

  Core handler function that implements the deletion logic for 'delete_quest'. It verifies the quest node exists by name and type='quest', then deletes it and associated edges using ApplicationManager.deleteNodes.

  export async function handleSchemaDelete(
      nodeName: string,
      nodeType: string,
      applicationManager: ApplicationManager
  ): Promise<ToolResponse> {
      try {
          const graph = await applicationManager.readGraph();
          const node = graph.nodes.find((n: Node) => n.name === nodeName && n.nodeType === nodeType);
  
          if (!node) {
              return formatToolError({
                  operation: 'deleteSchema',
                  error: `${nodeType} "${nodeName}" not found`,
                  context: {nodeName, nodeType},
                  suggestions: ["Verify node name and type"]
              });
          }
  
          await applicationManager.deleteNodes([nodeName]);
  
          return formatToolResponse({
              actionTaken: `Deleted ${nodeType}: ${nodeName}`
          });
      } catch (error) {
          return formatToolError({
              operation: 'deleteSchema',
              error: error instanceof Error ? error.message : 'Unknown error occurred',
              context: {nodeName, nodeType},
              suggestions: [
                  "Check node exists",
                  "Verify delete permissions"
              ],
              recoverySteps: [
                  "Ensure no dependent nodes exist",
                  "Try retrieving node first"
              ]
          });
      }
  }

• src/integration/tools/DynamicSchemaToolRegistry.ts:101-129 (schema)

  Dynamically generates the schema (inputSchema, description, name='delete_quest') for the delete_quest tool when processing the 'quest' schema.

  const deleteSchema: Tool = {
      name: `delete_${schemaName}`,
      description: `Delete
      an existing
      ${schemaName}
      from
      the
      knowledge
      graph`,
      inputSchema: {
          type: "object",
          properties: {
              [`delete_${schemaName}`]: {
                  type: "object",
                  description: `Delete parameters for ${schemaName}`,
                  properties: {
                      name: {
                          type: "string",
                          description: `The name of the ${schemaName} to delete`
                      }
                  },
                  required: ["name"]
              }
          },
          required: [`delete_${schemaName}`]
      }
  };
  
  tools.push(deleteSchema);

• src/integration/tools/DynamicSchemaToolRegistry.ts:89-131 (registration)

  Generates the add/update/delete_quest tools for the 'quest' schema and returns them for registration in toolsCache.

  private async generateToolsForSchema(schemaName: string, schema: SchemaBuilder): Promise<Tool[]> {
      const tools: Tool[] = [];
      const baseSchema = schema.build();
  
      // Add tool
      tools.push(baseSchema as unknown as Tool);
  
      // Update tool
      const updateSchema = schema.createUpdateSchema();
      tools.push(updateSchema as unknown as Tool);
  
      // Delete tool
      const deleteSchema: Tool = {
          name: `delete_${schemaName}`,
          description: `Delete
          an existing
          ${schemaName}
          from
          the
          knowledge
          graph`,
          inputSchema: {
              type: "object",
              properties: {
                  [`delete_${schemaName}`]: {
                      type: "object",
                      description: `Delete parameters for ${schemaName}`,
                      properties: {
                          name: {
                              type: "string",
                              description: `The name of the ${schemaName} to delete`
                          }
                      },
                      required: ["name"]
                  }
              },
              required: [`delete_${schemaName}`]
          }
      };
  
      tools.push(deleteSchema);
      return tools;
  }

• src/integration/tools/registry/toolsRegistry.ts:47-51 (registration)

  Registers all dynamic tools, including 'delete_quest', into the central ToolsRegistry Map used for tool lookup and list_tools.

  // Initialize and register dynamic tools
  await dynamicToolManager.initialize();
  dynamicToolManager.getTools().forEach(tool => {
      this.tools.set(tool.name, tool);
  });

• src/integration/tools/DynamicSchemaToolRegistry.ts:203-213 (helper)

  Handler dispatch for delete_quest: extracts node name from args.delete_quest.name and invokes the core handleSchemaDelete.

  case 'delete': {
      const {name} = args[`delete_${schemaName}`];
      if (!name) {
          return formatToolError({
              operation: toolName,
              error: `Name is required to delete a ${schemaName}`,
              suggestions: ["Provide the 'name' parameter"]
          });
      }
      return handleSchemaDelete(name, schemaName, knowledgeGraphManager);
  }