@soulcraft/brainy 0.35.0 → 0.37.0

package/dist/unified.js

@@ -6241,6 +6241,8 @@ class BaseStorageAdapter {
 const NOUNS_DIR = 'nouns';
 const VERBS_DIR = 'verbs';
 const METADATA_DIR = 'metadata';
+const NOUN_METADATA_DIR = 'noun-metadata';
+const VERB_METADATA_DIR = 'verb-metadata';
 const INDEX_DIR = 'index';
 const STATISTICS_KEY = 'statistics';
 /**
@@ -6305,14 +6307,84 @@ class BaseStorage extends BaseStorageAdapter {
      */
     async saveVerb(verb) {
         await this.ensureInitialized();
-        return this.saveVerb_internal(verb);
+        // Extract the lightweight HNSWVerb data
+        const hnswVerb = {
+            id: verb.id,
+            vector: verb.vector,
+            connections: verb.connections || new Map()
+        };
+        // Extract and save the metadata separately
+        const metadata = {
+            sourceId: verb.sourceId || verb.source,
+            targetId: verb.targetId || verb.target,
+            source: verb.source || verb.sourceId,
+            target: verb.target || verb.targetId,
+            type: verb.type || verb.verb,
+            verb: verb.verb || verb.type,
+            weight: verb.weight,
+            metadata: verb.metadata,
+            data: verb.data,
+            createdAt: verb.createdAt,
+            updatedAt: verb.updatedAt,
+            createdBy: verb.createdBy,
+            embedding: verb.embedding
+        };
+        // Save both the HNSWVerb and metadata
+        await this.saveVerb_internal(hnswVerb);
+        await this.saveVerbMetadata(verb.id, metadata);
     }
     /**
      * Get a verb from storage
      */
     async getVerb(id) {
         await this.ensureInitialized();
-        return this.getVerb_internal(id);
+        const hnswVerb = await this.getVerb_internal(id);
+        if (!hnswVerb) {
+            return null;
+        }
+        return this.convertHNSWVerbToGraphVerb(hnswVerb);
+    }
+    /**
+     * Convert HNSWVerb to GraphVerb by combining with metadata
+     */
+    async convertHNSWVerbToGraphVerb(hnswVerb) {
+        try {
+            const metadata = await this.getVerbMetadata(hnswVerb.id);
+            if (!metadata) {
+                return null;
+            }
+            // Create default timestamp if not present
+            const defaultTimestamp = {
+                seconds: Math.floor(Date.now() / 1000),
+                nanoseconds: (Date.now() % 1000) * 1000000
+            };
+            // Create default createdBy if not present
+            const defaultCreatedBy = {
+                augmentation: 'unknown',
+                version: '1.0'
+            };
+            return {
+                id: hnswVerb.id,
+                vector: hnswVerb.vector,
+                sourceId: metadata.sourceId,
+                targetId: metadata.targetId,
+                source: metadata.source,
+                target: metadata.target,
+                verb: metadata.verb,
+                type: metadata.type,
+                weight: metadata.weight || 1.0,
+                metadata: metadata.metadata || {},
+                createdAt: metadata.createdAt || defaultTimestamp,
+                updatedAt: metadata.updatedAt || defaultTimestamp,
+                createdBy: metadata.createdBy || defaultCreatedBy,
+                data: metadata.data,
+                embedding: hnswVerb.vector
+            };
+        }
+        catch (error) {
+            console.error(`Failed to convert HNSWVerb to GraphVerb for ${hnswVerb.id}:`, error);
+            return null;
+        }
     }
     /**
      * Get all verbs from storage
@@ -6322,28 +6394,42 @@ class BaseStorage extends BaseStorageAdapter {
     async getAllVerbs() {
         await this.ensureInitialized();
         console.warn('WARNING: getAllVerbs() is deprecated and will be removed in a future version. Use getVerbs() with pagination instead.');
-        return this.getAllVerbs_internal();
+        const hnswVerbs = await this.getAllVerbs_internal();
+        const graphVerbs = [];
+        for (const hnswVerb of hnswVerbs) {
+            const graphVerb = await this.convertHNSWVerbToGraphVerb(hnswVerb);
+            if (graphVerb) {
+                graphVerbs.push(graphVerb);
+            }
+        }
+        return graphVerbs;
     }
     /**
      * Get verbs by source
      */
     async getVerbsBySource(sourceId) {
         await this.ensureInitialized();
-        return this.getVerbsBySource_internal(sourceId);
+        // Get all verbs and filter by source
+        const allVerbs = await this.getAllVerbs();
+        return allVerbs.filter(verb => verb.sourceId === sourceId || verb.source === sourceId);
     }
     /**
      * Get verbs by target
      */
     async getVerbsByTarget(targetId) {
         await this.ensureInitialized();
-        return this.getVerbsByTarget_internal(targetId);
+        // Get all verbs and filter by target
+        const allVerbs = await this.getAllVerbs();
+        return allVerbs.filter(verb => verb.targetId === targetId || verb.target === targetId);
     }
     /**
      * Get verbs by type
      */
     async getVerbsByType(type) {
         await this.ensureInitialized();
-        return this.getVerbsByType_internal(type);
+        // Get all verbs and filter by type
+        const allVerbs = await this.getAllVerbs();
+        return allVerbs.filter(verb => verb.type === type || verb.verb === type);
     }
     /**
      * Get nouns with pagination and filtering
@@ -6640,7 +6726,7 @@ class BaseStorage extends BaseStorageAdapter {
             let allVerbs = [];
             try {
                 // Try to get only the verbs we need
-                allVerbs = await this.getAllVerbs_internal();
+                allVerbs = await this.getAllVerbs();
                 // If we have too many verbs, truncate the array to avoid memory issues
                 if (allVerbs.length > maxVerbs) {
                     console.warn(`Large number of verbs (${allVerbs.length}), truncating to ${maxVerbs} for filtering`);
@@ -6764,6 +6850,8 @@ class MemoryStorage extends BaseStorage {
         this.nouns = new Map();
         this.verbs = new Map();
         this.metadata = new Map();
+        this.nounMetadata = new Map();
+        this.verbMetadata = new Map();
         this.statistics = null;
     }
     /**
@@ -6941,15 +7029,7 @@ class MemoryStorage extends BaseStorage {
         const verbCopy = {
             id: verb.id,
             vector: [...verb.vector],
-            connections: new Map(),
-            sourceId: verb.sourceId,
-            targetId: verb.targetId,
-            source: verb.sourceId || verb.source,
-            target: verb.targetId || verb.target,
-            verb: verb.type || verb.verb,
-            type: verb.type || verb.verb,
-            weight: verb.weight,
-            metadata: verb.metadata
+            connections: new Map()
         };
         // Copy connections
         for (const [level, connections] of verb.connections.entries()) {
@@ -6968,32 +7048,11 @@ class MemoryStorage extends BaseStorage {
         if (!verb) {
             return null;
         }
-        // Create default timestamp if not present
-        const defaultTimestamp = {
-            seconds: Math.floor(Date.now() / 1000),
-            nanoseconds: (Date.now() % 1000) * 1000000
-        };
-        // Create default createdBy if not present
-        const defaultCreatedBy = {
-            augmentation: 'unknown',
-            version: '1.0'
-        };
-        // Return a deep copy to avoid reference issues
+        // Return a deep copy of the HNSWVerb
         const verbCopy = {
             id: verb.id,
             vector: [...verb.vector],
-            connections: new Map(),
-            sourceId: (verb.sourceId || verb.source || ""),
-            targetId: (verb.targetId || verb.target || ""),
-            source: (verb.sourceId || verb.source || ""),
-            target: (verb.targetId || verb.target || ""),
-            verb: verb.type || verb.verb,
-            type: verb.type || verb.verb, // Ensure type is also set
-            weight: verb.weight,
-            metadata: verb.metadata,
-            createdAt: verb.createdAt || defaultTimestamp,
-            updatedAt: verb.updatedAt || defaultTimestamp,
-            createdBy: verb.createdBy || defaultCreatedBy
+            connections: new Map()
         };
         // Copy connections
         for (const [level, connections] of verb.connections.entries()) {
@@ -7008,31 +7067,11 @@ class MemoryStorage extends BaseStorage {
         const allVerbs = [];
         // Iterate through all verbs in the verbs map
         for (const [verbId, verb] of this.verbs.entries()) {
-            // Create default timestamp if not present
-            const defaultTimestamp = {
-                seconds: Math.floor(Date.now() / 1000),
-                nanoseconds: (Date.now() % 1000) * 1000000
-            };
-            // Create default createdBy if not present
-            const defaultCreatedBy = {
-                augmentation: 'unknown',
-                version: '1.0'
-            };
-            // Return a deep copy to avoid reference issues
+            // Create a deep copy of the HNSWVerb
             const verbCopy = {
                 id: verb.id,
                 vector: [...verb.vector],
-                connections: new Map(),
-                sourceId: (verb.sourceId || verb.source || ""),
-                targetId: (verb.targetId || verb.target || ""),
-                source: (verb.sourceId || verb.source || ""),
-                target: (verb.targetId || verb.target || ""),
-                verb: verb.type || verb.verb,
-                weight: verb.weight,
-                metadata: verb.metadata,
-                createdAt: verb.createdAt || defaultTimestamp,
-                updatedAt: verb.updatedAt || defaultTimestamp,
-                createdBy: verb.createdBy || defaultCreatedBy
+                connections: new Map()
             };
             // Copy connections
             for (const [level, connections] of verb.connections.entries()) {
@@ -7069,24 +7108,26 @@ class MemoryStorage extends BaseStorage {
         // First, collect all verb IDs that match the filter criteria
         const matchingIds = [];
         // Iterate through all verbs to find matches
-        for (const [verbId, verb] of this.verbs.entries()) {
+        for (const [verbId, hnswVerb] of this.verbs.entries()) {
+            // Get the metadata for this verb to do filtering
+            const metadata = this.verbMetadata.get(verbId);
             // Filter by verb type if specified
-            if (verbTypes && !verbTypes.includes(verb.type || verb.verb || '')) {
+            if (verbTypes && metadata && !verbTypes.includes(metadata.type || metadata.verb || '')) {
                 continue;
             }
             // Filter by source ID if specified
-            if (sourceIds && !sourceIds.includes(verb.sourceId || verb.source || '')) {
+            if (sourceIds && metadata && !sourceIds.includes(metadata.sourceId || metadata.source || '')) {
                 continue;
             }
             // Filter by target ID if specified
-            if (targetIds && !targetIds.includes(verb.targetId || verb.target || '')) {
+            if (targetIds && metadata && !targetIds.includes(metadata.targetId || metadata.target || '')) {
                 continue;
             }
             // Filter by metadata fields if specified
-            if (filter.metadata && verb.metadata) {
+            if (filter.metadata && metadata && metadata.data) {
                 let metadataMatch = true;
                 for (const [key, value] of Object.entries(filter.metadata)) {
-                    if (verb.metadata[key] !== value) {
+                    if (metadata.data[key] !== value) {
                         metadataMatch = false;
                         break;
                     }
@@ -7095,8 +7136,8 @@ class MemoryStorage extends BaseStorage {
                     continue;
             }
             // Filter by service if specified
-            if (services && verb.metadata && verb.metadata.service &&
-                !services.includes(verb.metadata.service)) {
+            if (services && metadata && metadata.createdBy && metadata.createdBy.augmentation &&
+                !services.includes(metadata.createdBy.augmentation)) {
                 continue;
             }
             // If we got here, the verb matches all filters
@@ -7111,31 +7152,39 @@ class MemoryStorage extends BaseStorage {
         // Fetch the actual verbs for the current page
         const items = [];
         for (const id of paginatedIds) {
-            const verb = this.verbs.get(id);
-            if (!verb)
+            const hnswVerb = this.verbs.get(id);
+            const metadata = this.verbMetadata.get(id);
+            if (!hnswVerb)
+                continue;
+            if (!metadata) {
+                console.warn(`Verb ${id} found but no metadata - creating minimal GraphVerb`);
+                // Return minimal GraphVerb if metadata is missing
+                items.push({
+                    id: hnswVerb.id,
+                    vector: hnswVerb.vector,
+                    sourceId: '',
+                    targetId: ''
+                });
                 continue;
-            // Create a deep copy to avoid reference issues
-            const verbCopy = {
-                id: verb.id,
-                vector: [...verb.vector],
-                connections: new Map(),
-                sourceId: verb.sourceId || verb.source || '',
-                targetId: verb.targetId || verb.target || '',
-                source: verb.sourceId || verb.source || '',
-                target: verb.targetId || verb.target || '',
-                verb: verb.type || verb.verb,
-                type: verb.type || verb.verb,
-                weight: verb.weight,
-                metadata: verb.metadata ? JSON.parse(JSON.stringify(verb.metadata)) : undefined,
-                createdAt: verb.createdAt ? { ...verb.createdAt } : undefined,
-                updatedAt: verb.updatedAt ? { ...verb.updatedAt } : undefined,
-                createdBy: verb.createdBy ? { ...verb.createdBy } : undefined
-            };
-            // Copy connections
-            for (const [level, connections] of verb.connections.entries()) {
-                verbCopy.connections.set(level, new Set(connections));
             }
-            items.push(verbCopy);
+            // Create a complete GraphVerb by combining HNSWVerb with metadata
+            const graphVerb = {
+                id: hnswVerb.id,
+                vector: [...hnswVerb.vector],
+                sourceId: metadata.sourceId,
+                targetId: metadata.targetId,
+                source: metadata.source,
+                target: metadata.target,
+                verb: metadata.verb,
+                type: metadata.type,
+                weight: metadata.weight,
+                createdAt: metadata.createdAt,
+                updatedAt: metadata.updatedAt,
+                createdBy: metadata.createdBy,
+                data: metadata.data,
+                metadata: metadata.data // Alias for backward compatibility
+            };
+            items.push(graphVerb);
         }
         return {
             items,
@@ -7203,6 +7252,38 @@ class MemoryStorage extends BaseStorage {
         }
         return JSON.parse(JSON.stringify(metadata));
     }
+    /**
+     * Save noun metadata to storage
+     */
+    async saveNounMetadata(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
+     */
+    async saveVerbMetadata(id, metadata) {
+        this.verbMetadata.set(id, JSON.parse(JSON.stringify(metadata)));
+    }
+    /**
+     * 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
      */
@@ -7210,6 +7291,8 @@ class MemoryStorage extends BaseStorage {
         this.nouns.clear();
         this.verbs.clear();
         this.metadata.clear();
+        this.nounMetadata.clear();
+        this.verbMetadata.clear();
         this.statistics = null;
     }
     /**
@@ -7291,6 +7374,8 @@ class OPFSStorage extends BaseStorage {
         this.nounsDir = null;
         this.verbsDir = null;
         this.metadataDir = null;
+        this.nounMetadataDir = null;
+        this.verbMetadataDir = null;
         this.indexDir = null;
         this.isAvailable = false;
         this.isPersistentRequested = false;
@@ -7331,6 +7416,14 @@ class OPFSStorage extends BaseStorage {
             this.metadataDir = await this.rootDir.getDirectoryHandle(METADATA_DIR, {
                 create: true
             });
+            // Create or get noun metadata directory
+            this.nounMetadataDir = await this.rootDir.getDirectoryHandle(NOUN_METADATA_DIR, {
+                create: true
+            });
+            // Create or get verb metadata directory
+            this.verbMetadataDir = await this.rootDir.getDirectoryHandle(VERB_METADATA_DIR, {
+                create: true
+            });
             // Create or get index directory
             this.indexDir = await this.rootDir.getDirectoryHandle(INDEX_DIR, {
                 create: true
@@ -7620,17 +7713,7 @@ class OPFSStorage extends BaseStorage {
             return {
                 id: data.id,
                 vector: data.vector,
-                connections,
-                sourceId: data.sourceId || data.source,
-                targetId: data.targetId || data.target,
-                source: data.sourceId || data.source,
-                target: data.targetId || data.target,
-                verb: data.type || data.verb,
-                weight: data.weight,
-                metadata: data.metadata,
-                createdAt: data.createdAt || defaultTimestamp,
-                updatedAt: data.updatedAt || defaultTimestamp,
-                createdBy: data.createdBy || defaultCreatedBy
+                connections
             };
         }
         catch (error) {
@@ -7677,17 +7760,7 @@ class OPFSStorage extends BaseStorage {
                         allEdges.push({
                             id: data.id,
                             vector: data.vector,
-                            connections,
-                            sourceId: data.sourceId || data.source,
-                            targetId: data.targetId || data.target,
-                            source: data.sourceId || data.source,
-                            target: data.targetId || data.target,
-                            verb: data.type || data.verb,
-                            weight: data.weight,
-                            metadata: data.metadata,
-                            createdAt: data.createdAt || defaultTimestamp,
-                            updatedAt: data.updatedAt || defaultTimestamp,
-                            createdBy: data.createdBy || defaultCreatedBy
+                            connections
                         });
                     }
                     catch (error) {
@@ -7705,40 +7778,55 @@ class OPFSStorage extends BaseStorage {
      * Get verbs by source (internal implementation)
      */
     async getVerbsBySource_internal(sourceId) {
-        return this.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('getVerbsBySource_internal is deprecated and not efficiently supported in new storage pattern');
+        return [];
     }
     /**
      * Get edges by source
      */
     async getEdgesBySource(sourceId) {
-        const edges = await this.getAllEdges();
-        return edges.filter((edge) => (edge.sourceId || edge.source) === 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 verbs by target (internal implementation)
      */
     async getVerbsByTarget_internal(targetId) {
-        return this.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('getVerbsByTarget_internal is deprecated and not efficiently supported in new storage pattern');
+        return [];
     }
     /**
      * Get edges by target
      */
     async getEdgesByTarget(targetId) {
-        const edges = await this.getAllEdges();
-        return edges.filter((edge) => (edge.targetId || edge.target) === 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 verbs by type (internal implementation)
      */
     async getVerbsByType_internal(type) {
-        return this.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('getVerbsByType_internal is deprecated and not efficiently supported in new storage pattern');
+        return [];
     }
     /**
      * Get edges by type
      */
     async getEdgesByType(type) {
-        const edges = await this.getAllEdges();
-        return edges.filter((edge) => (edge.type || edge.verb) === 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 a verb from storage (internal implementation)
@@ -7800,6 +7888,66 @@ class OPFSStorage extends BaseStorage {
             return null;
         }
     }
+    /**
+     * Save verb metadata to storage
+     */
+    async saveVerbMetadata(id, metadata) {
+        await this.ensureInitialized();
+        const fileName = `${id}.json`;
+        const fileHandle = await this.verbMetadataDir.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();
+        const fileName = `${id}.json`;
+        try {
+            const fileHandle = await this.verbMetadataDir.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(id, metadata) {
+        await this.ensureInitialized();
+        const fileName = `${id}.json`;
+        const fileHandle = await this.nounMetadataDir.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();
+        const fileName = `${id}.json`;
+        try {
+            const fileHandle = await this.nounMetadataDir.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
      */
@@ -7825,6 +7973,10 @@ class OPFSStorage extends BaseStorage {
             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);
         }
@@ -10407,11 +10559,7 @@ class S3CompatibleStorage extends BaseStorage {
                 entityType: 'verb',
                 entityId: edge.id,
                 data: {
-                    sourceId: edge.sourceId || edge.source,
-                    targetId: edge.targetId || edge.target,
-                    type: edge.type || edge.verb,
-                    vector: edge.vector,
-                    metadata: edge.metadata
+                    vector: edge.vector
                 }
             });
         }
@@ -10458,10 +10606,7 @@ class S3CompatibleStorage extends BaseStorage {
                 if (!parsedEdge ||
                     !parsedEdge.id ||
                     !parsedEdge.vector ||
-                    !parsedEdge.connections ||
-                    !(parsedEdge.sourceId || parsedEdge.source) ||
-                    !(parsedEdge.targetId || parsedEdge.target) ||
-                    !(parsedEdge.type || parsedEdge.verb)) {
+                    !parsedEdge.connections) {
                     console.error(`Invalid edge data for ${id}:`, parsedEdge);
                     return null;
                 }
@@ -10470,31 +10615,10 @@ class S3CompatibleStorage extends BaseStorage {
                 for (const [level, nodeIds] of Object.entries(parsedEdge.connections)) {
                     connections.set(Number(level), new Set(nodeIds));
                 }
-                // Create default timestamp if not present
-                const defaultTimestamp = {
-                    seconds: Math.floor(Date.now() / 1000),
-                    nanoseconds: (Date.now() % 1000) * 1000000
-                };
-                // Create default createdBy if not present
-                const defaultCreatedBy = {
-                    augmentation: 'unknown',
-                    version: '1.0'
-                };
                 const edge = {
                     id: parsedEdge.id,
                     vector: parsedEdge.vector,
-                    connections,
-                    sourceId: parsedEdge.sourceId || parsedEdge.source,
-                    targetId: parsedEdge.targetId || parsedEdge.target,
-                    source: parsedEdge.sourceId || parsedEdge.source,
-                    target: parsedEdge.targetId || parsedEdge.target,
-                    verb: parsedEdge.type || parsedEdge.verb,
-                    type: parsedEdge.type || parsedEdge.verb,
-                    weight: parsedEdge.weight || 1.0, // Default weight if not provided
-                    metadata: parsedEdge.metadata || {},
-                    createdAt: parsedEdge.createdAt || defaultTimestamp,
-                    updatedAt: parsedEdge.updatedAt || defaultTimestamp,
-                    createdBy: parsedEdge.createdBy || defaultCreatedBy
+                    connections
                 };
                 console.log(`Successfully retrieved edge ${id}:`, edge);
                 return edge;
@@ -10651,23 +10775,10 @@ class S3CompatibleStorage extends BaseStorage {
      * @returns True if the edge matches the filter, false otherwise
      */
     filterEdge(edge, filter) {
-        // If no filter, include all edges
-        if (!filter.sourceId && !filter.targetId && !filter.type) {
-            return true;
-        }
-        // Filter by source ID
-        if (filter.sourceId && edge.sourceId !== filter.sourceId) {
-            return false;
-        }
-        // Filter by target ID
-        if (filter.targetId && edge.targetId !== filter.targetId) {
-            return false;
-        }
-        // Filter by type
-        if (filter.type && edge.type !== filter.type) {
-            return false;
-        }
-        return true;
+        // HNSWVerb filtering is not supported since metadata is stored separately
+        // This method is deprecated and should not be used with the new storage pattern
+        console.warn('Edge filtering is deprecated and not supported with the new storage pattern');
+        return true; // Return all edges since filtering requires metadata
     }
     /**
      * Get verbs with pagination
@@ -10705,9 +10816,16 @@ class S3CompatibleStorage extends BaseStorage {
             useCache: true,
             filter: edgeFilter
         });
-        // Convert edges to verbs (they're the same in this implementation)
+        // Convert HNSWVerbs to GraphVerbs by combining with metadata
+        const graphVerbs = [];
+        for (const hnswVerb of result.edges) {
+            const graphVerb = await this.convertHNSWVerbToGraphVerb(hnswVerb);
+            if (graphVerb) {
+                graphVerbs.push(graphVerb);
+            }
+        }
         return {
-            items: result.edges,
+            items: graphVerbs,
             hasMore: result.hasMore,
             nextCursor: result.nextCursor
         };
@@ -10722,8 +10840,10 @@ class S3CompatibleStorage extends BaseStorage {
      * Get edges by source
      */
     async getEdgesBySource(sourceId) {
-        const edges = await this.getAllEdges();
-        return edges.filter((edge) => (edge.sourceId || edge.source) === 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 verbs by target (internal implementation)
@@ -10735,8 +10855,10 @@ class S3CompatibleStorage extends BaseStorage {
      * Get edges by target
      */
     async getEdgesByTarget(targetId) {
-        const edges = await this.getAllEdges();
-        return edges.filter((edge) => (edge.targetId || edge.target) === 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 verbs by type (internal implementation)
@@ -10748,8 +10870,10 @@ class S3CompatibleStorage extends BaseStorage {
      * Get edges by type
      */
     async getEdgesByType(type) {
-        const edges = await this.getAllEdges();
-        return edges.filter((edge) => (edge.type || edge.verb) === 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 a verb from storage (internal implementation)
@@ -10836,6 +10960,158 @@ class S3CompatibleStorage extends BaseStorage {
             throw new Error(`Failed to save metadata for ${id}: ${error}`);
         }
     }
+    /**
+     * Save verb metadata to storage
+     */
+    async saveVerbMetadata(id, metadata) {
+        await this.ensureInitialized();
+        try {
+            console.log(`Saving verb metadata for ${id} to bucket ${this.bucketName}`);
+            // Import the PutObjectCommand only when needed
+            const { PutObjectCommand } = await import('@aws-sdk/client-s3');
+            const key = `verb-metadata/${id}.json`;
+            const body = JSON.stringify(metadata, null, 2);
+            console.log(`Saving verb metadata to key: ${key}`);
+            console.log(`Verb Metadata: ${body}`);
+            // Save the verb metadata to S3-compatible storage
+            const result = await this.s3Client.send(new PutObjectCommand({
+                Bucket: this.bucketName,
+                Key: key,
+                Body: body,
+                ContentType: 'application/json'
+            }));
+            console.log(`Verb metadata for ${id} saved successfully:`, result);
+        }
+        catch (error) {
+            console.error(`Failed to save verb metadata for ${id}:`, error);
+            throw new Error(`Failed to save verb metadata for ${id}: ${error}`);
+        }
+    }
+    /**
+     * Get verb metadata from storage
+     */
+    async getVerbMetadata(id) {
+        await this.ensureInitialized();
+        try {
+            // Import the GetObjectCommand only when needed
+            const { GetObjectCommand } = await import('@aws-sdk/client-s3');
+            console.log(`Getting verb metadata for ${id} from bucket ${this.bucketName}`);
+            const key = `verb-metadata/${id}.json`;
+            console.log(`Looking for verb metadata at key: ${key}`);
+            // Try to get the verb metadata
+            const response = await this.s3Client.send(new GetObjectCommand({
+                Bucket: this.bucketName,
+                Key: key
+            }));
+            // Check if response is null or undefined
+            if (!response || !response.Body) {
+                console.log(`No verb metadata found for ${id}`);
+                return null;
+            }
+            // Convert the response body to a string
+            const bodyContents = await response.Body.transformToString();
+            console.log(`Retrieved verb metadata body: ${bodyContents}`);
+            // Parse the JSON string
+            try {
+                const parsedMetadata = JSON.parse(bodyContents);
+                console.log(`Successfully retrieved verb metadata for ${id}:`, parsedMetadata);
+                return parsedMetadata;
+            }
+            catch (parseError) {
+                console.error(`Failed to parse verb metadata for ${id}:`, parseError);
+                return null;
+            }
+        }
+        catch (error) {
+            // Check if this is a "NoSuchKey" error (object doesn't exist)
+            if (error.name === 'NoSuchKey' ||
+                (error.message &&
+                    (error.message.includes('NoSuchKey') ||
+                        error.message.includes('not found') ||
+                        error.message.includes('does not exist')))) {
+                console.log(`Verb metadata not found for ${id}`);
+                return null;
+            }
+            // For other types of errors, convert to BrainyError for better classification
+            throw BrainyError.fromError(error, `getVerbMetadata(${id})`);
+        }
+    }
+    /**
+     * Save noun metadata to storage
+     */
+    async saveNounMetadata(id, metadata) {
+        await this.ensureInitialized();
+        try {
+            console.log(`Saving noun metadata for ${id} to bucket ${this.bucketName}`);
+            // Import the PutObjectCommand only when needed
+            const { PutObjectCommand } = await import('@aws-sdk/client-s3');
+            const key = `noun-metadata/${id}.json`;
+            const body = JSON.stringify(metadata, null, 2);
+            console.log(`Saving noun metadata to key: ${key}`);
+            console.log(`Noun Metadata: ${body}`);
+            // Save the noun metadata to S3-compatible storage
+            const result = await this.s3Client.send(new PutObjectCommand({
+                Bucket: this.bucketName,
+                Key: key,
+                Body: body,
+                ContentType: 'application/json'
+            }));
+            console.log(`Noun metadata for ${id} saved successfully:`, result);
+        }
+        catch (error) {
+            console.error(`Failed to save noun metadata for ${id}:`, error);
+            throw new Error(`Failed to save noun metadata for ${id}: ${error}`);
+        }
+    }
+    /**
+     * Get noun metadata from storage
+     */
+    async getNounMetadata(id) {
+        await this.ensureInitialized();
+        try {
+            // Import the GetObjectCommand only when needed
+            const { GetObjectCommand } = await import('@aws-sdk/client-s3');
+            console.log(`Getting noun metadata for ${id} from bucket ${this.bucketName}`);
+            const key = `noun-metadata/${id}.json`;
+            console.log(`Looking for noun metadata at key: ${key}`);
+            // Try to get the noun metadata
+            const response = await this.s3Client.send(new GetObjectCommand({
+                Bucket: this.bucketName,
+                Key: key
+            }));
+            // Check if response is null or undefined
+            if (!response || !response.Body) {
+                console.log(`No noun metadata found for ${id}`);
+                return null;
+            }
+            // Convert the response body to a string
+            const bodyContents = await response.Body.transformToString();
+            console.log(`Retrieved noun metadata body: ${bodyContents}`);
+            // Parse the JSON string
+            try {
+                const parsedMetadata = JSON.parse(bodyContents);
+                console.log(`Successfully retrieved noun metadata for ${id}:`, parsedMetadata);
+                return parsedMetadata;
+            }
+            catch (parseError) {
+                console.error(`Failed to parse noun metadata for ${id}:`, parseError);
+                return null;
+            }
+        }
+        catch (error) {
+            // Check if this is a "NoSuchKey" error (object doesn't exist)
+            if (error.name === 'NoSuchKey' ||
+                (error.message &&
+                    (error.message.includes('NoSuchKey') ||
+                        error.message.includes('not found') ||
+                        error.message.includes('does not exist')))) {
+                console.log(`Noun metadata not found for ${id}`);
+                return null;
+            }
+            // For other types of errors, convert to BrainyError for better classification
+            throw BrainyError.fromError(error, `getNounMetadata(${id})`);
+        }
+    }
     /**
      * Get metadata from storage
      */
@@ -11733,6 +12009,8 @@ class FileSystemStorage extends BaseStorage {
             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
@@ -11743,6 +12021,10 @@ class FileSystemStorage extends BaseStorage {
             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
@@ -11927,12 +12209,7 @@ class FileSystemStorage extends BaseStorage {
             return {
                 id: parsedEdge.id,
                 vector: parsedEdge.vector,
-                connections,
-                sourceId: parsedEdge.sourceId,
-                targetId: parsedEdge.targetId,
-                type: parsedEdge.type,
-                weight: parsedEdge.weight,
-                metadata: parsedEdge.metadata
+                connections
             };
         }
         catch (error) {
@@ -11963,12 +12240,7 @@ class FileSystemStorage extends BaseStorage {
                     allEdges.push({
                         id: parsedEdge.id,
                         vector: parsedEdge.vector,
-                        connections,
-                        sourceId: parsedEdge.sourceId,
-                        targetId: parsedEdge.targetId,
-                        type: parsedEdge.type,
-                        weight: parsedEdge.weight,
-                        metadata: parsedEdge.metadata
+                        connections
                     });
                 }
             }
@@ -11984,22 +12256,28 @@ class FileSystemStorage extends BaseStorage {
      * Get edges by source
      */
     async getEdgesBySource(sourceId) {
-        const edges = await this.getAllEdges();
-        return edges.filter((edge) => edge.sourceId === 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) {
-        const edges = await this.getAllEdges();
-        return edges.filter((edge) => edge.targetId === 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) {
-        const edges = await this.getAllEdges();
-        return edges.filter((edge) => edge.type === 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
@@ -12042,6 +12320,56 @@ class FileSystemStorage extends BaseStorage {
             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
      */
@@ -12081,6 +12409,10 @@ class FileSystemStorage extends BaseStorage {
         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);
     }
@@ -12246,19 +12578,28 @@ class FileSystemStorage extends BaseStorage {
      * Get verbs by source
      */
     async getVerbsBySource_internal(sourceId) {
-        return this.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('getVerbsBySource_internal is deprecated and not efficiently supported in new storage pattern');
+        return [];
     }
     /**
      * Get verbs by target
      */
     async getVerbsByTarget_internal(targetId) {
-        return this.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('getVerbsByTarget_internal is deprecated and not efficiently supported in new storage pattern');
+        return [];
     }
     /**
      * Get verbs by type
      */
     async getVerbsByType_internal(type) {
-        return this.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('getVerbsByType_internal is deprecated and not efficiently supported in new storage pattern');
+        return [];
     }
     /**
      * Delete a verb from storage
@@ -17053,11 +17394,14 @@ class BrainyData {
                 seconds: Math.floor(now.getTime() / 1000),
                 nanoseconds: (now.getTime() % 1000) * 1000000
             };
-            // Create verb
-            const verb = {
+            // Create lightweight verb for HNSW index storage
+            const hnswVerb = {
                 id,
                 vector: verbVector,
-                connections: new Map(),
+                connections: new Map()
+            };
+            // Create complete verb metadata separately
+            const verbMetadata = {
                 sourceId: sourceId,
                 targetId: targetId,
                 source: sourceId,
@@ -17065,13 +17409,13 @@ class BrainyData {
                 verb: verbType,
                 type: verbType, // Set the type property to match the verb type
                 weight: options.weight,
-                metadata: options.metadata,
                 createdAt: timestamp,
                 updatedAt: timestamp,
                 createdBy: {
                     augmentation: service,
                     version: '1.0' // TODO: Get actual version from augmentation
-                }
+                },
+                data: options.metadata // Store the original metadata in the data field
             };
             // Add to index
             await this.index.addItem({ id, vector: verbVector });
@@ -17081,9 +17425,28 @@ class BrainyData {
                 throw new Error(`Failed to retrieve newly created verb noun with ID ${id}`);
             }
             // Update verb connections from index
-            verb.connections = indexNoun.connections;
-            // Save verb to storage
-            await this.storage.saveVerb(verb);
+            hnswVerb.connections = indexNoun.connections;
+            // Combine HNSWVerb and metadata into a GraphVerb for storage
+            const fullVerb = {
+                id: hnswVerb.id,
+                vector: hnswVerb.vector,
+                connections: hnswVerb.connections,
+                sourceId: verbMetadata.sourceId,
+                targetId: verbMetadata.targetId,
+                source: verbMetadata.source,
+                target: verbMetadata.target,
+                verb: verbMetadata.verb,
+                type: verbMetadata.type,
+                weight: verbMetadata.weight,
+                createdAt: verbMetadata.createdAt,
+                updatedAt: verbMetadata.updatedAt,
+                createdBy: verbMetadata.createdBy,
+                metadata: verbMetadata.data,
+                data: verbMetadata.data,
+                embedding: hnswVerb.vector
+            };
+            // Save the complete verb (BaseStorage will handle the separation)
+            await this.storage.saveVerb(fullVerb);
             // Track verb statistics
             const serviceForStats = this.getServiceName(options);
             await this.storage.incrementStatistic('verb', serviceForStats);
@@ -17102,7 +17465,41 @@ class BrainyData {
     async getVerb(id) {
         await this.ensureInitialized();
         try {
-            return await this.storage.getVerb(id);
+            // Get the lightweight verb from storage
+            const hnswVerb = await this.storage.getVerb(id);
+            if (!hnswVerb) {
+                return null;
+            }
+            // Get the verb metadata
+            const metadata = await this.storage.getVerbMetadata(id);
+            if (!metadata) {
+                console.warn(`Verb ${id} found but no metadata - creating minimal GraphVerb`);
+                // Return minimal GraphVerb if metadata is missing
+                return {
+                    id: hnswVerb.id,
+                    vector: hnswVerb.vector,
+                    sourceId: '',
+                    targetId: ''
+                };
+            }
+            // Combine into a complete GraphVerb
+            const graphVerb = {
+                id: hnswVerb.id,
+                vector: hnswVerb.vector,
+                sourceId: metadata.sourceId,
+                targetId: metadata.targetId,
+                source: metadata.source,
+                target: metadata.target,
+                verb: metadata.verb,
+                type: metadata.type,
+                weight: metadata.weight,
+                createdAt: metadata.createdAt,
+                updatedAt: metadata.updatedAt,
+                createdBy: metadata.createdBy,
+                data: metadata.data,
+                metadata: metadata.data // Alias for backward compatibility
+            };
+            return graphVerb;
         }
         catch (error) {
             console.error(`Failed to get verb ${id}:`, error);
@@ -17116,13 +17513,36 @@ class BrainyData {
     async getAllVerbs() {
         await this.ensureInitialized();
         try {
-            // Use getVerbs with no pagination to get all verbs
-            const result = await this.getVerbs({
-                pagination: {
-                    limit: Number.MAX_SAFE_INTEGER // Request all verbs
+            // Get all lightweight verbs from storage
+            const hnswVerbs = await this.storage.getAllVerbs();
+            // Convert each HNSWVerb to GraphVerb by loading metadata
+            const graphVerbs = [];
+            for (const hnswVerb of hnswVerbs) {
+                const metadata = await this.storage.getVerbMetadata(hnswVerb.id);
+                if (metadata) {
+                    const graphVerb = {
+                        id: hnswVerb.id,
+                        vector: hnswVerb.vector,
+                        sourceId: metadata.sourceId,
+                        targetId: metadata.targetId,
+                        source: metadata.source,
+                        target: metadata.target,
+                        verb: metadata.verb,
+                        type: metadata.type,
+                        weight: metadata.weight,
+                        createdAt: metadata.createdAt,
+                        updatedAt: metadata.updatedAt,
+                        createdBy: metadata.createdBy,
+                        data: metadata.data,
+                        metadata: metadata.data // Alias for backward compatibility
+                    };
+                    graphVerbs.push(graphVerb);
                 }
-            });
-            return result.items;
+                else {
+                    console.warn(`Verb ${hnswVerb.id} found but no metadata - skipping`);
+                }
+            }
+            return graphVerbs;
         }
         catch (error) {
             console.error('Failed to get all verbs:', error);