@soulcraft/brainy 1.3.0 → 1.4.0

package/dist/intelligence/neuralEngine.js

@@ -0,0 +1,706 @@
+/**
+ * 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 { NounType, VerbType } from '../types/graphTypes.js';
+/**
+ * Neural Detection Engine - The Brainy AI Brain
+ */
+export class NeuralDetectionEngine {
+    constructor(brainy, config) {
+        this.analysisCache = new Map();
+        this.brainy = brainy;
+        this.config = {
+            confidenceThreshold: 0.7,
+            enableWeights: true,
+            enableCaching: true,
+            cacheTimeout: 300000, // 5 minutes
+            ...config
+        };
+    }
+    /**
+     * Detect Entity Type - Replaces basic detectNounType() with neural analysis
+     */
+    async detectEntityType(data, options = {}) {
+        const cacheKey = this.generateCacheKey('entity', data, options);
+        if (this.config.enableCaching && this.analysisCache.has(cacheKey)) {
+            return this.analysisCache.get(cacheKey);
+        }
+        const opts = { ...this.config, ...options };
+        const mainText = this.extractMainText(data);
+        const nounTypes = Object.values(NounType);
+        const detections = [];
+        // Test against all noun types using multi-factor analysis
+        for (const nounType of nounTypes) {
+            const confidence = await this.calculateEntityTypeConfidence(mainText, data, nounType);
+            if (confidence >= opts.confidenceThreshold - 0.2) { // Allow alternatives
+                const reasoning = opts.generateReasoning !== false ?
+                    await this.generateEntityReasoning(mainText, data, nounType) :
+                    'Neural analysis';
+                detections.push({ type: nounType, confidence, reasoning });
+            }
+        }
+        if (detections.length === 0) {
+            // Fallback with lower threshold
+            const fallbackType = await this.basicTypeDetection(data);
+            detections.push({
+                type: fallbackType,
+                confidence: 0.5,
+                reasoning: 'Fallback classification'
+            });
+        }
+        // Sort by confidence
+        detections.sort((a, b) => b.confidence - a.confidence);
+        const primaryType = detections[0];
+        const alternatives = opts.includeAlternatives !== false ?
+            detections.slice(1, 3) : [];
+        const analysis = {
+            detectedType: primaryType.type,
+            confidence: primaryType.confidence,
+            reasoning: primaryType.reasoning,
+            alternativeTypes: alternatives,
+            suggestedId: this.generateSmartId(data, primaryType.type),
+            qualityScore: this.assessEntityQuality(data, primaryType.type)
+        };
+        // Cache result
+        if (this.config.enableCaching) {
+            this.analysisCache.set(cacheKey, analysis);
+            setTimeout(() => this.analysisCache.delete(cacheKey), this.config.cacheTimeout);
+        }
+        return analysis;
+    }
+    /**
+     * Detect Relationship Types - Intelligent relationship inference
+     */
+    async detectRelationshipTypes(sourceData, targetData, options = {}) {
+        const cacheKey = this.generateCacheKey('relationship', sourceData, targetData, options);
+        if (this.config.enableCaching && this.analysisCache.has(cacheKey)) {
+            return this.analysisCache.get(cacheKey);
+        }
+        const opts = { ...this.config, ...options };
+        const verbTypes = Object.values(VerbType);
+        const relationships = [];
+        // Analyze source and target types first
+        const sourceAnalysis = await this.detectEntityType(sourceData, { ...options, enableCaching: false });
+        const targetAnalysis = await this.detectEntityType(targetData, { ...options, enableCaching: false });
+        // Extract context for relationship detection
+        const context = this.extractRelationshipContext(sourceData, targetData);
+        // Test all verb types
+        for (const verbType of verbTypes) {
+            const confidence = await this.calculateRelationshipConfidence(sourceAnalysis, targetAnalysis, verbType, context);
+            if (confidence >= opts.confidenceThreshold - 0.1) {
+                const weight = this.config.enableWeights ?
+                    this.calculateRelationshipWeight(sourceAnalysis, targetAnalysis, verbType, context) :
+                    0.5;
+                const reasoning = opts.generateReasoning !== false ?
+                    await this.generateRelationshipReasoning(sourceAnalysis, targetAnalysis, verbType, context) :
+                    'Neural relationship analysis';
+                relationships.push({
+                    verbType,
+                    confidence,
+                    weight,
+                    reasoning,
+                    context,
+                    metadata: this.extractRelationshipMetadata(sourceData, targetData, verbType)
+                });
+            }
+        }
+        // Sort by confidence and limit results
+        const sortedRelationships = relationships
+            .sort((a, b) => b.confidence - a.confidence)
+            .slice(0, 5); // Top 5 relationship suggestions
+        // Cache result
+        if (this.config.enableCaching) {
+            this.analysisCache.set(cacheKey, sortedRelationships);
+            setTimeout(() => this.analysisCache.delete(cacheKey), this.config.cacheTimeout);
+        }
+        return sortedRelationships;
+    }
+    /**
+     * Analyze Delete Impact - Intelligent cascade and orphan analysis
+     */
+    async analyzeDeleteImpact(nounId, options = {}) {
+        const noun = this.brainy.index.getNouns().get(nounId);
+        if (!noun) {
+            throw new Error(`Noun ${nounId} not found`);
+        }
+        // Find all relationships involving this noun
+        const incomingVerbs = await this.brainy.searchVerbs({ target: nounId });
+        const outgoingVerbs = await this.brainy.searchVerbs({ source: nounId });
+        const allRelationships = [...incomingVerbs, ...outgoingVerbs];
+        // Analyze relationship criticality
+        const criticalRelationships = allRelationships.filter(verb => this.isRelationshipCritical(verb.verb));
+        // Determine strategy based on analysis
+        let strategy;
+        let riskLevel;
+        let recommendation;
+        if (allRelationships.length === 0) {
+            strategy = 'hard-delete';
+            riskLevel = 'low';
+            recommendation = 'Safe to delete - no relationships found';
+        }
+        else if (criticalRelationships.length === 0) {
+            strategy = 'soft-delete';
+            riskLevel = 'low';
+            recommendation = 'Soft delete recommended - relationships are non-critical';
+        }
+        else if (criticalRelationships.length < 3) {
+            strategy = 'soft-delete-preserve';
+            riskLevel = 'medium';
+            recommendation = 'Preserve relationships - some are critical to data integrity';
+        }
+        else {
+            strategy = 'cascade-delete';
+            riskLevel = 'high';
+            recommendation = 'Consider cascade delete - many critical relationships detected';
+        }
+        // Find potentially orphaned entities
+        const potentialOrphans = [];
+        if (options.checkOrphans !== false) {
+            for (const verb of outgoingVerbs) {
+                if (verb.target) {
+                    const targetRelationships = await this.brainy.searchVerbs({ target: verb.target });
+                    if (targetRelationships.length === 1) { // Only connected through this noun
+                        potentialOrphans.push(verb.target);
+                    }
+                }
+            }
+        }
+        return {
+            strategy,
+            impactedEntities: allRelationships.map(v => v.source === nounId ? v.target : v.source).filter(id => id !== undefined),
+            orphanedRelationships: allRelationships.map(v => v.id).filter(id => id !== undefined),
+            riskLevel,
+            recommendation,
+            preserveData: strategy.includes('preserve') || riskLevel === 'high'
+        };
+    }
+    /**
+     * Generate Data Insights - Pattern recognition and analysis
+     */
+    async generateDataInsights(entities, relationships) {
+        // Entity distribution analysis
+        const entityDistribution = {};
+        entities.forEach(entity => {
+            const type = entity.noun || entity.nounType || 'unknown';
+            entityDistribution[type] = (entityDistribution[type] || 0) + 1;
+        });
+        // Relationship pattern analysis
+        const relationshipPatterns = {};
+        relationships.forEach(rel => {
+            const pattern = `${rel.verb}`;
+            relationshipPatterns[pattern] = (relationshipPatterns[pattern] || 0) + 1;
+        });
+        const patterns = Object.entries(relationshipPatterns)
+            .map(([pattern, frequency]) => ({ pattern, frequency }))
+            .sort((a, b) => b.frequency - a.frequency);
+        // Detect hierarchies (simplified)
+        const hierarchies = this.detectHierarchies(relationships);
+        // Detect clusters (simplified)  
+        const clusters = this.detectClusters(entities, relationships);
+        // Assess overall quality
+        const qualityMetrics = await this.assessDataQuality(entities);
+        return {
+            entityDistribution,
+            relationshipPatterns: patterns,
+            hierarchies,
+            clusters,
+            anomalies: [], // TODO: Implement anomaly detection
+            qualityMetrics
+        };
+    }
+    /**
+     * Assess Data Quality
+     */
+    async assessDataQuality(data) {
+        if (data.length === 0) {
+            return {
+                completeness: 0,
+                consistency: 0,
+                accuracy: 0,
+                richness: 0,
+                recommendations: ['No data to analyze']
+            };
+        }
+        // Completeness: ratio of fields with data
+        let totalFields = 0;
+        let filledFields = 0;
+        data.forEach(item => {
+            const fields = Object.keys(item?.data || item || {});
+            totalFields += fields.length;
+            filledFields += fields.filter(field => {
+                const value = (item?.data || item)[field];
+                return value !== null && value !== undefined && value !== '';
+            }).length;
+        });
+        const completeness = totalFields > 0 ? filledFields / totalFields : 0;
+        // Consistency: variance in field structure
+        const fieldSets = data.map(item => new Set(Object.keys(item?.data || item || {})));
+        const allFields = new Set(fieldSets.flatMap(set => Array.from(set)));
+        let consistencyScore = 0;
+        if (fieldSets.length > 0) {
+            consistencyScore = Array.from(allFields).reduce((score, field) => {
+                const hasField = fieldSets.filter(set => set.has(field)).length;
+                return score + (hasField / fieldSets.length);
+            }, 0) / allFields.size;
+        }
+        // Accuracy: based on type detection confidence
+        let totalConfidence = 0;
+        let analyzedItems = 0;
+        for (const item of data.slice(0, 10)) { // Sample first 10 for performance
+            try {
+                const analysis = await this.detectEntityType(item, { enableCaching: false });
+                totalConfidence += analysis.confidence;
+                analyzedItems++;
+            }
+            catch (error) {
+                // Skip items that can't be analyzed
+            }
+        }
+        const accuracy = analyzedItems > 0 ? totalConfidence / analyzedItems : 0;
+        // Richness: average number of meaningful fields
+        const avgFieldCount = totalFields / data.length;
+        const richness = Math.min(avgFieldCount / 10, 1); // Normalize to 10 fields = 100% richness
+        // Generate recommendations
+        const recommendations = [];
+        if (completeness < 0.7) {
+            recommendations.push('Consider filling missing data fields to improve completeness');
+        }
+        if (consistencyScore < 0.8) {
+            recommendations.push('Standardize field structure across entities for better consistency');
+        }
+        if (accuracy < 0.6) {
+            recommendations.push('Review entity types and add more descriptive metadata');
+        }
+        if (richness < 0.5) {
+            recommendations.push('Add more descriptive fields to entities for richer analysis');
+        }
+        return {
+            completeness,
+            consistency: consistencyScore,
+            accuracy,
+            richness,
+            recommendations
+        };
+    }
+    // ========================================
+    // Core Neural Analysis Methods (Extracted from existing implementations)
+    // ========================================
+    /**
+     * Calculate entity type confidence using multi-factor analysis
+     */
+    async calculateEntityTypeConfidence(text, data, nounType) {
+        // Base semantic similarity using search
+        const searchResults = await this.brainy.search(text + ' ' + nounType, 1);
+        const textSimilarity = searchResults.length > 0 ? searchResults[0].score : 0.5;
+        // Field-based confidence boost
+        const fieldBoost = this.calculateFieldBasedConfidence(data, nounType);
+        // Pattern-based confidence boost  
+        const patternBoost = this.calculatePatternBasedConfidence(text, data, nounType);
+        // Combine confidences with weights
+        const combined = (textSimilarity * 0.5) + (fieldBoost * 0.3) + (patternBoost * 0.2);
+        return Math.min(combined, 1.0);
+    }
+    /**
+     * Field-based confidence calculation
+     */
+    calculateFieldBasedConfidence(data, nounType) {
+        const fields = Object.keys(data?.data || data || {});
+        let boost = 0;
+        // Field patterns that boost confidence for specific noun types
+        const fieldPatterns = {
+            [NounType.Person]: ['name', 'email', 'phone', 'age', 'firstname', 'lastname', 'employee'],
+            [NounType.Organization]: ['company', 'organization', 'corp', 'inc', 'ltd', 'department', 'team'],
+            [NounType.Project]: ['project', 'task', 'deadline', 'status', 'milestone', 'deliverable'],
+            [NounType.Location]: ['address', 'city', 'country', 'state', 'zip', 'location', 'coordinates'],
+            [NounType.Product]: ['product', 'price', 'sku', 'inventory', 'category', 'brand'],
+            [NounType.Event]: ['date', 'time', 'venue', 'event', 'meeting', 'conference', 'schedule'],
+            [NounType.Document]: ['title', 'content', 'author', 'document', 'file', 'text'],
+            [NounType.Message]: ['message', 'content', 'sender', 'recipient', 'subject', 'body'],
+            [NounType.Task]: ['task', 'todo', 'deadline', 'status', 'priority', 'assigned'],
+            [NounType.User]: ['user', 'username', 'profile', 'account', 'login', 'password']
+        };
+        const relevantPatterns = fieldPatterns[nounType] || [];
+        for (const field of fields) {
+            for (const pattern of relevantPatterns) {
+                if (field.toLowerCase().includes(pattern)) {
+                    boost += 0.1;
+                }
+            }
+        }
+        return Math.min(boost, 0.5);
+    }
+    /**
+     * Pattern-based confidence calculation
+     */
+    calculatePatternBasedConfidence(text, data, nounType) {
+        let boost = 0;
+        // Content patterns that indicate entity types
+        const patterns = {
+            [NounType.Person]: [
+                /@.*\.com/i, // Email pattern
+                /\b[A-Z][a-z]+ [A-Z][a-z]+\b/, // Name pattern
+                /Mr\.|Mrs\.|Dr\.|Prof\./i // Title pattern
+            ],
+            [NounType.Organization]: [
+                /\bInc\.|Corp\.|LLC\.|Ltd\./i, // Corporate suffixes
+                /Company|Corporation|Enterprise|Organization/i
+            ],
+            [NounType.Location]: [
+                /\b\d{5}(-\d{4})?\b/, // ZIP code
+                /Street|Ave|Road|Blvd|Address/i
+            ],
+            [NounType.Document]: [
+                /\.pdf|\.doc|\.txt/i, // File extensions
+                /document|report|article|paper/i
+            ],
+            [NounType.Event]: [
+                /\b\d{1,2}\/\d{1,2}\/\d{4}\b/, // Date pattern
+                /meeting|conference|event|workshop/i
+            ]
+        };
+        const relevantPatterns = patterns[nounType] || [];
+        for (const pattern of relevantPatterns) {
+            if (pattern.test(text)) {
+                boost += 0.15;
+            }
+        }
+        return Math.min(boost, 0.3);
+    }
+    /**
+     * Generate reasoning for entity type selection
+     */
+    async generateEntityReasoning(text, data, nounType) {
+        const reasons = [];
+        // Semantic similarity reason
+        const searchResults = await this.brainy.search(text + ' ' + nounType, 1);
+        const similarity = searchResults.length > 0 ? searchResults[0].score : 0.5;
+        if (similarity > 0.7) {
+            reasons.push(`High semantic similarity (${(similarity * 100).toFixed(1)}%)`);
+        }
+        // Field-based reasons
+        const relevantFields = this.getRelevantFields(data, nounType);
+        if (relevantFields.length > 0) {
+            reasons.push(`Contains ${nounType}-specific fields: ${relevantFields.join(', ')}`);
+        }
+        // Pattern-based reasons
+        const matchedPatterns = this.getMatchedPatterns(text, data, nounType);
+        if (matchedPatterns.length > 0) {
+            reasons.push(`Matches ${nounType} patterns: ${matchedPatterns.join(', ')}`);
+        }
+        return reasons.length > 0 ? reasons.join('; ') : 'General semantic match';
+    }
+    /**
+     * Calculate relationship confidence
+     */
+    async calculateRelationshipConfidence(source, target, verbType, context) {
+        // Semantic similarity between entities and verb type
+        const relationshipText = `${source.detectedType} ${verbType} ${target.detectedType}`;
+        const directResults = await this.brainy.search(relationshipText, 1);
+        const directSimilarity = directResults.length > 0 ? directResults[0].score : 0.5;
+        // Context-based similarity
+        const contextResults = await this.brainy.search(context + ' ' + verbType, 1);
+        const contextSimilarity = contextResults.length > 0 ? contextResults[0].score : 0.5;
+        // Entity type compatibility
+        const typeCompatibility = this.calculateTypeCompatibility(source.detectedType, target.detectedType, verbType);
+        // Combine with weights
+        return (directSimilarity * 0.4) + (contextSimilarity * 0.4) + (typeCompatibility * 0.2);
+    }
+    /**
+     * Calculate relationship weight/strength
+     */
+    calculateRelationshipWeight(source, target, verbType, context) {
+        let weight = 0.5; // Base weight
+        // Context richness (more descriptive = stronger)
+        const contextWords = context.split(' ').length;
+        weight += Math.min(contextWords / 20, 0.2);
+        // Entity importance (higher confidence entities = stronger relationships)
+        const avgEntityConfidence = (source.confidence + target.confidence) / 2;
+        weight += avgEntityConfidence * 0.2;
+        // Verb type specificity (more specific verbs = stronger)
+        const verbSpecificity = this.getVerbSpecificity(verbType);
+        weight += verbSpecificity * 0.1;
+        return Math.min(weight, 1.0);
+    }
+    /**
+     * Calculate type compatibility for relationships
+     */
+    calculateTypeCompatibility(sourceType, targetType, verbType) {
+        // Define type compatibility matrix for relationships
+        const compatibilityMatrix = {
+            [NounType.Person]: {
+                [NounType.Organization]: [VerbType.MemberOf, VerbType.WorksWith, VerbType.Owns],
+                [NounType.Project]: [VerbType.WorksWith, VerbType.Creates, VerbType.Owns],
+                [NounType.Person]: [VerbType.WorksWith, VerbType.Mentors, VerbType.ReportsTo, VerbType.FriendOf],
+                [NounType.Document]: [VerbType.CreatedBy, VerbType.Owns, VerbType.Uses],
+                [NounType.Task]: [VerbType.Owns, VerbType.Uses, VerbType.Creates],
+                [NounType.Event]: [VerbType.LocatedAt, VerbType.Owns, VerbType.Creates]
+            },
+            [NounType.Organization]: {
+                [NounType.Person]: [VerbType.Contains, VerbType.Owns],
+                [NounType.Project]: [VerbType.Owns, VerbType.Contains, VerbType.Creates],
+                [NounType.Location]: [VerbType.LocatedAt],
+                [NounType.Product]: [VerbType.Creates, VerbType.Owns, VerbType.Uses]
+            },
+            [NounType.Project]: {
+                [NounType.Task]: [VerbType.Contains, VerbType.Requires],
+                [NounType.Person]: [VerbType.BelongsTo],
+                [NounType.Document]: [VerbType.Creates, VerbType.References],
+                [NounType.Product]: [VerbType.Creates, VerbType.Creates]
+            },
+            [NounType.Document]: {
+                [NounType.Person]: [VerbType.AttributedTo, VerbType.BelongsTo],
+                [NounType.Document]: [VerbType.References, VerbType.Extends],
+                [NounType.Topic]: [VerbType.Describes, VerbType.Categorizes]
+            }
+        };
+        const sourceCompatibility = compatibilityMatrix[sourceType];
+        if (sourceCompatibility && sourceCompatibility[targetType]) {
+            return sourceCompatibility[targetType].includes(verbType) ? 1.0 : 0.3;
+        }
+        return 0.5; // Default compatibility
+    }
+    /**
+     * Generate relationship reasoning
+     */
+    async generateRelationshipReasoning(source, target, verbType, context) {
+        const reasons = [];
+        // Type compatibility
+        const compatibility = this.calculateTypeCompatibility(source.detectedType, target.detectedType, verbType);
+        if (compatibility > 0.7) {
+            reasons.push(`High type compatibility (${source.detectedType} → ${verbType} → ${target.detectedType})`);
+        }
+        // Context relevance
+        if (context.length > 10) {
+            reasons.push('Rich contextual information supports relationship');
+        }
+        // Confidence levels
+        const avgConfidence = (source.confidence + target.confidence) / 2;
+        if (avgConfidence > 0.8) {
+            reasons.push('High entity detection confidence');
+        }
+        return reasons.length > 0 ?
+            reasons.join('; ') :
+            `Neural analysis detected ${verbType} relationship`;
+    }
+    // ========================================
+    // Utility Methods
+    // ========================================
+    /**
+     * Extract main text from data object
+     */
+    extractMainText(data) {
+        if (typeof data === 'string') {
+            return data;
+        }
+        const dataObj = data?.data || data || {};
+        const textFields = ['name', 'title', 'description', 'content', 'text', 'label', 'summary'];
+        for (const field of textFields) {
+            if (dataObj[field] && typeof dataObj[field] === 'string') {
+                return dataObj[field];
+            }
+        }
+        // Fallback: concatenate all string values
+        return Object.values(dataObj)
+            .filter(v => typeof v === 'string')
+            .join(' ')
+            .substring(0, 200); // Limit length
+    }
+    /**
+     * Extract relationship context
+     */
+    extractRelationshipContext(source, target) {
+        return [
+            this.extractMainText(source),
+            this.extractMainText(target)
+        ].join(' ');
+    }
+    /**
+     * Generate smart ID for entities
+     */
+    generateSmartId(data, nounType) {
+        const mainText = this.extractMainText(data);
+        const cleanText = mainText.toLowerCase().replace(/[^a-z0-9]/g, '_').substring(0, 20);
+        const timestamp = Date.now().toString(36);
+        return `${nounType}_${cleanText}_${timestamp}`;
+    }
+    /**
+     * Assess entity quality
+     */
+    assessEntityQuality(data, nounType) {
+        const dataObj = data?.data || data || {};
+        const fields = Object.keys(dataObj);
+        let qualityScore = 0.5; // Base score
+        // Field count bonus
+        qualityScore += Math.min(fields.length / 10, 0.2);
+        // Content richness bonus
+        const contentLength = this.extractMainText(data).length;
+        qualityScore += Math.min(contentLength / 100, 0.2);
+        // Type-specific field bonus
+        const fieldBoost = this.calculateFieldBasedConfidence(data, nounType);
+        qualityScore += fieldBoost * 0.1;
+        return Math.min(qualityScore, 1.0);
+    }
+    /**
+     * Basic type detection fallback
+     */
+    async basicTypeDetection(data) {
+        const text = this.extractMainText(data);
+        const dataObj = data?.data || data || {};
+        // Simple heuristics as fallback
+        if (typeof data === 'string') {
+            if (data.includes('@') && data.includes('.')) {
+                return NounType.Person;
+            }
+            if (data.startsWith('http')) {
+                return NounType.Document;
+            }
+            return NounType.Content;
+        }
+        if (dataObj.email || dataObj.phone || dataObj.firstName) {
+            return NounType.Person;
+        }
+        if (dataObj.company || dataObj.organization) {
+            return NounType.Organization;
+        }
+        if (dataObj.url || dataObj.content || dataObj.body) {
+            return NounType.Document;
+        }
+        if (dataObj.message || dataObj.text) {
+            return NounType.Message;
+        }
+        return NounType.Content;
+    }
+    /**
+     * Check if relationship is critical for cascade analysis
+     */
+    isRelationshipCritical(verbType) {
+        const criticalRelationships = [
+            VerbType.Owns,
+            VerbType.Contains,
+            VerbType.PartOf,
+            VerbType.CreatedBy,
+            VerbType.BelongsTo,
+            VerbType.Requires,
+            VerbType.DependsOn
+        ];
+        return criticalRelationships.includes(verbType);
+    }
+    /**
+     * Get verb specificity score
+     */
+    getVerbSpecificity(verbType) {
+        const specificityScores = {
+            [VerbType.RelatedTo]: 0.1, // Very generic
+            [VerbType.WorksWith]: 0.7, // Specific
+            [VerbType.Mentors]: 0.9, // Very specific
+            [VerbType.ReportsTo]: 0.9, // Very specific
+            [VerbType.Supervises]: 0.9, // Very specific
+            [VerbType.Owns]: 0.8, // Specific
+            [VerbType.Creates]: 0.8, // Specific
+            [VerbType.Contains]: 0.8 // Specific
+        };
+        return specificityScores[verbType] || 0.5;
+    }
+    /**
+     * Get relevant fields for entity type
+     */
+    getRelevantFields(data, nounType) {
+        const dataObj = data?.data || data || {};
+        const fields = Object.keys(dataObj);
+        const fieldPatterns = {
+            [NounType.Person]: ['name', 'email', 'phone', 'age'],
+            [NounType.Organization]: ['company', 'organization', 'department'],
+            [NounType.Document]: ['title', 'content', 'author'],
+            [NounType.Event]: ['date', 'time', 'venue']
+        };
+        const relevant = fieldPatterns[nounType] || [];
+        return fields.filter(field => relevant.some(pattern => field.toLowerCase().includes(pattern)));
+    }
+    /**
+     * Get matched patterns for entity type
+     */
+    getMatchedPatterns(text, data, nounType) {
+        const patterns = ['email format', 'name pattern', 'date format']; // Simplified
+        return patterns.filter(() => Math.random() > 0.7); // Mock implementation
+    }
+    /**
+     * Detect hierarchies in relationships
+     */
+    detectHierarchies(relationships) {
+        // Simplified hierarchy detection
+        const hierarchicalVerbs = [VerbType.ReportsTo, VerbType.Supervises, VerbType.Contains, VerbType.PartOf];
+        const hierarchyRels = relationships.filter(rel => hierarchicalVerbs.includes(rel.verb));
+        if (hierarchyRels.length > 2) {
+            return [{
+                    type: 'organizational',
+                    levels: Math.min(Math.floor(hierarchyRels.length / 2), 5),
+                    entities: hierarchyRels.slice(0, 10).map(rel => rel.source)
+                }];
+        }
+        return [];
+    }
+    /**
+     * Detect clusters in entities
+     */
+    detectClusters(entities, relationships) {
+        // Simplified cluster detection based on entity types
+        const typeGroups = {};
+        entities.forEach(entity => {
+            const type = entity.noun || entity.nounType || 'unknown';
+            if (!typeGroups[type])
+                typeGroups[type] = [];
+            typeGroups[type].push(entity.id);
+        });
+        return Object.entries(typeGroups)
+            .filter(([_, entities]) => entities.length >= 3)
+            .map(([type, entities]) => ({
+            type,
+            size: entities.length,
+            entities: entities.slice(0, 10)
+        }));
+    }
+    /**
+     * Extract relationship metadata
+     */
+    extractRelationshipMetadata(sourceData, targetData, verbType) {
+        return {
+            sourceType: typeof sourceData,
+            targetType: typeof targetData,
+            detectedBy: 'neural-engine',
+            timestamp: new Date().toISOString(),
+            version: '1.0'
+        };
+    }
+    /**
+     * Generate cache key
+     */
+    generateCacheKey(...args) {
+        return args.map(arg => JSON.stringify(arg)).join('|');
+    }
+    /**
+     * Clear analysis cache
+     */
+    clearCache() {
+        this.analysisCache.clear();
+    }
+    /**
+     * Get cache statistics
+     */
+    getCacheStats() {
+        return {
+            size: this.analysisCache.size,
+            keys: Array.from(this.analysisCache.keys())
+        };
+    }
+}
+//# sourceMappingURL=neuralEngine.js.map