@soulcraft/brainy 1.5.0 → 2.0.0

package/dist/intelligence/neuralEngine.js

@@ -1,706 +0,0 @@
-/**
- * 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