@soulcraft/brainy 5.7.7 → 5.7.9

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [5.7.9](https://github.com/soulcraftlabs/brainy/compare/v5.7.8...v5.7.9) (2025-11-13)
+
+- fix: implement exists: false and missing operators in MetadataIndexManager (b0f72ef)
+
+
+### [5.7.8](https://github.com/soulcraftlabs/brainy/compare/v5.7.7...v5.7.8) (2025-11-13)
+
+- fix: reconstruct Map from JSON for HNSW connections (v5.7.8 hotfix) (f6f2717)
+
+
 ### [5.7.7](https://github.com/soulcraftlabs/brainy/compare/v5.7.6...v5.7.7) (2025-11-13)
 
 - docs: update index architecture documentation for v5.7.7 lazy loading (67039fc)

package/dist/storage/baseStorage.js

@@ -925,9 +925,24 @@ export class BaseStorage extends BaseStorageAdapter {
                                         continue;
                                     }
                                 }
+                                // v5.7.8: Convert connections from plain object to Map (JSON deserialization fix)
+                                // When loaded from JSON, Map becomes plain object - must reconstruct
+                                const connections = new Map();
+                                if (noun.connections && typeof noun.connections === 'object') {
+                                    for (const [levelStr, ids] of Object.entries(noun.connections)) {
+                                        if (Array.isArray(ids)) {
+                                            connections.set(parseInt(levelStr, 10), new Set(ids));
+                                        }
+                                        else if (ids && typeof ids === 'object') {
+                                            // Handle if it's already an array-like or Set-like object
+                                            connections.set(parseInt(levelStr, 10), new Set(Object.values(ids)));
+                                        }
+                                    }
+                                }
                                 // Combine noun + metadata (v5.4.0: Extract standard fields to top-level)
                                 collectedNouns.push({
                                     ...noun,
+                                    connections, // Use reconstructed Map instead of plain object
                                     type: metadata.noun || type, // Required: Extract type from metadata
                                     confidence: metadata.confidence,
                                     weight: metadata.weight,

package/dist/utils/metadataIndex.js

@@ -1322,7 +1322,8 @@ export class MetadataIndexManager {
                         // exists: boolean - check if field exists (any value)
                         case 'exists':
                             if (operand) {
-                                // Get all IDs that have this field (any value) from chunked sparse index with roaring bitmaps (v3.43.0)
+                                // exists: true - Get all IDs that have this field (any value)
+                                // v3.43.0: From chunked sparse index with roaring bitmaps
                                 // v3.44.1: Now fully lazy-loaded via UnifiedCache (no local sparseIndices Map)
                                 const allIntIds = new Set();
                                 // Load sparse index via UnifiedCache (lazy loading)
@@ -1344,6 +1345,76 @@ export class MetadataIndexManager {
                                 // Convert integer IDs back to UUIDs
                                 fieldResults = this.idMapper.intsIterableToUuids(allIntIds);
                             }
+                            else {
+                                // exists: false - Get all IDs that DON'T have this field
+                                // v5.7.9: Fixed excludeVFS bug (was returning empty array)
+                                const allItemIds = await this.getAllIds();
+                                const existsIntIds = new Set();
+                                // Get IDs that HAVE this field
+                                const sparseIndex = await this.loadSparseIndex(field);
+                                if (sparseIndex) {
+                                    for (const chunkId of sparseIndex.getAllChunkIds()) {
+                                        const chunk = await this.chunkManager.loadChunk(field, chunkId);
+                                        if (chunk) {
+                                            for (const bitmap of chunk.entries.values()) {
+                                                for (const intId of bitmap) {
+                                                    existsIntIds.add(intId);
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                // Convert to UUIDs and subtract from all IDs
+                                const existsUuids = this.idMapper.intsIterableToUuids(existsIntIds);
+                                const existsSet = new Set(existsUuids);
+                                fieldResults = allItemIds.filter(id => !existsSet.has(id));
+                            }
+                            break;
+                        // ===== MISSING OPERATOR =====
+                        // missing: boolean - equivalent to exists: !boolean (for compatibility with metadataFilter.ts)
+                        case 'missing':
+                            // missing: true is equivalent to exists: false
+                            // missing: false is equivalent to exists: true
+                            // v5.7.9: Added for API consistency with in-memory metadataFilter
+                            if (operand) {
+                                // missing: true - field does NOT exist (same as exists: false)
+                                const allItemIds = await this.getAllIds();
+                                const existsIntIds = new Set();
+                                const sparseIndex = await this.loadSparseIndex(field);
+                                if (sparseIndex) {
+                                    for (const chunkId of sparseIndex.getAllChunkIds()) {
+                                        const chunk = await this.chunkManager.loadChunk(field, chunkId);
+                                        if (chunk) {
+                                            for (const bitmap of chunk.entries.values()) {
+                                                for (const intId of bitmap) {
+                                                    existsIntIds.add(intId);
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                const existsUuids = this.idMapper.intsIterableToUuids(existsIntIds);
+                                const existsSet = new Set(existsUuids);
+                                fieldResults = allItemIds.filter(id => !existsSet.has(id));
+                            }
+                            else {
+                                // missing: false - field DOES exist (same as exists: true)
+                                const allIntIds = new Set();
+                                const sparseIndex = await this.loadSparseIndex(field);
+                                if (sparseIndex) {
+                                    for (const chunkId of sparseIndex.getAllChunkIds()) {
+                                        const chunk = await this.chunkManager.loadChunk(field, chunkId);
+                                        if (chunk) {
+                                            for (const bitmap of chunk.entries.values()) {
+                                                for (const intId of bitmap) {
+                                                    allIntIds.add(intId);
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                fieldResults = this.idMapper.intsIterableToUuids(allIntIds);
+                            }
                             break;
                     }
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soulcraft/brainy",
-  "version": "5.7.7",
+  "version": "5.7.9",
   "description": "Universal Knowledge Protocol™ - World's first Triple Intelligence database unifying vector, graph, and document search in one API. Stage 3 CANONICAL: 42 nouns × 127 verbs covering 96-97% of all human knowledge.",
   "main": "dist/index.js",
   "module": "dist/index.js",