@danielsimonjr/memory-mcp 12.2.3 → 12.5.2

package/dist/core/TransactionManager.js

@@ -1,392 +0,0 @@
-/**
- * Transaction Manager
- *
- * Provides atomic transaction support for knowledge graph operations.
- * Ensures data consistency by allowing multiple operations to be
- * grouped together and committed atomically, with automatic rollback on failure.
- *
- * @module core/TransactionManager
- */
-import { IOManager } from '../features/IOManager.js';
-import { KnowledgeGraphError } from '../utils/errors.js';
-/**
- * Types of operations that can be performed in a transaction.
- */
-export var OperationType;
-(function (OperationType) {
-    OperationType["CREATE_ENTITY"] = "CREATE_ENTITY";
-    OperationType["UPDATE_ENTITY"] = "UPDATE_ENTITY";
-    OperationType["DELETE_ENTITY"] = "DELETE_ENTITY";
-    OperationType["CREATE_RELATION"] = "CREATE_RELATION";
-    OperationType["DELETE_RELATION"] = "DELETE_RELATION";
-})(OperationType || (OperationType = {}));
-/**
- * Manages atomic transactions for knowledge graph operations.
- *
- * Provides ACID-like guarantees:
- * - Atomicity: All operations succeed or all fail
- * - Consistency: Graph is always in a valid state
- * - Isolation: Each transaction operates on a snapshot
- * - Durability: Changes are persisted to disk
- *
- * @example
- * ```typescript
- * const storage = new GraphStorage('/data/memory.jsonl');
- * const txManager = new TransactionManager(storage);
- *
- * // Begin transaction
- * txManager.begin();
- *
- * // Stage operations
- * txManager.createEntity({ name: 'Alice', entityType: 'person', observations: [] });
- * txManager.createRelation({ from: 'Alice', to: 'Bob', relationType: 'knows' });
- *
- * // Commit atomically (or rollback on error)
- * const result = await txManager.commit();
- * if (result.success) {
- *   console.log(`Transaction completed: ${result.operationsExecuted} operations`);
- * }
- * ```
- */
-export class TransactionManager {
-    storage;
-    operations = [];
-    inTransaction = false;
-    ioManager;
-    transactionBackup;
-    constructor(storage) {
-        this.storage = storage;
-        this.ioManager = new IOManager(storage);
-    }
-    /**
-     * Begin a new transaction.
-     *
-     * Creates a backup of the current state for rollback purposes.
-     * Only one transaction can be active at a time.
-     *
-     * @throws {KnowledgeGraphError} If a transaction is already in progress
-     *
-     * @example
-     * ```typescript
-     * txManager.begin();
-     * // ... stage operations ...
-     * await txManager.commit();
-     * ```
-     */
-    begin() {
-        if (this.inTransaction) {
-            throw new KnowledgeGraphError('Transaction already in progress', 'TRANSACTION_ACTIVE');
-        }
-        this.operations = [];
-        this.inTransaction = true;
-    }
-    /**
-     * Stage a create entity operation.
-     *
-     * @param entity - Entity to create (without timestamps)
-     *
-     * @example
-     * ```typescript
-     * txManager.begin();
-     * txManager.createEntity({
-     *   name: 'Alice',
-     *   entityType: 'person',
-     *   observations: ['Software engineer'],
-     *   importance: 8
-     * });
-     * ```
-     */
-    createEntity(entity) {
-        this.ensureInTransaction();
-        this.operations.push({
-            type: OperationType.CREATE_ENTITY,
-            data: entity,
-        });
-    }
-    /**
-     * Stage an update entity operation.
-     *
-     * @param name - Name of entity to update
-     * @param updates - Partial entity updates
-     *
-     * @example
-     * ```typescript
-     * txManager.begin();
-     * txManager.updateEntity('Alice', {
-     *   importance: 9,
-     *   observations: ['Lead software engineer']
-     * });
-     * ```
-     */
-    updateEntity(name, updates) {
-        this.ensureInTransaction();
-        this.operations.push({
-            type: OperationType.UPDATE_ENTITY,
-            data: { name, updates },
-        });
-    }
-    /**
-     * Stage a delete entity operation.
-     *
-     * @param name - Name of entity to delete
-     *
-     * @example
-     * ```typescript
-     * txManager.begin();
-     * txManager.deleteEntity('OldEntity');
-     * ```
-     */
-    deleteEntity(name) {
-        this.ensureInTransaction();
-        this.operations.push({
-            type: OperationType.DELETE_ENTITY,
-            data: { name },
-        });
-    }
-    /**
-     * Stage a create relation operation.
-     *
-     * @param relation - Relation to create (without timestamps)
-     *
-     * @example
-     * ```typescript
-     * txManager.begin();
-     * txManager.createRelation({
-     *   from: 'Alice',
-     *   to: 'Bob',
-     *   relationType: 'mentors'
-     * });
-     * ```
-     */
-    createRelation(relation) {
-        this.ensureInTransaction();
-        this.operations.push({
-            type: OperationType.CREATE_RELATION,
-            data: relation,
-        });
-    }
-    /**
-     * Stage a delete relation operation.
-     *
-     * @param from - Source entity name
-     * @param to - Target entity name
-     * @param relationType - Type of relation
-     *
-     * @example
-     * ```typescript
-     * txManager.begin();
-     * txManager.deleteRelation('Alice', 'Bob', 'mentors');
-     * ```
-     */
-    deleteRelation(from, to, relationType) {
-        this.ensureInTransaction();
-        this.operations.push({
-            type: OperationType.DELETE_RELATION,
-            data: { from, to, relationType },
-        });
-    }
-    /**
-     * Commit the transaction, applying all staged operations atomically.
-     *
-     * Creates a backup before applying changes. If any operation fails,
-     * automatically rolls back to the pre-transaction state.
-     *
-     * @returns Promise resolving to transaction result
-     *
-     * @example
-     * ```typescript
-     * txManager.begin();
-     * txManager.createEntity({ name: 'Alice', entityType: 'person', observations: [] });
-     * txManager.createRelation({ from: 'Alice', to: 'Bob', relationType: 'knows' });
-     *
-     * const result = await txManager.commit();
-     * if (result.success) {
-     *   console.log(`Committed ${result.operationsExecuted} operations`);
-     * } else {
-     *   console.error(`Transaction failed: ${result.error}`);
-     * }
-     * ```
-     */
-    async commit() {
-        this.ensureInTransaction();
-        try {
-            // Create backup for rollback
-            const backupResult = await this.ioManager.createBackup({
-                description: 'Transaction backup (auto-created)',
-            });
-            this.transactionBackup = backupResult.path;
-            // Load mutable copy of graph for transaction
-            const graph = await this.storage.getGraphForMutation();
-            const timestamp = new Date().toISOString();
-            // Apply all operations
-            let operationsExecuted = 0;
-            for (const operation of this.operations) {
-                this.applyOperation(graph, operation, timestamp);
-                operationsExecuted++;
-            }
-            // Save the modified graph
-            await this.storage.saveGraph(graph);
-            // Clean up transaction state
-            this.inTransaction = false;
-            this.operations = [];
-            // Delete the transaction backup (no longer needed)
-            if (this.transactionBackup) {
-                await this.ioManager.deleteBackup(this.transactionBackup);
-                this.transactionBackup = undefined;
-            }
-            return {
-                success: true,
-                operationsExecuted,
-            };
-        }
-        catch (error) {
-            // Rollback on error
-            const rollbackResult = await this.rollback();
-            return {
-                success: false,
-                operationsExecuted: 0,
-                error: error instanceof Error ? error.message : String(error),
-                rollbackBackup: rollbackResult.backupUsed,
-            };
-        }
-    }
-    /**
-     * Rollback the current transaction.
-     *
-     * Restores the graph to the pre-transaction state using the backup.
-     * Automatically called by commit() on failure.
-     *
-     * @returns Promise resolving to rollback result
-     *
-     * @example
-     * ```typescript
-     * txManager.begin();
-     * txManager.createEntity({ name: 'Test', entityType: 'temp', observations: [] });
-     *
-     * // Explicit rollback (e.g., user cancellation)
-     * const result = await txManager.rollback();
-     * console.log(`Rolled back, restored from: ${result.backupUsed}`);
-     * ```
-     */
-    async rollback() {
-        if (!this.transactionBackup) {
-            this.inTransaction = false;
-            this.operations = [];
-            return { success: false };
-        }
-        try {
-            // Restore from backup
-            await this.ioManager.restoreFromBackup(this.transactionBackup);
-            // Clean up
-            const backupUsed = this.transactionBackup;
-            await this.ioManager.deleteBackup(this.transactionBackup);
-            this.inTransaction = false;
-            this.operations = [];
-            this.transactionBackup = undefined;
-            return { success: true, backupUsed };
-        }
-        catch (error) {
-            // Rollback failed - keep backup for manual recovery
-            this.inTransaction = false;
-            this.operations = [];
-            return { success: false, backupUsed: this.transactionBackup };
-        }
-    }
-    /**
-     * Check if a transaction is currently in progress.
-     *
-     * @returns True if transaction is active
-     */
-    isInTransaction() {
-        return this.inTransaction;
-    }
-    /**
-     * Get the number of staged operations in the current transaction.
-     *
-     * @returns Number of operations staged
-     */
-    getOperationCount() {
-        return this.operations.length;
-    }
-    /**
-     * Ensure a transaction is in progress, or throw an error.
-     *
-     * @private
-     */
-    ensureInTransaction() {
-        if (!this.inTransaction) {
-            throw new KnowledgeGraphError('No transaction in progress. Call begin() first.', 'NO_TRANSACTION');
-        }
-    }
-    /**
-     * Apply a single operation to the graph.
-     *
-     * @private
-     */
-    applyOperation(graph, operation, timestamp) {
-        switch (operation.type) {
-            case OperationType.CREATE_ENTITY: {
-                const entity = {
-                    ...operation.data,
-                    createdAt: timestamp,
-                    lastModified: timestamp,
-                };
-                // Check for duplicates
-                if (graph.entities.some(e => e.name === entity.name)) {
-                    throw new KnowledgeGraphError(`Entity "${entity.name}" already exists`, 'DUPLICATE_ENTITY');
-                }
-                graph.entities.push(entity);
-                break;
-            }
-            case OperationType.UPDATE_ENTITY: {
-                const { name, updates } = operation.data;
-                const entity = graph.entities.find(e => e.name === name);
-                if (!entity) {
-                    throw new KnowledgeGraphError(`Entity "${name}" not found`, 'ENTITY_NOT_FOUND');
-                }
-                Object.assign(entity, updates);
-                entity.lastModified = timestamp;
-                break;
-            }
-            case OperationType.DELETE_ENTITY: {
-                const { name } = operation.data;
-                const index = graph.entities.findIndex(e => e.name === name);
-                if (index === -1) {
-                    throw new KnowledgeGraphError(`Entity "${name}" not found`, 'ENTITY_NOT_FOUND');
-                }
-                graph.entities.splice(index, 1);
-                // Delete related relations
-                graph.relations = graph.relations.filter(r => r.from !== name && r.to !== name);
-                break;
-            }
-            case OperationType.CREATE_RELATION: {
-                const relation = {
-                    ...operation.data,
-                    createdAt: timestamp,
-                    lastModified: timestamp,
-                };
-                // Check for duplicates
-                const exists = graph.relations.some(r => r.from === relation.from && r.to === relation.to && r.relationType === relation.relationType);
-                if (exists) {
-                    throw new KnowledgeGraphError(`Relation "${relation.from}" -> "${relation.to}" (${relation.relationType}) already exists`, 'DUPLICATE_RELATION');
-                }
-                graph.relations.push(relation);
-                break;
-            }
-            case OperationType.DELETE_RELATION: {
-                const { from, to, relationType } = operation.data;
-                const index = graph.relations.findIndex(r => r.from === from && r.to === to && r.relationType === relationType);
-                if (index === -1) {
-                    throw new KnowledgeGraphError(`Relation "${from}" -> "${to}" (${relationType}) not found`, 'RELATION_NOT_FOUND');
-                }
-                graph.relations.splice(index, 1);
-                break;
-            }
-            default: {
-                // Exhaustiveness check - TypeScript will error if we miss a case
-                const _exhaustiveCheck = operation;
-                throw new KnowledgeGraphError(`Unknown operation type: ${_exhaustiveCheck.type}`, 'UNKNOWN_OPERATION');
-            }
-        }
-    }
-}

package/dist/core/index.d.ts

@@ -1,16 +0,0 @@
-/**
- * Core Module Barrel Export
- * Phase 4: Added ObservationManager, HierarchyManager, and GraphTraversal exports
- */
-export { GraphStorage } from './GraphStorage.js';
-export { SQLiteStorage } from './SQLiteStorage.js';
-export { EntityManager } from './EntityManager.js';
-export { RelationManager } from './RelationManager.js';
-export { ObservationManager } from './ObservationManager.js';
-export { HierarchyManager } from './HierarchyManager.js';
-export { ManagerContext } from './ManagerContext.js';
-export { GraphTraversal } from './GraphTraversal.js';
-export { ManagerContext as KnowledgeGraphManager } from './ManagerContext.js';
-export { TransactionManager, OperationType, type TransactionOperation, type TransactionResult, } from './TransactionManager.js';
-export { createStorage, createStorageFromPath } from './StorageFactory.js';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErD,OAAO,EAAE,cAAc,IAAI,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAC9E,OAAO,EACL,kBAAkB,EAClB,aAAa,EACb,KAAK,oBAAoB,EACzB,KAAK,iBAAiB,GACvB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/core/index.js

@@ -1,17 +0,0 @@
-/**
- * Core Module Barrel Export
- * Phase 4: Added ObservationManager, HierarchyManager, and GraphTraversal exports
- */
-export { GraphStorage } from './GraphStorage.js';
-export { SQLiteStorage } from './SQLiteStorage.js';
-export { EntityManager } from './EntityManager.js';
-export { RelationManager } from './RelationManager.js';
-export { ObservationManager } from './ObservationManager.js';
-export { HierarchyManager } from './HierarchyManager.js';
-export { ManagerContext } from './ManagerContext.js';
-// Phase 4 Sprint 6-8: Graph traversal algorithms
-export { GraphTraversal } from './GraphTraversal.js';
-// Backward compatibility alias
-export { ManagerContext as KnowledgeGraphManager } from './ManagerContext.js';
-export { TransactionManager, OperationType, } from './TransactionManager.js';
-export { createStorage, createStorageFromPath } from './StorageFactory.js';

package/dist/features/AnalyticsManager.d.ts

@@ -1,44 +0,0 @@
-/**
- * Analytics Manager
- *
- * Handles graph statistics and validation operations.
- * Extracted from SearchManager (Phase 4: Consolidate God Objects).
- *
- * @module features/AnalyticsManager
- */
-import type { GraphStorage } from '../core/GraphStorage.js';
-import type { GraphStats, ValidationReport } from '../types/index.js';
-/**
- * Manages analytics operations for the knowledge graph.
- */
-export declare class AnalyticsManager {
-    private storage;
-    constructor(storage: GraphStorage);
-    /**
-     * Validate the knowledge graph structure and data integrity.
-     *
-     * Checks for:
-     * - Orphaned relations (pointing to non-existent entities)
-     * - Duplicate entity names
-     * - Invalid entity data (missing name/type, invalid observations)
-     * - Isolated entities (no relations)
-     * - Empty observations
-     * - Missing metadata (createdAt, lastModified)
-     *
-     * @returns Validation report with errors, warnings, and summary
-     */
-    validateGraph(): Promise<ValidationReport>;
-    /**
-     * Get comprehensive statistics about the knowledge graph.
-     *
-     * Provides metrics including:
-     * - Total counts of entities and relations
-     * - Entity and relation type distributions
-     * - Oldest and newest entities/relations
-     * - Date ranges for entities and relations
-     *
-     * @returns Graph statistics object
-     */
-    getGraphStats(): Promise<GraphStats>;
-}
-//# sourceMappingURL=AnalyticsManager.d.ts.map

package/dist/features/AnalyticsManager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AnalyticsManager.d.ts","sourceRoot":"","sources":["../../src/features/AnalyticsManager.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAsC,MAAM,mBAAmB,CAAC;AAE1G;;GAEG;AACH,qBAAa,gBAAgB;IACf,OAAO,CAAC,OAAO;gBAAP,OAAO,EAAE,YAAY;IAEzC;;;;;;;;;;;;OAYG;IACG,aAAa,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAmIhD;;;;;;;;;;OAUG;IACG,aAAa,IAAI,OAAO,CAAC,UAAU,CAAC;CAsE3C"}