@soulcraft/brainy 3.0.0 → 3.0.1

package/dist/neural/naturalLanguageProcessorStatic.d.ts

@@ -26,7 +26,7 @@ export declare class NaturalLanguageProcessor {
     /**
      * Process natural language query into structured Triple Intelligence query
      * @param naturalQuery The natural language query string
-     * @param queryEmbedding Pre-computed embedding from BrainyData (passed in to avoid circular dependency)
+     * @param queryEmbedding Pre-computed embedding from Brainy (passed in to avoid circular dependency)
      */
     processNaturalQuery(naturalQuery: string, queryEmbedding?: Vector): Promise<TripleQuery>;
     /**
@@ -46,7 +46,7 @@ export declare class NaturalLanguageProcessor {
      */
     private buildFieldConstraints;
     /**
-     * Find similar queries from history (without using BrainyData)
+     * Find similar queries from history (without using Brainy)
      */
     private findSimilarQueries;
     /**

package/dist/neural/naturalLanguageProcessorStatic.js

@@ -20,7 +20,7 @@ export class NaturalLanguageProcessor {
     /**
      * Process natural language query into structured Triple Intelligence query
      * @param naturalQuery The natural language query string
-     * @param queryEmbedding Pre-computed embedding from BrainyData (passed in to avoid circular dependency)
+     * @param queryEmbedding Pre-computed embedding from Brainy (passed in to avoid circular dependency)
      */
     async processNaturalQuery(naturalQuery, queryEmbedding) {
         // Use static pattern matcher (no async, no memory allocation!)
@@ -33,7 +33,7 @@ export class NaturalLanguageProcessor {
                 structuredQuery.where = this.buildFieldConstraints(intent.extractedTerms.fields);
             }
         }
-        // Track for learning (but don't create new BrainyData!)
+        // Track for learning (but don't create new Brainy!)
         this.queryHistory.push({
             query: naturalQuery,
             result: structuredQuery,
@@ -118,7 +118,7 @@ export class NaturalLanguageProcessor {
         return constraints;
     }
     /**
-     * Find similar queries from history (without using BrainyData)
+     * Find similar queries from history (without using Brainy)
      */
     findSimilarQueries(embedding) {
         // Simple similarity check against recent history

package/dist/neural/neuralAPI.js

@@ -603,10 +603,16 @@ export class NeuralAPI {
         return { width: 100, height: 100 };
     }
     async getViewportLOD(viewport, lod) {
-        return {};
+        // LOD visualization is an optional advanced feature
+        // Return default view without LOD optimization
+        console.warn('Viewport LOD optimization not available. Using standard view.');
+        return { nodes: [], edges: [], optimized: false };
     }
     async getGlobalLOD(lod) {
-        return {};
+        // LOD visualization is an optional advanced feature
+        // Return default view without LOD optimization
+        console.warn('Global LOD optimization not available. Using standard view.');
+        return { nodes: [], edges: [], optimized: false };
     }
 }
 //# sourceMappingURL=neuralAPI.js.map

package/dist/neural/patternLibrary.d.ts

@@ -8,7 +8,7 @@
  * - Progressive learning from usage
  */
 import { Vector } from '../coreTypes.js';
-import { BrainyData } from '../brainyData.js';
+import { Brainy } from '../brainy.js';
 export interface Pattern {
     id: string;
     category: string;
@@ -19,10 +19,20 @@ export interface Pattern {
     embedding?: Vector;
     domain?: string;
     frequency?: number | string;
+    slots?: SlotDefinition[];
+}
+export interface SlotDefinition {
+    name: string;
+    type: 'text' | 'number' | 'date' | 'entity' | 'location' | 'person' | 'any';
+    required?: boolean;
+    default?: any;
+    pattern?: string;
+    transform?: (value: string) => any;
 }
 export interface SlotExtraction {
     slots: Record<string, any>;
     confidence: number;
+    errors?: string[];
 }
 export declare class PatternLibrary {
     private patterns;
@@ -30,7 +40,7 @@ export declare class PatternLibrary {
     private brain;
     private embeddingCache;
     private successMetrics;
-    constructor(brain: BrainyData);
+    constructor(brain: Brainy);
     /**
      * Initialize pattern library with pre-computed embeddings
      */
@@ -51,9 +61,53 @@ export declare class PatternLibrary {
         similarity: number;
     }>>;
     /**
-     * Extract slots from query based on pattern
+     * Extract slots from query based on pattern with enhanced fuzzy matching
      */
     extractSlots(query: string, pattern: Pattern): SlotExtraction;
+    /**
+     * Extract named slots with type validation
+     */
+    private extractNamedSlots;
+    /**
+     * Fuzzy extraction using Levenshtein distance
+     */
+    private fuzzyExtractSlots;
+    /**
+     * Fuzzy extraction for named slots
+     */
+    private fuzzyExtractNamedSlots;
+    /**
+     * Find slot value in tokens based on type
+     */
+    private findSlotValueInTokens;
+    /**
+     * Get default regex pattern for slot type
+     */
+    private getDefaultPatternForType;
+    /**
+     * Transform value based on type
+     */
+    private transformByType;
+    /**
+     * Validate slot value against definition
+     */
+    private validateSlotValue;
+    /**
+     * Calculate Levenshtein distance between two strings
+     */
+    private levenshteinDistance;
+    /**
+     * Align two strings for slot extraction
+     */
+    private alignStrings;
+    /**
+     * Find best token match using fuzzy comparison
+     */
+    private findBestTokenMatch;
+    /**
+     * Extract slots from string alignment
+     */
+    private extractSlotsFromAlignment;
     /**
      * Fill template with extracted slots
      */

package/dist/neural/patternLibrary.js

@@ -69,6 +69,7 @@ export class PatternLibrary {
         if (this.embeddingCache.has(text)) {
             return this.embeddingCache.get(text);
         }
+        // Use brain's embed method directly to avoid recursion
         const embedding = await this.brain.embed(text);
         this.embeddingCache.set(text, embedding);
         return embedding;
@@ -95,11 +96,16 @@ export class PatternLibrary {
         return matches.slice(0, k);
     }
     /**
-     * Extract slots from query based on pattern
+     * Extract slots from query based on pattern with enhanced fuzzy matching
      */
     extractSlots(query, pattern) {
         const slots = {};
+        const errors = [];
         let confidence = pattern.confidence;
+        // If pattern has named slot definitions, use them
+        if (pattern.slots && pattern.slots.length > 0) {
+            return this.extractNamedSlots(query, pattern);
+        }
         // Try regex extraction first
         const regex = new RegExp(pattern.pattern, 'i');
         const match = query.match(regex);
@@ -112,21 +118,350 @@ export class PatternLibrary {
             confidence = Math.min(confidence * 1.2, 1.0);
         }
         else {
-            // Fall back to token-based extraction
-            const tokens = this.tokenize(query);
-            const exampleTokens = this.tokenize(pattern.examples[0]);
-            // Simple alignment-based extraction
-            for (let i = 0; i < tokens.length; i++) {
-                if (i < exampleTokens.length && exampleTokens[i].startsWith('$')) {
-                    slots[exampleTokens[i]] = tokens[i];
-                }
+            // Enhanced fuzzy matching with Levenshtein distance
+            const fuzzyResult = this.fuzzyExtractSlots(query, pattern);
+            Object.assign(slots, fuzzyResult.slots);
+            confidence = fuzzyResult.confidence;
+            if (fuzzyResult.errors) {
+                errors.push(...fuzzyResult.errors);
             }
-            // Lower confidence for fuzzy matching
-            confidence *= 0.7;
         }
         // Post-process slots
         this.postProcessSlots(slots, pattern);
-        return { slots, confidence };
+        return { slots, confidence, errors: errors.length > 0 ? errors : undefined };
+    }
+    /**
+     * Extract named slots with type validation
+     */
+    extractNamedSlots(query, pattern) {
+        const slots = {};
+        const errors = [];
+        let confidence = pattern.confidence;
+        if (!pattern.slots) {
+            return { slots, confidence };
+        }
+        // Create a flexible regex from pattern
+        let flexiblePattern = pattern.pattern;
+        const slotPositions = new Map();
+        // Replace named slots in pattern with capture groups
+        pattern.slots.forEach((slot, index) => {
+            const slotPattern = slot.pattern || this.getDefaultPatternForType(slot.type);
+            flexiblePattern = flexiblePattern.replace(new RegExp(`\\{${slot.name}\\}`, 'g'), `(${slotPattern})`);
+            slotPositions.set(index + 1, slot);
+        });
+        const regex = new RegExp(flexiblePattern, 'i');
+        const match = query.match(regex);
+        if (match) {
+            // Extract and validate each slot
+            slotPositions.forEach((slotDef, position) => {
+                const value = match[position];
+                if (value) {
+                    // Apply transformation if defined
+                    const transformedValue = slotDef.transform
+                        ? slotDef.transform(value)
+                        : this.transformByType(value, slotDef.type);
+                    // Validate the value
+                    if (this.validateSlotValue(transformedValue, slotDef)) {
+                        slots[slotDef.name] = transformedValue;
+                    }
+                    else {
+                        errors.push(`Invalid value for slot '${slotDef.name}': expected ${slotDef.type}, got '${value}'`);
+                        confidence *= 0.8;
+                    }
+                }
+                else if (slotDef.required) {
+                    if (slotDef.default !== undefined) {
+                        slots[slotDef.name] = slotDef.default;
+                    }
+                    else {
+                        errors.push(`Required slot '${slotDef.name}' not found`);
+                        confidence *= 0.5;
+                    }
+                }
+            });
+        }
+        else {
+            // Try fuzzy matching for named slots
+            const fuzzyResult = this.fuzzyExtractNamedSlots(query, pattern);
+            Object.assign(slots, fuzzyResult.slots);
+            confidence = fuzzyResult.confidence;
+            if (fuzzyResult.errors) {
+                errors.push(...fuzzyResult.errors);
+            }
+        }
+        return { slots, confidence, errors: errors.length > 0 ? errors : undefined };
+    }
+    /**
+     * Fuzzy extraction using Levenshtein distance
+     */
+    fuzzyExtractSlots(query, pattern) {
+        const slots = {};
+        let bestConfidence = 0;
+        // Try each example with fuzzy matching
+        for (const example of pattern.examples) {
+            const distance = this.levenshteinDistance(query.toLowerCase(), example.toLowerCase());
+            const similarity = 1 - (distance / Math.max(query.length, example.length));
+            if (similarity > 0.6) { // 60% similarity threshold
+                // Extract slots using alignment
+                const aligned = this.alignStrings(query, example);
+                const extractedSlots = this.extractSlotsFromAlignment(aligned, pattern);
+                if (Object.keys(extractedSlots).length > 0) {
+                    const currentConfidence = pattern.confidence * similarity;
+                    if (currentConfidence > bestConfidence) {
+                        Object.assign(slots, extractedSlots);
+                        bestConfidence = currentConfidence;
+                    }
+                }
+            }
+        }
+        return {
+            slots,
+            confidence: bestConfidence,
+            errors: bestConfidence < 0.5 ? ['Low confidence fuzzy match'] : undefined
+        };
+    }
+    /**
+     * Fuzzy extraction for named slots
+     */
+    fuzzyExtractNamedSlots(query, pattern) {
+        const slots = {};
+        const errors = [];
+        let confidence = pattern.confidence * 0.7; // Lower confidence for fuzzy
+        if (!pattern.slots) {
+            return { slots, confidence };
+        }
+        // Tokenize query for flexible matching
+        const tokens = this.tokenize(query);
+        pattern.slots.forEach(slotDef => {
+            const value = this.findSlotValueInTokens(tokens, slotDef);
+            if (value) {
+                const transformedValue = slotDef.transform
+                    ? slotDef.transform(value)
+                    : this.transformByType(value, slotDef.type);
+                if (this.validateSlotValue(transformedValue, slotDef)) {
+                    slots[slotDef.name] = transformedValue;
+                }
+                else {
+                    errors.push(`Fuzzy match: uncertain value for '${slotDef.name}'`);
+                    confidence *= 0.9;
+                }
+            }
+            else if (slotDef.required && slotDef.default !== undefined) {
+                slots[slotDef.name] = slotDef.default;
+            }
+        });
+        return { slots, confidence, errors: errors.length > 0 ? errors : undefined };
+    }
+    /**
+     * Find slot value in tokens based on type
+     */
+    findSlotValueInTokens(tokens, slotDef) {
+        const joinedTokens = tokens.join(' ');
+        switch (slotDef.type) {
+            case 'number':
+                const numberMatch = joinedTokens.match(/\d+(\.\d+)?/);
+                return numberMatch ? numberMatch[0] : null;
+            case 'date':
+                const datePatterns = [
+                    /\d{4}-\d{2}-\d{2}/,
+                    /\d{1,2}\/\d{1,2}\/\d{2,4}/,
+                    /(january|february|march|april|may|june|july|august|september|october|november|december)\s+\d{1,2},?\s+\d{4}/i,
+                    /(today|tomorrow|yesterday)/i
+                ];
+                for (const pattern of datePatterns) {
+                    const match = joinedTokens.match(pattern);
+                    if (match)
+                        return match[0];
+                }
+                return null;
+            case 'person':
+                // Look for capitalized words (proper nouns)
+                const personMatch = joinedTokens.match(/\b[A-Z][a-z]+(\s+[A-Z][a-z]+)*\b/);
+                return personMatch ? personMatch[0] : null;
+            case 'location':
+                // Look for location indicators
+                const locationPatterns = [
+                    /\b(in|at|from|to)\s+([A-Z][a-z]+(\s+[A-Z][a-z]+)*)\b/,
+                    /\b[A-Z][a-z]+,\s+[A-Z]{2}\b/ // City, STATE format
+                ];
+                for (const pattern of locationPatterns) {
+                    const match = joinedTokens.match(pattern);
+                    if (match)
+                        return match[2] || match[0];
+                }
+                return null;
+            case 'entity':
+            case 'text':
+            case 'any':
+            default:
+                // Return first non-common word as potential value
+                const commonWords = new Set(['the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for']);
+                const significantToken = tokens.find(t => !commonWords.has(t.toLowerCase()));
+                return significantToken || null;
+        }
+    }
+    /**
+     * Get default regex pattern for slot type
+     */
+    getDefaultPatternForType(type) {
+        switch (type) {
+            case 'number':
+                return '\\d+(?:\\.\\d+)?';
+            case 'date':
+                return '[\\w\\s,/-]+';
+            case 'person':
+                return '[A-Z][a-z]+(?:\\s+[A-Z][a-z]+)*';
+            case 'location':
+                return '[A-Z][a-z]+(?:[\\s,]+[A-Z][a-z]+)*';
+            case 'entity':
+                return '[\\w\\s-]+';
+            case 'text':
+            case 'any':
+            default:
+                return '.+';
+        }
+    }
+    /**
+     * Transform value based on type
+     */
+    transformByType(value, type) {
+        switch (type) {
+            case 'number':
+                const num = parseFloat(value);
+                return isNaN(num) ? value : num;
+            case 'date':
+                // Simple date parsing
+                if (value.toLowerCase() === 'today') {
+                    return new Date().toISOString().split('T')[0];
+                }
+                else if (value.toLowerCase() === 'tomorrow') {
+                    const tomorrow = new Date();
+                    tomorrow.setDate(tomorrow.getDate() + 1);
+                    return tomorrow.toISOString().split('T')[0];
+                }
+                else if (value.toLowerCase() === 'yesterday') {
+                    const yesterday = new Date();
+                    yesterday.setDate(yesterday.getDate() - 1);
+                    return yesterday.toISOString().split('T')[0];
+                }
+                return value;
+            case 'person':
+            case 'location':
+            case 'entity':
+                // Capitalize properly
+                return value.split(' ')
+                    .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+                    .join(' ');
+            default:
+                return value.trim();
+        }
+    }
+    /**
+     * Validate slot value against definition
+     */
+    validateSlotValue(value, slotDef) {
+        if (value === null || value === undefined) {
+            return !slotDef.required;
+        }
+        switch (slotDef.type) {
+            case 'number':
+                return typeof value === 'number' && !isNaN(value);
+            case 'date':
+                return typeof value === 'string' && value.length > 0;
+            case 'text':
+            case 'person':
+            case 'location':
+            case 'entity':
+                return typeof value === 'string' && value.length > 0;
+            case 'any':
+                return true;
+            default:
+                return true;
+        }
+    }
+    /**
+     * Calculate Levenshtein distance between two strings
+     */
+    levenshteinDistance(s1, s2) {
+        const len1 = s1.length;
+        const len2 = s2.length;
+        const matrix = [];
+        for (let i = 0; i <= len1; i++) {
+            matrix[i] = [i];
+        }
+        for (let j = 0; j <= len2; j++) {
+            matrix[0][j] = j;
+        }
+        for (let i = 1; i <= len1; i++) {
+            for (let j = 1; j <= len2; j++) {
+                const cost = s1[i - 1] === s2[j - 1] ? 0 : 1;
+                matrix[i][j] = Math.min(matrix[i - 1][j] + 1, // deletion
+                matrix[i][j - 1] + 1, // insertion
+                matrix[i - 1][j - 1] + cost // substitution
+                );
+            }
+        }
+        return matrix[len1][len2];
+    }
+    /**
+     * Align two strings for slot extraction
+     */
+    alignStrings(query, example) {
+        const queryTokens = this.tokenize(query);
+        const exampleTokens = this.tokenize(example);
+        const aligned = [];
+        let i = 0, j = 0;
+        while (i < queryTokens.length && j < exampleTokens.length) {
+            if (queryTokens[i] === exampleTokens[j]) {
+                aligned.push([queryTokens[i], exampleTokens[j]]);
+                i++;
+                j++;
+            }
+            else {
+                // Try to find best match
+                const bestMatch = this.findBestTokenMatch(queryTokens[i], exampleTokens.slice(j, j + 3));
+                if (bestMatch.index >= 0) {
+                    j += bestMatch.index;
+                    aligned.push([queryTokens[i], exampleTokens[j]]);
+                }
+                else {
+                    aligned.push([queryTokens[i], exampleTokens[j]]);
+                }
+                i++;
+                j++;
+            }
+        }
+        return aligned;
+    }
+    /**
+     * Find best token match using fuzzy comparison
+     */
+    findBestTokenMatch(token, candidates) {
+        let bestIndex = -1;
+        let bestSimilarity = 0;
+        candidates.forEach((candidate, index) => {
+            const distance = this.levenshteinDistance(token.toLowerCase(), candidate.toLowerCase());
+            const similarity = 1 - (distance / Math.max(token.length, candidate.length));
+            if (similarity > bestSimilarity && similarity > 0.6) {
+                bestIndex = index;
+                bestSimilarity = similarity;
+            }
+        });
+        return { index: bestIndex, similarity: bestSimilarity };
+    }
+    /**
+     * Extract slots from string alignment
+     */
+    extractSlotsFromAlignment(aligned, _pattern) {
+        const slots = {};
+        let slotIndex = 1;
+        aligned.forEach(([queryToken, exampleToken]) => {
+            if (exampleToken.startsWith('$')) {
+                slots[`$${slotIndex}`] = queryToken;
+                slotIndex++;
+            }
+        });
+        return slots;
     }
     /**
      * Fill template with extracted slots
@@ -246,7 +581,7 @@ export class PatternLibrary {
     /**
      * Helper: Post-process extracted slots
      */
-    postProcessSlots(slots, pattern) {
+    postProcessSlots(slots, _pattern) {
         // Convert string numbers to actual numbers
         for (const [key, value] of Object.entries(slots)) {
             if (typeof value === 'string') {

package/dist/neural/staticPatternMatcher.d.ts

@@ -1,5 +1,5 @@
 /**
- * Static Pattern Matcher - NO runtime initialization, NO BrainyData needed
+ * Static Pattern Matcher - NO runtime initialization, NO Brainy needed
  *
  * All patterns and embeddings are pre-computed at build time
  * This is pure pattern matching with zero dependencies
@@ -24,7 +24,7 @@ export declare function matchPatternByRegex(query: string): {
 } | null;
 /**
  * Convert natural language to structured query using STATIC patterns
- * NO initialization needed, NO BrainyData required
+ * NO initialization needed, NO Brainy required
  */
 export declare function patternMatchQuery(query: string, queryEmbedding?: Vector): TripleQuery;
 export declare const PATTERN_STATS: {

package/dist/neural/staticPatternMatcher.js

@@ -1,5 +1,5 @@
 /**
- * Static Pattern Matcher - NO runtime initialization, NO BrainyData needed
+ * Static Pattern Matcher - NO runtime initialization, NO Brainy needed
  *
  * All patterns and embeddings are pre-computed at build time
  * This is pure pattern matching with zero dependencies
@@ -111,7 +111,7 @@ export function matchPatternByRegex(query) {
 }
 /**
  * Convert natural language to structured query using STATIC patterns
- * NO initialization needed, NO BrainyData required
+ * NO initialization needed, NO Brainy required
  */
 export function patternMatchQuery(query, queryEmbedding) {
     // ALWAYS use vector similarity when we have embeddings (which we always do!)