@danielsimonjr/memory-mcp 12.2.3 → 12.5.2

package/dist/core/ObservationManager.js

@@ -1,123 +0,0 @@
-/**
- * Observation Manager
- *
- * Handles observation CRUD operations for entities.
- * Extracted from EntityManager (Phase 4: Consolidate God Objects).
- *
- * @module core/ObservationManager
- */
-import { EntityNotFoundError } from '../utils/errors.js';
-/**
- * Manages observation operations for entities in the knowledge graph.
- */
-export class ObservationManager {
-    storage;
-    constructor(storage) {
-        this.storage = storage;
-    }
-    /**
-     * Add observations to multiple entities in a single batch operation.
-     *
-     * This method performs the following operations:
-     * - Adds new observations to specified entities
-     * - Filters out duplicate observations (already present)
-     * - Updates lastModified timestamp only if new observations were added
-     * - ATOMIC: All updates are saved in a single operation
-     *
-     * @param observations - Array of entity names and observations to add
-     * @returns Promise resolving to array of results showing which observations were added
-     * @throws {EntityNotFoundError} If any entity is not found
-     *
-     * @example
-     * ```typescript
-     * const manager = new ObservationManager(storage);
-     *
-     * // Add observations to multiple entities
-     * const results = await manager.addObservations([
-     *   { entityName: 'Alice', contents: ['Completed project X', 'Started project Y'] },
-     *   { entityName: 'Bob', contents: ['Joined team meeting'] }
-     * ]);
-     *
-     * // Check what was added (duplicates are filtered out)
-     * results.forEach(r => {
-     *   console.log(`${r.entityName}: added ${r.addedObservations.length} new observations`);
-     * });
-     * ```
-     */
-    async addObservations(observations) {
-        // Get mutable graph for atomic update
-        const graph = await this.storage.getGraphForMutation();
-        const timestamp = new Date().toISOString();
-        const results = [];
-        let hasChanges = false;
-        for (const o of observations) {
-            const entity = graph.entities.find(e => e.name === o.entityName);
-            if (!entity) {
-                throw new EntityNotFoundError(o.entityName);
-            }
-            const newObservations = o.contents.filter(content => !entity.observations.includes(content));
-            if (newObservations.length > 0) {
-                // Add new observations directly to the entity
-                entity.observations.push(...newObservations);
-                entity.lastModified = timestamp;
-                hasChanges = true;
-            }
-            results.push({ entityName: o.entityName, addedObservations: newObservations });
-        }
-        // Save all changes in a single atomic operation
-        if (hasChanges) {
-            await this.storage.saveGraph(graph);
-        }
-        return results;
-    }
-    /**
-     * Delete observations from multiple entities in a single batch operation.
-     *
-     * This method performs the following operations:
-     * - Removes specified observations from entities
-     * - Updates lastModified timestamp only if observations were deleted
-     * - Silently ignores entities that don't exist (no error thrown)
-     * - ATOMIC: All deletions are saved in a single operation
-     *
-     * @param deletions - Array of entity names and observations to delete
-     * @returns Promise that resolves when deletion is complete
-     *
-     * @example
-     * ```typescript
-     * const manager = new ObservationManager(storage);
-     *
-     * // Delete observations from multiple entities
-     * await manager.deleteObservations([
-     *   { entityName: 'Alice', observations: ['Old observation 1', 'Old observation 2'] },
-     *   { entityName: 'Bob', observations: ['Outdated info'] }
-     * ]);
-     *
-     * // Safe to delete from non-existent entities (no error)
-     * await manager.deleteObservations([
-     *   { entityName: 'NonExistent', observations: ['Some text'] }
-     * ]); // No error thrown
-     * ```
-     */
-    async deleteObservations(deletions) {
-        // Get mutable graph for atomic update
-        const graph = await this.storage.getGraphForMutation();
-        const timestamp = new Date().toISOString();
-        let hasChanges = false;
-        deletions.forEach(d => {
-            const entity = graph.entities.find(e => e.name === d.entityName);
-            if (entity) {
-                const originalLength = entity.observations.length;
-                entity.observations = entity.observations.filter(o => !d.observations.includes(o));
-                // Update lastModified timestamp if observations were deleted
-                if (entity.observations.length < originalLength) {
-                    entity.lastModified = timestamp;
-                    hasChanges = true;
-                }
-            }
-        });
-        // Save all changes in a single atomic operation
-        if (hasChanges) {
-            await this.storage.saveGraph(graph);
-        }
-    }
-}

package/dist/core/RelationManager.d.ts

@@ -1,131 +0,0 @@
-/**
- * Relation Manager
- *
- * Handles CRUD operations for relations in the knowledge graph.
- *
- * @module core/RelationManager
- */
-import type { Relation } from '../types/index.js';
-import type { GraphStorage } from './GraphStorage.js';
-/**
- * Manages relation operations with automatic timestamp handling.
- */
-export declare class RelationManager {
-    private storage;
-    constructor(storage: GraphStorage);
-    /**
-     * Create multiple relations in a single batch operation.
-     *
-     * This method performs the following operations:
-     * - Validates that all referenced entities exist (prevents dangling relations)
-     * - Filters out duplicate relations (same from, to, and relationType)
-     * - Automatically adds createdAt and lastModified timestamps
-     *
-     * A relation is considered duplicate if another relation exists with the same:
-     * - from entity name
-     * - to entity name
-     * - relationType
-     *
-     * @param relations - Array of relations to create
-     * @returns Promise resolving to array of newly created relations (excludes duplicates)
-     * @throws {ValidationError} If any relation references non-existent entities
-     *
-     * @example
-     * ```typescript
-     * const manager = new RelationManager(storage);
-     *
-     * // Create single relation
-     * const results = await manager.createRelations([{
-     *   from: 'Alice',
-     *   to: 'Bob',
-     *   relationType: 'works_with'
-     * }]);
-     *
-     * // Create multiple relations at once
-     * await manager.createRelations([
-     *   { from: 'Alice', to: 'Project_X', relationType: 'contributes_to' },
-     *   { from: 'Bob', to: 'Project_X', relationType: 'leads' },
-     *   { from: 'Charlie', to: 'Alice', relationType: 'reports_to' }
-     * ]);
-     *
-     * // Duplicate relations are filtered out
-     * await manager.createRelations([
-     *   { from: 'Alice', to: 'Bob', relationType: 'works_with' } // Already exists, won't be added
-     * ]);
-     * ```
-     */
-    createRelations(relations: Relation[]): Promise<Relation[]>;
-    /**
-     * Delete multiple relations in a single batch operation.
-     *
-     * This method performs the following operations:
-     * - Removes all specified relations from the graph
-     * - Automatically updates lastModified timestamp for all affected entities
-     * - Silently ignores relations that don't exist (no error thrown)
-     *
-     * An entity is considered "affected" if it appears as either the source (from)
-     * or target (to) of any deleted relation.
-     *
-     * @param relations - Array of relations to delete. Each relation is matched by from, to, and relationType.
-     * @returns Promise that resolves when deletion is complete
-     *
-     * @example
-     * ```typescript
-     * const manager = new RelationManager(storage);
-     *
-     * // Delete single relation
-     * await manager.deleteRelations([{
-     *   from: 'Alice',
-     *   to: 'Bob',
-     *   relationType: 'works_with'
-     * }]);
-     *
-     * // Delete multiple relations at once
-     * await manager.deleteRelations([
-     *   { from: 'Alice', to: 'Project_X', relationType: 'contributes_to' },
-     *   { from: 'Bob', to: 'Project_X', relationType: 'leads' }
-     * ]);
-     * // Note: Alice, Bob, and Project_X will all have their lastModified timestamp updated
-     *
-     * // Safe to delete non-existent relations
-     * await manager.deleteRelations([
-     *   { from: 'NonExistent', to: 'AlsoNonExistent', relationType: 'fake' } // No error
-     * ]);
-     * ```
-     */
-    deleteRelations(relations: Relation[]): Promise<void>;
-    /**
-     * Retrieve all relations involving a specific entity.
-     *
-     * This is a read-only operation that returns all relations where the specified
-     * entity appears as either the source (from) or target (to) of the relation.
-     * Entity names are case-sensitive.
-     *
-     * @param entityName - The unique name of the entity to find relations for
-     * @returns Promise resolving to array of Relation objects (empty array if no relations found)
-     *
-     * @example
-     * ```typescript
-     * const manager = new RelationManager(storage);
-     *
-     * // Get all relations for an entity
-     * const aliceRelations = await manager.getRelations('Alice');
-     * // Returns: [
-     * //   { from: 'Alice', to: 'Bob', relationType: 'works_with' },
-     * //   { from: 'Alice', to: 'Project_X', relationType: 'contributes_to' },
-     * //   { from: 'Charlie', to: 'Alice', relationType: 'reports_to' }
-     * // ]
-     *
-     * // Process relations by type
-     * const relations = await manager.getRelations('Alice');
-     * const outgoing = relations.filter(r => r.from === 'Alice');
-     * const incoming = relations.filter(r => r.to === 'Alice');
-     *
-     * // Handle entity with no relations
-     * const noRelations = await manager.getRelations('IsolatedEntity');
-     * console.log(noRelations); // []
-     * ```
-     */
-    getRelations(entityName: string): Promise<Relation[]>;
-}
-//# sourceMappingURL=RelationManager.d.ts.map

package/dist/core/RelationManager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"RelationManager.d.ts","sourceRoot":"","sources":["../../src/core/RelationManager.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAKtD;;GAEG;AACH,qBAAa,eAAe;IACd,OAAO,CAAC,OAAO;gBAAP,OAAO,EAAE,YAAY;IAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;IACG,eAAe,CAAC,SAAS,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;IAiEjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACG,eAAe,CAAC,SAAS,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAqC3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACG,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;CAK5D"}

package/dist/core/RelationManager.js

@@ -1,210 +0,0 @@
-/**
- * Relation Manager
- *
- * Handles CRUD operations for relations in the knowledge graph.
- *
- * @module core/RelationManager
- */
-import { ValidationError } from '../utils/errors.js';
-import { BatchCreateRelationsSchema, DeleteRelationsSchema } from '../utils/index.js';
-import { GRAPH_LIMITS } from '../utils/constants.js';
-/**
- * Manages relation operations with automatic timestamp handling.
- */
-export class RelationManager {
-    storage;
-    constructor(storage) {
-        this.storage = storage;
-    }
-    /**
-     * Create multiple relations in a single batch operation.
-     *
-     * This method performs the following operations:
-     * - Validates that all referenced entities exist (prevents dangling relations)
-     * - Filters out duplicate relations (same from, to, and relationType)
-     * - Automatically adds createdAt and lastModified timestamps
-     *
-     * A relation is considered duplicate if another relation exists with the same:
-     * - from entity name
-     * - to entity name
-     * - relationType
-     *
-     * @param relations - Array of relations to create
-     * @returns Promise resolving to array of newly created relations (excludes duplicates)
-     * @throws {ValidationError} If any relation references non-existent entities
-     *
-     * @example
-     * ```typescript
-     * const manager = new RelationManager(storage);
-     *
-     * // Create single relation
-     * const results = await manager.createRelations([{
-     *   from: 'Alice',
-     *   to: 'Bob',
-     *   relationType: 'works_with'
-     * }]);
-     *
-     * // Create multiple relations at once
-     * await manager.createRelations([
-     *   { from: 'Alice', to: 'Project_X', relationType: 'contributes_to' },
-     *   { from: 'Bob', to: 'Project_X', relationType: 'leads' },
-     *   { from: 'Charlie', to: 'Alice', relationType: 'reports_to' }
-     * ]);
-     *
-     * // Duplicate relations are filtered out
-     * await manager.createRelations([
-     *   { from: 'Alice', to: 'Bob', relationType: 'works_with' } // Already exists, won't be added
-     * ]);
-     * ```
-     */
-    async createRelations(relations) {
-        // Validate input
-        const validation = BatchCreateRelationsSchema.safeParse(relations);
-        if (!validation.success) {
-            const errors = validation.error.issues.map((e) => `${e.path.join('.')}: ${e.message}`);
-            throw new ValidationError('Invalid relation data', errors);
-        }
-        // Use read-only graph for checking existing relations and entity existence
-        const readGraph = await this.storage.loadGraph();
-        const timestamp = new Date().toISOString();
-        // Build set of existing entity names for O(1) lookup
-        const existingEntityNames = new Set(readGraph.entities.map(e => e.name));
-        // Validate that all referenced entities exist (fixes bug 7.2 from analysis)
-        const danglingRelations = [];
-        for (const relation of relations) {
-            const missingEntities = [];
-            if (!existingEntityNames.has(relation.from)) {
-                missingEntities.push(relation.from);
-            }
-            if (!existingEntityNames.has(relation.to)) {
-                missingEntities.push(relation.to);
-            }
-            if (missingEntities.length > 0) {
-                danglingRelations.push(`Relation from "${relation.from}" to "${relation.to}" references non-existent entities: ${missingEntities.join(', ')}`);
-            }
-        }
-        if (danglingRelations.length > 0) {
-            throw new ValidationError('Relations reference non-existent entities', danglingRelations);
-        }
-        // Check graph size limits
-        const relationsToAdd = relations.filter(r => !readGraph.relations.some(existing => existing.from === r.from &&
-            existing.to === r.to &&
-            existing.relationType === r.relationType));
-        if (readGraph.relations.length + relationsToAdd.length > GRAPH_LIMITS.MAX_RELATIONS) {
-            throw new ValidationError('Graph size limit exceeded', [`Adding ${relationsToAdd.length} relations would exceed maximum of ${GRAPH_LIMITS.MAX_RELATIONS} relations`]);
-        }
-        const newRelations = relationsToAdd
-            .map(r => ({
-            ...r,
-            createdAt: r.createdAt || timestamp,
-            lastModified: r.lastModified || timestamp,
-        }));
-        // Get mutable copy for write operation
-        const graph = await this.storage.getGraphForMutation();
-        graph.relations.push(...newRelations);
-        await this.storage.saveGraph(graph);
-        return newRelations;
-    }
-    /**
-     * Delete multiple relations in a single batch operation.
-     *
-     * This method performs the following operations:
-     * - Removes all specified relations from the graph
-     * - Automatically updates lastModified timestamp for all affected entities
-     * - Silently ignores relations that don't exist (no error thrown)
-     *
-     * An entity is considered "affected" if it appears as either the source (from)
-     * or target (to) of any deleted relation.
-     *
-     * @param relations - Array of relations to delete. Each relation is matched by from, to, and relationType.
-     * @returns Promise that resolves when deletion is complete
-     *
-     * @example
-     * ```typescript
-     * const manager = new RelationManager(storage);
-     *
-     * // Delete single relation
-     * await manager.deleteRelations([{
-     *   from: 'Alice',
-     *   to: 'Bob',
-     *   relationType: 'works_with'
-     * }]);
-     *
-     * // Delete multiple relations at once
-     * await manager.deleteRelations([
-     *   { from: 'Alice', to: 'Project_X', relationType: 'contributes_to' },
-     *   { from: 'Bob', to: 'Project_X', relationType: 'leads' }
-     * ]);
-     * // Note: Alice, Bob, and Project_X will all have their lastModified timestamp updated
-     *
-     * // Safe to delete non-existent relations
-     * await manager.deleteRelations([
-     *   { from: 'NonExistent', to: 'AlsoNonExistent', relationType: 'fake' } // No error
-     * ]);
-     * ```
-     */
-    async deleteRelations(relations) {
-        // Validate input
-        const validation = DeleteRelationsSchema.safeParse(relations);
-        if (!validation.success) {
-            const errors = validation.error.issues.map((e) => `${e.path.join('.')}: ${e.message}`);
-            throw new ValidationError('Invalid relation data', errors);
-        }
-        const graph = await this.storage.getGraphForMutation();
-        const timestamp = new Date().toISOString();
-        // Track affected entities
-        const affectedEntityNames = new Set();
-        relations.forEach(rel => {
-            affectedEntityNames.add(rel.from);
-            affectedEntityNames.add(rel.to);
-        });
-        // Remove relations
-        graph.relations = graph.relations.filter(r => !relations.some(delRelation => r.from === delRelation.from &&
-            r.to === delRelation.to &&
-            r.relationType === delRelation.relationType));
-        // Update lastModified for affected entities
-        graph.entities.forEach(entity => {
-            if (affectedEntityNames.has(entity.name)) {
-                entity.lastModified = timestamp;
-            }
-        });
-        await this.storage.saveGraph(graph);
-    }
-    /**
-     * Retrieve all relations involving a specific entity.
-     *
-     * This is a read-only operation that returns all relations where the specified
-     * entity appears as either the source (from) or target (to) of the relation.
-     * Entity names are case-sensitive.
-     *
-     * @param entityName - The unique name of the entity to find relations for
-     * @returns Promise resolving to array of Relation objects (empty array if no relations found)
-     *
-     * @example
-     * ```typescript
-     * const manager = new RelationManager(storage);
-     *
-     * // Get all relations for an entity
-     * const aliceRelations = await manager.getRelations('Alice');
-     * // Returns: [
-     * //   { from: 'Alice', to: 'Bob', relationType: 'works_with' },
-     * //   { from: 'Alice', to: 'Project_X', relationType: 'contributes_to' },
-     * //   { from: 'Charlie', to: 'Alice', relationType: 'reports_to' }
-     * // ]
-     *
-     * // Process relations by type
-     * const relations = await manager.getRelations('Alice');
-     * const outgoing = relations.filter(r => r.from === 'Alice');
-     * const incoming = relations.filter(r => r.to === 'Alice');
-     *
-     * // Handle entity with no relations
-     * const noRelations = await manager.getRelations('IsolatedEntity');
-     * console.log(noRelations); // []
-     * ```
-     */
-    async getRelations(entityName) {
-        // OPTIMIZED: Uses RelationIndex for O(1) lookup instead of O(n) array scan
-        await this.storage.ensureLoaded();
-        return this.storage.getRelationsFor(entityName);
-    }
-}