@soulcraft/brainy 0.51.2 → 0.52.0

package/dist/brainyData.js

@@ -12,6 +12,7 @@ import { matchesMetadataFilter } from './utils/metadataFilter.js';
 import { MetadataIndexManager } from './utils/metadataIndex.js';
 import { NounType, VerbType } from './types/graphTypes.js';
 import { createServerSearchAugmentations } from './augmentations/serverSearchAugmentations.js';
+import { IntelligentVerbScoring } from './augmentations/intelligentVerbScoring.js';
 import { augmentationPipeline } from './augmentationPipeline.js';
 import { prepareJsonForVectorization, extractFieldFromJson } from './utils/jsonProcessing.js';
 import { DistributedConfigManager, HashPartitioner, OperationalModeFactory, DomainDetector, HealthMonitor } from './distributed/index.js';
@@ -69,6 +70,7 @@ export class BrainyData {
         this.remoteServerConfig = null;
         this.serverSearchConduit = null;
         this.serverConnection = null;
+        this.intelligentVerbScoring = null;
         // Distributed mode properties
         this.distributedConfig = null;
         this.configManager = null;
@@ -198,6 +200,11 @@ export class BrainyData {
         }
         // Initialize search cache with final configuration
         this.searchCache = new SearchCache(finalSearchCacheConfig);
+        // Initialize intelligent verb scoring if enabled
+        if (config.intelligentVerbScoring?.enabled) {
+            this.intelligentVerbScoring = new IntelligentVerbScoring(config.intelligentVerbScoring);
+            this.intelligentVerbScoring.enabled = true;
+        }
     }
     /**
      * Check if the database is in read-only mode and throw an error if it is
@@ -542,6 +549,48 @@ export class BrainyData {
             throw error;
         }
     }
+    /**
+     * Provide feedback to the intelligent verb scoring system for learning
+     * This allows the system to learn from user corrections or validation
+     *
+     * @param sourceId - Source entity ID
+     * @param targetId - Target entity ID
+     * @param verbType - Relationship type
+     * @param feedbackWeight - The corrected/validated weight (0-1)
+     * @param feedbackConfidence - The corrected/validated confidence (0-1)
+     * @param feedbackType - Type of feedback ('correction', 'validation', 'enhancement')
+     */
+    async provideFeedbackForVerbScoring(sourceId, targetId, verbType, feedbackWeight, feedbackConfidence, feedbackType = 'correction') {
+        if (this.intelligentVerbScoring?.enabled) {
+            await this.intelligentVerbScoring.provideFeedback(sourceId, targetId, verbType, feedbackWeight, feedbackConfidence, feedbackType);
+        }
+    }
+    /**
+     * Get learning statistics from the intelligent verb scoring system
+     */
+    getVerbScoringStats() {
+        if (this.intelligentVerbScoring?.enabled) {
+            return this.intelligentVerbScoring.getLearningStats();
+        }
+        return null;
+    }
+    /**
+     * Export learning data from the intelligent verb scoring system
+     */
+    exportVerbScoringLearningData() {
+        if (this.intelligentVerbScoring?.enabled) {
+            return this.intelligentVerbScoring.exportLearningData();
+        }
+        return null;
+    }
+    /**
+     * Import learning data into the intelligent verb scoring system
+     */
+    importVerbScoringLearningData(jsonData) {
+        if (this.intelligentVerbScoring?.enabled) {
+            this.intelligentVerbScoring.importLearningData(jsonData);
+        }
+    }
     /**
      * Get the current augmentation name if available
      * This is used to auto-detect the service performing data operations
@@ -765,6 +814,13 @@ export class BrainyData {
                     }
                 }
             }
+            // Initialize intelligent verb scoring augmentation if enabled
+            if (this.intelligentVerbScoring) {
+                await this.intelligentVerbScoring.initialize();
+                this.intelligentVerbScoring.setBrainyInstance(this);
+                // Register with augmentation pipeline
+                augmentationPipeline.register(this.intelligentVerbScoring);
+            }
             this.isInitialized = true;
             this.isInitializing = false;
             // Start real-time updates if enabled
@@ -2540,6 +2596,28 @@ export class BrainyData {
                 vector: verbVector,
                 connections: new Map()
             };
+            // Apply intelligent verb scoring if enabled and weight/confidence not provided
+            let finalWeight = options.weight;
+            let finalConfidence;
+            let scoringReasoning = [];
+            if (this.intelligentVerbScoring?.enabled && (!options.weight || options.weight === 0.5)) {
+                try {
+                    const scores = await this.intelligentVerbScoring.computeVerbScores(sourceId, targetId, verbType, options.weight, options.metadata);
+                    finalWeight = scores.weight;
+                    finalConfidence = scores.confidence;
+                    scoringReasoning = scores.reasoning;
+                    if (this.loggingConfig?.verbose && scoringReasoning.length > 0) {
+                        console.log(`Intelligent verb scoring for ${sourceId}-${verbType}-${targetId}:`, scoringReasoning);
+                    }
+                }
+                catch (error) {
+                    if (this.loggingConfig?.verbose) {
+                        console.warn('Error in intelligent verb scoring:', error);
+                    }
+                    // Fall back to original weight
+                    finalWeight = options.weight;
+                }
+            }
             // Create complete verb metadata separately
             const verbMetadata = {
                 sourceId: sourceId,
@@ -2548,7 +2626,12 @@ export class BrainyData {
                 target: targetId,
                 verb: verbType,
                 type: verbType, // Set the type property to match the verb type
-                weight: options.weight,
+                weight: finalWeight,
+                confidence: finalConfidence, // Add confidence to metadata
+                intelligentScoring: scoringReasoning.length > 0 ? {
+                    reasoning: scoringReasoning,
+                    computedAt: new Date().toISOString()
+                } : undefined,
                 createdAt: timestamp,
                 updatedAt: timestamp,
                 createdBy: getAugmentationVersion(service),