@soulcraft/brainy 0.40.0 → 0.43.0

package/dist/storage/adapters/fileSystemStorage.js

@@ -0,0 +1,846 @@
+/**
+ * File System Storage Adapter
+ * File system storage adapter for Node.js environments
+ */
+import { BaseStorage, NOUNS_DIR, VERBS_DIR, METADATA_DIR, NOUN_METADATA_DIR, VERB_METADATA_DIR, INDEX_DIR, STATISTICS_KEY } from '../baseStorage.js';
+// Node.js modules - dynamically imported to avoid issues in browser environments
+let fs;
+let path;
+let moduleLoadingPromise = null;
+// Try to load Node.js modules
+try {
+    // Using dynamic imports to avoid issues in browser environments
+    const fsPromise = import('fs');
+    const pathPromise = import('path');
+    moduleLoadingPromise = Promise.all([fsPromise, pathPromise])
+        .then(([fsModule, pathModule]) => {
+        fs = fsModule;
+        path = pathModule.default;
+    })
+        .catch((error) => {
+        console.error('Failed to load Node.js modules:', error);
+        throw error;
+    });
+}
+catch (error) {
+    console.error('FileSystemStorage: Failed to load Node.js modules. This adapter is not supported in this environment.', error);
+}
+/**
+ * File system storage adapter for Node.js environments
+ * Uses the file system to store data in the specified directory structure
+ */
+export class FileSystemStorage extends BaseStorage {
+    /**
+     * Initialize the storage adapter
+     * @param rootDirectory The root directory for storage
+     */
+    constructor(rootDirectory) {
+        super();
+        this.activeLocks = new Set();
+        this.rootDir = rootDirectory;
+        // Defer path operations until init() when path module is guaranteed to be loaded
+    }
+    /**
+     * Initialize the storage adapter
+     */
+    async init() {
+        if (this.isInitialized) {
+            return;
+        }
+        // Wait for module loading to complete
+        if (moduleLoadingPromise) {
+            try {
+                await moduleLoadingPromise;
+            }
+            catch (error) {
+                throw new Error('FileSystemStorage requires a Node.js environment, but `fs` and `path` modules could not be loaded.');
+            }
+        }
+        // Check if Node.js modules are available
+        if (!fs || !path) {
+            throw new Error('FileSystemStorage requires a Node.js environment, but `fs` and `path` modules could not be loaded.');
+        }
+        try {
+            // Initialize directory paths now that path module is loaded
+            this.nounsDir = path.join(this.rootDir, NOUNS_DIR);
+            this.verbsDir = path.join(this.rootDir, VERBS_DIR);
+            this.metadataDir = path.join(this.rootDir, METADATA_DIR);
+            this.nounMetadataDir = path.join(this.rootDir, NOUN_METADATA_DIR);
+            this.verbMetadataDir = path.join(this.rootDir, VERB_METADATA_DIR);
+            this.indexDir = path.join(this.rootDir, INDEX_DIR);
+            this.lockDir = path.join(this.rootDir, 'locks');
+            // Create the root directory if it doesn't exist
+            await this.ensureDirectoryExists(this.rootDir);
+            // Create the nouns directory if it doesn't exist
+            await this.ensureDirectoryExists(this.nounsDir);
+            // Create the verbs directory if it doesn't exist
+            await this.ensureDirectoryExists(this.verbsDir);
+            // Create the metadata directory if it doesn't exist
+            await this.ensureDirectoryExists(this.metadataDir);
+            // Create the noun metadata directory if it doesn't exist
+            await this.ensureDirectoryExists(this.nounMetadataDir);
+            // Create the verb metadata directory if it doesn't exist
+            await this.ensureDirectoryExists(this.verbMetadataDir);
+            // Create the index directory if it doesn't exist
+            await this.ensureDirectoryExists(this.indexDir);
+            // Create the locks directory if it doesn't exist
+            await this.ensureDirectoryExists(this.lockDir);
+            this.isInitialized = true;
+        }
+        catch (error) {
+            console.error('Error initializing FileSystemStorage:', error);
+            throw error;
+        }
+    }
+    /**
+     * Ensure a directory exists, creating it if necessary
+     */
+    async ensureDirectoryExists(dirPath) {
+        try {
+            await fs.promises.mkdir(dirPath, { recursive: true });
+        }
+        catch (error) {
+            // Ignore EEXIST error, which means the directory already exists
+            if (error.code !== 'EEXIST') {
+                throw error;
+            }
+        }
+    }
+    /**
+     * Save a node to storage
+     */
+    async saveNode(node) {
+        await this.ensureInitialized();
+        // Convert connections Map to a serializable format
+        const serializableNode = {
+            ...node,
+            connections: this.mapToObject(node.connections, (set) => Array.from(set))
+        };
+        const filePath = path.join(this.nounsDir, `${node.id}.json`);
+        await fs.promises.writeFile(filePath, JSON.stringify(serializableNode, null, 2));
+    }
+    /**
+     * Get a node from storage
+     */
+    async getNode(id) {
+        await this.ensureInitialized();
+        const filePath = path.join(this.nounsDir, `${id}.json`);
+        try {
+            const data = await fs.promises.readFile(filePath, 'utf-8');
+            const parsedNode = JSON.parse(data);
+            // Convert serialized connections back to Map<number, Set<string>>
+            const connections = new Map();
+            for (const [level, nodeIds] of Object.entries(parsedNode.connections)) {
+                connections.set(Number(level), new Set(nodeIds));
+            }
+            return {
+                id: parsedNode.id,
+                vector: parsedNode.vector,
+                connections,
+                level: parsedNode.level || 0
+            };
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                console.error(`Error reading node ${id}:`, error);
+            }
+            return null;
+        }
+    }
+    /**
+     * Get all nodes from storage
+     */
+    async getAllNodes() {
+        await this.ensureInitialized();
+        const allNodes = [];
+        try {
+            const files = await fs.promises.readdir(this.nounsDir);
+            for (const file of files) {
+                if (file.endsWith('.json')) {
+                    const filePath = path.join(this.nounsDir, file);
+                    const data = await fs.promises.readFile(filePath, 'utf-8');
+                    const parsedNode = JSON.parse(data);
+                    // Convert serialized connections back to Map<number, Set<string>>
+                    const connections = new Map();
+                    for (const [level, nodeIds] of Object.entries(parsedNode.connections)) {
+                        connections.set(Number(level), new Set(nodeIds));
+                    }
+                    allNodes.push({
+                        id: parsedNode.id,
+                        vector: parsedNode.vector,
+                        connections,
+                        level: parsedNode.level || 0
+                    });
+                }
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                console.error(`Error reading directory ${this.nounsDir}:`, error);
+            }
+        }
+        return allNodes;
+    }
+    /**
+     * Get nodes by noun type
+     * @param nounType The noun type to filter by
+     * @returns Promise that resolves to an array of nodes of the specified noun type
+     */
+    async getNodesByNounType(nounType) {
+        await this.ensureInitialized();
+        const nouns = [];
+        try {
+            const files = await fs.promises.readdir(this.nounsDir);
+            for (const file of files) {
+                if (file.endsWith('.json')) {
+                    const filePath = path.join(this.nounsDir, file);
+                    const data = await fs.promises.readFile(filePath, 'utf-8');
+                    const parsedNode = JSON.parse(data);
+                    // Filter by noun type using metadata
+                    const nodeId = parsedNode.id;
+                    const metadata = await this.getMetadata(nodeId);
+                    if (metadata && metadata.noun === nounType) {
+                        // Convert serialized connections back to Map<number, Set<string>>
+                        const connections = new Map();
+                        for (const [level, nodeIds] of Object.entries(parsedNode.connections)) {
+                            connections.set(Number(level), new Set(nodeIds));
+                        }
+                        nouns.push({
+                            id: parsedNode.id,
+                            vector: parsedNode.vector,
+                            connections,
+                            level: parsedNode.level || 0
+                        });
+                    }
+                }
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                console.error(`Error reading directory ${this.nounsDir}:`, error);
+            }
+        }
+        return nouns;
+    }
+    /**
+     * Delete a node from storage
+     */
+    async deleteNode(id) {
+        await this.ensureInitialized();
+        const filePath = path.join(this.nounsDir, `${id}.json`);
+        try {
+            await fs.promises.unlink(filePath);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                console.error(`Error deleting node file ${filePath}:`, error);
+                throw error;
+            }
+        }
+    }
+    /**
+     * Save an edge to storage
+     */
+    async saveEdge(edge) {
+        await this.ensureInitialized();
+        // Convert connections Map to a serializable format
+        const serializableEdge = {
+            ...edge,
+            connections: this.mapToObject(edge.connections, (set) => Array.from(set))
+        };
+        const filePath = path.join(this.verbsDir, `${edge.id}.json`);
+        await fs.promises.writeFile(filePath, JSON.stringify(serializableEdge, null, 2));
+    }
+    /**
+     * Get an edge from storage
+     */
+    async getEdge(id) {
+        await this.ensureInitialized();
+        const filePath = path.join(this.verbsDir, `${id}.json`);
+        try {
+            const data = await fs.promises.readFile(filePath, 'utf-8');
+            const parsedEdge = JSON.parse(data);
+            // Convert serialized connections back to Map<number, Set<string>>
+            const connections = new Map();
+            for (const [level, nodeIds] of Object.entries(parsedEdge.connections)) {
+                connections.set(Number(level), new Set(nodeIds));
+            }
+            return {
+                id: parsedEdge.id,
+                vector: parsedEdge.vector,
+                connections
+            };
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                console.error(`Error reading edge ${id}:`, error);
+            }
+            return null;
+        }
+    }
+    /**
+     * Get all edges from storage
+     */
+    async getAllEdges() {
+        await this.ensureInitialized();
+        const allEdges = [];
+        try {
+            const files = await fs.promises.readdir(this.verbsDir);
+            for (const file of files) {
+                if (file.endsWith('.json')) {
+                    const filePath = path.join(this.verbsDir, file);
+                    const data = await fs.promises.readFile(filePath, 'utf-8');
+                    const parsedEdge = JSON.parse(data);
+                    // Convert serialized connections back to Map<number, Set<string>>
+                    const connections = new Map();
+                    for (const [level, nodeIds] of Object.entries(parsedEdge.connections)) {
+                        connections.set(Number(level), new Set(nodeIds));
+                    }
+                    allEdges.push({
+                        id: parsedEdge.id,
+                        vector: parsedEdge.vector,
+                        connections
+                    });
+                }
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                console.error(`Error reading directory ${this.verbsDir}:`, error);
+            }
+        }
+        return allEdges;
+    }
+    /**
+     * Get edges by source
+     */
+    async getEdgesBySource(sourceId) {
+        // This method is deprecated and would require loading metadata for each edge
+        // For now, return empty array since this is not efficiently implementable with new storage pattern
+        console.warn('getEdgesBySource is deprecated and not efficiently supported in new storage pattern');
+        return [];
+    }
+    /**
+     * Get edges by target
+     */
+    async getEdgesByTarget(targetId) {
+        // This method is deprecated and would require loading metadata for each edge
+        // For now, return empty array since this is not efficiently implementable with new storage pattern
+        console.warn('getEdgesByTarget is deprecated and not efficiently supported in new storage pattern');
+        return [];
+    }
+    /**
+     * Get edges by type
+     */
+    async getEdgesByType(type) {
+        // This method is deprecated and would require loading metadata for each edge
+        // For now, return empty array since this is not efficiently implementable with new storage pattern
+        console.warn('getEdgesByType is deprecated and not efficiently supported in new storage pattern');
+        return [];
+    }
+    /**
+     * Delete an edge from storage
+     */
+    async deleteEdge(id) {
+        await this.ensureInitialized();
+        const filePath = path.join(this.verbsDir, `${id}.json`);
+        try {
+            await fs.promises.unlink(filePath);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                console.error(`Error deleting edge file ${filePath}:`, error);
+                throw error;
+            }
+        }
+    }
+    /**
+     * Save metadata to storage
+     */
+    async saveMetadata(id, metadata) {
+        await this.ensureInitialized();
+        const filePath = path.join(this.metadataDir, `${id}.json`);
+        await fs.promises.writeFile(filePath, JSON.stringify(metadata, null, 2));
+    }
+    /**
+     * Get metadata from storage
+     */
+    async getMetadata(id) {
+        await this.ensureInitialized();
+        const filePath = path.join(this.metadataDir, `${id}.json`);
+        try {
+            const data = await fs.promises.readFile(filePath, 'utf-8');
+            return JSON.parse(data);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                console.error(`Error reading metadata ${id}:`, error);
+            }
+            return null;
+        }
+    }
+    /**
+     * Save noun metadata to storage
+     */
+    async saveNounMetadata(id, metadata) {
+        await this.ensureInitialized();
+        const filePath = path.join(this.nounMetadataDir, `${id}.json`);
+        await fs.promises.writeFile(filePath, JSON.stringify(metadata, null, 2));
+    }
+    /**
+     * Get noun metadata from storage
+     */
+    async getNounMetadata(id) {
+        await this.ensureInitialized();
+        const filePath = path.join(this.nounMetadataDir, `${id}.json`);
+        try {
+            const data = await fs.promises.readFile(filePath, 'utf-8');
+            return JSON.parse(data);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                console.error(`Error reading noun metadata ${id}:`, error);
+            }
+            return null;
+        }
+    }
+    /**
+     * Save verb metadata to storage
+     */
+    async saveVerbMetadata(id, metadata) {
+        await this.ensureInitialized();
+        const filePath = path.join(this.verbMetadataDir, `${id}.json`);
+        await fs.promises.writeFile(filePath, JSON.stringify(metadata, null, 2));
+    }
+    /**
+     * Get verb metadata from storage
+     */
+    async getVerbMetadata(id) {
+        await this.ensureInitialized();
+        const filePath = path.join(this.verbMetadataDir, `${id}.json`);
+        try {
+            const data = await fs.promises.readFile(filePath, 'utf-8');
+            return JSON.parse(data);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                console.error(`Error reading verb metadata ${id}:`, error);
+            }
+            return null;
+        }
+    }
+    /**
+     * Clear all data from storage
+     */
+    async clear() {
+        await this.ensureInitialized();
+        // Check if fs module is available
+        if (!fs || !fs.promises) {
+            console.warn('FileSystemStorage.clear: fs module not available, skipping clear operation');
+            return;
+        }
+        // Helper function to remove all files in a directory
+        const removeDirectoryContents = async (dirPath) => {
+            try {
+                const files = await fs.promises.readdir(dirPath);
+                for (const file of files) {
+                    const filePath = path.join(dirPath, file);
+                    const stats = await fs.promises.stat(filePath);
+                    if (stats.isDirectory()) {
+                        await removeDirectoryContents(filePath);
+                        await fs.promises.rmdir(filePath);
+                    }
+                    else {
+                        await fs.promises.unlink(filePath);
+                    }
+                }
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT') {
+                    console.error(`Error removing directory contents ${dirPath}:`, error);
+                    throw error;
+                }
+            }
+        };
+        // Remove all files in the nouns directory
+        await removeDirectoryContents(this.nounsDir);
+        // Remove all files in the verbs directory
+        await removeDirectoryContents(this.verbsDir);
+        // Remove all files in the metadata directory
+        await removeDirectoryContents(this.metadataDir);
+        // Remove all files in the noun metadata directory
+        await removeDirectoryContents(this.nounMetadataDir);
+        // Remove all files in the verb metadata directory
+        await removeDirectoryContents(this.verbMetadataDir);
+        // Remove all files in the index directory
+        await removeDirectoryContents(this.indexDir);
+        // Clear the statistics cache
+        this.statisticsCache = null;
+        this.statisticsModified = false;
+    }
+    /**
+     * Get information about storage usage and capacity
+     */
+    async getStorageStatus() {
+        await this.ensureInitialized();
+        // Check if fs module is available
+        if (!fs || !fs.promises) {
+            console.warn('FileSystemStorage.getStorageStatus: fs module not available, returning default values');
+            return {
+                type: 'filesystem',
+                used: 0,
+                quota: null,
+                details: {
+                    nounsCount: 0,
+                    verbsCount: 0,
+                    metadataCount: 0,
+                    directorySizes: {
+                        nouns: 0,
+                        verbs: 0,
+                        metadata: 0,
+                        index: 0
+                    }
+                }
+            };
+        }
+        try {
+            // Calculate the total size of all files in the storage directories
+            let totalSize = 0;
+            // Helper function to calculate directory size
+            const calculateSize = async (dirPath) => {
+                let size = 0;
+                try {
+                    const files = await fs.promises.readdir(dirPath);
+                    for (const file of files) {
+                        const filePath = path.join(dirPath, file);
+                        const stats = await fs.promises.stat(filePath);
+                        if (stats.isDirectory()) {
+                            size += await calculateSize(filePath);
+                        }
+                        else {
+                            size += stats.size;
+                        }
+                    }
+                }
+                catch (error) {
+                    if (error.code !== 'ENOENT') {
+                        console.error(`Error calculating size for directory ${dirPath}:`, error);
+                    }
+                }
+                return size;
+            };
+            // Calculate size for each directory
+            const nounsDirSize = await calculateSize(this.nounsDir);
+            const verbsDirSize = await calculateSize(this.verbsDir);
+            const metadataDirSize = await calculateSize(this.metadataDir);
+            const indexDirSize = await calculateSize(this.indexDir);
+            totalSize = nounsDirSize + verbsDirSize + metadataDirSize + indexDirSize;
+            // Count files in each directory
+            const nounsCount = (await fs.promises.readdir(this.nounsDir)).filter((file) => file.endsWith('.json')).length;
+            const verbsCount = (await fs.promises.readdir(this.verbsDir)).filter((file) => file.endsWith('.json')).length;
+            const metadataCount = (await fs.promises.readdir(this.metadataDir)).filter((file) => file.endsWith('.json')).length;
+            // Count nouns by type using metadata
+            const nounTypeCounts = {};
+            const metadataFiles = await fs.promises.readdir(this.metadataDir);
+            for (const file of metadataFiles) {
+                if (file.endsWith('.json')) {
+                    try {
+                        const filePath = path.join(this.metadataDir, file);
+                        const data = await fs.promises.readFile(filePath, 'utf-8');
+                        const metadata = JSON.parse(data);
+                        if (metadata.noun) {
+                            nounTypeCounts[metadata.noun] =
+                                (nounTypeCounts[metadata.noun] || 0) + 1;
+                        }
+                    }
+                    catch (error) {
+                        console.error(`Error reading metadata file ${file}:`, error);
+                    }
+                }
+            }
+            return {
+                type: 'filesystem',
+                used: totalSize,
+                quota: null, // File system doesn't provide quota information
+                details: {
+                    rootDirectory: this.rootDir,
+                    nounsCount,
+                    verbsCount,
+                    metadataCount,
+                    nounsDirSize,
+                    verbsDirSize,
+                    metadataDirSize,
+                    indexDirSize,
+                    nounTypes: nounTypeCounts
+                }
+            };
+        }
+        catch (error) {
+            console.error('Failed to get storage status:', error);
+            return {
+                type: 'filesystem',
+                used: 0,
+                quota: null,
+                details: { error: String(error) }
+            };
+        }
+    }
+    /**
+     * Implementation of abstract methods from BaseStorage
+     */
+    /**
+     * Save a noun to storage
+     */
+    async saveNoun_internal(noun) {
+        return this.saveNode(noun);
+    }
+    /**
+     * Get a noun from storage
+     */
+    async getNoun_internal(id) {
+        return this.getNode(id);
+    }
+    /**
+     * Get all nouns from storage
+     */
+    async getAllNouns_internal() {
+        return this.getAllNodes();
+    }
+    /**
+     * Get nouns by noun type
+     */
+    async getNounsByNounType_internal(nounType) {
+        return this.getNodesByNounType(nounType);
+    }
+    /**
+     * Delete a noun from storage
+     */
+    async deleteNoun_internal(id) {
+        return this.deleteNode(id);
+    }
+    /**
+     * Save a verb to storage
+     */
+    async saveVerb_internal(verb) {
+        return this.saveEdge(verb);
+    }
+    /**
+     * Get a verb from storage
+     */
+    async getVerb_internal(id) {
+        return this.getEdge(id);
+    }
+    /**
+     * Get all verbs from storage
+     */
+    async getAllVerbs_internal() {
+        return this.getAllEdges();
+    }
+    /**
+     * Get verbs by source
+     */
+    async getVerbsBySource_internal(sourceId) {
+        // This method is deprecated and would require loading metadata for each edge
+        // For now, return empty array since this is not efficiently implementable with new storage pattern
+        console.warn('getVerbsBySource_internal is deprecated and not efficiently supported in new storage pattern');
+        return [];
+    }
+    /**
+     * Get verbs by target
+     */
+    async getVerbsByTarget_internal(targetId) {
+        // This method is deprecated and would require loading metadata for each edge
+        // For now, return empty array since this is not efficiently implementable with new storage pattern
+        console.warn('getVerbsByTarget_internal is deprecated and not efficiently supported in new storage pattern');
+        return [];
+    }
+    /**
+     * Get verbs by type
+     */
+    async getVerbsByType_internal(type) {
+        // This method is deprecated and would require loading metadata for each edge
+        // For now, return empty array since this is not efficiently implementable with new storage pattern
+        console.warn('getVerbsByType_internal is deprecated and not efficiently supported in new storage pattern');
+        return [];
+    }
+    /**
+     * Delete a verb from storage
+     */
+    async deleteVerb_internal(id) {
+        return this.deleteEdge(id);
+    }
+    /**
+     * Acquire a file-based lock for coordinating operations across multiple processes
+     * @param lockKey The key to lock on
+     * @param ttl Time to live for the lock in milliseconds (default: 30 seconds)
+     * @returns Promise that resolves to true if lock was acquired, false otherwise
+     */
+    async acquireLock(lockKey, ttl = 30000) {
+        await this.ensureInitialized();
+        const lockFile = path.join(this.lockDir, `${lockKey}.lock`);
+        const lockValue = `${Date.now()}_${Math.random()}_${process.pid || 'unknown'}`;
+        const expiresAt = Date.now() + ttl;
+        try {
+            // Check if lock file already exists and is still valid
+            try {
+                const lockData = await fs.promises.readFile(lockFile, 'utf-8');
+                const lockInfo = JSON.parse(lockData);
+                if (lockInfo.expiresAt > Date.now()) {
+                    // Lock exists and is still valid
+                    return false;
+                }
+            }
+            catch (error) {
+                // If file doesn't exist or can't be read, we can proceed to create the lock
+                if (error.code !== 'ENOENT') {
+                    console.warn(`Error reading lock file ${lockFile}:`, error);
+                }
+            }
+            // Try to create the lock file
+            const lockInfo = {
+                lockValue,
+                expiresAt,
+                pid: process.pid || 'unknown',
+                timestamp: Date.now()
+            };
+            await fs.promises.writeFile(lockFile, JSON.stringify(lockInfo, null, 2));
+            // Add to active locks for cleanup
+            this.activeLocks.add(lockKey);
+            // Schedule automatic cleanup when lock expires
+            setTimeout(() => {
+                this.releaseLock(lockKey, lockValue).catch((error) => {
+                    console.warn(`Failed to auto-release expired lock ${lockKey}:`, error);
+                });
+            }, ttl);
+            return true;
+        }
+        catch (error) {
+            console.warn(`Failed to acquire lock ${lockKey}:`, error);
+            return false;
+        }
+    }
+    /**
+     * Release a file-based lock
+     * @param lockKey The key to unlock
+     * @param lockValue The value used when acquiring the lock (for verification)
+     * @returns Promise that resolves when lock is released
+     */
+    async releaseLock(lockKey, lockValue) {
+        await this.ensureInitialized();
+        const lockFile = path.join(this.lockDir, `${lockKey}.lock`);
+        try {
+            // If lockValue is provided, verify it matches before releasing
+            if (lockValue) {
+                try {
+                    const lockData = await fs.promises.readFile(lockFile, 'utf-8');
+                    const lockInfo = JSON.parse(lockData);
+                    if (lockInfo.lockValue !== lockValue) {
+                        // Lock was acquired by someone else, don't release it
+                        return;
+                    }
+                }
+                catch (error) {
+                    // If lock file doesn't exist, that's fine
+                    if (error.code === 'ENOENT') {
+                        return;
+                    }
+                    throw error;
+                }
+            }
+            // Delete the lock file
+            await fs.promises.unlink(lockFile);
+            // Remove from active locks
+            this.activeLocks.delete(lockKey);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                console.warn(`Failed to release lock ${lockKey}:`, error);
+            }
+        }
+    }
+    /**
+     * Clean up expired lock files
+     */
+    async cleanupExpiredLocks() {
+        await this.ensureInitialized();
+        try {
+            const lockFiles = await fs.promises.readdir(this.lockDir);
+            const now = Date.now();
+            for (const lockFile of lockFiles) {
+                if (!lockFile.endsWith('.lock'))
+                    continue;
+                const lockPath = path.join(this.lockDir, lockFile);
+                try {
+                    const lockData = await fs.promises.readFile(lockPath, 'utf-8');
+                    const lockInfo = JSON.parse(lockData);
+                    if (lockInfo.expiresAt <= now) {
+                        await fs.promises.unlink(lockPath);
+                        const lockKey = lockFile.replace('.lock', '');
+                        this.activeLocks.delete(lockKey);
+                    }
+                }
+                catch (error) {
+                    // If we can't read or parse the lock file, remove it
+                    try {
+                        await fs.promises.unlink(lockPath);
+                    }
+                    catch (unlinkError) {
+                        console.warn(`Failed to cleanup invalid lock file ${lockPath}:`, unlinkError);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.warn('Failed to cleanup expired locks:', error);
+        }
+    }
+    /**
+     * Save statistics data to storage with file-based locking
+     */
+    async saveStatisticsData(statistics) {
+        const lockKey = 'statistics';
+        const lockAcquired = await this.acquireLock(lockKey, 10000); // 10 second timeout
+        if (!lockAcquired) {
+            console.warn('Failed to acquire lock for statistics update, proceeding without lock');
+        }
+        try {
+            // Get existing statistics to merge with new data
+            const existingStats = (await this.getMetadata(STATISTICS_KEY));
+            if (existingStats) {
+                // Merge statistics data
+                const mergedStats = {
+                    totalNodes: Math.max(statistics.totalNodes || 0, existingStats.totalNodes || 0),
+                    totalEdges: Math.max(statistics.totalEdges || 0, existingStats.totalEdges || 0),
+                    totalMetadata: Math.max(statistics.totalMetadata || 0, existingStats.totalMetadata || 0),
+                    // Preserve any additional fields from existing stats
+                    ...existingStats,
+                    // Override with new values where provided
+                    ...statistics,
+                    // Always update lastUpdated to current time
+                    lastUpdated: new Date().toISOString()
+                };
+                await this.saveMetadata(STATISTICS_KEY, mergedStats);
+            }
+            else {
+                // No existing statistics, save new ones
+                const newStats = {
+                    ...statistics,
+                    lastUpdated: new Date().toISOString()
+                };
+                await this.saveMetadata(STATISTICS_KEY, newStats);
+            }
+        }
+        finally {
+            if (lockAcquired) {
+                await this.releaseLock(lockKey);
+            }
+        }
+    }
+    /**
+     * Get statistics data from storage
+     */
+    async getStatisticsData() {
+        return this.getMetadata(STATISTICS_KEY);
+    }
+}
+//# sourceMappingURL=fileSystemStorage.js.map