Zanny's Persistent Memory Manager

Verified
Knowledge & Memory
Overview InspectNew Schema Related Servers Reviews Score
mcp-memory-bank-1
src
import fs from 'fs-extra';
import path from 'path';
import crypto from 'crypto';
import { config } from './config';
import logger from './logger';

export interface Memory {
  id: string;
  content: string;
  tags?: string[];
  createdAt: Date;
  updatedAt: Date;
}

export class MemoryManager {
  private memoriesDir: string;

  constructor() {
    this.memoriesDir = config.memoriesDir;
    this.ensureMemoriesDirectory();
  }

  /**
   * Ensures the memories directory exists
   */
  private ensureMemoriesDirectory(): void {
    try {
      fs.ensureDirSync(this.memoriesDir);
      logger.info(`Ensured memories directory exists at: ${this.memoriesDir}`);
    } catch (error) {
      logger.error(`Failed to create memories directory: ${error}`);
      throw new Error(`Failed to create memories directory: ${error}`);
    }
  }

  /**
   * Generates a file path for a memory
   * @param id Memory ID
   * @returns Full file path for the memory
   */
  private getMemoryFilePath(id: string): string {
    return path.join(this.memoriesDir, `${id}.json`);
  }

  /**
   * Stores a new memory or updates an existing one
   * @param content Memory content
   * @param tags Optional tags for categorization
   * @returns Stored memory object
   */
  public async storeMemory(content: string, tags?: string[]): Promise<Memory> {
    try {
      // Generate a unique ID based on content hash
      const id = crypto.createHash('md5').update(content).digest('hex');
      const filePath = this.getMemoryFilePath(id);
      
      // Check if memory already exists
      let memory: Memory;
      const now = new Date();
      
      if (await fs.pathExists(filePath)) {
        // Update existing memory
        memory = await fs.readJson(filePath);
        memory.content = content;
        memory.tags = tags || memory.tags;
        memory.updatedAt = now;
      } else {
        // Create new memory
        memory = {
          id,
          content,
          tags: tags || [],
          createdAt: now,
          updatedAt: now
        };
      }
      
      // Write memory to file
      await fs.writeJson(filePath, memory, { spaces: 2 });
      logger.info(`Memory stored: ${id}`);
      
      return memory;
    } catch (error) {
      logger.error(`Failed to store memory: ${error}`);
      throw new Error(`Failed to store memory: ${error}`);
    }
  }

  /**
   * Retrieves a memory by its ID
   * @param id Memory ID
   * @returns Memory object or null if not found
   */
  public async getMemoryById(id: string): Promise<Memory | null> {
    try {
      const filePath = this.getMemoryFilePath(id);
      if (await fs.pathExists(filePath)) {
        const memory = await fs.readJson(filePath);
        logger.info(`Memory retrieved: ${id}`);
        return memory;
      }
      logger.warn(`Memory not found: ${id}`);
      return null;
    } catch (error) {
      logger.error(`Failed to retrieve memory by ID: ${error}`);
      throw new Error(`Failed to retrieve memory by ID: ${error}`);
    }
  }

  /**
   * Searches for memories that contain specific text or have specific tags
   * @param searchText Text to search for in memory content
   * @param tags Tags to filter by
   * @returns Array of matching memories
   */
  public async searchMemories(searchText?: string, tags?: string[]): Promise<Memory[]> {
    try {
      const result: Memory[] = [];
      const files = await fs.readdir(this.memoriesDir);
      
      for (const file of files) {
        if (path.extname(file) === '.json') {
          const filePath = path.join(this.memoriesDir, file);
          const memory: Memory = await fs.readJson(filePath);
          
          let match = true;
          
          // Match by content if searchText is provided
          if (searchText && !memory.content.toLowerCase().includes(searchText.toLowerCase())) {
            match = false;
          }
          
          // Match by tags if provided
          if (tags && tags.length > 0) {
            if (!memory.tags || !tags.some(tag => memory.tags?.includes(tag))) {
              match = false;
            }
          }
          
          if (match) {
            result.push(memory);
          }
        }
      }
      
      logger.info(`Found ${result.length} memories matching search criteria`);
      return result;
    } catch (error) {
      logger.error(`Failed to search memories: ${error}`);
      throw new Error(`Failed to search memories: ${error}`);
    }
  }

  /**
   * Lists all memories
   * @returns Array of all memories
   */
  public async listAllMemories(): Promise<Memory[]> {
    try {
      const result: Memory[] = [];
      const files = await fs.readdir(this.memoriesDir);
      
      for (const file of files) {
        if (path.extname(file) === '.json') {
          const filePath = path.join(this.memoriesDir, file);
          const memory: Memory = await fs.readJson(filePath);
          result.push(memory);
        }
      }
      
      logger.info(`Listed all memories: ${result.length} found`);
      return result;
    } catch (error) {
      logger.error(`Failed to list all memories: ${error}`);
      throw new Error(`Failed to list all memories: ${error}`);
    }
  }

  /**
   * Deletes a memory by its ID
   * @param id Memory ID
   * @returns Whether the memory was deleted
   */
  public async deleteMemory(id: string): Promise<boolean> {
    try {
      const filePath = this.getMemoryFilePath(id);
      if (await fs.pathExists(filePath)) {
        await fs.unlink(filePath);
        logger.info(`Memory deleted: ${id}`);
        return true;
      }
      logger.warn(`Cannot delete - Memory not found: ${id}`);
      return false;
    } catch (error) {
      logger.error(`Failed to delete memory: ${error}`);
      throw new Error(`Failed to delete memory: ${error}`);
    }
  }
} 