@danielsimonjr/memory-mcp 0.47.1 → 9.8.0

package/dist/core/StorageFactory.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Storage Factory
+ *
+ * Factory for creating IGraphStorage implementations.
+ * Supports different storage backends based on configuration.
+ *
+ * Supported storage types:
+ * - 'jsonl': JSONL file-based storage (default) - simple, human-readable
+ * - 'sqlite': SQLite database storage (better-sqlite3 native) - indexed, ACID transactions, FTS5
+ *
+ * @module core/StorageFactory
+ */
+import type { IGraphStorage, StorageConfig } from '../types/index.js';
+/**
+ * Create a storage instance based on configuration.
+ *
+ * Uses environment variable MEMORY_STORAGE_TYPE to override default.
+ *
+ * @param config - Storage configuration
+ * @returns IGraphStorage implementation
+ * @throws Error if storage type is not supported
+ *
+ * @example
+ * ```typescript
+ * // Create default JSONL storage
+ * const storage = createStorage({ type: 'jsonl', path: './memory.jsonl' });
+ *
+ * // Create SQLite storage
+ * const storage = createStorage({ type: 'sqlite', path: './memory.db' });
+ *
+ * // Or use path-only shorthand (uses MEMORY_STORAGE_TYPE env var or defaults to jsonl)
+ * const storage = createStorageFromPath('./memory.jsonl');
+ * ```
+ */
+export declare function createStorage(config: StorageConfig): IGraphStorage;
+/**
+ * Create a storage instance from a file path.
+ *
+ * Uses default storage type (jsonl) or MEMORY_STORAGE_TYPE env var.
+ *
+ * @param path - Path to storage file
+ * @returns IGraphStorage implementation
+ */
+export declare function createStorageFromPath(path: string): IGraphStorage;
+//# sourceMappingURL=StorageFactory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StorageFactory.d.ts","sourceRoot":"","sources":["../../src/core/StorageFactory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAOtE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,aAAa,GAAG,aAAa,CAiBlE;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,CAGjE"}

package/dist/core/StorageFactory.js

@@ -0,0 +1,64 @@
+/**
+ * Storage Factory
+ *
+ * Factory for creating IGraphStorage implementations.
+ * Supports different storage backends based on configuration.
+ *
+ * Supported storage types:
+ * - 'jsonl': JSONL file-based storage (default) - simple, human-readable
+ * - 'sqlite': SQLite database storage (better-sqlite3 native) - indexed, ACID transactions, FTS5
+ *
+ * @module core/StorageFactory
+ */
+import { GraphStorage } from './GraphStorage.js';
+import { SQLiteStorage } from './SQLiteStorage.js';
+/**
+ * Default storage type when not specified.
+ */
+const DEFAULT_STORAGE_TYPE = 'jsonl';
+/**
+ * Create a storage instance based on configuration.
+ *
+ * Uses environment variable MEMORY_STORAGE_TYPE to override default.
+ *
+ * @param config - Storage configuration
+ * @returns IGraphStorage implementation
+ * @throws Error if storage type is not supported
+ *
+ * @example
+ * ```typescript
+ * // Create default JSONL storage
+ * const storage = createStorage({ type: 'jsonl', path: './memory.jsonl' });
+ *
+ * // Create SQLite storage
+ * const storage = createStorage({ type: 'sqlite', path: './memory.db' });
+ *
+ * // Or use path-only shorthand (uses MEMORY_STORAGE_TYPE env var or defaults to jsonl)
+ * const storage = createStorageFromPath('./memory.jsonl');
+ * ```
+ */
+export function createStorage(config) {
+    // Allow environment override
+    const storageType = process.env.MEMORY_STORAGE_TYPE || config.type || DEFAULT_STORAGE_TYPE;
+    switch (storageType) {
+        case 'jsonl':
+            return new GraphStorage(config.path);
+        case 'sqlite':
+            return new SQLiteStorage(config.path);
+        default:
+            throw new Error(`Unknown storage type: ${storageType}. ` +
+                `Supported types: jsonl, sqlite`);
+    }
+}
+/**
+ * Create a storage instance from a file path.
+ *
+ * Uses default storage type (jsonl) or MEMORY_STORAGE_TYPE env var.
+ *
+ * @param path - Path to storage file
+ * @returns IGraphStorage implementation
+ */
+export function createStorageFromPath(path) {
+    const storageType = process.env.MEMORY_STORAGE_TYPE || DEFAULT_STORAGE_TYPE;
+    return createStorage({ type: storageType, path });
+}

package/dist/core/TransactionManager.d.ts

@@ -0,0 +1,464 @@
+/**
+ * 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 type { Entity, Relation, LongRunningOperationOptions, BatchOperation, BatchResult, BatchOptions } from '../types/index.js';
+import type { GraphStorage } from './GraphStorage.js';
+/**
+ * Types of operations that can be performed in a transaction.
+ */
+export declare enum OperationType {
+    CREATE_ENTITY = "CREATE_ENTITY",
+    UPDATE_ENTITY = "UPDATE_ENTITY",
+    DELETE_ENTITY = "DELETE_ENTITY",
+    CREATE_RELATION = "CREATE_RELATION",
+    DELETE_RELATION = "DELETE_RELATION"
+}
+/**
+ * Represents a single operation in a transaction using discriminated union.
+ */
+export type TransactionOperation = {
+    type: OperationType.CREATE_ENTITY;
+    data: Omit<Entity, 'createdAt' | 'lastModified'>;
+} | {
+    type: OperationType.UPDATE_ENTITY;
+    data: {
+        name: string;
+        updates: Partial<Entity>;
+    };
+} | {
+    type: OperationType.DELETE_ENTITY;
+    data: {
+        name: string;
+    };
+} | {
+    type: OperationType.CREATE_RELATION;
+    data: Omit<Relation, 'createdAt' | 'lastModified'>;
+} | {
+    type: OperationType.DELETE_RELATION;
+    data: {
+        from: string;
+        to: string;
+        relationType: string;
+    };
+};
+/**
+ * Transaction execution result.
+ */
+export interface TransactionResult {
+    /** Whether the transaction was successful */
+    success: boolean;
+    /** Number of operations executed */
+    operationsExecuted: number;
+    /** Error message if transaction failed */
+    error?: string;
+    /** Path to rollback backup if created */
+    rollbackBackup?: string;
+}
+/**
+ * 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 declare class TransactionManager {
+    private storage;
+    private operations;
+    private inTransaction;
+    private ioManager;
+    private transactionBackup?;
+    constructor(storage: GraphStorage);
+    /**
+     * 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(): void;
+    /**
+     * 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: Omit<Entity, 'createdAt' | 'lastModified'>): void;
+    /**
+     * 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: string, updates: Partial<Entity>): void;
+    /**
+     * Stage a delete entity operation.
+     *
+     * @param name - Name of entity to delete
+     *
+     * @example
+     * ```typescript
+     * txManager.begin();
+     * txManager.deleteEntity('OldEntity');
+     * ```
+     */
+    deleteEntity(name: string): void;
+    /**
+     * 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: Omit<Relation, 'createdAt' | 'lastModified'>): void;
+    /**
+     * 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: string, to: string, relationType: string): void;
+    /**
+     * 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.
+     *
+     * Phase 9B: Supports progress tracking and cancellation via LongRunningOperationOptions.
+     *
+     * @param options - Optional progress/cancellation options (Phase 9B)
+     * @returns Promise resolving to transaction result
+     * @throws {OperationCancelledError} If operation is cancelled via signal (Phase 9B)
+     *
+     * @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}`);
+     * }
+     *
+     * // With progress tracking (Phase 9B)
+     * const result = await txManager.commit({
+     *   onProgress: (p) => console.log(`${p.percentage}% complete`),
+     * });
+     * ```
+     */
+    commit(options?: LongRunningOperationOptions): Promise<TransactionResult>;
+    /**
+     * 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}`);
+     * ```
+     */
+    rollback(): Promise<{
+        success: boolean;
+        backupUsed?: string;
+    }>;
+    /**
+     * Check if a transaction is currently in progress.
+     *
+     * @returns True if transaction is active
+     */
+    isInTransaction(): boolean;
+    /**
+     * Get the number of staged operations in the current transaction.
+     *
+     * @returns Number of operations staged
+     */
+    getOperationCount(): number;
+    /**
+     * Ensure a transaction is in progress, or throw an error.
+     *
+     * @private
+     */
+    private ensureInTransaction;
+    /**
+     * Apply a single operation to the graph.
+     *
+     * @private
+     */
+    private applyOperation;
+}
+/**
+ * Phase 10 Sprint 1: Fluent API for building and executing batch transactions.
+ *
+ * BatchTransaction provides a builder pattern for accumulating multiple
+ * graph operations and executing them atomically in a single transaction.
+ * This reduces I/O overhead and ensures consistency across related changes.
+ *
+ * @example
+ * ```typescript
+ * const storage = new GraphStorage('/data/memory.jsonl');
+ * const batch = new BatchTransaction(storage);
+ *
+ * // Build the batch with fluent API
+ * const result = await batch
+ *   .createEntity({ name: 'Alice', entityType: 'person', observations: ['Developer'] })
+ *   .createEntity({ name: 'Bob', entityType: 'person', observations: ['Designer'] })
+ *   .createRelation({ from: 'Alice', to: 'Bob', relationType: 'knows' })
+ *   .updateEntity('Alice', { importance: 8 })
+ *   .execute();
+ *
+ * if (result.success) {
+ *   console.log(`Batch completed: ${result.operationsExecuted} operations in ${result.executionTimeMs}ms`);
+ * }
+ * ```
+ */
+export declare class BatchTransaction {
+    private operations;
+    private storage;
+    /**
+     * Create a new BatchTransaction instance.
+     *
+     * @param storage - GraphStorage instance to execute operations against
+     */
+    constructor(storage: GraphStorage);
+    /**
+     * Add a create entity operation to the batch.
+     *
+     * @param entity - Entity to create (without timestamps)
+     * @returns This BatchTransaction for chaining
+     *
+     * @example
+     * ```typescript
+     * batch.createEntity({
+     *   name: 'Alice',
+     *   entityType: 'person',
+     *   observations: ['Software engineer'],
+     *   importance: 8
+     * });
+     * ```
+     */
+    createEntity(entity: Omit<Entity, 'createdAt' | 'lastModified'>): this;
+    /**
+     * Add an update entity operation to the batch.
+     *
+     * @param name - Name of entity to update
+     * @param updates - Partial entity updates
+     * @returns This BatchTransaction for chaining
+     *
+     * @example
+     * ```typescript
+     * batch.updateEntity('Alice', { importance: 9 });
+     * ```
+     */
+    updateEntity(name: string, updates: Partial<Entity>): this;
+    /**
+     * Add a delete entity operation to the batch.
+     *
+     * @param name - Name of entity to delete
+     * @returns This BatchTransaction for chaining
+     *
+     * @example
+     * ```typescript
+     * batch.deleteEntity('OldEntity');
+     * ```
+     */
+    deleteEntity(name: string): this;
+    /**
+     * Add a create relation operation to the batch.
+     *
+     * @param relation - Relation to create (without timestamps)
+     * @returns This BatchTransaction for chaining
+     *
+     * @example
+     * ```typescript
+     * batch.createRelation({
+     *   from: 'Alice',
+     *   to: 'Bob',
+     *   relationType: 'mentors'
+     * });
+     * ```
+     */
+    createRelation(relation: Omit<Relation, 'createdAt' | 'lastModified'>): this;
+    /**
+     * Add a delete relation operation to the batch.
+     *
+     * @param from - Source entity name
+     * @param to - Target entity name
+     * @param relationType - Type of relation
+     * @returns This BatchTransaction for chaining
+     *
+     * @example
+     * ```typescript
+     * batch.deleteRelation('Alice', 'Bob', 'mentors');
+     * ```
+     */
+    deleteRelation(from: string, to: string, relationType: string): this;
+    /**
+     * Add observations to an existing entity.
+     *
+     * @param name - Name of entity to add observations to
+     * @param observations - Observations to add
+     * @returns This BatchTransaction for chaining
+     *
+     * @example
+     * ```typescript
+     * batch.addObservations('Alice', ['Knows TypeScript', 'Leads team']);
+     * ```
+     */
+    addObservations(name: string, observations: string[]): this;
+    /**
+     * Delete observations from an existing entity.
+     *
+     * @param name - Name of entity to delete observations from
+     * @param observations - Observations to delete
+     * @returns This BatchTransaction for chaining
+     *
+     * @example
+     * ```typescript
+     * batch.deleteObservations('Alice', ['Old fact']);
+     * ```
+     */
+    deleteObservations(name: string, observations: string[]): this;
+    /**
+     * Add multiple operations from an array.
+     *
+     * @param operations - Array of batch operations
+     * @returns This BatchTransaction for chaining
+     *
+     * @example
+     * ```typescript
+     * batch.addOperations([
+     *   { type: 'createEntity', data: { name: 'A', entityType: 'x', observations: [] } },
+     *   { type: 'createEntity', data: { name: 'B', entityType: 'x', observations: [] } }
+     * ]);
+     * ```
+     */
+    addOperations(operations: BatchOperation[]): this;
+    /**
+     * Get the number of operations in this batch.
+     *
+     * @returns Number of operations queued
+     */
+    size(): number;
+    /**
+     * Clear all operations from the batch.
+     *
+     * @returns This BatchTransaction for chaining
+     */
+    clear(): this;
+    /**
+     * Get a copy of the operations in this batch.
+     *
+     * @returns Array of batch operations
+     */
+    getOperations(): BatchOperation[];
+    /**
+     * Execute all operations in the batch atomically.
+     *
+     * All operations are applied within a single transaction. If any
+     * operation fails, all changes are rolled back (when stopOnError is true).
+     *
+     * @param options - Batch execution options
+     * @returns Promise resolving to batch result
+     *
+     * @example
+     * ```typescript
+     * const result = await batch.execute();
+     * if (result.success) {
+     *   console.log(`Created ${result.entitiesCreated} entities`);
+     * } else {
+     *   console.error(`Failed at operation ${result.failedOperationIndex}: ${result.error}`);
+     * }
+     * ```
+     */
+    execute(options?: BatchOptions): Promise<BatchResult>;
+    /**
+     * Validate all operations before executing.
+     * @private
+     */
+    private validateOperations;
+    /**
+     * Apply a single batch operation to the graph.
+     * @private
+     */
+    private applyBatchOperation;
+}
+//# sourceMappingURL=TransactionManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TransactionManager.d.ts","sourceRoot":"","sources":["../../src/core/TransactionManager.ts"],"names":[],"mappings":"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"}