@soulcraft/brainy 0.20.0 → 0.22.0

package/dist/unified.js

@@ -5195,19 +5195,115 @@ class HNSWIndexOptimized extends HNSWIndex {
  * Base class for storage adapters that implements statistics tracking
  */
 class BaseStorageAdapter {
+    constructor() {
+        // Statistics cache
+        this.statisticsCache = null;
+        // Batch update timer ID
+        this.statisticsBatchUpdateTimerId = null;
+        // Flag to indicate if statistics have been modified since last save
+        this.statisticsModified = false;
+        // Time of last statistics flush to storage
+        this.lastStatisticsFlushTime = 0;
+        // Minimum time between statistics flushes (5 seconds)
+        this.MIN_FLUSH_INTERVAL_MS = 5000;
+        // Maximum time to wait before flushing statistics (30 seconds)
+        this.MAX_FLUSH_DELAY_MS = 30000;
+    }
     /**
      * Save statistics data
      * @param statistics The statistics data to save
      */
     async saveStatistics(statistics) {
-        await this.saveStatisticsData(statistics);
+        // Update the cache with a deep copy to avoid reference issues
+        this.statisticsCache = {
+            nounCount: { ...statistics.nounCount },
+            verbCount: { ...statistics.verbCount },
+            metadataCount: { ...statistics.metadataCount },
+            hnswIndexSize: statistics.hnswIndexSize,
+            lastUpdated: statistics.lastUpdated
+        };
+        // Schedule a batch update instead of saving immediately
+        this.scheduleBatchUpdate();
     }
     /**
      * Get statistics data
      * @returns Promise that resolves to the statistics data
      */
     async getStatistics() {
-        return await this.getStatisticsData();
+        // If we have cached statistics, return a deep copy
+        if (this.statisticsCache) {
+            return {
+                nounCount: { ...this.statisticsCache.nounCount },
+                verbCount: { ...this.statisticsCache.verbCount },
+                metadataCount: { ...this.statisticsCache.metadataCount },
+                hnswIndexSize: this.statisticsCache.hnswIndexSize,
+                lastUpdated: this.statisticsCache.lastUpdated
+            };
+        }
+        // Otherwise, get from storage
+        const statistics = await this.getStatisticsData();
+        // If we found statistics, update the cache
+        if (statistics) {
+            // Update the cache with a deep copy
+            this.statisticsCache = {
+                nounCount: { ...statistics.nounCount },
+                verbCount: { ...statistics.verbCount },
+                metadataCount: { ...statistics.metadataCount },
+                hnswIndexSize: statistics.hnswIndexSize,
+                lastUpdated: statistics.lastUpdated
+            };
+        }
+        return statistics;
+    }
+    /**
+     * Schedule a batch update of statistics
+     */
+    scheduleBatchUpdate() {
+        // Mark statistics as modified
+        this.statisticsModified = true;
+        // If a timer is already set, don't set another one
+        if (this.statisticsBatchUpdateTimerId !== null) {
+            return;
+        }
+        // Calculate time since last flush
+        const now = Date.now();
+        const timeSinceLastFlush = now - this.lastStatisticsFlushTime;
+        // If we've recently flushed, wait longer before the next flush
+        const delayMs = timeSinceLastFlush < this.MIN_FLUSH_INTERVAL_MS
+            ? this.MAX_FLUSH_DELAY_MS
+            : this.MIN_FLUSH_INTERVAL_MS;
+        // Schedule the batch update
+        this.statisticsBatchUpdateTimerId = setTimeout(() => {
+            this.flushStatistics();
+        }, delayMs);
+    }
+    /**
+     * Flush statistics to storage
+     */
+    async flushStatistics() {
+        // Clear the timer
+        if (this.statisticsBatchUpdateTimerId !== null) {
+            clearTimeout(this.statisticsBatchUpdateTimerId);
+            this.statisticsBatchUpdateTimerId = null;
+        }
+        // If statistics haven't been modified, no need to flush
+        if (!this.statisticsModified || !this.statisticsCache) {
+            return;
+        }
+        try {
+            // Save the statistics to storage
+            await this.saveStatisticsData(this.statisticsCache);
+            // Update the last flush time
+            this.lastStatisticsFlushTime = Date.now();
+            // Reset the modified flag
+            this.statisticsModified = false;
+        }
+        catch (error) {
+            console.error('Failed to flush statistics data:', error);
+            // Mark as still modified so we'll try again later
+            this.statisticsModified = true;
+            // Don't throw the error to avoid disrupting the application
+        }
     }
     /**
      * Increment a statistic counter
@@ -5216,23 +5312,34 @@ class BaseStorageAdapter {
      * @param amount The amount to increment by (default: 1)
      */
     async incrementStatistic(type, service, amount = 1) {
-        // Get current statistics or create default if not exists
-        let statistics = await this.getStatisticsData();
+        // Get current statistics from cache or storage
+        let statistics = this.statisticsCache;
         if (!statistics) {
-            statistics = this.createDefaultStatistics();
+            statistics = await this.getStatisticsData();
+            if (!statistics) {
+                statistics = this.createDefaultStatistics();
+            }
+            // Update the cache
+            this.statisticsCache = {
+                nounCount: { ...statistics.nounCount },
+                verbCount: { ...statistics.verbCount },
+                metadataCount: { ...statistics.metadataCount },
+                hnswIndexSize: statistics.hnswIndexSize,
+                lastUpdated: statistics.lastUpdated
+            };
         }
         // Increment the appropriate counter
         const counterMap = {
-            noun: statistics.nounCount,
-            verb: statistics.verbCount,
-            metadata: statistics.metadataCount
+            noun: this.statisticsCache.nounCount,
+            verb: this.statisticsCache.verbCount,
+            metadata: this.statisticsCache.metadataCount
         };
         const counter = counterMap[type];
         counter[service] = (counter[service] || 0) + amount;
         // Update timestamp
-        statistics.lastUpdated = new Date().toISOString();
-        // Save updated statistics
-        await this.saveStatisticsData(statistics);
+        this.statisticsCache.lastUpdated = new Date().toISOString();
+        // Schedule a batch update instead of saving immediately
+        this.scheduleBatchUpdate();
     }
     /**
      * Decrement a statistic counter
@@ -5241,40 +5348,62 @@ class BaseStorageAdapter {
      * @param amount The amount to decrement by (default: 1)
      */
     async decrementStatistic(type, service, amount = 1) {
-        // Get current statistics or create default if not exists
-        let statistics = await this.getStatisticsData();
+        // Get current statistics from cache or storage
+        let statistics = this.statisticsCache;
         if (!statistics) {
-            statistics = this.createDefaultStatistics();
+            statistics = await this.getStatisticsData();
+            if (!statistics) {
+                statistics = this.createDefaultStatistics();
+            }
+            // Update the cache
+            this.statisticsCache = {
+                nounCount: { ...statistics.nounCount },
+                verbCount: { ...statistics.verbCount },
+                metadataCount: { ...statistics.metadataCount },
+                hnswIndexSize: statistics.hnswIndexSize,
+                lastUpdated: statistics.lastUpdated
+            };
         }
         // Decrement the appropriate counter
         const counterMap = {
-            noun: statistics.nounCount,
-            verb: statistics.verbCount,
-            metadata: statistics.metadataCount
+            noun: this.statisticsCache.nounCount,
+            verb: this.statisticsCache.verbCount,
+            metadata: this.statisticsCache.metadataCount
         };
         const counter = counterMap[type];
         counter[service] = Math.max(0, (counter[service] || 0) - amount);
         // Update timestamp
-        statistics.lastUpdated = new Date().toISOString();
-        // Save updated statistics
-        await this.saveStatisticsData(statistics);
+        this.statisticsCache.lastUpdated = new Date().toISOString();
+        // Schedule a batch update instead of saving immediately
+        this.scheduleBatchUpdate();
     }
     /**
      * Update the HNSW index size statistic
      * @param size The new size of the HNSW index
      */
     async updateHnswIndexSize(size) {
-        // Get current statistics or create default if not exists
-        let statistics = await this.getStatisticsData();
+        // Get current statistics from cache or storage
+        let statistics = this.statisticsCache;
         if (!statistics) {
-            statistics = this.createDefaultStatistics();
+            statistics = await this.getStatisticsData();
+            if (!statistics) {
+                statistics = this.createDefaultStatistics();
+            }
+            // Update the cache
+            this.statisticsCache = {
+                nounCount: { ...statistics.nounCount },
+                verbCount: { ...statistics.verbCount },
+                metadataCount: { ...statistics.metadataCount },
+                hnswIndexSize: statistics.hnswIndexSize,
+                lastUpdated: statistics.lastUpdated
+            };
         }
         // Update HNSW index size
-        statistics.hnswIndexSize = size;
+        this.statisticsCache.hnswIndexSize = size;
         // Update timestamp
-        statistics.lastUpdated = new Date().toISOString();
-        // Save updated statistics
-        await this.saveStatisticsData(statistics);
+        this.statisticsCache.lastUpdated = new Date().toISOString();
+        // Schedule a batch update instead of saving immediately
+        this.scheduleBatchUpdate();
     }
     /**
      * Create default statistics data
@@ -5323,21 +5452,21 @@ class BaseStorage extends BaseStorageAdapter {
      */
     async saveNoun(noun) {
         await this.ensureInitialized();
-        return this.saveNode(noun);
+        return this.saveNoun_internal(noun);
     }
     /**
      * Get a noun from storage
      */
     async getNoun(id) {
         await this.ensureInitialized();
-        return this.getNode(id);
+        return this.getNoun_internal(id);
     }
     /**
      * Get all nouns from storage
      */
     async getAllNouns() {
         await this.ensureInitialized();
-        return this.getAllNodes();
+        return this.getAllNouns_internal();
     }
     /**
      * Get nouns by noun type
@@ -5346,63 +5475,63 @@ class BaseStorage extends BaseStorageAdapter {
      */
     async getNounsByNounType(nounType) {
         await this.ensureInitialized();
-        return this.getNodesByNounType(nounType);
+        return this.getNounsByNounType_internal(nounType);
     }
     /**
      * Delete a noun from storage
      */
     async deleteNoun(id) {
         await this.ensureInitialized();
-        return this.deleteNode(id);
+        return this.deleteNoun_internal(id);
     }
     /**
      * Save a verb to storage
      */
     async saveVerb(verb) {
         await this.ensureInitialized();
-        return this.saveEdge(verb);
+        return this.saveVerb_internal(verb);
     }
     /**
      * Get a verb from storage
      */
     async getVerb(id) {
         await this.ensureInitialized();
-        return this.getEdge(id);
+        return this.getVerb_internal(id);
     }
     /**
      * Get all verbs from storage
      */
     async getAllVerbs() {
         await this.ensureInitialized();
-        return this.getAllEdges();
+        return this.getAllVerbs_internal();
     }
     /**
      * Get verbs by source
      */
     async getVerbsBySource(sourceId) {
         await this.ensureInitialized();
-        return this.getEdgesBySource(sourceId);
+        return this.getVerbsBySource_internal(sourceId);
     }
     /**
      * Get verbs by target
      */
     async getVerbsByTarget(targetId) {
         await this.ensureInitialized();
-        return this.getEdgesByTarget(targetId);
+        return this.getVerbsByTarget_internal(targetId);
     }
     /**
      * Get verbs by type
      */
     async getVerbsByType(type) {
         await this.ensureInitialized();
-        return this.getEdgesByType(type);
+        return this.getVerbsByType_internal(type);
     }
     /**
      * Delete a verb from storage
      */
     async deleteVerb(id) {
         await this.ensureInitialized();
-        return this.deleteEdge(id);
+        return this.deleteVerb_internal(id);
     }
     /**
      * Helper method to convert a Map to a plain object for serialization
@@ -5441,201 +5570,230 @@ class MemoryStorage extends BaseStorage {
         this.isInitialized = true;
     }
     /**
-     * Save a node to storage
+     * Save a noun to storage
      */
-    async saveNode(node) {
+    async saveNoun_internal(noun) {
         // Create a deep copy to avoid reference issues
-        const nodeCopy = {
-            id: node.id,
-            vector: [...node.vector],
+        const nounCopy = {
+            id: noun.id,
+            vector: [...noun.vector],
             connections: new Map()
         };
         // Copy connections
-        for (const [level, connections] of node.connections.entries()) {
-            nodeCopy.connections.set(level, new Set(connections));
+        for (const [level, connections] of noun.connections.entries()) {
+            nounCopy.connections.set(level, new Set(connections));
         }
-        // Save the node directly in the nouns map
-        this.nouns.set(node.id, nodeCopy);
+        // Save the noun directly in the nouns map
+        this.nouns.set(noun.id, nounCopy);
     }
     /**
-     * Get a node from storage
+     * Get a noun from storage
      */
-    async getNode(id) {
-        // Get the node directly from the nouns map
-        const node = this.nouns.get(id);
+    async getNoun_internal(id) {
+        // Get the noun directly from the nouns map
+        const noun = this.nouns.get(id);
         // If not found, return null
-        if (!node) {
+        if (!noun) {
             return null;
         }
         // Return a deep copy to avoid reference issues
-        const nodeCopy = {
-            id: node.id,
-            vector: [...node.vector],
+        const nounCopy = {
+            id: noun.id,
+            vector: [...noun.vector],
             connections: new Map()
         };
         // Copy connections
-        for (const [level, connections] of node.connections.entries()) {
-            nodeCopy.connections.set(level, new Set(connections));
+        for (const [level, connections] of noun.connections.entries()) {
+            nounCopy.connections.set(level, new Set(connections));
         }
-        return nodeCopy;
+        return nounCopy;
     }
     /**
-     * Get all nodes from storage
+     * Get all nouns from storage
      */
-    async getAllNodes() {
-        const allNodes = [];
-        // Iterate through all nodes in the nouns map
-        for (const [nodeId, node] of this.nouns.entries()) {
+    async getAllNouns_internal() {
+        const allNouns = [];
+        // Iterate through all nouns in the nouns map
+        for (const [nounId, noun] of this.nouns.entries()) {
             // Return a deep copy to avoid reference issues
-            const nodeCopy = {
-                id: node.id,
-                vector: [...node.vector],
+            const nounCopy = {
+                id: noun.id,
+                vector: [...noun.vector],
                 connections: new Map()
             };
             // Copy connections
-            for (const [level, connections] of node.connections.entries()) {
-                nodeCopy.connections.set(level, new Set(connections));
+            for (const [level, connections] of noun.connections.entries()) {
+                nounCopy.connections.set(level, new Set(connections));
             }
-            allNodes.push(nodeCopy);
+            allNouns.push(nounCopy);
         }
-        return allNodes;
+        return allNouns;
     }
     /**
-     * Get nodes by noun type
+     * Get nouns 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
+     * @returns Promise that resolves to an array of nouns of the specified noun type
      */
-    async getNodesByNounType(nounType) {
-        const nodes = [];
-        // Iterate through all nodes and filter by noun type using metadata
-        for (const [nodeId, node] of this.nouns.entries()) {
+    async getNounsByNounType_internal(nounType) {
+        const nouns = [];
+        // Iterate through all nouns and filter by noun type using metadata
+        for (const [nounId, noun] of this.nouns.entries()) {
             // Get the metadata to check the noun type
-            const metadata = await this.getMetadata(nodeId);
-            // Include the node if its noun type matches the requested type
+            const metadata = await this.getMetadata(nounId);
+            // Include the noun if its noun type matches the requested type
             if (metadata && metadata.noun === nounType) {
                 // Return a deep copy to avoid reference issues
-                const nodeCopy = {
-                    id: node.id,
-                    vector: [...node.vector],
+                const nounCopy = {
+                    id: noun.id,
+                    vector: [...noun.vector],
                     connections: new Map()
                 };
                 // Copy connections
-                for (const [level, connections] of node.connections.entries()) {
-                    nodeCopy.connections.set(level, new Set(connections));
+                for (const [level, connections] of noun.connections.entries()) {
+                    nounCopy.connections.set(level, new Set(connections));
                 }
-                nodes.push(nodeCopy);
+                nouns.push(nounCopy);
             }
         }
-        return nodes;
+        return nouns;
     }
     /**
-     * Delete a node from storage
+     * Delete a noun from storage
      */
-    async deleteNode(id) {
-        // Delete the node directly from the nouns map
+    async deleteNoun_internal(id) {
         this.nouns.delete(id);
     }
     /**
-     * Save an edge to storage
+     * Save a verb to storage
      */
-    async saveEdge(edge) {
+    async saveVerb_internal(verb) {
         // Create a deep copy to avoid reference issues
-        const edgeCopy = {
-            id: edge.id,
-            vector: [...edge.vector],
+        const verbCopy = {
+            id: verb.id,
+            vector: [...verb.vector],
             connections: new Map(),
-            sourceId: edge.sourceId,
-            targetId: edge.targetId,
-            type: edge.type,
-            weight: edge.weight,
-            metadata: edge.metadata
+            sourceId: verb.sourceId,
+            targetId: verb.targetId,
+            type: verb.type,
+            weight: verb.weight,
+            metadata: verb.metadata
         };
         // Copy connections
-        for (const [level, connections] of edge.connections.entries()) {
-            edgeCopy.connections.set(level, new Set(connections));
+        for (const [level, connections] of verb.connections.entries()) {
+            verbCopy.connections.set(level, new Set(connections));
         }
-        // Save the edge directly in the verbs map
-        this.verbs.set(edge.id, edgeCopy);
+        // Save the verb directly in the verbs map
+        this.verbs.set(verb.id, verbCopy);
     }
     /**
-     * Get an edge from storage
+     * Get a verb from storage
      */
-    async getEdge(id) {
-        // Get the edge directly from the verbs map
-        const edge = this.verbs.get(id);
+    async getVerb_internal(id) {
+        // Get the verb directly from the verbs map
+        const verb = this.verbs.get(id);
         // If not found, return null
-        if (!edge) {
+        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
-        const edgeCopy = {
-            id: edge.id,
-            vector: [...edge.vector],
+        const verbCopy = {
+            id: verb.id,
+            vector: [...verb.vector],
             connections: new Map(),
-            sourceId: edge.sourceId,
-            targetId: edge.targetId,
-            type: edge.type,
-            weight: edge.weight,
-            metadata: edge.metadata
+            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
         };
         // Copy connections
-        for (const [level, connections] of edge.connections.entries()) {
-            edgeCopy.connections.set(level, new Set(connections));
+        for (const [level, connections] of verb.connections.entries()) {
+            verbCopy.connections.set(level, new Set(connections));
         }
-        return edgeCopy;
+        return verbCopy;
     }
     /**
-     * Get all edges from storage
+     * Get all verbs from storage
      */
-    async getAllEdges() {
-        const allEdges = [];
-        // Iterate through all edges in the verbs map
-        for (const [edgeId, edge] of this.verbs.entries()) {
+    async getAllVerbs_internal() {
+        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
-            const edgeCopy = {
-                id: edge.id,
-                vector: [...edge.vector],
+            const verbCopy = {
+                id: verb.id,
+                vector: [...verb.vector],
                 connections: new Map(),
-                sourceId: edge.sourceId,
-                targetId: edge.targetId,
-                type: edge.type,
-                weight: edge.weight,
-                metadata: edge.metadata
+                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
             };
             // Copy connections
-            for (const [level, connections] of edge.connections.entries()) {
-                edgeCopy.connections.set(level, new Set(connections));
+            for (const [level, connections] of verb.connections.entries()) {
+                verbCopy.connections.set(level, new Set(connections));
             }
-            allEdges.push(edgeCopy);
+            allVerbs.push(verbCopy);
         }
-        return allEdges;
+        return allVerbs;
     }
     /**
-     * Get edges by source
+     * Get verbs by source
      */
-    async getEdgesBySource(sourceId) {
-        const edges = await this.getAllEdges();
-        return edges.filter((edge) => edge.sourceId === sourceId);
+    async getVerbsBySource_internal(sourceId) {
+        const allVerbs = await this.getAllVerbs_internal();
+        return allVerbs.filter((verb) => (verb.sourceId || verb.source) === sourceId);
     }
     /**
-     * Get edges by target
+     * Get verbs by target
      */
-    async getEdgesByTarget(targetId) {
-        const edges = await this.getAllEdges();
-        return edges.filter((edge) => edge.targetId === targetId);
+    async getVerbsByTarget_internal(targetId) {
+        const allVerbs = await this.getAllVerbs_internal();
+        return allVerbs.filter((verb) => (verb.targetId || verb.target) === targetId);
     }
     /**
-     * Get edges by type
+     * Get verbs by type
      */
-    async getEdgesByType(type) {
-        const edges = await this.getAllEdges();
-        return edges.filter((edge) => edge.type === type);
+    async getVerbsByType_internal(type) {
+        const allVerbs = await this.getAllVerbs_internal();
+        return allVerbs.filter((verb) => (verb.type || verb.verb) === type);
     }
     /**
-     * Delete an edge from storage
+     * Delete a verb from storage
      */
-    async deleteEdge(id) {
-        // Delete the edge directly from the verbs map
+    async deleteVerb_internal(id) {
+        // Delete the verb directly from the verbs map
         this.verbs.delete(id);
     }
     /**
@@ -5682,6 +5840,7 @@ class MemoryStorage extends BaseStorage {
      * @param statistics The statistics data to save
      */
     async saveStatisticsData(statistics) {
+        // For memory storage, we just need to store the statistics in memory
         // Create a deep copy to avoid reference issues
         this.statistics = {
             nounCount: { ...statistics.nounCount },
@@ -5690,6 +5849,8 @@ class MemoryStorage extends BaseStorage {
             hnswIndexSize: statistics.hnswIndexSize,
             lastUpdated: statistics.lastUpdated
         };
+        // Since this is in-memory, there's no need for time-based partitioning
+        // or legacy file handling
     }
     /**
      * Get statistics data from storage
@@ -5707,6 +5868,8 @@ class MemoryStorage extends BaseStorage {
             hnswIndexSize: this.statistics.hnswIndexSize,
             lastUpdated: this.statistics.lastUpdated
         };
+        // Since this is in-memory, there's no need for fallback mechanisms
+        // to check multiple storage locations
     }
 }
 
@@ -5833,46 +5996,46 @@ class OPFSStorage extends BaseStorage {
         }
     }
     /**
-     * Save a node to storage
+     * Save a noun to storage
      */
-    async saveNode(node) {
+    async saveNoun_internal(noun) {
         await this.ensureInitialized();
         try {
             // Convert connections Map to a serializable format
-            const serializableNode = {
-                ...node,
-                connections: this.mapToObject(node.connections, (set) => Array.from(set))
+            const serializableNoun = {
+                ...noun,
+                connections: this.mapToObject(noun.connections, (set) => Array.from(set))
             };
             // Create or get the file for this noun
-            const fileHandle = await this.nounsDir.getFileHandle(node.id, {
+            const fileHandle = await this.nounsDir.getFileHandle(noun.id, {
                 create: true
             });
             // Write the noun data to the file
             const writable = await fileHandle.createWritable();
-            await writable.write(JSON.stringify(serializableNode));
+            await writable.write(JSON.stringify(serializableNoun));
             await writable.close();
         }
         catch (error) {
-            console.error(`Failed to save node ${node.id}:`, error);
-            throw new Error(`Failed to save node ${node.id}: ${error}`);
+            console.error(`Failed to save noun ${noun.id}:`, error);
+            throw new Error(`Failed to save noun ${noun.id}: ${error}`);
         }
     }
     /**
-     * Get a node from storage
+     * Get a noun from storage
      */
-    async getNode(id) {
+    async getNoun_internal(id) {
         await this.ensureInitialized();
         try {
-            // Get the file handle for this node
+            // Get the file handle for this noun
             const fileHandle = await this.nounsDir.getFileHandle(id);
-            // Read the node data from the file
+            // Read the noun data from the file
             const file = await fileHandle.getFile();
             const text = await file.text();
             const data = JSON.parse(text);
             // Convert serialized connections back to Map<number, Set<string>>
             const connections = new Map();
-            for (const [level, nodeIds] of Object.entries(data.connections)) {
-                connections.set(Number(level), new Set(nodeIds));
+            for (const [level, nounIds] of Object.entries(data.connections)) {
+                connections.set(Number(level), new Set(nounIds));
             }
             return {
                 id: data.id,
@@ -5881,38 +6044,38 @@ class OPFSStorage extends BaseStorage {
             };
         }
         catch (error) {
-            // Node not found or other error
+            // Noun not found or other error
             return null;
         }
     }
     /**
-     * Get all nodes from storage
+     * Get all nouns from storage
      */
-    async getAllNodes() {
+    async getAllNouns_internal() {
         await this.ensureInitialized();
-        const allNodes = [];
+        const allNouns = [];
         try {
             // Iterate through all files in the nouns directory
             for await (const [name, handle] of this.nounsDir.entries()) {
                 if (handle.kind === 'file') {
                     try {
-                        // Read the node data from the file
+                        // Read the noun data from the file
                         const file = await safeGetFile(handle);
                         const text = await file.text();
                         const data = JSON.parse(text);
                         // Convert serialized connections back to Map<number, Set<string>>
                         const connections = new Map();
-                        for (const [level, nodeIds] of Object.entries(data.connections)) {
-                            connections.set(Number(level), new Set(nodeIds));
+                        for (const [level, nounIds] of Object.entries(data.connections)) {
+                            connections.set(Number(level), new Set(nounIds));
                         }
-                        allNodes.push({
+                        allNouns.push({
                             id: data.id,
                             vector: data.vector,
                             connections
                         });
                     }
                     catch (error) {
-                        console.error(`Error reading node file ${name}:`, error);
+                        console.error(`Error reading noun file ${name}:`, error);
                     }
                 }
             }
@@ -5920,7 +6083,15 @@ class OPFSStorage extends BaseStorage {
         catch (error) {
             console.error('Error reading nouns directory:', error);
         }
-        return allNodes;
+        return allNouns;
+    }
+    /**
+     * Get nouns by noun type (internal implementation)
+     * @param nounType The noun type to filter by
+     * @returns Promise that resolves to an array of nouns of the specified noun type
+     */
+    async getNounsByNounType_internal(nounType) {
+        return this.getNodesByNounType(nounType);
     }
     /**
      * Get nodes by noun type
@@ -5966,6 +6137,12 @@ class OPFSStorage extends BaseStorage {
         }
         return nodes;
     }
+    /**
+     * Delete a noun from storage (internal implementation)
+     */
+    async deleteNoun_internal(id) {
+        return this.deleteNode(id);
+    }
     /**
      * Delete a node from storage
      */
@@ -5982,6 +6159,12 @@ class OPFSStorage extends BaseStorage {
             }
         }
     }
+    /**
+     * Save a verb to storage (internal implementation)
+     */
+    async saveVerb_internal(verb) {
+        return this.saveEdge(verb);
+    }
     /**
      * Save an edge to storage
      */
@@ -6007,6 +6190,12 @@ class OPFSStorage extends BaseStorage {
             throw new Error(`Failed to save edge ${edge.id}: ${error}`);
         }
     }
+    /**
+     * Get a verb from storage (internal implementation)
+     */
+    async getVerb_internal(id) {
+        return this.getEdge(id);
+    }
     /**
      * Get an edge from storage
      */
@@ -6024,15 +6213,30 @@ class OPFSStorage extends BaseStorage {
             for (const [level, nodeIds] of Object.entries(data.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'
+            };
             return {
                 id: data.id,
                 vector: data.vector,
                 connections,
-                sourceId: data.sourceId,
-                targetId: data.targetId,
-                type: data.type,
+                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
+                metadata: data.metadata,
+                createdAt: data.createdAt || defaultTimestamp,
+                updatedAt: data.updatedAt || defaultTimestamp,
+                createdBy: data.createdBy || defaultCreatedBy
             };
         }
         catch (error) {
@@ -6040,6 +6244,12 @@ class OPFSStorage extends BaseStorage {
             return null;
         }
     }
+    /**
+     * Get all verbs from storage (internal implementation)
+     */
+    async getAllVerbs_internal() {
+        return this.getAllEdges();
+    }
     /**
      * Get all edges from storage
      */
@@ -6060,15 +6270,30 @@ class OPFSStorage extends BaseStorage {
                         for (const [level, nodeIds] of Object.entries(data.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'
+                        };
                         allEdges.push({
                             id: data.id,
                             vector: data.vector,
                             connections,
-                            sourceId: data.sourceId,
-                            targetId: data.targetId,
-                            type: data.type,
+                            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
+                            metadata: data.metadata,
+                            createdAt: data.createdAt || defaultTimestamp,
+                            updatedAt: data.updatedAt || defaultTimestamp,
+                            createdBy: data.createdBy || defaultCreatedBy
                         });
                     }
                     catch (error) {
@@ -6082,26 +6307,50 @@ class OPFSStorage extends BaseStorage {
         }
         return allEdges;
     }
+    /**
+     * Get verbs by source (internal implementation)
+     */
+    async getVerbsBySource_internal(sourceId) {
+        return this.getEdgesBySource(sourceId);
+    }
     /**
      * Get edges by source
      */
     async getEdgesBySource(sourceId) {
         const edges = await this.getAllEdges();
-        return edges.filter((edge) => edge.sourceId === sourceId);
+        return edges.filter((edge) => (edge.sourceId || edge.source) === sourceId);
+    }
+    /**
+     * Get verbs by target (internal implementation)
+     */
+    async getVerbsByTarget_internal(targetId) {
+        return this.getEdgesByTarget(targetId);
     }
     /**
      * Get edges by target
      */
     async getEdgesByTarget(targetId) {
         const edges = await this.getAllEdges();
-        return edges.filter((edge) => edge.targetId === targetId);
+        return edges.filter((edge) => (edge.targetId || edge.target) === targetId);
+    }
+    /**
+     * Get verbs by type (internal implementation)
+     */
+    async getVerbsByType_internal(type) {
+        return this.getEdgesByType(type);
     }
     /**
      * Get edges by type
      */
     async getEdgesByType(type) {
         const edges = await this.getAllEdges();
-        return edges.filter((edge) => edge.type === type);
+        return edges.filter((edge) => (edge.type || edge.verb) === type);
+    }
+    /**
+     * Delete a verb from storage (internal implementation)
+     */
+    async deleteVerb_internal(id) {
+        return this.deleteEdge(id);
     }
     /**
      * Delete an edge from storage
@@ -6315,6 +6564,31 @@ class OPFSStorage extends BaseStorage {
             };
         }
     }
+    /**
+     * Get the statistics key for a specific date
+     * @param date The date to get the key for
+     * @returns The statistics key for the specified date
+     */
+    getStatisticsKeyForDate(date) {
+        const year = date.getUTCFullYear();
+        const month = String(date.getUTCMonth() + 1).padStart(2, '0');
+        const day = String(date.getUTCDate()).padStart(2, '0');
+        return `statistics_${year}${month}${day}.json`;
+    }
+    /**
+     * Get the current statistics key
+     * @returns The current statistics key
+     */
+    getCurrentStatisticsKey() {
+        return this.getStatisticsKeyForDate(new Date());
+    }
+    /**
+     * Get the legacy statistics key (for backward compatibility)
+     * @returns The legacy statistics key
+     */
+    getLegacyStatisticsKey() {
+        return 'statistics.json';
+    }
     /**
      * Save statistics data to storage
      * @param statistics The statistics data to save
@@ -6335,8 +6609,10 @@ class OPFSStorage extends BaseStorage {
             if (!this.indexDir) {
                 throw new Error('Index directory not initialized');
             }
+            // Get the current statistics key
+            const currentKey = this.getCurrentStatisticsKey();
             // Create a file for the statistics data
-            const fileHandle = await this.indexDir.getFileHandle('statistics.json', {
+            const fileHandle = await this.indexDir.getFileHandle(currentKey, {
                 create: true
             });
             // Create a writable stream
@@ -6345,6 +6621,16 @@ class OPFSStorage extends BaseStorage {
             await writable.write(JSON.stringify(this.statistics, null, 2));
             // Close the stream
             await writable.close();
+            // Also update the legacy key for backward compatibility, but less frequently
+            if (Math.random() < 0.1) {
+                const legacyKey = this.getLegacyStatisticsKey();
+                const legacyFileHandle = await this.indexDir.getFileHandle(legacyKey, {
+                    create: true
+                });
+                const legacyWritable = await legacyFileHandle.createWritable();
+                await legacyWritable.write(JSON.stringify(this.statistics, null, 2));
+                await legacyWritable.close();
+            }
         }
         catch (error) {
             console.error('Failed to save statistics data:', error);
@@ -6372,17 +6658,15 @@ class OPFSStorage extends BaseStorage {
             if (!this.indexDir) {
                 throw new Error('Index directory not initialized');
             }
+            // First try to get statistics from today's file
+            const currentKey = this.getCurrentStatisticsKey();
             try {
-                // Try to get the statistics file
-                const fileHandle = await this.indexDir.getFileHandle('statistics.json', {
+                const fileHandle = await this.indexDir.getFileHandle(currentKey, {
                     create: false
                 });
-                // Get the file data
                 const file = await fileHandle.getFile();
                 const text = await file.text();
-                // Parse the statistics data
                 this.statistics = JSON.parse(text);
-                // Return a deep copy
                 if (this.statistics) {
                     return {
                         nounCount: { ...this.statistics.nounCount },
@@ -6392,13 +6676,57 @@ class OPFSStorage extends BaseStorage {
                         lastUpdated: this.statistics.lastUpdated
                     };
                 }
-                // If statistics is null, return default statistics
-                return this.createDefaultStatistics();
             }
             catch (error) {
-                // If the file doesn't exist, return null
-                return null;
+                // If today's file doesn't exist, try yesterday's file
+                const yesterday = new Date();
+                yesterday.setDate(yesterday.getDate() - 1);
+                const yesterdayKey = this.getStatisticsKeyForDate(yesterday);
+                try {
+                    const fileHandle = await this.indexDir.getFileHandle(yesterdayKey, {
+                        create: false
+                    });
+                    const file = await fileHandle.getFile();
+                    const text = await file.text();
+                    this.statistics = JSON.parse(text);
+                    if (this.statistics) {
+                        return {
+                            nounCount: { ...this.statistics.nounCount },
+                            verbCount: { ...this.statistics.verbCount },
+                            metadataCount: { ...this.statistics.metadataCount },
+                            hnswIndexSize: this.statistics.hnswIndexSize,
+                            lastUpdated: this.statistics.lastUpdated
+                        };
+                    }
+                }
+                catch (error) {
+                    // If yesterday's file doesn't exist, try the legacy file
+                    const legacyKey = this.getLegacyStatisticsKey();
+                    try {
+                        const fileHandle = await this.indexDir.getFileHandle(legacyKey, {
+                            create: false
+                        });
+                        const file = await fileHandle.getFile();
+                        const text = await file.text();
+                        this.statistics = JSON.parse(text);
+                        if (this.statistics) {
+                            return {
+                                nounCount: { ...this.statistics.nounCount },
+                                verbCount: { ...this.statistics.verbCount },
+                                metadataCount: { ...this.statistics.metadataCount },
+                                hnswIndexSize: this.statistics.hnswIndexSize,
+                                lastUpdated: this.statistics.lastUpdated
+                            };
+                        }
+                    }
+                    catch (error) {
+                        // If the legacy file doesn't exist either, return null
+                        return null;
+                    }
+                }
             }
+            // If we get here and statistics is null, return default statistics
+            return this.statistics ? this.statistics : null;
         }
         catch (error) {
             console.error('Failed to get statistics data:', error);
@@ -6490,66 +6818,66 @@ class FileSystemStorage extends BaseStorage {
         }
     }
     /**
-     * Save a node to storage
+     * Save a noun to storage
      */
-    async saveNode(node) {
+    async saveNoun_internal(noun) {
         await this.ensureInitialized();
         // Convert connections Map to a serializable format
-        const serializableNode = {
-            ...node,
-            connections: this.mapToObject(node.connections, (set) => Array.from(set))
+        const serializableNoun = {
+            ...noun,
+            connections: this.mapToObject(noun.connections, (set) => Array.from(set))
         };
-        const filePath = path.join(this.nounsDir, `${node.id}.json`);
-        await fs.promises.writeFile(filePath, JSON.stringify(serializableNode, null, 2));
+        const filePath = path.join(this.nounsDir, `${noun.id}.json`);
+        await fs.promises.writeFile(filePath, JSON.stringify(serializableNoun, null, 2));
     }
     /**
-     * Get a node from storage
+     * Get a noun from storage
      */
-    async getNode(id) {
+    async getNoun_internal(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);
+            const parsedNoun = 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));
+            for (const [level, nounIds] of Object.entries(parsedNoun.connections)) {
+                connections.set(Number(level), new Set(nounIds));
             }
             return {
-                id: parsedNode.id,
-                vector: parsedNode.vector,
+                id: parsedNoun.id,
+                vector: parsedNoun.vector,
                 connections
             };
         }
         catch (error) {
             if (error.code !== 'ENOENT') {
-                console.error(`Error reading node ${id}:`, error);
+                console.error(`Error reading noun ${id}:`, error);
             }
             return null;
         }
     }
     /**
-     * Get all nodes from storage
+     * Get all nouns from storage
      */
-    async getAllNodes() {
+    async getAllNouns_internal() {
         await this.ensureInitialized();
-        const allNodes = [];
+        const allNouns = [];
         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);
+                    const parsedNoun = 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));
+                    for (const [level, nounIds] of Object.entries(parsedNoun.connections)) {
+                        connections.set(Number(level), new Set(nounIds));
                     }
-                    allNodes.push({
-                        id: parsedNode.id,
-                        vector: parsedNode.vector,
+                    allNouns.push({
+                        id: parsedNoun.id,
+                        vector: parsedNoun.vector,
                         connections
                     });
                 }
@@ -6560,14 +6888,14 @@ class FileSystemStorage extends BaseStorage {
                 console.error(`Error reading directory ${this.nounsDir}:`, error);
             }
         }
-        return allNodes;
+        return allNouns;
     }
     /**
-     * Get nodes by noun type
+     * Get nouns 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
+     * @returns Promise that resolves to an array of nouns of the specified noun type
      */
-    async getNodesByNounType(nounType) {
+    async getNounsByNounType_internal(nounType) {
         await this.ensureInitialized();
         const nouns = [];
         try {
@@ -6576,19 +6904,19 @@ class FileSystemStorage extends BaseStorage {
                 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);
+                    const parsedNoun = JSON.parse(data);
                     // Filter by noun type using metadata
-                    const nodeId = parsedNode.id;
-                    const metadata = await this.getMetadata(nodeId);
+                    const nounId = parsedNoun.id;
+                    const metadata = await this.getMetadata(nounId);
                     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));
+                        for (const [level, nounIds] of Object.entries(parsedNoun.connections)) {
+                            connections.set(Number(level), new Set(nounIds));
                         }
                         nouns.push({
-                            id: parsedNode.id,
-                            vector: parsedNode.vector,
+                            id: parsedNoun.id,
+                            vector: parsedNoun.vector,
                             connections
                         });
                     }
@@ -6603,9 +6931,9 @@ class FileSystemStorage extends BaseStorage {
         return nouns;
     }
     /**
-     * Delete a node from storage
+     * Delete a noun from storage
      */
-    async deleteNode(id) {
+    async deleteNoun_internal(id) {
         await this.ensureInitialized();
         const filePath = path.join(this.nounsDir, `${id}.json`);
         try {
@@ -6613,83 +6941,98 @@ class FileSystemStorage extends BaseStorage {
         }
         catch (error) {
             if (error.code !== 'ENOENT') {
-                console.error(`Error deleting node file ${filePath}:`, error);
+                console.error(`Error deleting noun ${id}:`, error);
                 throw error;
             }
         }
     }
     /**
-     * Save an edge to storage
+     * Save a verb to storage
      */
-    async saveEdge(edge) {
+    async saveVerb_internal(verb) {
         await this.ensureInitialized();
         // Convert connections Map to a serializable format
-        const serializableEdge = {
-            ...edge,
-            connections: this.mapToObject(edge.connections, (set) => Array.from(set))
+        const serializableVerb = {
+            ...verb,
+            connections: this.mapToObject(verb.connections, (set) => Array.from(set))
         };
-        const filePath = path.join(this.verbsDir, `${edge.id}.json`);
-        await fs.promises.writeFile(filePath, JSON.stringify(serializableEdge, null, 2));
+        const filePath = path.join(this.verbsDir, `${verb.id}.json`);
+        await fs.promises.writeFile(filePath, JSON.stringify(serializableVerb, null, 2));
     }
     /**
-     * Get an edge from storage
+     * Get a verb from storage
      */
-    async getEdge(id) {
+    async getVerb_internal(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);
+            const parsedVerb = 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)) {
+            for (const [level, nodeIds] of Object.entries(parsedVerb.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'
+            };
             return {
-                id: parsedEdge.id,
-                vector: parsedEdge.vector,
+                id: parsedVerb.id,
+                vector: parsedVerb.vector,
                 connections,
-                sourceId: parsedEdge.sourceId,
-                targetId: parsedEdge.targetId,
-                type: parsedEdge.type,
-                weight: parsedEdge.weight,
-                metadata: parsedEdge.metadata
+                sourceId: parsedVerb.sourceId || parsedVerb.source,
+                targetId: parsedVerb.targetId || parsedVerb.target,
+                source: parsedVerb.sourceId || parsedVerb.source,
+                target: parsedVerb.targetId || parsedVerb.target,
+                verb: parsedVerb.type || parsedVerb.verb,
+                weight: parsedVerb.weight,
+                metadata: parsedVerb.metadata,
+                createdAt: parsedVerb.createdAt || defaultTimestamp,
+                updatedAt: parsedVerb.updatedAt || defaultTimestamp,
+                createdBy: parsedVerb.createdBy || defaultCreatedBy
             };
         }
         catch (error) {
             if (error.code !== 'ENOENT') {
-                console.error(`Error reading edge ${id}:`, error);
+                console.error(`Error reading verb ${id}:`, error);
             }
             return null;
         }
     }
     /**
-     * Get all edges from storage
+     * Get all verbs from storage
      */
-    async getAllEdges() {
+    async getAllVerbs_internal() {
         await this.ensureInitialized();
-        const allEdges = [];
+        const allVerbs = [];
         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);
+                    const parsedVerb = 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)) {
+                    for (const [level, nodeIds] of Object.entries(parsedVerb.connections)) {
                         connections.set(Number(level), new Set(nodeIds));
                     }
-                    allEdges.push({
-                        id: parsedEdge.id,
-                        vector: parsedEdge.vector,
+                    allVerbs.push({
+                        id: parsedVerb.id,
+                        vector: parsedVerb.vector,
                         connections,
-                        sourceId: parsedEdge.sourceId,
-                        targetId: parsedEdge.targetId,
-                        type: parsedEdge.type,
-                        weight: parsedEdge.weight,
-                        metadata: parsedEdge.metadata
+                        sourceId: parsedVerb.sourceId,
+                        targetId: parsedVerb.targetId,
+                        type: parsedVerb.type,
+                        weight: parsedVerb.weight,
+                        metadata: parsedVerb.metadata
                     });
                 }
             }
@@ -6699,33 +7042,33 @@ class FileSystemStorage extends BaseStorage {
                 console.error(`Error reading directory ${this.verbsDir}:`, error);
             }
         }
-        return allEdges;
+        return allVerbs;
     }
     /**
-     * Get edges by source
+     * Get verbs by source
      */
-    async getEdgesBySource(sourceId) {
-        const edges = await this.getAllEdges();
-        return edges.filter((edge) => edge.sourceId === sourceId);
+    async getVerbsBySource_internal(sourceId) {
+        const verbs = await this.getAllVerbs_internal();
+        return verbs.filter((verb) => (verb.sourceId || verb.source) === sourceId);
     }
     /**
-     * Get edges by target
+     * Get verbs by target
      */
-    async getEdgesByTarget(targetId) {
-        const edges = await this.getAllEdges();
-        return edges.filter((edge) => edge.targetId === targetId);
+    async getVerbsByTarget_internal(targetId) {
+        const verbs = await this.getAllVerbs_internal();
+        return verbs.filter((verb) => (verb.targetId || verb.target) === targetId);
     }
     /**
-     * Get edges by type
+     * Get verbs by type
      */
-    async getEdgesByType(type) {
-        const edges = await this.getAllEdges();
-        return edges.filter((edge) => edge.type === type);
+    async getVerbsByType_internal(type) {
+        const verbs = await this.getAllVerbs_internal();
+        return verbs.filter((verb) => (verb.type || verb.verb) === type);
     }
     /**
-     * Delete an edge from storage
+     * Delete a verb from storage
      */
-    async deleteEdge(id) {
+    async deleteVerb_internal(id) {
         await this.ensureInitialized();
         const filePath = path.join(this.verbsDir, `${id}.json`);
         try {
@@ -6733,7 +7076,7 @@ class FileSystemStorage extends BaseStorage {
         }
         catch (error) {
             if (error.code !== 'ENOENT') {
-                console.error(`Error deleting edge file ${filePath}:`, error);
+                console.error(`Error deleting verb file ${filePath}:`, error);
                 throw error;
             }
         }
@@ -6893,8 +7236,20 @@ class FileSystemStorage extends BaseStorage {
     async saveStatisticsData(statistics) {
         await this.ensureInitialized();
         try {
-            const filePath = path.join(this.indexDir, `${STATISTICS_KEY}.json`);
-            await fs.promises.writeFile(filePath, JSON.stringify(statistics, null, 2));
+            // Get the current date for time-based partitioning
+            const now = new Date();
+            const year = now.getUTCFullYear();
+            const month = String(now.getUTCMonth() + 1).padStart(2, '0');
+            const day = String(now.getUTCDate()).padStart(2, '0');
+            const dateStr = `${year}${month}${day}`;
+            // Save to the current day's file
+            const currentFilePath = path.join(this.indexDir, `${STATISTICS_KEY}_${dateStr}.json`);
+            await fs.promises.writeFile(currentFilePath, JSON.stringify(statistics, null, 2));
+            // Also update the legacy file for backward compatibility (less frequently)
+            if (Math.random() < 0.1) {
+                const legacyFilePath = path.join(this.indexDir, `${STATISTICS_KEY}.json`);
+                await fs.promises.writeFile(legacyFilePath, JSON.stringify(statistics, null, 2));
+            }
         }
         catch (error) {
             console.error('Failed to save statistics data:', error);
@@ -6908,15 +7263,54 @@ class FileSystemStorage extends BaseStorage {
     async getStatisticsData() {
         await this.ensureInitialized();
         try {
-            const filePath = path.join(this.indexDir, `${STATISTICS_KEY}.json`);
-            const data = await fs.promises.readFile(filePath, 'utf-8');
-            return JSON.parse(data);
+            // Try to get statistics from today's file first
+            const now = new Date();
+            const year = now.getUTCFullYear();
+            const month = String(now.getUTCMonth() + 1).padStart(2, '0');
+            const day = String(now.getUTCDate()).padStart(2, '0');
+            const dateStr = `${year}${month}${day}`;
+            const currentFilePath = path.join(this.indexDir, `${STATISTICS_KEY}_${dateStr}.json`);
+            try {
+                const data = await fs.promises.readFile(currentFilePath, 'utf-8');
+                return JSON.parse(data);
+            }
+            catch (currentError) {
+                // If today's file doesn't exist, try yesterday's file
+                if (currentError.code === 'ENOENT') {
+                    const yesterday = new Date();
+                    yesterday.setDate(yesterday.getDate() - 1);
+                    const yesterdayYear = yesterday.getUTCFullYear();
+                    const yesterdayMonth = String(yesterday.getUTCMonth() + 1).padStart(2, '0');
+                    const yesterdayDay = String(yesterday.getUTCDate()).padStart(2, '0');
+                    const yesterdayDateStr = `${yesterdayYear}${yesterdayMonth}${yesterdayDay}`;
+                    const yesterdayFilePath = path.join(this.indexDir, `${STATISTICS_KEY}_${yesterdayDateStr}.json`);
+                    try {
+                        const yesterdayData = await fs.promises.readFile(yesterdayFilePath, 'utf-8');
+                        return JSON.parse(yesterdayData);
+                    }
+                    catch (yesterdayError) {
+                        // If yesterday's file doesn't exist, try the legacy file
+                        if (yesterdayError.code === 'ENOENT') {
+                            const legacyFilePath = path.join(this.indexDir, `${STATISTICS_KEY}.json`);
+                            try {
+                                const legacyData = await fs.promises.readFile(legacyFilePath, 'utf-8');
+                                return JSON.parse(legacyData);
+                            }
+                            catch (legacyError) {
+                                // If the legacy file doesn't exist either, return null
+                                if (legacyError.code === 'ENOENT') {
+                                    return null;
+                                }
+                                throw legacyError;
+                            }
+                        }
+                        throw yesterdayError;
+                    }
+                }
+                throw currentError;
+            }
         }
         catch (error) {
-            // If the file doesn't exist, return null
-            if (error.code === 'ENOENT') {
-                return null;
-            }
             console.error('Error getting statistics data:', error);
             throw error;
         }
@@ -6960,6 +7354,16 @@ class S3CompatibleStorage extends BaseStorage {
         this.s3Client = null;
         // Statistics caching for better performance
         this.statisticsCache = null;
+        // Batch update timer ID
+        this.statisticsBatchUpdateTimerId = null;
+        // Flag to indicate if statistics have been modified since last save
+        this.statisticsModified = false;
+        // Time of last statistics flush to storage
+        this.lastStatisticsFlushTime = 0;
+        // Minimum time between statistics flushes (5 seconds)
+        this.MIN_FLUSH_INTERVAL_MS = 5000;
+        // Maximum time to wait before flushing statistics (30 seconds)
+        this.MAX_FLUSH_DELAY_MS = 30000;
         this.bucketName = options.bucketName;
         this.region = options.region || 'auto';
         this.endpoint = options.endpoint;
@@ -7018,6 +7422,12 @@ class S3CompatibleStorage extends BaseStorage {
             throw new Error(`Failed to initialize ${this.serviceType} storage: ${error}`);
         }
     }
+    /**
+     * Save a noun to storage (internal implementation)
+     */
+    async saveNoun_internal(noun) {
+        return this.saveNode(noun);
+    }
     /**
      * Save a node to storage
      */
@@ -7067,6 +7477,12 @@ class S3CompatibleStorage extends BaseStorage {
             throw new Error(`Failed to save node ${node.id}: ${error}`);
         }
     }
+    /**
+     * Get a noun from storage (internal implementation)
+     */
+    async getNoun_internal(id) {
+        return this.getNode(id);
+    }
     /**
      * Get a node from storage
      */
@@ -7124,6 +7540,12 @@ class S3CompatibleStorage extends BaseStorage {
             return null;
         }
     }
+    /**
+     * Get all nouns from storage (internal implementation)
+     */
+    async getAllNouns_internal() {
+        return this.getAllNodes();
+    }
     /**
      * Get all nodes from storage
      */
@@ -7222,6 +7644,14 @@ class S3CompatibleStorage extends BaseStorage {
             return [];
         }
     }
+    /**
+     * Get nouns by noun type (internal implementation)
+     * @param nounType The noun type to filter by
+     * @returns Promise that resolves to an array of nouns of the specified noun type
+     */
+    async getNounsByNounType_internal(nounType) {
+        return this.getNodesByNounType(nounType);
+    }
     /**
      * Get nodes by noun type
      * @param nounType The noun type to filter by
@@ -7247,6 +7677,12 @@ class S3CompatibleStorage extends BaseStorage {
             return [];
         }
     }
+    /**
+     * Delete a noun from storage (internal implementation)
+     */
+    async deleteNoun_internal(id) {
+        return this.deleteNode(id);
+    }
     /**
      * Delete a node from storage
      */
@@ -7266,6 +7702,12 @@ class S3CompatibleStorage extends BaseStorage {
             throw new Error(`Failed to delete node ${id}: ${error}`);
         }
     }
+    /**
+     * Save a verb to storage (internal implementation)
+     */
+    async saveVerb_internal(verb) {
+        return this.saveEdge(verb);
+    }
     /**
      * Save an edge to storage
      */
@@ -7292,6 +7734,12 @@ class S3CompatibleStorage extends BaseStorage {
             throw new Error(`Failed to save edge ${edge.id}: ${error}`);
         }
     }
+    /**
+     * Get a verb from storage (internal implementation)
+     */
+    async getVerb_internal(id) {
+        return this.getEdge(id);
+    }
     /**
      * Get an edge from storage
      */
@@ -7322,7 +7770,9 @@ class S3CompatibleStorage extends BaseStorage {
                 console.log(`Parsed edge data for ${id}:`, parsedEdge);
                 // Ensure the parsed edge has the expected properties
                 if (!parsedEdge || !parsedEdge.id || !parsedEdge.vector || !parsedEdge.connections ||
-                    !parsedEdge.sourceId || !parsedEdge.targetId || !parsedEdge.type) {
+                    !(parsedEdge.sourceId || parsedEdge.source) ||
+                    !(parsedEdge.targetId || parsedEdge.target) ||
+                    !(parsedEdge.type || parsedEdge.verb)) {
                     console.error(`Invalid edge data for ${id}:`, parsedEdge);
                     return null;
                 }
@@ -7331,15 +7781,31 @@ 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,
-                    targetId: parsedEdge.targetId,
-                    type: parsedEdge.type,
+                    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 || {}
+                    metadata: parsedEdge.metadata || {},
+                    createdAt: parsedEdge.createdAt || defaultTimestamp,
+                    updatedAt: parsedEdge.updatedAt || defaultTimestamp,
+                    createdBy: parsedEdge.createdBy || defaultCreatedBy
                 };
                 console.log(`Successfully retrieved edge ${id}:`, edge);
                 return edge;
@@ -7355,6 +7821,12 @@ class S3CompatibleStorage extends BaseStorage {
             return null;
         }
     }
+    /**
+     * Get all verbs from storage (internal implementation)
+     */
+    async getAllVerbs_internal() {
+        return this.getAllEdges();
+    }
     /**
      * Get all edges from storage
      */
@@ -7391,15 +7863,31 @@ 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'
+                    };
                     return {
                         id: parsedEdge.id,
                         vector: parsedEdge.vector,
                         connections,
-                        sourceId: parsedEdge.sourceId,
-                        targetId: parsedEdge.targetId,
-                        type: parsedEdge.type,
-                        weight: parsedEdge.weight,
-                        metadata: parsedEdge.metadata
+                        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,
+                        metadata: parsedEdge.metadata || {},
+                        createdAt: parsedEdge.createdAt || defaultTimestamp,
+                        updatedAt: parsedEdge.updatedAt || defaultTimestamp,
+                        createdBy: parsedEdge.createdBy || defaultCreatedBy
                     };
                 }
                 catch (error) {
@@ -7416,26 +7904,50 @@ class S3CompatibleStorage extends BaseStorage {
             return [];
         }
     }
+    /**
+     * Get verbs by source (internal implementation)
+     */
+    async getVerbsBySource_internal(sourceId) {
+        return this.getEdgesBySource(sourceId);
+    }
     /**
      * Get edges by source
      */
     async getEdgesBySource(sourceId) {
         const edges = await this.getAllEdges();
-        return edges.filter((edge) => edge.sourceId === sourceId);
+        return edges.filter((edge) => (edge.sourceId || edge.source) === sourceId);
+    }
+    /**
+     * Get verbs by target (internal implementation)
+     */
+    async getVerbsByTarget_internal(targetId) {
+        return this.getEdgesByTarget(targetId);
     }
     /**
      * Get edges by target
      */
     async getEdgesByTarget(targetId) {
         const edges = await this.getAllEdges();
-        return edges.filter((edge) => edge.targetId === targetId);
+        return edges.filter((edge) => (edge.targetId || edge.target) === targetId);
+    }
+    /**
+     * Get verbs by type (internal implementation)
+     */
+    async getVerbsByType_internal(type) {
+        return this.getEdgesByType(type);
     }
     /**
      * Get edges by type
      */
     async getEdgesByType(type) {
         const edges = await this.getAllEdges();
-        return edges.filter((edge) => edge.type === type);
+        return edges.filter((edge) => (edge.type || edge.verb) === type);
+    }
+    /**
+     * Delete a verb from storage (internal implementation)
+     */
+    async deleteVerb_internal(id) {
+        return this.deleteEdge(id);
     }
     /**
      * Delete an edge from storage
@@ -7723,6 +8235,102 @@ class S3CompatibleStorage extends BaseStorage {
             };
         }
     }
+    /**
+     * Get the statistics key for a specific date
+     * @param date The date to get the key for
+     * @returns The statistics key for the specified date
+     */
+    getStatisticsKeyForDate(date) {
+        const year = date.getUTCFullYear();
+        const month = String(date.getUTCMonth() + 1).padStart(2, '0');
+        const day = String(date.getUTCDate()).padStart(2, '0');
+        return `${this.indexPrefix}${STATISTICS_KEY}_${year}${month}${day}.json`;
+    }
+    /**
+     * Get the current statistics key
+     * @returns The current statistics key
+     */
+    getCurrentStatisticsKey() {
+        return this.getStatisticsKeyForDate(new Date());
+    }
+    /**
+     * Get the legacy statistics key (for backward compatibility)
+     * @returns The legacy statistics key
+     */
+    getLegacyStatisticsKey() {
+        return `${this.indexPrefix}${STATISTICS_KEY}.json`;
+    }
+    /**
+     * Schedule a batch update of statistics
+     */
+    scheduleBatchUpdate() {
+        // Mark statistics as modified
+        this.statisticsModified = true;
+        // If a timer is already set, don't set another one
+        if (this.statisticsBatchUpdateTimerId !== null) {
+            return;
+        }
+        // Calculate time since last flush
+        const now = Date.now();
+        const timeSinceLastFlush = now - this.lastStatisticsFlushTime;
+        // If we've recently flushed, wait longer before the next flush
+        const delayMs = timeSinceLastFlush < this.MIN_FLUSH_INTERVAL_MS
+            ? this.MAX_FLUSH_DELAY_MS
+            : this.MIN_FLUSH_INTERVAL_MS;
+        // Schedule the batch update
+        this.statisticsBatchUpdateTimerId = setTimeout(() => {
+            this.flushStatistics();
+        }, delayMs);
+    }
+    /**
+     * Flush statistics to storage
+     */
+    async flushStatistics() {
+        // Clear the timer
+        if (this.statisticsBatchUpdateTimerId !== null) {
+            clearTimeout(this.statisticsBatchUpdateTimerId);
+            this.statisticsBatchUpdateTimerId = null;
+        }
+        // If statistics haven't been modified, no need to flush
+        if (!this.statisticsModified || !this.statisticsCache) {
+            return;
+        }
+        try {
+            // Import the PutObjectCommand only when needed
+            const { PutObjectCommand } = await import('@aws-sdk/client-s3');
+            // Get the current statistics key
+            const key = this.getCurrentStatisticsKey();
+            const body = JSON.stringify(this.statisticsCache, null, 2);
+            // Save the statistics to S3-compatible storage
+            await this.s3Client.send(new PutObjectCommand({
+                Bucket: this.bucketName,
+                Key: key,
+                Body: body,
+                ContentType: 'application/json'
+            }));
+            // Update the last flush time
+            this.lastStatisticsFlushTime = Date.now();
+            // Reset the modified flag
+            this.statisticsModified = false;
+            // Also update the legacy key for backward compatibility, but less frequently
+            // Only update it once every 10 flushes (approximately)
+            if (Math.random() < 0.1) {
+                const legacyKey = this.getLegacyStatisticsKey();
+                await this.s3Client.send(new PutObjectCommand({
+                    Bucket: this.bucketName,
+                    Key: legacyKey,
+                    Body: body,
+                    ContentType: 'application/json'
+                }));
+            }
+        }
+        catch (error) {
+            console.error('Failed to flush statistics data:', error);
+            // Mark as still modified so we'll try again later
+            this.statisticsModified = true;
+            // Don't throw the error to avoid disrupting the application
+        }
+    }
     /**
      * Save statistics data to storage
      * @param statistics The statistics data to save
@@ -7738,17 +8346,8 @@ class S3CompatibleStorage extends BaseStorage {
                 hnswIndexSize: statistics.hnswIndexSize,
                 lastUpdated: statistics.lastUpdated
             };
-            // Import the PutObjectCommand only when needed
-            const { PutObjectCommand } = await import('@aws-sdk/client-s3');
-            const key = `${this.indexPrefix}${STATISTICS_KEY}.json`;
-            const body = JSON.stringify(statistics, null, 2);
-            // Save the statistics to S3-compatible storage
-            await this.s3Client.send(new PutObjectCommand({
-                Bucket: this.bucketName,
-                Key: key,
-                Body: body,
-                ContentType: 'application/json'
-            }));
+            // Schedule a batch update instead of saving immediately
+            this.scheduleBatchUpdate();
         }
         catch (error) {
             console.error('Failed to save statistics data:', error);
@@ -7774,8 +8373,49 @@ class S3CompatibleStorage extends BaseStorage {
         try {
             // Import the GetObjectCommand only when needed
             const { GetObjectCommand } = await import('@aws-sdk/client-s3');
-            const key = `${this.indexPrefix}${STATISTICS_KEY}.json`;
-            // Try to get the statistics from the index directory
+            // First try to get statistics from today's file
+            const currentKey = this.getCurrentStatisticsKey();
+            let statistics = await this.tryGetStatisticsFromKey(currentKey);
+            // If not found, try yesterday's file (in case it's just after midnight)
+            if (!statistics) {
+                const yesterday = new Date();
+                yesterday.setDate(yesterday.getDate() - 1);
+                const yesterdayKey = this.getStatisticsKeyForDate(yesterday);
+                statistics = await this.tryGetStatisticsFromKey(yesterdayKey);
+            }
+            // If still not found, try the legacy location
+            if (!statistics) {
+                const legacyKey = this.getLegacyStatisticsKey();
+                statistics = await this.tryGetStatisticsFromKey(legacyKey);
+            }
+            // If we found statistics, update the cache
+            if (statistics) {
+                // Update the cache with a deep copy
+                this.statisticsCache = {
+                    nounCount: { ...statistics.nounCount },
+                    verbCount: { ...statistics.verbCount },
+                    metadataCount: { ...statistics.metadataCount },
+                    hnswIndexSize: statistics.hnswIndexSize,
+                    lastUpdated: statistics.lastUpdated
+                };
+            }
+            return statistics;
+        }
+        catch (error) {
+            console.error('Error getting statistics data:', error);
+            throw error;
+        }
+    }
+    /**
+     * Try to get statistics from a specific key
+     * @param key The key to try to get statistics from
+     * @returns The statistics data or null if not found
+     */
+    async tryGetStatisticsFromKey(key) {
+        try {
+            // Import the GetObjectCommand only when needed
+            const { GetObjectCommand } = await import('@aws-sdk/client-s3');
+            // Try to get the statistics from the specified key
             const response = await this.s3Client.send(new GetObjectCommand({
                 Bucket: this.bucketName,
                 Key: key
@@ -7786,17 +8426,8 @@ class S3CompatibleStorage extends BaseStorage {
             }
             // Convert the response body to a string
             const bodyContents = await response.Body.transformToString();
-            // Parse the JSON string and update the cache
-            const statistics = JSON.parse(bodyContents);
-            // Update the cache with a deep copy
-            this.statisticsCache = {
-                nounCount: { ...statistics.nounCount },
-                verbCount: { ...statistics.verbCount },
-                metadataCount: { ...statistics.metadataCount },
-                hnswIndexSize: statistics.hnswIndexSize,
-                lastUpdated: statistics.lastUpdated
-            };
-            return statistics;
+            // Parse the JSON string
+            return JSON.parse(bodyContents);
         }
         catch (error) {
             // Check if this is a "NoSuchKey" error (object doesn't exist)
@@ -7806,7 +8437,7 @@ class S3CompatibleStorage extends BaseStorage {
                     error.message.includes('does not exist')))) {
                 return null;
             }
-            console.error('Error getting statistics data:', error);
+            // For other errors, propagate them
             throw error;
         }
     }
@@ -11325,16 +11956,32 @@ class BrainyData {
                     verbType = VerbType.RelatedTo;
                 }
             }
+            // Get service name from options or current augmentation
+            const service = options.service || this.getCurrentAugmentation();
+            // Create timestamp for creation/update time
+            const now = new Date();
+            const timestamp = {
+                seconds: Math.floor(now.getTime() / 1000),
+                nanoseconds: (now.getTime() % 1000) * 1000000
+            };
             // Create verb
             const verb = {
                 id,
                 vector: verbVector,
                 connections: new Map(),
-                sourceId,
-                targetId,
-                type: verbType,
+                sourceId: sourceId,
+                targetId: targetId,
+                source: sourceId,
+                target: targetId,
+                verb: verbType,
                 weight: options.weight,
-                metadata: options.metadata
+                metadata: options.metadata,
+                createdAt: timestamp,
+                updatedAt: timestamp,
+                createdBy: {
+                    augmentation: service,
+                    version: '1.0' // TODO: Get actual version from augmentation
+                }
             };
             // Add to index
             await this.index.addItem({ id, vector: verbVector });
@@ -11348,8 +11995,8 @@ class BrainyData {
             // Save verb to storage
             await this.storage.saveVerb(verb);
             // Track verb statistics
-            const service = options.service || 'default';
-            await this.storage.incrementStatistic('verb', service);
+            const serviceForStats = options.service || 'default';
+            await this.storage.incrementStatistic('verb', serviceForStats);
             // Update HNSW index size (excluding verbs)
             await this.storage.updateHnswIndexSize(await this.getNounCount());
             return id;