MemoryMesh

Instructions

Implementation Reference

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

  Dynamically generates the schema/definition for the 'delete_npc' tool when processing the 'npc' schema. Defines input as {delete_npc: {name: string}}.

  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:203-214 (handler)

  Dispatches calls to 'delete_npc' by parsing input args[`delete_npc`] to extract node name and invoking the core delete handler.

  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);
  }

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

  Core handler function that performs the deletion of the NPC node. Verifies existence by name and type ('npc'), then invokes deleteNodes on ApplicationManager, which removes the node and its edges.

  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/registry/toolsRegistry.ts:48-52 (registration)

  Registers all dynamic tools, including 'delete_npc', from the dynamic tool manager into the central ToolsRegistry during initialization.

  await dynamicToolManager.initialize();
  dynamicToolManager.getTools().forEach(tool => {
      this.tools.set(tool.name, tool);
  });

• src/integration/tools/DynamicSchemaToolRegistry.ts:66-71 (registration)

  During initialization, generates and caches dynamic tools for each schema loaded from data/schemas/, including 'delete_npc' for 'npc.schema.json'.

  // Generate tools for each schema
  for (const [schemaName, schema] of this.schemas.entries()) {
      const tools = await this.generateToolsForSchema(schemaName, schema);
      tools.forEach(tool => this.toolsCache.set(tool.name, tool));
  }