@soulcraft/brainy 4.1.4 → 4.2.0

package/dist/importers/SmartDOCXImporter.js

@@ -0,0 +1,227 @@
+/**
+ * Smart DOCX Importer
+ *
+ * Extracts entities and relationships from Word documents using:
+ * - Mammoth parser for DOCX → HTML/text conversion
+ * - Heading extraction for document structure
+ * - Table extraction for structured data
+ * - NeuralEntityExtractor for entity extraction from paragraphs
+ * - NaturalLanguageProcessor for relationship inference
+ * - Hierarchical relationship creation based on heading hierarchy
+ *
+ * v4.2.0: New format handler
+ * NO MOCKS - Production-ready implementation
+ */
+import { NeuralEntityExtractor } from '../neural/entityExtractor.js';
+import { NaturalLanguageProcessor } from '../neural/naturalLanguageProcessor.js';
+import { SmartRelationshipExtractor } from '../neural/SmartRelationshipExtractor.js';
+import { VerbType } from '../types/graphTypes.js';
+// Dynamic import for mammoth (ESM compatibility)
+let mammoth;
+/**
+ * SmartDOCXImporter - Extracts structured knowledge from Word documents
+ */
+export class SmartDOCXImporter {
+    constructor(brain) {
+        this.mammothLoaded = false;
+        this.brain = brain;
+        this.extractor = new NeuralEntityExtractor(brain);
+        this.nlp = new NaturalLanguageProcessor(brain);
+        this.relationshipExtractor = new SmartRelationshipExtractor(brain);
+    }
+    /**
+     * Initialize the importer
+     */
+    async init() {
+        await this.nlp.init();
+        // Lazy load mammoth
+        if (!this.mammothLoaded) {
+            try {
+                mammoth = await import('mammoth');
+                this.mammothLoaded = true;
+            }
+            catch (error) {
+                throw new Error(`Failed to load mammoth parser: ${error.message}`);
+            }
+        }
+    }
+    /**
+     * Extract entities and relationships from DOCX buffer
+     */
+    async extract(buffer, options = {}) {
+        const startTime = Date.now();
+        // Ensure mammoth is loaded
+        if (!this.mammothLoaded) {
+            await this.init();
+        }
+        // Extract raw text for entity extraction
+        const textResult = await mammoth.extractRawText({ buffer });
+        // Extract HTML for structure analysis (headings, tables)
+        const htmlResult = await mammoth.convertToHtml({ buffer });
+        // Process the document
+        const result = await this.extractFromContent(textResult.value, htmlResult.value, options);
+        result.processingTime = Date.now() - startTime;
+        return result;
+    }
+    /**
+     * Extract entities and relationships from parsed DOCX content
+     */
+    async extractFromContent(rawText, html, options) {
+        const opts = {
+            enableNeuralExtraction: options.enableNeuralExtraction !== false,
+            enableHierarchicalRelationships: options.enableHierarchicalRelationships !== false,
+            enableConceptExtraction: options.enableConceptExtraction !== false,
+            confidenceThreshold: options.confidenceThreshold || 0.6,
+            minParagraphLength: options.minParagraphLength || 20
+        };
+        const entities = [];
+        const relationships = [];
+        const entityMap = new Map();
+        const stats = {
+            byType: {},
+            bySection: {},
+            byConfidence: { high: 0, medium: 0, low: 0 }
+        };
+        // Parse document structure from HTML
+        const structure = this.parseStructure(html);
+        // Split into paragraphs
+        const paragraphs = rawText.split(/\n\n+/).filter(p => p.trim().length >= opts.minParagraphLength);
+        let currentSection = 'Introduction';
+        let headingIndex = 0;
+        // Process each paragraph
+        for (let i = 0; i < paragraphs.length; i++) {
+            const paragraph = paragraphs[i].trim();
+            // Check if this paragraph is a heading
+            if (headingIndex < structure.headings.length) {
+                const heading = structure.headings[headingIndex];
+                if (paragraph.startsWith(heading.text) || heading.text.includes(paragraph.substring(0, 50))) {
+                    currentSection = heading.text;
+                    headingIndex++;
+                    stats.bySection[currentSection] = 0;
+                    continue;
+                }
+            }
+            // Extract entities from paragraph
+            if (opts.enableNeuralExtraction) {
+                const extractedEntities = await this.extractor.extract(paragraph, {
+                    confidence: opts.confidenceThreshold
+                });
+                for (const extracted of extractedEntities) {
+                    const entityId = `para${i}:${extracted.text}`;
+                    const entity = {
+                        id: entityId,
+                        name: extracted.text,
+                        type: extracted.type,
+                        description: paragraph,
+                        confidence: extracted.confidence,
+                        weight: extracted.weight || 1.0,
+                        section: currentSection,
+                        paragraphIndex: i,
+                        metadata: {
+                            position: extracted.position,
+                            headingContext: currentSection
+                        }
+                    };
+                    entities.push(entity);
+                    entityMap.set(entityId, entityId);
+                    // Update stats
+                    stats.byType[entity.type] = (stats.byType[entity.type] || 0) + 1;
+                    stats.bySection[currentSection] = (stats.bySection[currentSection] || 0) + 1;
+                    if (entity.confidence > 0.8)
+                        stats.byConfidence.high++;
+                    else if (entity.confidence >= 0.6)
+                        stats.byConfidence.medium++;
+                    else
+                        stats.byConfidence.low++;
+                }
+            }
+            // Report progress
+            if (options.onProgress && i % 10 === 0) {
+                options.onProgress({
+                    processed: i,
+                    entities: entities.length,
+                    relationships: relationships.length
+                });
+            }
+        }
+        // Create hierarchical relationships based on sections
+        if (opts.enableHierarchicalRelationships) {
+            const entitiesBySection = new Map();
+            for (const entity of entities) {
+                const section = entity.section || 'Unknown';
+                if (!entitiesBySection.has(section)) {
+                    entitiesBySection.set(section, []);
+                }
+                entitiesBySection.get(section).push(entity);
+            }
+            // Create relationships within sections
+            for (const [section, sectionEntities] of entitiesBySection) {
+                for (let i = 0; i < sectionEntities.length - 1; i++) {
+                    for (let j = i + 1; j < Math.min(i + 3, sectionEntities.length); j++) {
+                        const entityA = sectionEntities[i];
+                        const entityB = sectionEntities[j];
+                        // Infer relationship type using SmartRelationshipExtractor
+                        // Combine entity descriptions for better context
+                        const context = `In section "${section}": ${entityA.description.substring(0, 150)}... ${entityB.description.substring(0, 150)}...`;
+                        const inferredRelationship = await this.relationshipExtractor.infer(entityA.name, entityB.name, context, {
+                            subjectType: entityA.type,
+                            objectType: entityB.type
+                        });
+                        relationships.push({
+                            from: entityA.id,
+                            to: entityB.id,
+                            type: inferredRelationship?.type || VerbType.RelatedTo, // Fallback to RelatedTo for co-occurrence
+                            confidence: inferredRelationship?.confidence || 0.7,
+                            weight: inferredRelationship?.weight || 0.8,
+                            evidence: inferredRelationship?.evidence || `Both entities appear in section: ${section}`
+                        });
+                    }
+                }
+            }
+        }
+        // Final progress report
+        if (options.onProgress) {
+            options.onProgress({
+                processed: paragraphs.length,
+                entities: entities.length,
+                relationships: relationships.length
+            });
+        }
+        return {
+            paragraphsProcessed: paragraphs.length,
+            entitiesExtracted: entities.length,
+            relationshipsInferred: relationships.length,
+            entities,
+            relationships,
+            entityMap,
+            processingTime: 0, // Will be set by caller
+            structure,
+            stats
+        };
+    }
+    /**
+     * Parse document structure from HTML
+     */
+    parseStructure(html) {
+        const headings = [];
+        // Extract headings (h1-h6)
+        const headingRegex = /<h([1-6])>(.*?)<\/h\1>/gi;
+        let match;
+        let index = 0;
+        while ((match = headingRegex.exec(html)) !== null) {
+            const level = parseInt(match[1]);
+            const text = match[2].replace(/<[^>]+>/g, '').trim(); // Strip HTML tags
+            headings.push({ level, text, index: index++ });
+        }
+        // Count paragraphs
+        const paragraphCount = (html.match(/<p>/g) || []).length;
+        // Count tables
+        const tableCount = (html.match(/<table>/g) || []).length;
+        return {
+            headings,
+            paragraphCount,
+            tableCount
+        };
+    }
+}
+//# sourceMappingURL=SmartDOCXImporter.js.map

package/dist/importers/SmartExcelImporter.d.ts

@@ -88,6 +88,16 @@ export interface SmartExcelResult {
             low: number;
         };
     };
+    /** Sheet-specific data for VFS extraction (v4.2.0) */
+    sheets?: Array<{
+        name: string;
+        rows: ExtractedRow[];
+        stats: {
+            rowCount: number;
+            entityCount: number;
+            relationshipCount: number;
+        };
+    }>;
 }
 /**
  * SmartExcelImporter - Extracts structured knowledge from Excel files
@@ -96,6 +106,7 @@ export declare class SmartExcelImporter {
     private brain;
     private extractor;
     private nlp;
+    private relationshipExtractor;
     private excelHandler;
     constructor(brain: Brainy);
     /**
@@ -119,7 +130,7 @@ export declare class SmartExcelImporter {
      */
     private mapTypeString;
     /**
-     * Infer relationship type from context
+     * Infer relationship type from context using SmartRelationshipExtractor
      */
     private inferRelationship;
     /**

package/dist/importers/SmartExcelImporter.js

@@ -10,6 +10,7 @@
  */
 import { NeuralEntityExtractor } from '../neural/entityExtractor.js';
 import { NaturalLanguageProcessor } from '../neural/naturalLanguageProcessor.js';
+import { SmartRelationshipExtractor } from '../neural/SmartRelationshipExtractor.js';
 import { NounType, VerbType } from '../types/graphTypes.js';
 import { ExcelHandler } from '../augmentations/intelligentImport/handlers/excelHandler.js';
 /**
@@ -20,6 +21,7 @@ export class SmartExcelImporter {
         this.brain = brain;
         this.extractor = new NeuralEntityExtractor(brain);
         this.nlp = new NaturalLanguageProcessor(brain);
+        this.relationshipExtractor = new SmartRelationshipExtractor(brain);
         this.excelHandler = new ExcelHandler();
     }
     /**
@@ -131,7 +133,9 @@ export class SmartExcelImporter {
                 if (opts.enableRelationshipInference) {
                     // Extract relationships from definition text
                     for (const relEntity of relatedEntities) {
-                        const verbType = await this.inferRelationship(term, relEntity.text, definition);
+                        const verbType = await this.inferRelationship(term, relEntity.text, definition, mainEntityType, // Pass subject type hint
+                        relEntity.type // Pass object type hint
+                        );
                         relationships.push({
                             from: entityId,
                             to: relEntity.text,
@@ -145,10 +149,13 @@ export class SmartExcelImporter {
                         const terms = relatedTerms.split(/[,;]/).map(t => t.trim()).filter(Boolean);
                         for (const relTerm of terms) {
                             if (relTerm.toLowerCase() !== term.toLowerCase()) {
+                                // Use SmartRelationshipExtractor even for explicit relationships
+                                const verbType = await this.inferRelationship(term, relTerm, `${term} related to ${relTerm}. ${definition}`, // Combine for better context
+                                mainEntityType);
                                 relationships.push({
                                     from: entityId,
                                     to: relTerm,
-                                    type: VerbType.RelatedTo,
+                                    type: verbType,
                                     confidence: 0.9,
                                     evidence: `Explicitly listed in "Related" column`
                                 });
@@ -203,6 +210,26 @@ export class SmartExcelImporter {
                 phase: 'extracting'
             });
         }
+        // Group rows by sheet for VFS extraction (v4.2.0)
+        const sheetGroups = new Map();
+        extractedRows.forEach((extractedRow, index) => {
+            const originalRow = rows[index];
+            const sheetName = originalRow._sheet || 'Sheet1';
+            if (!sheetGroups.has(sheetName)) {
+                sheetGroups.set(sheetName, []);
+            }
+            sheetGroups.get(sheetName).push(extractedRow);
+        });
+        // Build sheet-specific statistics
+        const sheets = Array.from(sheetGroups.entries()).map(([name, sheetRows]) => ({
+            name,
+            rows: sheetRows,
+            stats: {
+                rowCount: sheetRows.length,
+                entityCount: sheetRows.reduce((sum, row) => sum + 1 + row.relatedEntities.length, 0),
+                relationshipCount: sheetRows.reduce((sum, row) => sum + row.relationships.length, 0)
+            }
+        }));
         return {
             rowsProcessed: rows.length,
             entitiesExtracted: extractedRows.reduce((sum, row) => sum + 1 + row.relatedEntities.length, 0),
@@ -210,7 +237,8 @@ export class SmartExcelImporter {
             rows: extractedRows,
             entityMap,
             processingTime: Date.now() - startTime,
-            stats
+            stats,
+            sheets
         };
     }
     /**
@@ -270,29 +298,16 @@ export class SmartExcelImporter {
         return mapping[normalized] || NounType.Thing;
     }
     /**
-     * Infer relationship type from context
+     * Infer relationship type from context using SmartRelationshipExtractor
      */
-    async inferRelationship(fromTerm, toTerm, context) {
-        const lowerContext = context.toLowerCase();
-        // Pattern-based relationship detection
-        const patterns = [
-            [new RegExp(`${toTerm}.*of.*${fromTerm}`, 'i'), VerbType.PartOf],
-            [new RegExp(`${fromTerm}.*contains.*${toTerm}`, 'i'), VerbType.Contains],
-            [new RegExp(`located in.*${toTerm}`, 'i'), VerbType.LocatedAt],
-            [new RegExp(`ruled by.*${toTerm}`, 'i'), VerbType.Owns],
-            [new RegExp(`capital.*${toTerm}`, 'i'), VerbType.Contains],
-            [new RegExp(`created by.*${toTerm}`, 'i'), VerbType.CreatedBy],
-            [new RegExp(`authored by.*${toTerm}`, 'i'), VerbType.CreatedBy],
-            [new RegExp(`part of.*${toTerm}`, 'i'), VerbType.PartOf],
-            [new RegExp(`related to.*${toTerm}`, 'i'), VerbType.RelatedTo]
-        ];
-        for (const [pattern, verbType] of patterns) {
-            if (pattern.test(lowerContext)) {
-                return verbType;
-            }
-        }
-        // Default to RelatedTo
-        return VerbType.RelatedTo;
+    async inferRelationship(fromTerm, toTerm, context, fromType, toType) {
+        // Use SmartRelationshipExtractor for robust relationship classification
+        const result = await this.relationshipExtractor.infer(fromTerm, toTerm, context, {
+            subjectType: fromType,
+            objectType: toType
+        });
+        // Return inferred type or fallback to RelatedTo
+        return result?.type || VerbType.RelatedTo;
     }
     /**
      * Generate consistent entity ID from name

package/dist/importers/SmartJSONImporter.d.ts

@@ -95,6 +95,7 @@ export declare class SmartJSONImporter {
     private brain;
     private extractor;
     private nlp;
+    private relationshipExtractor;
     constructor(brain: Brainy);
     /**
      * Initialize the importer

package/dist/importers/SmartJSONImporter.js

@@ -11,6 +11,7 @@
  */
 import { NeuralEntityExtractor } from '../neural/entityExtractor.js';
 import { NaturalLanguageProcessor } from '../neural/naturalLanguageProcessor.js';
+import { SmartRelationshipExtractor } from '../neural/SmartRelationshipExtractor.js';
 import { NounType, VerbType } from '../types/graphTypes.js';
 /**
  * SmartJSONImporter - Extracts structured knowledge from JSON files
@@ -20,6 +21,7 @@ export class SmartJSONImporter {
         this.brain = brain;
         this.extractor = new NeuralEntityExtractor(brain);
         this.nlp = new NaturalLanguageProcessor(brain);
+        this.relationshipExtractor = new SmartRelationshipExtractor(brain);
     }
     /**
      * Initialize the importer
@@ -120,12 +122,20 @@ export class SmartJSONImporter {
                 // Create hierarchical relationship if parent exists
                 if (options.enableHierarchicalRelationships && parentPath && entityMap.has(parentPath)) {
                     const parentId = entityMap.get(parentPath);
+                    // Extract parent and child names from paths
+                    const parentName = parentPath.split('.').pop()?.replace(/\[(\d+)\]/, 'item $1') || 'parent';
+                    const childName = entity.name;
+                    // Infer relationship type using SmartRelationshipExtractor
+                    const context = `Hierarchical JSON structure: ${parentName} contains ${childName}. Parent path: ${parentPath}, Child path: ${path}`;
+                    const inferredRelationship = await this.relationshipExtractor.infer(parentName, childName, context, {
+                        objectType: entity.type // Pass child entity type as hint
+                    });
                     relationships.push({
                         from: parentId,
                         to: entity.id,
-                        type: VerbType.Contains,
-                        confidence: 0.95,
-                        evidence: `Hierarchical relationship: ${parentPath} contains ${path}`
+                        type: inferredRelationship?.type || VerbType.Contains, // Fallback to Contains for hierarchical relationships
+                        confidence: inferredRelationship?.confidence || 0.95,
+                        evidence: inferredRelationship?.evidence || `Hierarchical relationship: ${parentPath} contains ${path}`
                     });
                 }
             }
@@ -165,12 +175,21 @@ export class SmartJSONImporter {
                     // Link to parent if exists
                     if (options.enableHierarchicalRelationships && parentPath && entityMap.has(parentPath)) {
                         const parentId = entityMap.get(parentPath);
+                        // Extract parent name from path
+                        const parentName = parentPath.split('.').pop()?.replace(/\[(\d+)\]/, 'item $1') || 'parent';
+                        const childName = entity.name;
+                        // Infer relationship type using SmartRelationshipExtractor
+                        // Context: entity was extracted from string value within parent container
+                        const context = `Entity "${childName}" found in text value at path ${path} within parent "${parentName}". Full text: "${node.substring(0, 200)}..."`;
+                        const inferredRelationship = await this.relationshipExtractor.infer(parentName, childName, context, {
+                            objectType: entity.type // Pass extracted entity type as hint
+                        });
                         relationships.push({
                             from: parentId,
                             to: entity.id,
-                            type: VerbType.RelatedTo,
-                            confidence: extracted.confidence * 0.9,
-                            evidence: `Found in: ${path}`
+                            type: inferredRelationship?.type || VerbType.RelatedTo, // Fallback to RelatedTo for text extraction
+                            confidence: inferredRelationship?.confidence || (extracted.confidence * 0.9),
+                            evidence: inferredRelationship?.evidence || `Found in: ${path}`
                         });
                     }
                 }

package/dist/importers/SmartMarkdownImporter.d.ts

@@ -107,6 +107,7 @@ export declare class SmartMarkdownImporter {
     private brain;
     private extractor;
     private nlp;
+    private relationshipExtractor;
     constructor(brain: Brainy);
     /**
      * Initialize the importer
@@ -145,7 +146,7 @@ export declare class SmartMarkdownImporter {
      */
     private entitiesAreRelated;
     /**
-     * Infer relationship type from context
+     * Infer relationship type from context using SmartRelationshipExtractor
      */
     private inferRelationship;
     /**

package/dist/importers/SmartMarkdownImporter.js

@@ -11,6 +11,7 @@
  */
 import { NeuralEntityExtractor } from '../neural/entityExtractor.js';
 import { NaturalLanguageProcessor } from '../neural/naturalLanguageProcessor.js';
+import { SmartRelationshipExtractor } from '../neural/SmartRelationshipExtractor.js';
 import { NounType, VerbType } from '../types/graphTypes.js';
 /**
  * SmartMarkdownImporter - Extracts structured knowledge from Markdown files
@@ -20,6 +21,7 @@ export class SmartMarkdownImporter {
         this.brain = brain;
         this.extractor = new NeuralEntityExtractor(brain);
         this.nlp = new NaturalLanguageProcessor(brain);
+        this.relationshipExtractor = new SmartRelationshipExtractor(brain);
     }
     /**
      * Initialize the importer
@@ -321,23 +323,16 @@ export class SmartMarkdownImporter {
         return Math.abs(index1 - index2) < 300;
     }
     /**
-     * Infer relationship type from context
+     * Infer relationship type from context using SmartRelationshipExtractor
      */
-    async inferRelationship(fromEntity, toEntity, context) {
-        const lowerContext = context.toLowerCase();
-        const patterns = [
-            [new RegExp(`${toEntity}.*of.*${fromEntity}`, 'i'), VerbType.PartOf],
-            [new RegExp(`${fromEntity}.*contains.*${toEntity}`, 'i'), VerbType.Contains],
-            [new RegExp(`${fromEntity}.*in.*${toEntity}`, 'i'), VerbType.LocatedAt],
-            [new RegExp(`${fromEntity}.*created.*${toEntity}`, 'i'), VerbType.Creates],
-            [new RegExp(`${fromEntity}.*and.*${toEntity}`, 'i'), VerbType.RelatedTo]
-        ];
-        for (const [pattern, verbType] of patterns) {
-            if (pattern.test(lowerContext)) {
-                return verbType;
-            }
-        }
-        return VerbType.RelatedTo;
+    async inferRelationship(fromEntity, toEntity, context, fromType, toType) {
+        // Use SmartRelationshipExtractor for robust relationship classification
+        const result = await this.relationshipExtractor.infer(fromEntity, toEntity, context, {
+            subjectType: fromType,
+            objectType: toType
+        });
+        // Return inferred type or fallback to RelatedTo
+        return result?.type || VerbType.RelatedTo;
     }
     /**
      * Generate consistent entity ID

package/dist/importers/SmartPDFImporter.d.ts

@@ -111,6 +111,7 @@ export declare class SmartPDFImporter {
     private brain;
     private extractor;
     private nlp;
+    private relationshipExtractor;
     private pdfHandler;
     constructor(brain: Brainy);
     /**
@@ -142,7 +143,7 @@ export declare class SmartPDFImporter {
      */
     private extractRelationshipContext;
     /**
-     * Infer relationship type from context
+     * Infer relationship type from context using SmartRelationshipExtractor
      */
     private inferRelationship;
     /**

package/dist/importers/SmartPDFImporter.js

@@ -11,6 +11,7 @@
  */
 import { NeuralEntityExtractor } from '../neural/entityExtractor.js';
 import { NaturalLanguageProcessor } from '../neural/naturalLanguageProcessor.js';
+import { SmartRelationshipExtractor } from '../neural/SmartRelationshipExtractor.js';
 import { VerbType } from '../types/graphTypes.js';
 import { PDFHandler } from '../augmentations/intelligentImport/handlers/pdfHandler.js';
 /**
@@ -21,6 +22,7 @@ export class SmartPDFImporter {
         this.brain = brain;
         this.extractor = new NeuralEntityExtractor(brain);
         this.nlp = new NaturalLanguageProcessor(brain);
+        this.relationshipExtractor = new SmartRelationshipExtractor(brain);
         this.pdfHandler = new PDFHandler();
     }
     /**
@@ -272,29 +274,16 @@ export class SmartPDFImporter {
         return text.substring(start, end + 100).trim();
     }
     /**
-     * Infer relationship type from context
+     * Infer relationship type from context using SmartRelationshipExtractor
      */
-    async inferRelationship(fromEntity, toEntity, context) {
-        const lowerContext = context.toLowerCase();
-        // Pattern-based relationship detection
-        const patterns = [
-            [new RegExp(`${toEntity}.*of.*${fromEntity}`, 'i'), VerbType.PartOf],
-            [new RegExp(`${fromEntity}.*contains.*${toEntity}`, 'i'), VerbType.Contains],
-            [new RegExp(`${fromEntity}.*in.*${toEntity}`, 'i'), VerbType.LocatedAt],
-            [new RegExp(`${fromEntity}.*by.*${toEntity}`, 'i'), VerbType.CreatedBy],
-            [new RegExp(`${fromEntity}.*created.*${toEntity}`, 'i'), VerbType.Creates],
-            [new RegExp(`${fromEntity}.*authored.*${toEntity}`, 'i'), VerbType.CreatedBy],
-            [new RegExp(`${fromEntity}.*part of.*${toEntity}`, 'i'), VerbType.PartOf],
-            [new RegExp(`${fromEntity}.*related to.*${toEntity}`, 'i'), VerbType.RelatedTo],
-            [new RegExp(`${fromEntity}.*and.*${toEntity}`, 'i'), VerbType.RelatedTo]
-        ];
-        for (const [pattern, verbType] of patterns) {
-            if (pattern.test(lowerContext)) {
-                return verbType;
-            }
-        }
-        // Default to RelatedTo
-        return VerbType.RelatedTo;
+    async inferRelationship(fromEntity, toEntity, context, fromType, toType) {
+        // Use SmartRelationshipExtractor for robust relationship classification
+        const result = await this.relationshipExtractor.infer(fromEntity, toEntity, context, {
+            subjectType: fromType,
+            objectType: toType
+        });
+        // Return inferred type or fallback to RelatedTo
+        return result?.type || VerbType.RelatedTo;
     }
     /**
      * Generate consistent entity ID