@soulcraft/brainy 4.8.3 → 4.8.5

package/dist/brainy.js

@@ -464,6 +464,13 @@ export class Brainy {
     async convertNounToEntity(noun) {
         // v4.8.0: Storage adapters ALREADY extract standard fields to top-level!
         // Just read from top-level fields of HNSWNounWithMetadata
+        console.log(`[DEBUG convertNounToEntity] Converting noun ${noun.id}:`, {
+            nounMetadataKeys: noun.metadata ? Object.keys(noun.metadata) : [],
+            nounType: noun.type,
+            hasName: !!noun.metadata?.name,
+            hasPath: !!noun.metadata?.path,
+            hasVfsType: !!noun.metadata?.vfsType
+        });
         // v4.8.0: Clean structure with standard fields at top-level
         const entity = {
             id: noun.id,
@@ -480,6 +487,12 @@ export class Brainy {
             // ONLY custom user fields in metadata (v4.8.0: already separated by storage adapter)
             metadata: noun.metadata
         };
+        console.log(`[DEBUG convertNounToEntity] Converted entity metadata:`, {
+            entityMetadataKeys: entity.metadata ? Object.keys(entity.metadata) : [],
+            metadata_name: entity.metadata?.name,
+            metadata_path: entity.metadata?.path,
+            metadata_vfsType: entity.metadata?.vfsType
+        });
         return entity;
     }
     /**

package/dist/storage/adapters/fileSystemStorage.js

@@ -1057,41 +1057,33 @@ export class FileSystemStorage extends BaseStorage {
      * Get verbs by source
      */
     async getVerbsBySource_internal(sourceId) {
-        console.log(`[DEBUG] getVerbsBySource_internal called for sourceId: ${sourceId}`);
-        console.log(`[DEBUG] verbsDir: ${this.verbsDir}`);
         // Use the working pagination method with source filter
         const result = await this.getVerbsWithPagination({
             limit: 10000,
             filter: { sourceId: [sourceId] }
         });
-        console.log(`[DEBUG] Found ${result.items.length} verbs for source ${sourceId}`);
-        console.log(`[DEBUG] Total verb files found: ${result.totalCount}`);
         return result.items;
     }
     /**
      * Get verbs by target
      */
     async getVerbsByTarget_internal(targetId) {
-        console.log(`[DEBUG] getVerbsByTarget_internal called for targetId: ${targetId}`);
         // Use the working pagination method with target filter
         const result = await this.getVerbsWithPagination({
             limit: 10000,
             filter: { targetId: [targetId] }
         });
-        console.log(`[DEBUG] Found ${result.items.length} verbs for target ${targetId}`);
         return result.items;
     }
     /**
      * Get verbs by type
      */
     async getVerbsByType_internal(type) {
-        console.log(`[DEBUG] getVerbsByType_internal called for type: ${type}`);
         // Use the working pagination method with type filter
         const result = await this.getVerbsWithPagination({
             limit: 10000,
             filter: { verbType: [type] }
         });
-        console.log(`[DEBUG] Found ${result.items.length} verbs for type ${type}`);
         return result.items;
     }
     /**
@@ -1105,12 +1097,10 @@ export class FileSystemStorage extends BaseStorage {
         try {
             // Get actual verb files first (critical for accuracy)
             const verbFiles = await this.getAllShardedFiles(this.verbsDir);
-            console.log(`[DEBUG] getAllShardedFiles returned ${verbFiles.length} files from ${this.verbsDir}`);
             verbFiles.sort(); // Consistent ordering for pagination
             // Use actual file count - don't trust cached totalVerbCount
             // This prevents accessing undefined array elements
             const actualFileCount = verbFiles.length;
-            console.log(`[DEBUG] actualFileCount: ${actualFileCount}, startIndex: ${startIndex}, limit: ${limit}`);
             // For large datasets, warn about performance
             if (actualFileCount > 1000000) {
                 console.warn(`Very large verb dataset detected (${actualFileCount} verbs). Performance may be degraded. Consider database storage for optimal performance.`);
@@ -1182,12 +1172,8 @@ export class FileSystemStorage extends BaseStorage {
                         // Check sourceId filter
                         if (filter.sourceId) {
                             const sources = Array.isArray(filter.sourceId) ? filter.sourceId : [filter.sourceId];
-                            console.log(`[DEBUG] Checking verb ${verbWithMetadata.id}: sourceId=${verbWithMetadata.sourceId}, filter=${JSON.stringify(sources)}`);
-                            if (!sources.includes(verbWithMetadata.sourceId)) {
-                                console.log(`[DEBUG] Verb ${verbWithMetadata.id} filtered out (sourceId mismatch)`);
+                            if (!sources.includes(verbWithMetadata.sourceId))
                                 continue;
-                            }
-                            console.log(`[DEBUG] Verb ${verbWithMetadata.id} MATCHES source filter!`);
                         }
                         // Check targetId filter
                         if (filter.targetId) {
@@ -1969,67 +1955,34 @@ export class FileSystemStorage extends BaseStorage {
      * Traverses all shard subdirectories (00-ff)
      */
     async getAllShardedFiles(baseDir) {
-        console.log(`[DEBUG] getAllShardedFiles called with baseDir: ${baseDir}`);
-        console.log(`[DEBUG] Current working directory: ${process.cwd()}`);
-        console.log(`[DEBUG] Resolved absolute path: ${path.resolve(baseDir)}`);
         const allFiles = [];
         try {
-            // Check if directory exists
-            try {
-                const baseStat = await fs.promises.stat(baseDir);
-                console.log(`[DEBUG] baseDir exists: ${baseStat.isDirectory() ? 'is directory' : 'is NOT directory'}`);
-            }
-            catch (statError) {
-                console.log(`[DEBUG] baseDir stat failed: ${statError.message}`);
-                if (statError.code === 'ENOENT') {
-                    console.log(`[DEBUG] baseDir does not exist, returning empty array`);
-                    return [];
-                }
-                throw statError;
-            }
             const shardDirs = await fs.promises.readdir(baseDir);
-            console.log(`[DEBUG] Found ${shardDirs.length} entries in baseDir: ${JSON.stringify(shardDirs.slice(0, 10))}${shardDirs.length > 10 ? '...' : ''}`);
-            let dirsProcessed = 0;
-            let filesFound = 0;
             for (const shardDir of shardDirs) {
                 const shardPath = path.join(baseDir, shardDir);
                 try {
                     const stat = await fs.promises.stat(shardPath);
                     if (stat.isDirectory()) {
-                        dirsProcessed++;
-                        console.log(`[DEBUG] Processing shard directory ${dirsProcessed}: ${shardDir}`);
                         const shardFiles = await fs.promises.readdir(shardPath);
-                        console.log(`[DEBUG]   Found ${shardFiles.length} entries in ${shardDir}`);
-                        let jsonCount = 0;
                         for (const file of shardFiles) {
                             if (file.endsWith('.json')) {
                                 allFiles.push(file);
-                                jsonCount++;
-                                filesFound++;
                             }
                         }
-                        console.log(`[DEBUG]   Added ${jsonCount} .json files from ${shardDir} (total so far: ${filesFound})`);
-                    }
-                    else {
-                        console.log(`[DEBUG] Skipping non-directory entry: ${shardDir}`);
                     }
                 }
                 catch (shardError) {
                     // Skip inaccessible shard directories
-                    console.log(`[DEBUG] Error accessing shard ${shardDir}: ${shardError.message}`);
                     continue;
                 }
             }
-            console.log(`[DEBUG] getAllShardedFiles complete: processed ${dirsProcessed} directories, found ${allFiles.length} total .json files`);
             // Sort for consistent ordering
             allFiles.sort();
             return allFiles;
         }
         catch (error) {
-            console.log(`[DEBUG] getAllShardedFiles error: ${error.message}, code: ${error.code}`);
             if (error.code === 'ENOENT') {
                 // Directory doesn't exist yet
-                console.log(`[DEBUG] Directory does not exist, returning empty array`);
                 return [];
             }
             throw error;

package/dist/vfs/PathResolver.js

@@ -162,16 +162,29 @@ export class PathResolver {
             from: dirId,
             type: VerbType.Contains
         });
+        console.log(`[DEBUG PathResolver] getChildren(${dirId}): Found ${relations.length} Contains relations`);
         const validChildren = [];
         const childNames = new Set();
         // Fetch all child entities via relationships
         for (const relation of relations) {
             const entity = await this.brain.get(relation.to);
+            console.log(`[DEBUG PathResolver] Retrieved entity ${relation.to}:`, {
+                exists: !!entity,
+                type: entity?.type,
+                hasMetadata: !!entity?.metadata,
+                metadataKeys: entity?.metadata ? Object.keys(entity.metadata) : [],
+                metadata_vfsType: entity?.metadata?.vfsType,
+                metadata_name: entity?.metadata?.name
+            });
             if (entity && entity.metadata?.vfsType && entity.metadata?.name) {
                 validChildren.push(entity);
                 childNames.add(entity.metadata.name);
             }
+            else {
+                console.log(`[DEBUG PathResolver] ❌ FILTERED OUT entity ${relation.to} - missing vfsType or name`);
+            }
         }
+        console.log(`[DEBUG PathResolver] Returning ${validChildren.length} valid children (filtered from ${relations.length})`);
         // Update cache
         this.parentCache.set(dirId, childNames);
         return validChildren;

package/dist/vfs/VirtualFileSystem.js

@@ -683,6 +683,19 @@ export class VirtualFileSystem {
         }
         // Get children
         let children = await this.pathResolver.getChildren(entityId);
+        console.log(`[DEBUG VFS] readdir(${path}): Found ${children.length} children`);
+        // Debug first child
+        if (children.length > 0) {
+            const firstChild = children[0];
+            console.log(`[DEBUG VFS] First child structure:`, {
+                id: firstChild.id,
+                type: firstChild.type,
+                metadataKeys: Object.keys(firstChild.metadata || {}),
+                metadata_name: firstChild.metadata?.name,
+                metadata_path: firstChild.metadata?.path,
+                metadata_vfsType: firstChild.metadata?.vfsType
+            });
+        }
         // Apply filters
         if (options?.filter) {
             children = this.filterDirectoryEntries(children, options.filter);
@@ -702,12 +715,17 @@ export class VirtualFileSystem {
         await this.updateAccessTime(entityId);
         // Return appropriate format
         if (options?.withFileTypes) {
-            return children.map(child => ({
+            const result = children.map(child => ({
                 name: child.metadata.name,
                 path: child.metadata.path,
                 type: child.metadata.vfsType,
                 entityId: child.id
             }));
+            console.log(`[DEBUG VFS] Returning ${result.length} VFSDirent items`);
+            if (result.length > 0) {
+                console.log(`[DEBUG VFS] First VFSDirent:`, result[0]);
+            }
+            return result;
         }
         return children.map(child => child.metadata.name);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soulcraft/brainy",
-  "version": "4.8.3",
+  "version": "4.8.5",
   "description": "Universal Knowledge Protocol™ - World's first Triple Intelligence database unifying vector, graph, and document search in one API. 31 nouns × 40 verbs for infinite expressiveness.",
   "main": "dist/index.js",
   "module": "dist/index.js",