@soulcraft/brainy 2.15.0 → 3.0.1

package/dist/neural/naturalLanguageProcessor.d.ts

@@ -9,9 +9,10 @@
  * - Progressive learning from usage
  */
 import { TripleQuery } from '../triple/TripleIntelligence.js';
-import { BrainyData } from '../brainyData.js';
+import { Brainy } from '../brainy.js';
 export interface NaturalQueryIntent {
     type: 'vector' | 'field' | 'graph' | 'combined';
+    primaryIntent: 'search' | 'filter' | 'aggregate' | 'navigate' | 'compare' | 'explain';
     confidence: number;
     extractedTerms: {
         searchTerms?: string[];
@@ -26,31 +27,113 @@ export interface NaturalQueryIntent {
             popular?: boolean;
             limit?: number;
             boost?: string;
+            sortBy?: string;
+            groupBy?: string;
         };
     };
+    context?: {
+        domain?: string;
+        temporalScope?: 'past' | 'present' | 'future' | 'all';
+        complexity?: 'simple' | 'moderate' | 'complex';
+    };
 }
 export declare class NaturalLanguageProcessor {
     private brain;
     private patternLibrary;
     private queryHistory;
     private initialized;
-    constructor(brain: BrainyData);
+    private embeddingCache;
+    private fieldEmbeddings;
+    private fieldNames;
+    private lastFieldRefresh;
+    private readonly FIELD_REFRESH_INTERVAL;
+    private nounTypeEmbeddings;
+    private verbTypeEmbeddings;
+    private typeEmbeddingsInitialized;
+    constructor(brain: Brainy);
+    /**
+     * Get embedding directly using brain's embed method
+     */
+    private getEmbedding;
     /**
      * Initialize the pattern library (lazy loading)
      */
     private ensureInitialized;
+    /**
+     * Initialize embeddings for all NounTypes and VerbTypes
+     * These are fixed types that never change - perfect for caching
+     */
+    private initializeTypeEmbeddings;
+    /**
+     * Find best matching NounType using semantic similarity
+     */
+    private findBestNounType;
+    /**
+     * Find best matching VerbType using semantic similarity
+     */
+    private findBestVerbType;
+    /**
+     * Refresh field embeddings from metadata index
+     * Creates embeddings for all indexed fields for semantic matching
+     */
+    private refreshFieldEmbeddings;
+    /**
+     * Generate linguistic variations of field names - NO HARDCODED TERMS
+     * Uses algorithmic patterns to create natural variations
+     */
+    private getFieldVariations;
+    /**
+     * Find best matching field using semantic similarity
+     * Returns field name and confidence score
+     */
+    private findBestMatchingField;
+    /**
+     * Find best matching field with type context prioritization
+     * Fields with high type affinity get boosted scores
+     */
+    private findBestMatchingFieldWithTypeContext;
+    /**
+     * Validate field-type compatibility
+     * Returns validation result with suggestions for invalid combinations
+     */
+    private validateFieldForType;
+    /**
+     * Enhanced intelligent parse with validation
+     */
+    private validateAndOptimizeQuery;
+    /**
+     * Calculate cosine similarity between two vectors
+     */
+    private cosineSimilarity;
+    /**
+     * Public initialization method for external callers
+     */
+    init(): Promise<void>;
     /**
      * 🎯 MAIN METHOD: Convert natural language to Triple Intelligence query
      */
     processNaturalQuery(naturalQuery: string): Promise<TripleQuery>;
     /**
-     * Hybrid parse when pattern matching fails
+     * Intelligent parse using type-aware field discovery and semantic matching
+     * NO FALLBACKS - uses actual indexed fields, entities, and type context
      */
-    private hybridParse;
+    private intelligentParse;
     /**
-     * Analyze intent using keywords and structure
+     * Analyze intent using keywords and structure with enhanced classification
      */
     private analyzeIntent;
+    /**
+     * Detect the domain of the query
+     */
+    private detectDomain;
+    /**
+     * Detect temporal scope in query
+     */
+    private detectTemporalScope;
+    /**
+     * Assess query complexity
+     */
+    private assessComplexity;
     /**
      * Step 2: Use neural analysis to decompose complex queries
      */
@@ -80,15 +163,77 @@ export declare class NaturalLanguageProcessor {
      */
     private extractTerms;
     /**
-     * Find entity matches using Brainy's search capabilities
+     * Find entity matches using type context and semantic similarity
      */
     private findEntityMatches;
     /**
-     * Check if term is a known field name
+     * Find entity matches with type context for better field prioritization
+     */
+    private findEntityMatchesWithTypeContext;
+    /**
+     * Find similar successful queries from history
+     * Uses Brainy's vector search to find semantically similar previous queries
+     */
+    private findSimilarQueries;
+    /**
+     * Extract entities from query using Brainy's semantic search
+     * Identifies known entities, concepts, and relationships in the query text
+     */
+    private extractEntities;
+    /**
+     * Build final TripleQuery based on intent, entities, and query analysis
+     * Constructs optimized query combining vector, graph, and field searches
      */
-    private isKnownField;
+    private buildQuery;
+    /**
+     * Extract entities from text using NEURAL matching to strict NounTypes
+     * ALWAYS uses neural matching, NEVER falls back to patterns
+     */
+    extract(text: string, options?: {
+        types?: string[];
+        includeMetadata?: boolean;
+        confidence?: number;
+    }): Promise<Array<{
+        text: string;
+        type: string;
+        position: {
+            start: number;
+            end: number;
+        };
+        confidence: number;
+        metadata?: any;
+    }>>;
+    /**
+     * DEPRECATED - Old pattern-based extraction
+     * This should NEVER be used - kept only for reference
+     */
+    private extractWithPatterns_DEPRECATED;
+    /**
+     * Analyze sentiment of text
+     */
+    sentiment(text: string, options?: {
+        granularity?: 'document' | 'sentence' | 'aspect';
+        aspects?: string[];
+    }): Promise<{
+        overall: {
+            score: number;
+            magnitude: number;
+            label: 'positive' | 'negative' | 'neutral' | 'mixed';
+        };
+        sentences?: Array<{
+            text: string;
+            score: number;
+            magnitude: number;
+            label: string;
+        }>;
+        aspects?: Record<string, {
+            score: number;
+            magnitude: number;
+            mentions: number;
+        }>;
+    }>;
     /**
-     * Map colloquial terms to actual field names
+     * Calculate confidence for entity extraction
      */
-    private mapToFieldName;
+    private calculateConfidence;
 }