@soulcraft/brainy 3.30.0 → 3.30.1

package/dist/storage/adapters/memoryStorage.js

@@ -9,15 +9,24 @@ import { BaseStorage } from '../baseStorage.js';
  * Uses Maps to store data in memory
  */
 export class MemoryStorage extends BaseStorage {
+    // Backward compatibility aliases
+    get metadata() {
+        return this.objectStore;
+    }
+    get nounMetadata() {
+        return this.objectStore;
+    }
+    get verbMetadata() {
+        return this.objectStore;
+    }
     constructor() {
         super();
         // Single map of noun ID to noun
         this.nouns = new Map();
         this.verbs = new Map();
-        this.metadata = new Map();
-        this.nounMetadata = new Map();
-        this.verbMetadata = new Map();
         this.statistics = null;
+        // Unified object store for primitive operations (replaces metadata, nounMetadata, verbMetadata)
+        this.objectStore = new Map();
     }
     /**
      * Initialize the storage adapter
@@ -412,20 +421,43 @@ export class MemoryStorage extends BaseStorage {
         this.verbs.delete(id);
     }
     /**
-     * Save metadata to storage
+     * Primitive operation: Write object to path
+     * All metadata operations use this internally via base class routing
      */
-    async saveMetadata(id, metadata) {
-        this.metadata.set(id, JSON.parse(JSON.stringify(metadata)));
+    async writeObjectToPath(path, data) {
+        // Store in unified object store using path as key
+        this.objectStore.set(path, JSON.parse(JSON.stringify(data)));
     }
     /**
-     * Get metadata from storage
+     * Primitive operation: Read object from path
+     * All metadata operations use this internally via base class routing
      */
-    async getMetadata(id) {
-        const metadata = this.metadata.get(id);
-        if (!metadata) {
+    async readObjectFromPath(path) {
+        const data = this.objectStore.get(path);
+        if (!data) {
             return null;
         }
-        return JSON.parse(JSON.stringify(metadata));
+        return JSON.parse(JSON.stringify(data));
+    }
+    /**
+     * Primitive operation: Delete object from path
+     * All metadata operations use this internally via base class routing
+     */
+    async deleteObjectFromPath(path) {
+        this.objectStore.delete(path);
+    }
+    /**
+     * Primitive operation: List objects under path prefix
+     * All metadata operations use this internally via base class routing
+     */
+    async listObjectsUnderPath(prefix) {
+        const paths = [];
+        for (const key of this.objectStore.keys()) {
+            if (key.startsWith(prefix)) {
+                paths.push(key);
+            }
+        }
+        return paths.sort();
     }
     /**
      * Get multiple metadata objects in batches (CRITICAL: Prevents socket exhaustion)
@@ -435,61 +467,20 @@ export class MemoryStorage extends BaseStorage {
         const results = new Map();
         // Memory storage can handle all IDs at once since it's in-memory
         for (const id of ids) {
-            const metadata = this.metadata.get(id);
+            const metadata = await this.getMetadata(id);
             if (metadata) {
-                // Deep clone to prevent mutation
-                results.set(id, JSON.parse(JSON.stringify(metadata)));
+                results.set(id, metadata);
             }
         }
         return results;
     }
-    /**
-     * Save noun metadata to storage (internal implementation)
-     */
-    async saveNounMetadata_internal(id, metadata) {
-        this.nounMetadata.set(id, JSON.parse(JSON.stringify(metadata)));
-    }
-    /**
-     * Get noun metadata from storage
-     */
-    async getNounMetadata(id) {
-        const metadata = this.nounMetadata.get(id);
-        if (!metadata) {
-            return null;
-        }
-        return JSON.parse(JSON.stringify(metadata));
-    }
-    /**
-     * Save verb metadata to storage (internal implementation)
-     */
-    async saveVerbMetadata_internal(id, metadata) {
-        const isNew = !this.verbMetadata.has(id);
-        this.verbMetadata.set(id, JSON.parse(JSON.stringify(metadata)));
-        // Update counts for new verbs
-        if (isNew) {
-            const type = metadata?.verb || metadata?.type || 'default';
-            this.incrementVerbCount(type);
-        }
-    }
-    /**
-     * Get verb metadata from storage
-     */
-    async getVerbMetadata(id) {
-        const metadata = this.verbMetadata.get(id);
-        if (!metadata) {
-            return null;
-        }
-        return JSON.parse(JSON.stringify(metadata));
-    }
     /**
      * Clear all data from storage
      */
     async clear() {
         this.nouns.clear();
         this.verbs.clear();
-        this.metadata.clear();
-        this.nounMetadata.clear();
-        this.verbMetadata.clear();
+        this.objectStore.clear();
         this.statistics = null;
         // Clear the statistics cache
         this.statisticsCache = null;
@@ -506,7 +497,7 @@ export class MemoryStorage extends BaseStorage {
             details: {
                 nodeCount: this.nouns.size,
                 edgeCount: this.verbs.size,
-                metadataCount: this.metadata.size
+                metadataCount: this.objectStore.size
             }
         };
     }

package/dist/storage/adapters/opfsStorage.d.ts

@@ -129,34 +129,30 @@ export declare class OPFSStorage extends BaseStorage {
      */
     protected deleteEdge(id: string): Promise<void>;
     /**
-     * Save metadata to storage
+     * Primitive operation: Write object to path
+     * All metadata operations use this internally via base class routing
      */
-    saveMetadata(id: string, metadata: any): Promise<void>;
+    protected writeObjectToPath(path: string, data: any): Promise<void>;
     /**
-     * Get metadata from storage
+     * Primitive operation: Read object from path
+     * All metadata operations use this internally via base class routing
      */
-    getMetadata(id: string): Promise<any | null>;
+    protected readObjectFromPath(path: string): Promise<any | null>;
     /**
-     * Get multiple metadata objects in batches (CRITICAL: Prevents socket exhaustion)
-     * OPFS implementation uses controlled concurrency for file operations
-     */
-    getMetadataBatch(ids: string[]): Promise<Map<string, any>>;
-    /**
-     * Save verb metadata to storage
+     * Primitive operation: Delete object from path
+     * All metadata operations use this internally via base class routing
      */
-    protected saveVerbMetadata_internal(id: string, metadata: any): Promise<void>;
+    protected deleteObjectFromPath(path: string): Promise<void>;
     /**
-     * Get verb metadata from storage
+     * Primitive operation: List objects under path prefix
+     * All metadata operations use this internally via base class routing
      */
-    getVerbMetadata(id: string): Promise<any | null>;
+    protected listObjectsUnderPath(prefix: string): Promise<string[]>;
     /**
-     * Save noun metadata to storage
-     */
-    protected saveNounMetadata_internal(id: string, metadata: any): Promise<void>;
-    /**
-     * Get noun metadata from storage
+     * Get multiple metadata objects in batches (CRITICAL: Prevents socket exhaustion)
+     * OPFS implementation uses controlled concurrency for file operations
      */
-    getNounMetadata(id: string): Promise<any | null>;
+    getMetadataBatch(ids: string[]): Promise<Map<string, any>>;
     /**
      * Clear all data from storage
      */

package/dist/storage/adapters/opfsStorage.js

@@ -511,43 +511,132 @@ export class OPFSStorage extends BaseStorage {
         }
     }
     /**
-     * Save metadata to storage
+     * Primitive operation: Write object to path
+     * All metadata operations use this internally via base class routing
      */
-    async saveMetadata(id, metadata) {
+    async writeObjectToPath(path, data) {
         await this.ensureInitialized();
         try {
-            // Create or get the file for this metadata
-            const fileHandle = await this.metadataDir.getFileHandle(`${id}.json`, {
-                create: true
-            });
-            // Write the metadata to the file
+            // Parse path to get directory structure and filename
+            // Path format: "dir1/dir2/file.json"
+            const parts = path.split('/');
+            const filename = parts.pop();
+            // Navigate to the correct directory, creating as needed
+            let currentDir = this.rootDir;
+            for (const dirName of parts) {
+                currentDir = await currentDir.getDirectoryHandle(dirName, { create: true });
+            }
+            // Create or get the file
+            const fileHandle = await currentDir.getFileHandle(filename, { create: true });
+            // Write the data to the file
             const writable = await fileHandle.createWritable();
-            await writable.write(JSON.stringify(metadata));
+            await writable.write(JSON.stringify(data, null, 2));
             await writable.close();
         }
         catch (error) {
-            console.error(`Failed to save metadata ${id}:`, error);
-            throw new Error(`Failed to save metadata ${id}: ${error}`);
+            console.error(`Failed to write object to ${path}:`, error);
+            throw new Error(`Failed to write object to ${path}: ${error}`);
         }
     }
     /**
-     * Get metadata from storage
+     * Primitive operation: Read object from path
+     * All metadata operations use this internally via base class routing
      */
-    async getMetadata(id) {
+    async readObjectFromPath(path) {
         await this.ensureInitialized();
         try {
-            // Get the file handle for this metadata
-            const fileHandle = await this.metadataDir.getFileHandle(`${id}.json`);
-            // Read the metadata from the file
+            // Parse path to get directory structure and filename
+            const parts = path.split('/');
+            const filename = parts.pop();
+            // Navigate to the correct directory
+            let currentDir = this.rootDir;
+            for (const dirName of parts) {
+                currentDir = await currentDir.getDirectoryHandle(dirName);
+            }
+            // Get the file handle
+            const fileHandle = await currentDir.getFileHandle(filename);
+            // Read the data from the file
             const file = await fileHandle.getFile();
             const text = await file.text();
             return JSON.parse(text);
         }
         catch (error) {
-            // Metadata not found or other error
+            // NotFoundError means object doesn't exist
+            if (error.name === 'NotFoundError') {
+                return null;
+            }
+            console.error(`Failed to read object from ${path}:`, error);
             return null;
         }
     }
+    /**
+     * Primitive operation: Delete object from path
+     * All metadata operations use this internally via base class routing
+     */
+    async deleteObjectFromPath(path) {
+        await this.ensureInitialized();
+        try {
+            // Parse path to get directory structure and filename
+            const parts = path.split('/');
+            const filename = parts.pop();
+            // Navigate to the correct directory
+            let currentDir = this.rootDir;
+            for (const dirName of parts) {
+                currentDir = await currentDir.getDirectoryHandle(dirName);
+            }
+            // Delete the file
+            await currentDir.removeEntry(filename);
+        }
+        catch (error) {
+            // NotFoundError is ok (already deleted)
+            if (error.name === 'NotFoundError') {
+                return;
+            }
+            console.error(`Failed to delete object from ${path}:`, error);
+            throw new Error(`Failed to delete object from ${path}: ${error}`);
+        }
+    }
+    /**
+     * Primitive operation: List objects under path prefix
+     * All metadata operations use this internally via base class routing
+     */
+    async listObjectsUnderPath(prefix) {
+        await this.ensureInitialized();
+        try {
+            const paths = [];
+            // Parse prefix to get directory structure
+            const parts = prefix.split('/');
+            // Navigate to the directory
+            let currentDir = this.rootDir;
+            for (const dirName of parts) {
+                if (dirName) {
+                    currentDir = await currentDir.getDirectoryHandle(dirName);
+                }
+            }
+            // Recursively list all files
+            const listFiles = async (dir, pathPrefix) => {
+                for await (const [name, handle] of dir.entries()) {
+                    const fullPath = pathPrefix ? `${pathPrefix}/${name}` : name;
+                    if (handle.kind === 'file') {
+                        paths.push(`${prefix}${fullPath}`);
+                    }
+                    else if (handle.kind === 'directory') {
+                        await listFiles(handle, fullPath);
+                    }
+                }
+            };
+            await listFiles(currentDir, '');
+            return paths;
+        }
+        catch (error) {
+            // NotFoundError means directory doesn't exist
+            if (error.name === 'NotFoundError') {
+                return [];
+            }
+            console.error(`Failed to list objects under ${prefix}:`, error);
+            throw new Error(`Failed to list objects under ${prefix}: ${error}`);
+        }
+    }
     /**
      * Get multiple metadata objects in batches (CRITICAL: Prevents socket exhaustion)
      * OPFS implementation uses controlled concurrency for file operations
@@ -580,86 +669,6 @@ export class OPFSStorage extends BaseStorage {
         }
         return results;
     }
-    /**
-     * Save verb metadata to storage
-     */
-    async saveVerbMetadata_internal(id, metadata) {
-        await this.ensureInitialized();
-        // Use UUID-based sharding for metadata (consistent with verb vectors)
-        const shardId = getShardIdFromUuid(id);
-        // Get or create the shard directory
-        const shardDir = await this.verbMetadataDir.getDirectoryHandle(shardId, { create: true });
-        // Create or get the file in the shard directory
-        const fileName = `${id}.json`;
-        const fileHandle = await shardDir.getFileHandle(fileName, { create: true });
-        const writable = await fileHandle.createWritable();
-        await writable.write(JSON.stringify(metadata, null, 2));
-        await writable.close();
-    }
-    /**
-     * Get verb metadata from storage
-     */
-    async getVerbMetadata(id) {
-        await this.ensureInitialized();
-        // Use UUID-based sharding for metadata (consistent with verb vectors)
-        const shardId = getShardIdFromUuid(id);
-        const fileName = `${id}.json`;
-        try {
-            // Get the shard directory
-            const shardDir = await this.verbMetadataDir.getDirectoryHandle(shardId);
-            // Get the file from the shard directory
-            const fileHandle = await shardDir.getFileHandle(fileName);
-            const file = await safeGetFile(fileHandle);
-            const text = await file.text();
-            return JSON.parse(text);
-        }
-        catch (error) {
-            if (error.name !== 'NotFoundError') {
-                console.error(`Error reading verb metadata ${id}:`, error);
-            }
-            return null;
-        }
-    }
-    /**
-     * Save noun metadata to storage
-     */
-    async saveNounMetadata_internal(id, metadata) {
-        await this.ensureInitialized();
-        // Use UUID-based sharding for metadata (consistent with noun vectors)
-        const shardId = getShardIdFromUuid(id);
-        // Get or create the shard directory
-        const shardDir = await this.nounMetadataDir.getDirectoryHandle(shardId, { create: true });
-        // Create or get the file in the shard directory
-        const fileName = `${id}.json`;
-        const fileHandle = await shardDir.getFileHandle(fileName, { create: true });
-        const writable = await fileHandle.createWritable();
-        await writable.write(JSON.stringify(metadata, null, 2));
-        await writable.close();
-    }
-    /**
-     * Get noun metadata from storage
-     */
-    async getNounMetadata(id) {
-        await this.ensureInitialized();
-        // Use UUID-based sharding for metadata (consistent with noun vectors)
-        const shardId = getShardIdFromUuid(id);
-        const fileName = `${id}.json`;
-        try {
-            // Get the shard directory
-            const shardDir = await this.nounMetadataDir.getDirectoryHandle(shardId);
-            // Get the file from the shard directory
-            const fileHandle = await shardDir.getFileHandle(fileName);
-            const file = await safeGetFile(fileHandle);
-            const text = await file.text();
-            return JSON.parse(text);
-        }
-        catch (error) {
-            if (error.name !== 'NotFoundError') {
-                console.error(`Error reading noun metadata ${id}:`, error);
-            }
-            return null;
-        }
-    }
     /**
      * Clear all data from storage
      */

package/dist/storage/adapters/s3CompatibleStorage.d.ts

@@ -377,21 +377,25 @@ export declare class S3CompatibleStorage extends BaseStorage {
      */
     protected deleteEdge(id: string): Promise<void>;
     /**
-     * Save metadata to storage
+     * Primitive operation: Write object to path
+     * All metadata operations use this internally via base class routing
      */
-    saveMetadata(id: string, metadata: any): Promise<void>;
+    protected writeObjectToPath(path: string, data: any): Promise<void>;
     /**
-     * Save verb metadata to storage
+     * Primitive operation: Read object from path
+     * All metadata operations use this internally via base class routing
      */
-    protected saveVerbMetadata_internal(id: string, metadata: any): Promise<void>;
+    protected readObjectFromPath(path: string): Promise<any | null>;
     /**
-     * Get verb metadata from storage
+     * Primitive operation: Delete object from path
+     * All metadata operations use this internally via base class routing
      */
-    getVerbMetadata(id: string): Promise<any | null>;
+    protected deleteObjectFromPath(path: string): Promise<void>;
     /**
-     * Save noun metadata to storage
+     * Primitive operation: List objects under path prefix
+     * All metadata operations use this internally via base class routing
      */
-    protected saveNounMetadata_internal(id: string, metadata: any): Promise<void>;
+    protected listObjectsUnderPath(prefix: string): Promise<string[]>;
     /**
      * Get multiple metadata objects in batches (CRITICAL: Prevents socket exhaustion)
      * This is the solution to the metadata reading socket exhaustion during initialization
@@ -401,14 +405,6 @@ export declare class S3CompatibleStorage extends BaseStorage {
      * Get multiple verb metadata objects in batches (prevents socket exhaustion)
      */
     getVerbMetadataBatch(ids: string[]): Promise<Map<string, any>>;
-    /**
-     * Get noun metadata from storage
-     */
-    getNounMetadata(id: string): Promise<any | null>;
-    /**
-     * Get metadata from storage
-     */
-    getMetadata(id: string): Promise<any | null>;
     /**
      * Clear all data from storage
      */