@soulcraft/brainy 6.3.0 → 6.3.1

package/dist/query/typeInference.js

@@ -1,760 +0,0 @@
-/**
- * Type Inference System - Phase 3: Type-First Query Optimization
- *
- * Automatically infers NounTypes from natural language queries using keyword-based
- * heuristics for fast O(1) type detection.
- *
- * Performance Guarantee: < 1ms per query
- * Accuracy Target: > 80%
- *
- * Examples:
- * - "Find engineers in San Francisco" → [Person, Location]
- * - "Show documents about AI" → [Document, Concept]
- * - "List companies in tech sector" → [Organization, Topic]
- */
-import { NounType } from '../types/graphTypes.js';
-import { prodLog } from '../utils/logger.js';
-/**
- * Type Inference System
- *
- * Uses keyword matching for fast type detection from natural language.
- * Designed for billion-scale performance with minimal latency.
- */
-export class TypeInferenceSystem {
-    constructor(config) {
-        this.typeEmbeddings = null;
-        this.embedder = null; // Lazy-loaded TransformerEmbedding
-        this.config = {
-            minConfidence: config?.minConfidence ?? 0.4,
-            maxTypes: config?.maxTypes ?? 5,
-            debug: config?.debug ?? false,
-            enableVectorFallback: config?.enableVectorFallback ?? false,
-            fallbackConfidenceThreshold: config?.fallbackConfidenceThreshold ?? 0.7,
-            vectorThreshold: config?.vectorThreshold ?? 0.5
-        };
-        this.keywordMap = this.buildKeywordMap();
-        this.phraseMap = this.buildPhraseMap();
-        // Load pre-compiled type embeddings if vector fallback is enabled
-        // Note: This is async but we don't await in constructor
-        // The embeddings will be loaded before first inferTypesAsync() call
-        if (this.config.enableVectorFallback) {
-            this.loadTypeEmbeddings().catch(err => {
-                prodLog.warn(`Failed to load type embeddings in constructor: ${err.message}`);
-            });
-        }
-        prodLog.info(`TypeInferenceSystem initialized: ${this.keywordMap.size} keywords, ${this.phraseMap.size} phrases` +
-            (this.config.enableVectorFallback ? ', vector fallback enabled' : ''));
-    }
-    /**
-     * Infer noun types from a natural language query (synchronous keyword matching only)
-     * For hybrid mode with vector fallback, use inferTypesAsync()
-     *
-     * @param query - Natural language query string
-     * @returns Array of type inferences sorted by confidence (highest first)
-     */
-    inferTypes(query) {
-        const startTime = performance.now();
-        if (!query || query.trim().length === 0) {
-            return [];
-        }
-        // Keyword matching only (fast path - O(1) lookup)
-        const results = this.inferTypesViaKeywords(query);
-        const elapsed = performance.now() - startTime;
-        if (this.config.debug) {
-            prodLog.debug(`Type inference (keyword): ${results.length} types inferred in ${elapsed.toFixed(2)}ms`);
-        }
-        return results;
-    }
-    /**
-     * Infer noun types with hybrid approach: keyword matching + optional vector fallback
-     * This is the async version that supports vector similarity fallback
-     *
-     * @param query - Natural language query string
-     * @returns Promise resolving to array of type inferences
-     */
-    async inferTypesAsync(query) {
-        const startTime = performance.now();
-        if (!query || query.trim().length === 0) {
-            return [];
-        }
-        // Step 1: Try keyword matching (fast path - O(1) lookup)
-        const keywordResults = this.inferTypesViaKeywords(query);
-        // Step 2: Check if we should use vector fallback
-        const shouldUseFallback = this.config.enableVectorFallback && (keywordResults.length === 0 ||
-            keywordResults[0].confidence < this.config.fallbackConfidenceThreshold);
-        if (!shouldUseFallback) {
-            // Fast path: Return keyword results immediately
-            const elapsed = performance.now() - startTime;
-            if (this.config.debug) {
-                prodLog.debug(`Type inference (keyword): ${keywordResults.length} types inferred in ${elapsed.toFixed(2)}ms`);
-            }
-            return keywordResults;
-        }
-        // Slow path: Use vector similarity fallback (async)
-        return this.inferTypesWithFallback(query, keywordResults, startTime);
-    }
-    /**
-     * Internal: Keyword-based type inference (synchronous, fast)
-     */
-    inferTypesViaKeywords(query) {
-        // Normalize query
-        const normalized = query.toLowerCase().trim();
-        // Track inferred types with scores
-        const typeScores = new Map();
-        // Phase 1: Multi-word phrase matching (highest confidence)
-        this.matchPhrases(normalized, typeScores);
-        // Phase 2: Single keyword matching
-        this.matchKeywords(normalized, typeScores);
-        // Convert to result array
-        const results = [];
-        for (const [type, data] of typeScores) {
-            if (data.confidence >= this.config.minConfidence) {
-                results.push({
-                    type,
-                    confidence: data.confidence,
-                    matchedKeywords: Array.from(data.keywords)
-                });
-            }
-        }
-        // Sort by confidence (descending)
-        results.sort((a, b) => b.confidence - a.confidence);
-        // Limit results
-        return results.slice(0, this.config.maxTypes);
-    }
-    /**
-     * Internal: Hybrid inference with vector fallback (asynchronous)
-     */
-    async inferTypesWithFallback(query, keywordResults, startTime) {
-        if (this.config.debug) {
-            prodLog.debug(`Type inference: Low keyword confidence (${keywordResults.length > 0 ? keywordResults[0].confidence.toFixed(2) : '0.00'}), triggering vector fallback`);
-        }
-        // Use vector similarity fallback
-        const vectorResults = await this.inferTypesViaVectorSimilarity(query);
-        // Merge keyword and vector results
-        const mergedResults = this.mergeResults(keywordResults, vectorResults);
-        const elapsed = performance.now() - startTime;
-        if (this.config.debug) {
-            prodLog.debug(`Type inference (hybrid): ${mergedResults.length} types inferred in ${elapsed.toFixed(2)}ms ` +
-                `(${keywordResults.length} keyword, ${vectorResults.length} vector)`);
-        }
-        // Performance warning (only for fallback path)
-        if (elapsed > 100) {
-            prodLog.warn(`Type inference slow (vector fallback): Took ${elapsed.toFixed(2)}ms`);
-        }
-        return mergedResults;
-    }
-    /**
-     * Match multi-word phrases in query
-     */
-    matchPhrases(query, typeScores) {
-        for (const [phrase, entry] of this.phraseMap) {
-            if (query.includes(phrase)) {
-                for (const type of entry.types) {
-                    this.updateTypeScore(type, entry.confidence, phrase, typeScores);
-                }
-            }
-        }
-    }
-    /**
-     * Match individual keywords in query
-     */
-    matchKeywords(query, typeScores) {
-        // Tokenize query (split on non-alphanumeric)
-        const tokens = query.split(/[^a-z0-9]+/).filter(t => t.length > 0);
-        for (const token of tokens) {
-            let entry = this.keywordMap.get(token);
-            let matchedKeyword = token;
-            // If no exact match, try singular form (simple plural handling)
-            if (!entry && token.endsWith('s') && token.length > 2) {
-                const singular = token.slice(0, -1);
-                entry = this.keywordMap.get(singular);
-                if (entry)
-                    matchedKeyword = singular;
-            }
-            // If still no match and ends with 'es', try removing 'es'
-            if (!entry && token.endsWith('es') && token.length > 3) {
-                const singular = token.slice(0, -2);
-                entry = this.keywordMap.get(singular);
-                if (entry)
-                    matchedKeyword = singular;
-            }
-            // If still no match and ends with 'ies', try changing to 'y'
-            if (!entry && token.endsWith('ies') && token.length > 4) {
-                const singular = token.slice(0, -3) + 'y';
-                entry = this.keywordMap.get(singular);
-                if (entry)
-                    matchedKeyword = singular;
-            }
-            // If still no match, try fuzzy matching for typos (edit distance <= 1)
-            if (!entry && token.length >= 5) {
-                const fuzzyMatch = this.findFuzzyKeywordMatch(token);
-                if (fuzzyMatch) {
-                    entry = fuzzyMatch.entry;
-                    matchedKeyword = `${token}→${fuzzyMatch.keyword}`;
-                }
-            }
-            if (entry) {
-                for (const type of entry.types) {
-                    this.updateTypeScore(type, entry.confidence * (matchedKeyword.includes('→') ? 0.85 : 1.0), // Reduce confidence for fuzzy matches
-                    matchedKeyword, typeScores);
-                }
-            }
-        }
-    }
-    /**
-     * Find closest keyword using edit distance (for typo correction)
-     * Allows edit distance 1-2 depending on word length
-     */
-    findFuzzyKeywordMatch(token) {
-        // Only attempt fuzzy matching for words 5+ characters
-        if (token.length < 5)
-            return null;
-        // Determine max edit distance based on word length
-        // Shorter words (5-7 chars): distance <= 1
-        // Longer words (8+ chars): distance <= 2
-        const maxDistance = token.length >= 8 ? 2 : 1;
-        for (const [keyword, entry] of this.keywordMap) {
-            // Only match keywords of similar length (±2 for distance 2, ±1 for distance 1)
-            if (Math.abs(keyword.length - token.length) > maxDistance)
-                continue;
-            // Calculate edit distance
-            const distance = this.levenshteinDistance(token, keyword);
-            // Accept if within threshold
-            if (distance > 0 && distance <= maxDistance) {
-                return { keyword, entry };
-            }
-        }
-        return null;
-    }
-    /**
-     * Calculate Levenshtein (edit) distance between two strings
-     */
-    levenshteinDistance(a, b) {
-        const matrix = [];
-        for (let i = 0; i <= b.length; i++) {
-            matrix[i] = [i];
-        }
-        for (let j = 0; j <= a.length; j++) {
-            matrix[0][j] = j;
-        }
-        for (let i = 1; i <= b.length; i++) {
-            for (let j = 1; j <= a.length; j++) {
-                if (b.charAt(i - 1) === a.charAt(j - 1)) {
-                    matrix[i][j] = matrix[i - 1][j - 1];
-                }
-                else {
-                    matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, // substitution
-                    matrix[i][j - 1] + 1, // insertion
-                    matrix[i - 1][j] + 1 // deletion
-                    );
-                }
-            }
-        }
-        return matrix[b.length][a.length];
-    }
-    /**
-     * Update type score with new match
-     */
-    updateTypeScore(type, confidence, keyword, typeScores) {
-        const existing = typeScores.get(type);
-        if (existing) {
-            // Boost confidence for multiple matches (max 1.0)
-            existing.confidence = Math.min(1.0, existing.confidence + confidence * 0.2);
-            existing.keywords.add(keyword);
-        }
-        else {
-            typeScores.set(type, {
-                confidence,
-                keywords: new Set([keyword])
-            });
-        }
-    }
-    /**
-     * Load pre-compiled type embeddings from embeddedTypeEmbeddings.ts
-     */
-    async loadTypeEmbeddings() {
-        try {
-            // Dynamically import to avoid loading if not needed
-            const module = await import('../neural/embeddedTypeEmbeddings.js');
-            this.typeEmbeddings = module.getNounTypeEmbeddings();
-            if (this.config.debug) {
-                prodLog.debug(`Loaded ${this.typeEmbeddings?.size || 0} pre-compiled type embeddings for vector fallback`);
-            }
-        }
-        catch (error) {
-            prodLog.warn(`Failed to load type embeddings: ${error.message}`);
-            this.config.enableVectorFallback = false;
-        }
-    }
-    /**
-     * Lazy-load TransformerEmbedding model (only when vector fallback is triggered)
-     */
-    async loadEmbedder() {
-        if (this.embedder) {
-            return this.embedder;
-        }
-        try {
-            const { TransformerEmbedding } = await import('../utils/embedding.js');
-            const embedder = new TransformerEmbedding({ verbose: false });
-            await embedder.init();
-            this.embedder = embedder;
-            if (this.config.debug) {
-                prodLog.debug('TransformerEmbedding model loaded for vector fallback');
-            }
-            return embedder;
-        }
-        catch (error) {
-            prodLog.error(`Failed to load embedder: ${error.message}`);
-            throw new Error(`Cannot use vector fallback: ${error.message}`);
-        }
-    }
-    /**
-     * Calculate cosine similarity between two vectors
-     */
-    cosineSimilarity(a, b) {
-        if (!a || !b || a.length !== b.length)
-            return 0;
-        let dotProduct = 0;
-        let normA = 0;
-        let normB = 0;
-        for (let i = 0; i < a.length; i++) {
-            dotProduct += a[i] * b[i];
-            normA += a[i] * a[i];
-            normB += b[i] * b[i];
-        }
-        const denominator = Math.sqrt(normA) * Math.sqrt(normB);
-        return denominator === 0 ? 0 : dotProduct / denominator;
-    }
-    /**
-     * Infer types using vector similarity against pre-compiled type embeddings
-     */
-    async inferTypesViaVectorSimilarity(query) {
-        const startTime = performance.now();
-        try {
-            // Ensure type embeddings are loaded (wait if still loading)
-            if (!this.typeEmbeddings) {
-                if (this.config.enableVectorFallback) {
-                    // Try loading once more in case constructor load failed
-                    await this.loadTypeEmbeddings();
-                }
-                if (!this.typeEmbeddings) {
-                    prodLog.warn('Type embeddings not loaded, cannot use vector fallback');
-                    return [];
-                }
-            }
-            // Lazy-load embedder if not already loaded
-            const embedder = await this.loadEmbedder();
-            // Generate query embedding
-            const queryEmbedding = await embedder.embed(query);
-            // Calculate similarity against all type embeddings
-            const similarities = [];
-            for (const [type, typeEmbedding] of this.typeEmbeddings) {
-                const similarity = this.cosineSimilarity(queryEmbedding, typeEmbedding);
-                if (similarity >= this.config.vectorThreshold) {
-                    similarities.push({
-                        type,
-                        confidence: similarity,
-                        matchedKeywords: ['<vector-similarity>']
-                    });
-                }
-            }
-            // Sort by confidence (descending)
-            similarities.sort((a, b) => b.confidence - a.confidence);
-            const elapsed = performance.now() - startTime;
-            if (this.config.debug) {
-                prodLog.debug(`Vector similarity inference complete: ${similarities.length} types found in ${elapsed.toFixed(2)}ms`);
-            }
-            return similarities.slice(0, this.config.maxTypes);
-        }
-        catch (error) {
-            prodLog.error(`Vector similarity inference failed: ${error.message}`);
-            return [];
-        }
-    }
-    /**
-     * Merge keyword-based and vector-based results
-     * Prioritizes keyword results (explicit matches) over vector results (semantic matches)
-     */
-    mergeResults(keywordResults, vectorResults) {
-        const merged = new Map();
-        // Add keyword results first (higher priority, boost confidence)
-        for (const result of keywordResults) {
-            merged.set(result.type, {
-                ...result,
-                confidence: Math.min(1.0, result.confidence * 1.2) // Boost keyword matches by 20%
-            });
-        }
-        // Add vector results if not already present
-        for (const result of vectorResults) {
-            if (!merged.has(result.type)) {
-                merged.set(result.type, result);
-            }
-        }
-        // Convert to array and sort by confidence
-        const results = Array.from(merged.values())
-            .sort((a, b) => b.confidence - a.confidence)
-            .slice(0, this.config.maxTypes);
-        return results;
-    }
-    /**
-     * Build keyword dictionary for single-word matching
-     */
-    buildKeywordMap() {
-        const map = new Map();
-        // Helper to add keywords
-        const add = (keywords, types, confidence) => {
-            for (const keyword of keywords) {
-                map.set(keyword, { types, confidence });
-            }
-        };
-        // Person (100+ keywords)
-        add([
-            // Roles - Professional
-            'person', 'people', 'individual', 'human',
-            'user', 'employee', 'worker', 'staff', 'personnel', 'member', 'team',
-            'engineer', 'developer', 'programmer', 'coder', 'architect', 'designer',
-            'manager', 'director', 'executive', 'leader', 'supervisor', 'coordinator',
-            'ceo', 'cto', 'cfo', 'coo', 'vp', 'president', 'founder', 'owner',
-            'analyst', 'consultant', 'specialist', 'expert', 'professional',
-            'technician', 'operator', 'administrator', 'assistant', 'associate',
-            // Roles - Specific Professions (Medical)
-            'doctor', 'physician', 'surgeon', 'nurse', 'therapist',
-            'cardiologist', 'oncologist', 'neurologist', 'psychiatrist', 'psychologist',
-            'radiologist', 'pathologist', 'anesthesiologist', 'dermatologist',
-            'pediatrician', 'obstetrician', 'gynecologist', 'ophthalmologist',
-            'dentist', 'orthodontist', 'pharmacist', 'paramedic', 'emt',
-            // Roles - Legal
-            'lawyer', 'attorney', 'judge', 'paralegal',
-            'teacher', 'professor', 'instructor', 'educator', 'tutor',
-            'student', 'pupil', 'learner', 'trainee', 'intern',
-            'artist', 'musician', 'painter', 'sculptor', 'performer',
-            'author', 'writer', 'journalist', 'editor', 'reporter',
-            'researcher', 'scientist', 'scholar', 'academic',
-            'accountant', 'auditor', 'banker', 'trader', 'broker',
-            'salesperson', 'marketer', 'recruiter', 'agent',
-            // Social Relationships
-            'friend', 'colleague', 'coworker', 'teammate', 'partner',
-            'customer', 'client', 'vendor', 'supplier', 'contractor',
-            'mentor', 'mentee', 'coach', 'advisor', 'counselor',
-            'volunteer', 'activist', 'advocate', 'supporter',
-            // Demographics
-            'male', 'female', 'adult', 'child', 'teen', 'senior', 'junior'
-        ], [NounType.Person], 0.9);
-        // Organization (70+ keywords)
-        add([
-            'organization', 'company', 'business', 'corporation', 'enterprise',
-            'firm', 'agency', 'bureau', 'office', 'department',
-            'startup', 'venture', 'subsidiary', 'branch', 'division',
-            'institution', 'foundation', 'association', 'society', 'club',
-            'nonprofit', 'ngo', 'charity', 'trust', 'federation',
-            'government', 'ministry', 'administration', 'authority',
-            'university', 'college', 'school', 'academy', 'institute',
-            'hospital', 'clinic', 'medical center', 'healthcare',
-            'bank', 'credit union', 'financial', 'insurance',
-            'manufacturer', 'factory', 'plant', 'facility',
-            'retailer', 'store', 'shop', 'outlet', 'chain',
-            'restaurant', 'hotel', 'resort', 'casino',
-            'publisher', 'studio', 'gallery', 'museum', 'library',
-            'lab', 'laboratory', 'research center',
-            'team', 'squad', 'crew', 'group', 'committee'
-        ], [NounType.Organization], 0.9);
-        // Location (60+ keywords)
-        add([
-            'location', 'place', 'area', 'region', 'zone', 'district',
-            'city', 'town', 'village', 'municipality', 'metro',
-            'country', 'nation', 'state', 'province', 'territory',
-            'county', 'parish', 'prefecture', 'canton',
-            'continent', 'island', 'peninsula', 'archipelago',
-            'street', 'road', 'avenue', 'boulevard', 'lane', 'drive',
-            'address', 'building', 'structure', 'tower', 'complex',
-            'office', 'headquarters', 'hq', 'campus', 'site',
-            'facility', 'center', 'venue', 'space', 'room',
-            'warehouse', 'depot', 'terminal', 'station', 'port',
-            'park', 'garden', 'plaza', 'square', 'mall',
-            'neighborhood', 'suburb', 'downtown', 'uptown',
-            'north', 'south', 'east', 'west', 'central',
-            'coastal', 'inland', 'urban', 'rural', 'remote'
-        ], [NounType.Location], 0.9);
-        // Document (80+ keywords)
-        add([
-            'document', 'file', 'text', 'writing', 'manuscript',
-            'report', 'summary', 'brief', 'overview', 'analysis',
-            'article', 'essay', 'paper', 'publication', 'journal',
-            'book', 'ebook', 'novel', 'chapter', 'volume',
-            'manual', 'guide', 'handbook', 'reference', 'documentation',
-            'tutorial', 'howto', 'walkthrough', 'instructions',
-            'specification', 'spec', 'standard', 'protocol',
-            'proposal', 'pitch', 'presentation', 'slide', 'deck',
-            'contract', 'agreement', 'license', 'terms', 'policy',
-            'invoice', 'receipt', 'statement', 'bill', 'voucher',
-            'form', 'application', 'survey', 'questionnaire',
-            'transcript', 'minutes', 'record', 'log', 'entry',
-            'note', 'memo', 'message', 'email', 'letter',
-            'whitepaper', 'thesis', 'dissertation', 'abstract',
-            'readme', 'changelog', 'documentation', 'wiki',
-            'cv', 'resume', 'portfolio', 'profile'
-        ], [NounType.Document], 0.9);
-        // Media (40+ keywords)
-        add([
-            'media', 'multimedia', 'content',
-            'image', 'photo', 'picture', 'photograph', 'illustration',
-            'graphic', 'icon', 'logo', 'banner', 'thumbnail',
-            'video', 'movie', 'film', 'clip', 'recording',
-            'animation', 'gif', 'webm', 'stream', 'broadcast',
-            'audio', 'sound', 'music', 'song', 'track', 'album',
-            'podcast', 'episode', 'audiobook', 'voicemail',
-            'screenshot', 'screen capture', 'demo', 'tutorial',
-            'asset', 'resource', 'attachment'
-        ], [NounType.Media], 0.85);
-        // Concept/Topic (80+ keywords)
-        add([
-            'concept', 'idea', 'notion', 'theory', 'principle',
-            'philosophy', 'ideology', 'belief', 'doctrine',
-            'topic', 'subject', 'theme', 'matter', 'issue',
-            'category', 'classification', 'taxonomy', 'domain',
-            'field', 'discipline', 'specialty', 'area',
-            'technology', 'tech', 'innovation', 'invention',
-            'science', 'scientific', 'research',
-            'mathematics', 'math', 'statistics', 'algebra', 'calculus',
-            'physics', 'quantum', 'mechanics', 'thermodynamics',
-            'chemistry', 'biology', 'genetics', 'neuroscience',
-            'engineering', 'architecture', 'design',
-            'computer science', 'programming', 'algorithm',
-            'artificial intelligence', 'machine learning', 'ai', 'ml',
-            'data science', 'analytics', 'big data',
-            'history', 'historical', 'ancient', 'medieval', 'modern',
-            'geography', 'geology', 'ecology', 'environment',
-            'literature', 'poetry', 'fiction', 'nonfiction',
-            'art', 'artistic', 'visual', 'creative',
-            'music', 'musical', 'classical', 'jazz', 'rock',
-            'sports', 'athletics', 'competition', 'game',
-            'politics', 'political', 'government', 'policy',
-            'economics', 'economic', 'finance', 'market',
-            'psychology', 'sociology', 'anthropology',
-            'religion', 'spiritual', 'philosophy'
-        ], [NounType.Concept], 0.8);
-        // Event (50+ keywords)
-        add([
-            'event', 'occasion', 'happening', 'occurrence',
-            'meeting', 'conference', 'summit', 'convention',
-            'seminar', 'symposium', 'colloquium', 'forum',
-            'workshop', 'training', 'bootcamp', 'course',
-            'webinar', 'presentation', 'talk', 'lecture',
-            'session', 'class', 'lesson', 'tutorial',
-            'party', 'celebration', 'festivity', 'gathering',
-            'ceremony', 'ritual', 'service', 'function',
-            'festival', 'carnival', 'fair', 'exhibition',
-            'concert', 'performance', 'show', 'gig',
-            'game', 'match', 'tournament', 'championship',
-            'race', 'competition', 'contest', 'trial',
-            'launch', 'release', 'premiere', 'debut',
-            'announcement', 'reveal', 'unveiling'
-        ], [NounType.Event], 0.85);
-        // Product (50+ keywords)
-        add([
-            'product', 'item', 'goods', 'merchandise', 'commodity',
-            'offering', 'solution', 'package', 'bundle',
-            'software', 'app', 'application', 'program', 'tool',
-            'platform', 'system', 'framework', 'library',
-            'device', 'gadget', 'machine', 'equipment', 'apparatus',
-            'hardware', 'component', 'part', 'accessory',
-            'vehicle', 'car', 'automobile', 'truck', 'bike',
-            'phone', 'smartphone', 'mobile', 'tablet', 'ipad',
-            'computer', 'laptop', 'desktop', 'pc', 'mac',
-            'watch', 'wearable', 'tracker', 'monitor',
-            'camera', 'lens', 'sensor', 'scanner'
-        ], [NounType.Product], 0.85);
-        // Service (40+ keywords)
-        add([
-            'service', 'offering', 'solution', 'support',
-            'consulting', 'advisory', 'guidance', 'assistance',
-            'maintenance', 'repair', 'installation', 'setup',
-            'hosting', 'cloud', 'saas', 'paas', 'iaas',
-            'delivery', 'shipping', 'logistics', 'transport',
-            'subscription', 'membership', 'plan', 'tier',
-            'training', 'education', 'coaching', 'mentoring',
-            'healthcare', 'medical', 'dental', 'therapy',
-            'legal', 'accounting', 'financial', 'insurance',
-            'marketing', 'advertising', 'promotion', 'pr'
-        ], [NounType.Service], 0.85);
-        // User (30+ keywords)
-        add([
-            'user', 'account', 'profile', 'identity',
-            'username', 'userid', 'login', 'credential',
-            'subscriber', 'follower', 'fan', 'supporter',
-            'member', 'participant', 'contributor', 'author',
-            'viewer', 'reader', 'listener', 'watcher',
-            'player', 'gamer', 'competitor', 'contestant',
-            'guest', 'visitor', 'attendee', 'participant'
-        ], [NounType.User], 0.8);
-        // Task/Project (60+ keywords)
-        add([
-            // Tasks
-            'task', 'todo', 'action', 'activity', 'job',
-            'assignment', 'chore', 'duty', 'work', 'effort',
-            'ticket', 'issue', 'bug', 'defect', 'problem',
-            'feature', 'enhancement', 'improvement', 'request',
-            'story', 'epic', 'saga', 'initiative',
-            'backlog', 'queue', 'pipeline', 'workflow',
-            // Projects
-            'project', 'program', 'initiative', 'undertaking',
-            'campaign', 'drive', 'effort', 'venture',
-            'plan', 'scheme', 'strategy', 'roadmap',
-            'milestone', 'deliverable', 'objective', 'goal',
-            'sprint', 'iteration', 'cycle', 'phase',
-            'release', 'version', 'build', 'deployment'
-        ], [NounType.Task], 0.8);
-        // Process (30+ keywords)
-        add([
-            'process', 'procedure', 'method', 'approach',
-            'workflow', 'pipeline', 'sequence', 'flow',
-            'algorithm', 'logic', 'routine', 'operation',
-            'protocol', 'standard', 'guideline', 'practice',
-            'step', 'stage', 'phase', 'cycle',
-            'system', 'framework', 'structure', 'architecture',
-            'automation', 'mechanism', 'procedure'
-        ], [NounType.Process], 0.75);
-        // Collection/Dataset (40+ keywords)
-        add([
-            'collection', 'set', 'group', 'batch', 'bundle',
-            'list', 'array', 'series', 'sequence', 'range',
-            'category', 'class', 'type', 'kind', 'sort',
-            'dataset', 'data', 'database', 'table', 'schema',
-            'corpus', 'repository', 'archive', 'library',
-            'catalog', 'index', 'registry', 'directory',
-            'inventory', 'stockpile', 'cache', 'pool',
-            'queue', 'stack', 'heap', 'tree', 'graph'
-        ], [NounType.Collection], 0.75);
-        // State/Role/Topic (25+ keywords each)
-        add([
-            'state', 'status', 'condition', 'situation',
-            'phase', 'stage', 'level', 'mode',
-            'active', 'inactive', 'pending', 'completed',
-            'open', 'closed', 'locked', 'enabled', 'disabled'
-        ], [NounType.State], 0.7);
-        add([
-            'role', 'position', 'title', 'rank',
-            'responsibility', 'duty', 'function', 'capacity',
-            'permission', 'access', 'privilege', 'right'
-        ], [NounType.Role], 0.7);
-        add([
-            'topic', 'subject', 'theme', 'matter',
-            'area', 'field', 'domain', 'sector',
-            'category', 'genre', 'type', 'style'
-        ], [NounType.Topic], 0.7);
-        // Scientific Types
-        add([
-            'hypothesis', 'theory', 'conjecture', 'proposition',
-            'assumption', 'premise', 'postulate', 'thesis'
-        ], [NounType.Hypothesis], 0.8);
-        add([
-            'experiment', 'study', 'trial', 'test',
-            'research', 'investigation', 'analysis', 'examination'
-        ], [NounType.Experiment], 0.8);
-        // Legal Types
-        add([
-            'contract', 'agreement', 'treaty', 'pact',
-            'deal', 'arrangement', 'settlement', 'accord'
-        ], [NounType.Contract], 0.85);
-        add([
-            'regulation', 'rule', 'law', 'statute',
-            'ordinance', 'code', 'compliance', 'requirement'
-        ], [NounType.Regulation], 0.85);
-        // Technical Types
-        add([
-            'interface', 'api', 'endpoint', 'protocol',
-            'contract', 'specification', 'definition'
-        ], [NounType.Interface], 0.8);
-        add([
-            'resource', 'asset', 'capacity', 'bandwidth',
-            'storage', 'memory', 'compute', 'infrastructure'
-        ], [NounType.Resource], 0.75);
-        return map;
-    }
-    /**
-     * Build phrase dictionary for multi-word matching
-     */
-    buildPhraseMap() {
-        const map = new Map();
-        // Helper to add phrases
-        const add = (phrases, types, confidence) => {
-            for (const phrase of phrases) {
-                map.set(phrase, { types, confidence });
-            }
-        };
-        // Person-related phrases
-        add([
-            'software engineer', 'software developer', 'web developer',
-            'data scientist', 'machine learning engineer', 'ml engineer',
-            'product manager', 'project manager', 'engineering manager',
-            'ux designer', 'ui designer', 'graphic designer',
-            'sales rep', 'account manager', 'customer success'
-        ], [NounType.Person], 0.95);
-        // Location phrases
-        add([
-            'san francisco', 'new york', 'los angeles', 'silicon valley',
-            'bay area', 'new york city', 'washington dc',
-            'hong kong', 'united states', 'united kingdom'
-        ], [NounType.Location], 0.95);
-        // Concept phrases
-        add([
-            'artificial intelligence', 'machine learning', 'deep learning',
-            'natural language processing', 'computer vision',
-            'quantum computing', 'quantum mechanics', 'quantum physics',
-            'climate change', 'global warming', 'renewable energy',
-            'data science', 'big data', 'data analytics'
-        ], [NounType.Concept], 0.95);
-        // Multi-type phrases (query patterns)
-        add([
-            'people at', 'employees at', 'workers at', 'staff at',
-            'team at', 'people from', 'employees from'
-        ], [NounType.Person, NounType.Organization], 0.9);
-        add([
-            'companies in', 'organizations in', 'businesses in',
-            'offices in', 'locations in'
-        ], [NounType.Organization, NounType.Location], 0.9);
-        add([
-            'documents about', 'papers about', 'articles about',
-            'reports about', 'research about'
-        ], [NounType.Document, NounType.Concept], 0.9);
-        add([
-            'events in', 'conferences in', 'meetings in',
-            'workshops in', 'seminars in'
-        ], [NounType.Event, NounType.Location], 0.9);
-        add([
-            'products from', 'services from', 'offerings from',
-            'solutions from'
-        ], [NounType.Product, NounType.Organization], 0.85);
-        return map;
-    }
-    /**
-     * Get statistics about the inference system
-     */
-    getStats() {
-        return {
-            keywordCount: this.keywordMap.size,
-            phraseCount: this.phraseMap.size,
-            config: this.config
-        };
-    }
-}
-/**
- * Global singleton instance for convenience
- */
-let globalInstance = null;
-/**
- * Get or create the global TypeInferenceSystem instance
- */
-export function getTypeInferenceSystem(config) {
-    if (!globalInstance) {
-        globalInstance = new TypeInferenceSystem(config);
-    }
-    return globalInstance;
-}
-/**
- * Convenience function to infer types from a query
- */
-export function inferTypes(query, config) {
-    return getTypeInferenceSystem(config).inferTypes(query);
-}
-//# sourceMappingURL=typeInference.js.map