@soulcraft/brainy 6.3.0 → 6.3.1

package/dist/importManager.js

@@ -1,267 +0,0 @@
-/**
- * Import Manager - Comprehensive data import with intelligent type detection
- *
- * Handles multiple data sources:
- * - Direct data (objects, arrays)
- * - Files (JSON, CSV, text)
- * - URLs (fetch and parse)
- * - Streams (for large files)
- *
- * Uses NeuralImportAugmentation for intelligent processing
- */
-import { VerbType } from './types/graphTypes.js';
-import { NeuralImportAugmentation } from './augmentations/neuralImport.js';
-import * as fs from './universal/fs.js';
-import * as path from './universal/path.js';
-import { prodLog } from './utils/logger.js';
-export class ImportManager {
-    constructor(brain) {
-        this.typeMatcher = null;
-        this.brain = brain;
-        this.neuralImport = new NeuralImportAugmentation();
-    }
-    /**
-     * Initialize the import manager
-     */
-    async init() {
-        // Initialize neural import with proper context
-        const context = {
-            brain: this.brain,
-            storage: this.brain.storage,
-            config: {},
-            log: (message, level) => {
-                if (level === 'error') {
-                    prodLog.error(message);
-                }
-                else if (level === 'warn') {
-                    prodLog.warn(message);
-                }
-                else {
-                    prodLog.info(message);
-                }
-            }
-        };
-        await this.neuralImport.initialize(context);
-        // Get type matcher
-        const { getBrainyTypes } = await import('./augmentations/typeMatching/brainyTypes.js');
-        this.typeMatcher = await getBrainyTypes();
-    }
-    /**
-     * Main import method - handles all sources
-     */
-    async import(source, options = {}) {
-        const result = {
-            success: false,
-            nouns: [],
-            verbs: [],
-            errors: [],
-            stats: {
-                total: 0,
-                imported: 0,
-                failed: 0,
-                relationships: 0
-            }
-        };
-        try {
-            // Detect source type
-            const sourceType = await this.detectSourceType(source, options.source);
-            // Get data based on source type
-            let data;
-            let format = options.format || 'auto';
-            switch (sourceType) {
-                case 'url':
-                    data = await this.fetchFromUrl(source);
-                    break;
-                case 'file':
-                    const filePath = source;
-                    data = await this.readFile(filePath);
-                    if (format === 'auto') {
-                        format = this.detectFormatFromPath(filePath);
-                    }
-                    break;
-                case 'data':
-                default:
-                    data = source;
-                    break;
-            }
-            // Process data through neural import
-            let items;
-            let relationships = [];
-            if (Buffer.isBuffer(data) || typeof data === 'string') {
-                // Use neural import for parsing and analysis
-                const analysis = await this.neuralImport.getNeuralAnalysis(data, format);
-                // Extract items and relationships
-                items = analysis.detectedEntities.map(entity => ({
-                    data: entity.originalData,
-                    type: entity.nounType,
-                    confidence: entity.confidence,
-                    id: entity.suggestedId
-                }));
-                if (options.extractRelationships !== false) {
-                    relationships = analysis.detectedRelationships;
-                }
-                // Log insights
-                for (const insight of analysis.insights) {
-                    prodLog.info(`🧠 ${insight.description} (confidence: ${insight.confidence})`);
-                }
-            }
-            else if (Array.isArray(data)) {
-                items = data;
-            }
-            else {
-                items = [data];
-            }
-            result.stats.total = items.length;
-            // Import items in batches
-            const batchSize = options.batchSize || 50;
-            for (let i = 0; i < items.length; i += batchSize) {
-                const batch = items.slice(i, i + batchSize);
-                // Process batch in parallel if enabled
-                const promises = batch.map(async (item) => {
-                    try {
-                        // Detect type if needed
-                        let nounType = item.type || options.typeHint;
-                        if (!nounType && options.autoDetect !== false && this.typeMatcher) {
-                            const match = await this.typeMatcher.matchNounType(item.data || item);
-                            nounType = match.type;
-                        }
-                        // Prepare the data to import
-                        const dataToImport = item.data || item;
-                        // Create metadata combining original data with import metadata
-                        const metadata = {
-                            ...(typeof dataToImport === 'object' ? dataToImport : {}),
-                            ...(item.data?.metadata || {}),
-                            nounType,
-                            _importedAt: new Date().toISOString(),
-                            _confidence: item.confidence
-                        };
-                        // Add to brain using modern API signature
-                        const id = await this.brain.add({ data: dataToImport, type: nounType || 'content', metadata });
-                        result.nouns.push(id);
-                        result.stats.imported++;
-                        return id;
-                    }
-                    catch (error) {
-                        result.errors.push(`Failed to import item: ${error.message}`);
-                        result.stats.failed++;
-                        return null;
-                    }
-                });
-                if (options.parallel !== false) {
-                    await Promise.all(promises);
-                }
-                else {
-                    for (const promise of promises) {
-                        await promise;
-                    }
-                }
-            }
-            // Import relationships
-            for (const rel of relationships) {
-                try {
-                    // Match verb type if needed
-                    let verbType = rel.verbType;
-                    if (!Object.values(VerbType).includes(verbType) && this.typeMatcher) {
-                        const match = await this.typeMatcher.matchVerbType({ id: rel.sourceId }, { id: rel.targetId }, rel.verbType);
-                        verbType = match.type;
-                    }
-                    const verbId = await this.brain.relate({
-                        from: rel.sourceId,
-                        to: rel.targetId,
-                        type: verbType,
-                        metadata: rel.metadata,
-                        weight: rel.weight
-                    });
-                    result.verbs.push(verbId);
-                    result.stats.relationships++;
-                }
-                catch (error) {
-                    result.errors.push(`Failed to create relationship: ${error.message}`);
-                }
-            }
-            result.success = result.stats.imported > 0;
-            prodLog.info(`✨ Import complete: ${result.stats.imported}/${result.stats.total} items, ${result.stats.relationships} relationships`);
-        }
-        catch (error) {
-            result.errors.push(`Import failed: ${error.message}`);
-            prodLog.error('Import failed:', error);
-        }
-        return result;
-    }
-    /**
-     * Import from file
-     */
-    async importFile(filePath, options = {}) {
-        return this.import(filePath, { ...options, source: 'file' });
-    }
-    /**
-     * Import from URL
-     */
-    async importUrl(url, options = {}) {
-        return this.import(url, { ...options, source: 'url' });
-    }
-    /**
-     * Detect source type
-     */
-    async detectSourceType(source, hint) {
-        if (hint && hint !== 'auto') {
-            return hint;
-        }
-        if (typeof source === 'string') {
-            // Check if URL
-            if (source.startsWith('http://') || source.startsWith('https://')) {
-                return 'url';
-            }
-            // Check if file path exists
-            try {
-                if (await fs.exists(source)) {
-                    return 'file';
-                }
-            }
-            catch (error) {
-                // File system check failed, not a file path
-                console.debug('File path check failed:', error);
-            }
-        }
-        return 'data';
-    }
-    /**
-     * Detect format from file path
-     */
-    detectFormatFromPath(filePath) {
-        const ext = path.extname(filePath).toLowerCase();
-        switch (ext) {
-            case '.json': return 'json';
-            case '.csv': return 'csv';
-            case '.txt': return 'text';
-            case '.md': return 'text';
-            case '.yaml':
-            case '.yml': return 'yaml';
-            default: return 'auto';
-        }
-    }
-    /**
-     * Read file
-     */
-    async readFile(filePath) {
-        const content = await fs.readFile(filePath, 'utf8');
-        return Buffer.from(content, 'utf8');
-    }
-    /**
-     * Fetch from URL
-     */
-    async fetchFromUrl(url) {
-        const response = await fetch(url);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch ${url}: ${response.statusText}`);
-        }
-        return response.text();
-    }
-}
-/**
- * Create an import manager instance
- */
-export function createImportManager(brain) {
-    return new ImportManager(brain);
-}
-//# sourceMappingURL=importManager.js.map

package/dist/query/typeInference.d.ts

@@ -1,158 +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';
-/**
- * Result of type inference with confidence score
- */
-export interface TypeInference {
-    type: NounType;
-    confidence: number;
-    matchedKeywords: string[];
-}
-/**
- * Configuration for type inference behavior
- */
-export interface TypeInferenceConfig {
-    /**
-     * Minimum confidence threshold to include a type (default: 0.4)
-     */
-    minConfidence?: number;
-    /**
-     * Maximum number of types to return (default: 5)
-     */
-    maxTypes?: number;
-    /**
-     * Enable debug logging (default: false)
-     */
-    debug?: boolean;
-    /**
-     * Enable vector similarity fallback for unknown words (default: false)
-     * When enabled, queries with low keyword confidence trigger vector-based type inference
-     */
-    enableVectorFallback?: boolean;
-    /**
-     * Minimum confidence threshold to trigger vector fallback (default: 0.7)
-     * If keyword matching produces confidence below this, vector fallback is used
-     */
-    fallbackConfidenceThreshold?: number;
-    /**
-     * Minimum similarity score for vector-based type matches (default: 0.5)
-     */
-    vectorThreshold?: number;
-}
-/**
- * Type Inference System
- *
- * Uses keyword matching for fast type detection from natural language.
- * Designed for billion-scale performance with minimal latency.
- */
-export declare class TypeInferenceSystem {
-    private keywordMap;
-    private phraseMap;
-    private config;
-    private typeEmbeddings;
-    private embedder;
-    constructor(config?: TypeInferenceConfig);
-    /**
-     * 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: string): TypeInference[];
-    /**
-     * 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
-     */
-    inferTypesAsync(query: string): Promise<TypeInference[]>;
-    /**
-     * Internal: Keyword-based type inference (synchronous, fast)
-     */
-    private inferTypesViaKeywords;
-    /**
-     * Internal: Hybrid inference with vector fallback (asynchronous)
-     */
-    private inferTypesWithFallback;
-    /**
-     * Match multi-word phrases in query
-     */
-    private matchPhrases;
-    /**
-     * Match individual keywords in query
-     */
-    private matchKeywords;
-    /**
-     * Find closest keyword using edit distance (for typo correction)
-     * Allows edit distance 1-2 depending on word length
-     */
-    private findFuzzyKeywordMatch;
-    /**
-     * Calculate Levenshtein (edit) distance between two strings
-     */
-    private levenshteinDistance;
-    /**
-     * Update type score with new match
-     */
-    private updateTypeScore;
-    /**
-     * Load pre-compiled type embeddings from embeddedTypeEmbeddings.ts
-     */
-    private loadTypeEmbeddings;
-    /**
-     * Lazy-load TransformerEmbedding model (only when vector fallback is triggered)
-     */
-    private loadEmbedder;
-    /**
-     * Calculate cosine similarity between two vectors
-     */
-    private cosineSimilarity;
-    /**
-     * Infer types using vector similarity against pre-compiled type embeddings
-     */
-    private inferTypesViaVectorSimilarity;
-    /**
-     * Merge keyword-based and vector-based results
-     * Prioritizes keyword results (explicit matches) over vector results (semantic matches)
-     */
-    private mergeResults;
-    /**
-     * Build keyword dictionary for single-word matching
-     */
-    private buildKeywordMap;
-    /**
-     * Build phrase dictionary for multi-word matching
-     */
-    private buildPhraseMap;
-    /**
-     * Get statistics about the inference system
-     */
-    getStats(): {
-        keywordCount: number;
-        phraseCount: number;
-        config: Required<TypeInferenceConfig>;
-    };
-}
-/**
- * Get or create the global TypeInferenceSystem instance
- */
-export declare function getTypeInferenceSystem(config?: TypeInferenceConfig): TypeInferenceSystem;
-/**
- * Convenience function to infer types from a query
- */
-export declare function inferTypes(query: string, config?: TypeInferenceConfig): TypeInference[];