@soulcraft/brainy 1.3.0 → 1.5.0

package/dist/brainyData.js

@@ -657,15 +657,16 @@ export class BrainyData {
         }
         this.isInitializing = true;
         // CRITICAL: Ensure model is available before ANY operations
-        // This is THE most critical part of the system
-        // Without the model, users CANNOT access their data
+        // HYBRID SOLUTION: Use our best-of-both-worlds model manager
+        // This ensures models are loaded with singleton pattern + multi-source fallbacks
         if (typeof this.embeddingFunction === 'function') {
             try {
-                const { modelGuardian } = await import('./critical/model-guardian.js');
-                await modelGuardian.ensureCriticalModel();
+                const { hybridModelManager } = await import('./utils/hybridModelManager.js');
+                await hybridModelManager.getPrimaryModel();
+                console.log('✅ HYBRID: Model successfully initialized with best-of-both approach');
             }
             catch (error) {
-                console.error('🚨 CRITICAL: Model verification failed!');
+                console.error('🚨 CRITICAL: Hybrid model initialization failed!');
                 console.error('Brainy cannot function without the transformer model.');
                 console.error('Users cannot access their data without it.');
                 this.isInitializing = false;
@@ -1788,7 +1789,21 @@ export class BrainyData {
         }
         // Default behavior (backward compatible): search locally
         try {
-            const hasMetadataFilter = options.metadata && Object.keys(options.metadata).length > 0;
+            // BEST OF BOTH: Automatically exclude soft-deleted items (Neural Intelligence improvement)
+            // BUT only when there's already metadata filtering happening
+            let metadataFilter = options.metadata;
+            // Only add soft-delete filter if there's already metadata being filtered
+            // This preserves pure vector searches without metadata
+            if (metadataFilter && Object.keys(metadataFilter).length > 0) {
+                // If no explicit deleted filter is provided, exclude soft-deleted items
+                if (!metadataFilter.deleted && !metadataFilter.$or) {
+                    metadataFilter = {
+                        ...metadataFilter,
+                        deleted: { $ne: true }
+                    };
+                }
+            }
+            const hasMetadataFilter = metadataFilter && Object.keys(metadataFilter).length > 0;
             // Check cache first (transparent to user) - but skip cache if we have metadata filters
             if (!hasMetadataFilter) {
                 const cacheKey = this.searchCache.getCacheKey(queryVectorOrData, k, options);
@@ -1806,7 +1821,7 @@ export class BrainyData {
             // Cache miss - perform actual search
             const results = await this.searchLocal(queryVectorOrData, k, {
                 ...options,
-                metadata: options.metadata
+                metadata: metadataFilter
             });
             // Cache results for future queries (unless explicitly disabled or has metadata filter)
             if (!options.skipCache && !hasMetadataFilter) {
@@ -2506,9 +2521,17 @@ export class BrainyData {
         if (relationType === null || relationType === undefined) {
             throw new Error('Relation type cannot be null or undefined');
         }
+        // NEURAL INTELLIGENCE: Enhanced metadata with smart inference
+        const enhancedMetadata = {
+            ...metadata,
+            createdAt: new Date().toISOString(),
+            inferenceScore: 1.0, // Could be enhanced with ML-based confidence scoring
+            relationType: relationType,
+            neuralEnhanced: true
+        };
         return this._addVerbInternal(sourceId, targetId, undefined, {
             type: relationType,
-            metadata: metadata
+            metadata: enhancedMetadata
         });
     }
     /**
@@ -2805,6 +2828,7 @@ export class BrainyData {
                 }
             }
             // Create complete verb metadata separately
+            // Merge original metadata with system metadata to preserve neural enhancements
             const verbMetadata = {
                 sourceId: sourceId,
                 targetId: targetId,
@@ -2821,7 +2845,9 @@ export class BrainyData {
                 createdAt: timestamp,
                 updatedAt: timestamp,
                 createdBy: getAugmentationVersion(service),
-                data: options.metadata // Store the original metadata in the data field
+                // Merge original metadata to preserve neural enhancements from relate()
+                ...(options.metadata || {}),
+                data: options.metadata // Also store in data field for backwards compatibility
             };
             // Add to index
             await this.index.addItem({ id, vector: verbVector });
@@ -2847,7 +2873,7 @@ export class BrainyData {
                 createdAt: verbMetadata.createdAt,
                 updatedAt: verbMetadata.updatedAt,
                 createdBy: verbMetadata.createdBy,
-                metadata: verbMetadata.data,
+                metadata: verbMetadata, // Use full metadata with neural enhancements
                 data: verbMetadata.data,
                 embedding: hnswVerb.vector
             };
@@ -4875,7 +4901,9 @@ export class BrainyData {
             // The config data is now stored in metadata
             const value = storedNoun.metadata?.configValue;
             const encrypted = storedNoun.metadata?.encrypted;
-            if (encrypted && typeof value === 'string') {
+            // BEST OF BOTH: Respect explicit decrypt option OR auto-decrypt if encrypted
+            const shouldDecrypt = options?.decrypt !== undefined ? options.decrypt : encrypted;
+            if (shouldDecrypt && encrypted && typeof value === 'string') {
                 const decrypted = await this.decryptData(value);
                 return JSON.parse(decrypted);
             }

package/dist/critical/model-guardian.js

@@ -28,16 +28,16 @@ const CRITICAL_MODEL_CONFIG = {
     },
     embeddingDimensions: 384,
     fallbackSources: [
-        // Primary: Our GitHub releases (we control this)
+        // Primary: Our Google Cloud Storage CDN (we control this, fastest)
         {
-            name: 'GitHub (Primary)',
-            url: 'https://github.com/soulcraftlabs/brainy-models/releases/download/v1.0.0/all-MiniLM-L6-v2.tar.gz',
+            name: 'Soulcraft CDN (Primary)',
+            url: 'https://models.soulcraft.com/models/all-MiniLM-L6-v2.tar.gz',
             type: 'tarball'
         },
-        // Secondary: Our CDN (future, for speed)
+        // Secondary: GitHub releases backup
         {
-            name: 'Soulcraft CDN',
-            url: 'https://models.soulcraft.com/brainy/v1/all-MiniLM-L6-v2.tar.gz',
+            name: 'GitHub Backup',
+            url: 'https://github.com/soulcraftlabs/brainy-models/releases/download/v1.0.0/all-MiniLM-L6-v2.tar.gz',
             type: 'tarball'
         },
         // Tertiary: Hugging Face (original source)

package/dist/intelligence/neuralEngine.d.ts

@@ -0,0 +1,207 @@
+/**
+ * Neural Detection Engine - Shared AI Intelligence Infrastructure
+ *
+ * 🧠 Consolidates all neural analysis capabilities for consistent intelligence across Brainy
+ * ⚛️ Replaces basic heuristics with sophisticated semantic analysis
+ *
+ * This engine provides the core AI capabilities that power:
+ * - Smart entity type detection
+ * - Intelligent relationship inference
+ * - Data quality assessment
+ * - Impact analysis for operations
+ * - Pattern recognition and insights
+ */
+import { BrainyData } from '../brainyData.js';
+import { NounType, VerbType } from '../types/graphTypes.js';
+export interface EntityAnalysis {
+    detectedType: NounType;
+    confidence: number;
+    reasoning: string;
+    alternativeTypes: Array<{
+        type: NounType;
+        confidence: number;
+    }>;
+    suggestedId?: string;
+    qualityScore: number;
+}
+export interface RelationshipAnalysis {
+    verbType: VerbType;
+    confidence: number;
+    weight: number;
+    reasoning: string;
+    context: string;
+    metadata?: Record<string, any>;
+}
+export interface DeleteAnalysis {
+    strategy: 'soft-delete' | 'hard-delete' | 'cascade-delete' | 'soft-delete-preserve';
+    impactedEntities: string[];
+    orphanedRelationships: string[];
+    riskLevel: 'low' | 'medium' | 'high';
+    recommendation: string;
+    preserveData: boolean;
+}
+export interface DataInsights {
+    entityDistribution: Record<string, number>;
+    relationshipPatterns: Array<{
+        pattern: string;
+        frequency: number;
+    }>;
+    hierarchies: Array<{
+        type: string;
+        levels: number;
+        entities: string[];
+    }>;
+    clusters: Array<{
+        type: string;
+        size: number;
+        entities: string[];
+    }>;
+    anomalies: Array<{
+        type: string;
+        description: string;
+        entities: string[];
+    }>;
+    qualityMetrics: QualityAssessment;
+}
+export interface QualityAssessment {
+    completeness: number;
+    consistency: number;
+    accuracy: number;
+    richness: number;
+    recommendations: string[];
+}
+export interface DetectionOptions {
+    confidenceThreshold?: number;
+    includeAlternatives?: boolean;
+    generateReasoning?: boolean;
+    enableCaching?: boolean;
+}
+export interface ImpactOptions {
+    analyzeCascade?: boolean;
+    checkOrphans?: boolean;
+    riskAssessment?: boolean;
+}
+/**
+ * Neural Detection Engine - The Brainy AI Brain
+ */
+export declare class NeuralDetectionEngine {
+    private brainy;
+    private analysisCache;
+    private config;
+    constructor(brainy: BrainyData, config?: Partial<typeof NeuralDetectionEngine.prototype.config>);
+    /**
+     * Detect Entity Type - Replaces basic detectNounType() with neural analysis
+     */
+    detectEntityType(data: any, options?: DetectionOptions): Promise<EntityAnalysis>;
+    /**
+     * Detect Relationship Types - Intelligent relationship inference
+     */
+    detectRelationshipTypes(sourceData: any, targetData: any, options?: DetectionOptions): Promise<RelationshipAnalysis[]>;
+    /**
+     * Analyze Delete Impact - Intelligent cascade and orphan analysis
+     */
+    analyzeDeleteImpact(nounId: string, options?: ImpactOptions): Promise<DeleteAnalysis>;
+    /**
+     * Generate Data Insights - Pattern recognition and analysis
+     */
+    generateDataInsights(entities: any[], relationships: any[]): Promise<DataInsights>;
+    /**
+     * Assess Data Quality
+     */
+    assessDataQuality(data: any[]): Promise<QualityAssessment>;
+    /**
+     * Calculate entity type confidence using multi-factor analysis
+     */
+    private calculateEntityTypeConfidence;
+    /**
+     * Field-based confidence calculation
+     */
+    private calculateFieldBasedConfidence;
+    /**
+     * Pattern-based confidence calculation
+     */
+    private calculatePatternBasedConfidence;
+    /**
+     * Generate reasoning for entity type selection
+     */
+    private generateEntityReasoning;
+    /**
+     * Calculate relationship confidence
+     */
+    private calculateRelationshipConfidence;
+    /**
+     * Calculate relationship weight/strength
+     */
+    private calculateRelationshipWeight;
+    /**
+     * Calculate type compatibility for relationships
+     */
+    private calculateTypeCompatibility;
+    /**
+     * Generate relationship reasoning
+     */
+    private generateRelationshipReasoning;
+    /**
+     * Extract main text from data object
+     */
+    private extractMainText;
+    /**
+     * Extract relationship context
+     */
+    private extractRelationshipContext;
+    /**
+     * Generate smart ID for entities
+     */
+    private generateSmartId;
+    /**
+     * Assess entity quality
+     */
+    private assessEntityQuality;
+    /**
+     * Basic type detection fallback
+     */
+    private basicTypeDetection;
+    /**
+     * Check if relationship is critical for cascade analysis
+     */
+    private isRelationshipCritical;
+    /**
+     * Get verb specificity score
+     */
+    private getVerbSpecificity;
+    /**
+     * Get relevant fields for entity type
+     */
+    private getRelevantFields;
+    /**
+     * Get matched patterns for entity type
+     */
+    private getMatchedPatterns;
+    /**
+     * Detect hierarchies in relationships
+     */
+    private detectHierarchies;
+    /**
+     * Detect clusters in entities
+     */
+    private detectClusters;
+    /**
+     * Extract relationship metadata
+     */
+    private extractRelationshipMetadata;
+    /**
+     * Generate cache key
+     */
+    private generateCacheKey;
+    /**
+     * Clear analysis cache
+     */
+    clearCache(): void;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): {
+        size: number;
+        keys: string[];
+    };
+}