@soulcraft/brainy 3.10.1 → 3.12.0

package/dist/vfs/PathResolver.d.ts

@@ -40,10 +40,12 @@ export declare class PathResolver {
     private fullResolve;
     /**
      * Resolve a child entity by name within a parent directory
+     * Uses proper graph relationships instead of metadata queries
      */
     private resolveChild;
     /**
      * Get all children of a directory
+     * Uses proper graph relationships to traverse the tree
      */
     getChildren(dirId: string): Promise<VFSEntity[]>;
     /**

package/dist/vfs/PathResolver.js

@@ -122,69 +122,56 @@ export class PathResolver {
     }
     /**
      * Resolve a child entity by name within a parent directory
+     * Uses proper graph relationships instead of metadata queries
      */
     async resolveChild(parentId, name) {
         // Check parent cache first
         const cachedChildren = this.parentCache.get(parentId);
         if (cachedChildren && cachedChildren.has(name)) {
-            // We know this child exists, find it by path since parent queries don't work
-            const parentEntity = await this.getEntity(parentId);
-            const parentPath = parentEntity.metadata.path;
-            const childPath = this.joinPath(parentPath, name);
-            const pathResults = await this.brain.find({
-                where: { path: childPath },
-                limit: 1
-            });
-            if (pathResults.length > 0) {
-                return pathResults[0].entity.id;
-            }
+            // Use cached knowledge to quickly find the child
+            // Still need to verify it exists
         }
-        // Since parent field queries don't work reliably, construct the expected path
-        // and query by path instead
-        const parentEntity = await this.getEntity(parentId);
-        const parentPath = parentEntity.metadata.path;
-        const childPath = this.joinPath(parentPath, name);
-        const results = await this.brain.find({
-            where: { path: childPath },
-            limit: 1
+        // Use proper graph traversal to find children
+        // Get all relationships where parentId contains other entities
+        const relations = await this.brain.getRelations({
+            from: parentId,
+            type: VerbType.Contains
         });
-        if (results.length > 0) {
-            const childId = results[0].entity.id;
-            // Update parent cache
-            if (!this.parentCache.has(parentId)) {
-                this.parentCache.set(parentId, new Set());
+        // Find the child with matching name
+        for (const relation of relations) {
+            const childEntity = await this.brain.get(relation.to);
+            if (childEntity && childEntity.metadata?.name === name) {
+                // Update parent cache
+                if (!this.parentCache.has(parentId)) {
+                    this.parentCache.set(parentId, new Set());
+                }
+                this.parentCache.get(parentId).add(name);
+                return childEntity.id;
             }
-            this.parentCache.get(parentId).add(name);
-            return childId;
         }
         return null;
     }
     /**
      * Get all children of a directory
+     * Uses proper graph relationships to traverse the tree
      */
     async getChildren(dirId) {
-        // Use Brainy's relationship query to find all children
-        const results = await this.brain.find({
-            connected: {
-                from: dirId,
-                via: VerbType.Contains
-            },
-            limit: 10000 // Large limit for directories
+        // Use proper graph API to get all Contains relationships from this directory
+        const relations = await this.brain.getRelations({
+            from: dirId,
+            type: VerbType.Contains
         });
-        // Filter and process valid VFS entities only
         const validChildren = [];
         const childNames = new Set();
-        for (const result of results) {
-            const entity = result.entity;
-            // Only include entities with proper VFS metadata and non-empty names
-            if (entity.metadata?.vfsType &&
-                entity.metadata?.name &&
-                entity.metadata?.path &&
-                entity.id !== dirId) { // Don't include the directory itself
+        // Fetch all child entities
+        for (const relation of relations) {
+            const entity = await this.brain.get(relation.to);
+            if (entity && entity.metadata?.vfsType && entity.metadata?.name) {
                 validChildren.push(entity);
                 childNames.add(entity.metadata.name);
             }
         }
+        // Update cache
         this.parentCache.set(dirId, childNames);
         return validChildren;
     }

package/dist/vfs/VirtualFileSystem.js

@@ -1364,37 +1364,29 @@ export class VirtualFileSystem {
         await this.ensureInitialized();
         const entityId = await this.pathResolver.resolve(path);
         const results = [];
-        // Get all relationships involving this entity (both from and to)
+        // Use proper Brainy relationship API to get all relationships
         const [fromRelations, toRelations] = await Promise.all([
-            this.brain.find({
-                connected: {
-                    from: entityId
-                },
-                limit: 1000
-            }),
-            this.brain.find({
-                connected: {
-                    to: entityId
-                },
-                limit: 1000
-            })
+            this.brain.getRelations({ from: entityId }),
+            this.brain.getRelations({ to: entityId })
         ]);
         // Add outgoing relationships
         for (const rel of fromRelations) {
-            if (rel.entity.metadata?.path) {
+            const targetEntity = await this.brain.get(rel.to);
+            if (targetEntity && targetEntity.metadata?.path) {
                 results.push({
-                    path: rel.entity.metadata.path,
-                    relationship: 'related',
+                    path: targetEntity.metadata.path,
+                    relationship: rel.type || 'related',
                     direction: 'from'
                 });
             }
         }
         // Add incoming relationships
         for (const rel of toRelations) {
-            if (rel.entity.metadata?.path) {
+            const sourceEntity = await this.brain.get(rel.from);
+            if (sourceEntity && sourceEntity.metadata?.path) {
                 results.push({
-                    path: rel.entity.metadata.path,
-                    relationship: 'related',
+                    path: sourceEntity.metadata.path,
+                    relationship: rel.type || 'related',
                     direction: 'to'
                 });
             }
@@ -1405,49 +1397,37 @@ export class VirtualFileSystem {
         await this.ensureInitialized();
         const entityId = await this.pathResolver.resolve(path);
         const relationships = [];
-        // Get all relationships involving this entity (both from and to)
+        // Use proper Brainy relationship API
         const [fromRelations, toRelations] = await Promise.all([
-            this.brain.find({
-                connected: {
-                    from: entityId
-                },
-                limit: 1000
-            }),
-            this.brain.find({
-                connected: {
-                    to: entityId
-                },
-                limit: 1000
-            })
+            this.brain.getRelations({ from: entityId }),
+            this.brain.getRelations({ to: entityId })
         ]);
-        // Add outgoing relationships (exclude parent-child relationships)
+        // Process outgoing relationships (excluding Contains for parent-child)
         for (const rel of fromRelations) {
-            if (rel.entity.metadata?.path && rel.entity.metadata?.vfsType) {
-                // Skip parent-child relationships to focus on user-defined relationships
-                const parentPath = this.getParentPath(rel.entity.metadata.path);
-                if (parentPath !== path) { // Not a direct child
+            if (rel.type !== VerbType.Contains) { // Skip filesystem hierarchy
+                const targetEntity = await this.brain.get(rel.to);
+                if (targetEntity && targetEntity.metadata?.path) {
                     relationships.push({
-                        id: crypto.randomUUID(),
-                        from: path,
-                        to: rel.entity.metadata.path,
-                        type: VerbType.References,
-                        createdAt: Date.now()
+                        id: rel.id || crypto.randomUUID(),
+                        from: entityId,
+                        to: rel.to,
+                        type: rel.type,
+                        createdAt: rel.createdAt || Date.now()
                     });
                 }
             }
         }
-        // Add incoming relationships (exclude parent-child relationships)
+        // Process incoming relationships (excluding Contains for parent-child)
         for (const rel of toRelations) {
-            if (rel.entity.metadata?.path && rel.entity.metadata?.vfsType) {
-                // Skip parent-child relationships to focus on user-defined relationships
-                const parentPath = this.getParentPath(path);
-                if (rel.entity.metadata.path !== parentPath) { // Not the parent
+            if (rel.type !== VerbType.Contains) { // Skip filesystem hierarchy
+                const sourceEntity = await this.brain.get(rel.from);
+                if (sourceEntity && sourceEntity.metadata?.path) {
                     relationships.push({
-                        id: crypto.randomUUID(),
-                        from: rel.entity.metadata.path,
-                        to: path,
-                        type: VerbType.References,
-                        createdAt: Date.now()
+                        id: rel.id || crypto.randomUUID(),
+                        from: rel.from,
+                        to: entityId,
+                        type: rel.type,
+                        createdAt: rel.createdAt || Date.now()
                     });
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soulcraft/brainy",
-  "version": "3.10.1",
+  "version": "3.12.0",
   "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",