@soulcraft/brainy 3.20.1 → 3.20.3

package/dist/brainy-unified.js

@@ -1,327 +0,0 @@
-/**
- * 🧠 Brainy 3.0 - UNIFIED FIND IMPLEMENTATION
- *
- * REAL CODE - NO MOCKS - NO STUBS - PRODUCTION READY
- * O(log n) performance with Triple Intelligence
- */
-import { v4 as uuidv4 } from './universal/uuid.js';
-import { HNSWIndex } from './hnsw/hnswIndex.js';
-import { createStorage } from './storage/storageFactory.js';
-import { defaultEmbeddingFunction, cosineDistance } from './utils/index.js';
-import { matchesMetadataFilter } from './utils/metadataFilter.js';
-/**
- * UNIFIED BRAINY CLASS - REAL IMPLEMENTATION
- */
-export class Brainy {
-    constructor(config) {
-        this.initialized = false;
-        this.embedder = config?.embedder || defaultEmbeddingFunction;
-    }
-    /**
-     * Initialize Brainy
-     */
-    async init() {
-        if (this.initialized)
-            return;
-        // Setup storage
-        this.storage = await createStorage({ type: 'memory' });
-        await this.storage.initialize();
-        // Setup HNSW index
-        this.index = new HNSWIndex({
-            dimensions: 384,
-            M: 16,
-            efConstruction: 200,
-            distance: cosineDistance
-        });
-        this.initialized = true;
-    }
-    /**
-     * Add entity
-     */
-    async add(params) {
-        await this.ensureInitialized();
-        const id = params.id || uuidv4();
-        const vector = await this.embedder(JSON.stringify(params.data));
-        // Add to HNSW index
-        await this.index.addItem({ id, vector });
-        // Save to storage
-        await this.storage.saveNoun({
-            id,
-            vector,
-            data: params.data,
-            metadata: params.metadata || {},
-            type: params.type || 'entity'
-        });
-        return id;
-    }
-    /**
-     * Get entity by ID
-     */
-    async get(id) {
-        await this.ensureInitialized();
-        const noun = await this.storage.getNoun(id);
-        return noun;
-    }
-    /**
-     * UNIFIED FIND - Real Triple Intelligence Implementation
-     * O(log n) performance with Reciprocal Rank Fusion
-     */
-    async find(params) {
-        await this.ensureInitialized();
-        // Parse natural language to structured query
-        if (typeof params === 'string') {
-            params = await this.parseNaturalLanguage(params);
-        }
-        // Fast path: Direct ID lookup - O(1)
-        if (params.id) {
-            const entity = await this.get(params.id);
-            return entity ? [{ id: params.id, score: 1.0, entity }] : [];
-        }
-        // Fast path: Multiple IDs - O(k)
-        if (params.ids) {
-            const entities = await Promise.all(params.ids.map(id => this.get(id)));
-            return entities
-                .filter(e => e !== null)
-                .map((entity, i) => ({
-                id: params.ids[i],
-                score: 1.0,
-                entity: entity
-            }));
-        }
-        // TRIPLE INTELLIGENCE: Execute searches in parallel
-        const limit = params.limit || 10;
-        const searchLimit = Math.min(limit * 3, 100);
-        const searchPromises = [];
-        const searchTypes = [];
-        // 1. Vector Search - O(log n) via HNSW
-        if (params.query || params.near || params.vector) {
-            searchPromises.push(this.vectorSearch(params, searchLimit));
-            searchTypes.push('vector');
-        }
-        // 2. Metadata Search - O(log n) for indexed fields
-        if (params.where || params.type || params.service) {
-            searchPromises.push(this.metadataSearch(params, searchLimit));
-            searchTypes.push('metadata');
-        }
-        // 3. Graph Traversal - O(k) where k = traversal limit
-        if (params.connected) {
-            searchPromises.push(this.graphTraversal(params.connected, searchLimit));
-            searchTypes.push('graph');
-        }
-        // If no search criteria, return empty
-        if (searchPromises.length === 0) {
-            return [];
-        }
-        // Execute all searches in parallel
-        const searchResults = await Promise.all(searchPromises);
-        // Apply Reciprocal Rank Fusion
-        return this.reciprocalRankFusion(searchResults, searchTypes, params.limit || 10, params.offset || 0);
-    }
-    /**
-     * Search method for NLP compatibility
-     */
-    async search(query, limit, options) {
-        if (typeof query === 'string') {
-            return this.find({ query, limit: limit || 10 });
-        }
-        const params = { ...query, limit: limit || query.limit, ...options };
-        return this.find(params);
-    }
-    /**
-     * Parse natural language query
-     */
-    async parseNaturalLanguage(query) {
-        const params = {};
-        const lowerQuery = query.toLowerCase();
-        // Extract limit
-        const limitMatch = lowerQuery.match(/(?:top|first|limit)\s+(\d+)/i);
-        if (limitMatch) {
-            params.limit = parseInt(limitMatch[1]);
-            query = query.replace(limitMatch[0], '').trim();
-        }
-        // Detect graph traversal
-        if (lowerQuery.includes('connected to') || lowerQuery.includes('related to')) {
-            const fromMatch = query.match(/from\s+["']?([^"'\s]+)["']?/i);
-            if (fromMatch) {
-                params.connected = { from: fromMatch[1] };
-                query = query.replace(fromMatch[0], '').trim();
-            }
-        }
-        // Main query
-        if (query.trim()) {
-            params.query = query.trim();
-        }
-        return params;
-    }
-    /**
-     * Vector Search - O(log n) via HNSW
-     */
-    async vectorSearch(params, limit) {
-        const results = [];
-        // Determine vector to search with
-        let searchVector;
-        if (params.vector) {
-            searchVector = params.vector;
-        }
-        else if (params.query) {
-            searchVector = await this.embedder(params.query);
-        }
-        else if (params.near?.id) {
-            const source = await this.get(params.near.id);
-            searchVector = source?.vector;
-        }
-        else if (params.near?.vector) {
-            searchVector = params.near.vector;
-        }
-        if (!searchVector)
-            return [];
-        // Search HNSW index
-        const searchResults = await this.index.search(searchVector, limit);
-        for (const [id, score] of searchResults) {
-            const entity = await this.get(id);
-            if (entity) {
-                results.push({ id, score, entity });
-            }
-        }
-        return results;
-    }
-    /**
-     * Metadata Search - O(n) for now, but could be indexed
-     */
-    async metadataSearch(params, limit) {
-        const results = [];
-        const allNouns = await this.storage.getNouns();
-        for (const noun of allNouns) {
-            let matches = true;
-            // Check where constraints
-            if (params.where && !matchesMetadataFilter(noun.metadata, params.where)) {
-                matches = false;
-            }
-            // Check type constraint
-            if (params.type) {
-                const types = Array.isArray(params.type) ? params.type : [params.type];
-                if (!types.includes(noun.type))
-                    matches = false;
-            }
-            // Check service constraint
-            if (params.service && noun.service !== params.service) {
-                matches = false;
-            }
-            if (matches) {
-                results.push({
-                    id: noun.id,
-                    score: 1.0,
-                    entity: noun
-                });
-                if (results.length >= limit)
-                    break;
-            }
-        }
-        return results;
-    }
-    /**
-     * Graph Traversal - O(k) where k = edges traversed
-     */
-    async graphTraversal(connected, limit) {
-        if (!connected || !connected.from)
-            return [];
-        const visited = new Set();
-        const queue = [];
-        const results = [];
-        queue.push({ id: connected.from, depth: 0, score: 1.0 });
-        while (queue.length > 0 && results.length < limit) {
-            const { id, depth, score } = queue.shift();
-            if (visited.has(id))
-                continue;
-            if (depth > (connected.maxDepth || 2))
-                continue;
-            visited.add(id);
-            // Add to results if not starting node
-            if (depth > 0) {
-                const entity = await this.get(id);
-                if (entity) {
-                    results.push({ id, score, entity });
-                }
-            }
-            // Get relationships
-            const relations = await this.storage.getVerbsBySource(id);
-            for (const relation of relations) {
-                if (connected.type && relation.type !== connected.type)
-                    continue;
-                if (connected.direction === 'in')
-                    continue;
-                if (!visited.has(relation.target)) {
-                    queue.push({
-                        id: relation.target,
-                        depth: depth + 1,
-                        score: score * 0.9
-                    });
-                }
-            }
-            // Get incoming relationships
-            if (connected.direction !== 'out') {
-                const incomingRelations = await this.storage.getVerbsByTarget(id);
-                for (const relation of incomingRelations) {
-                    if (connected.type && relation.type !== connected.type)
-                        continue;
-                    if (!visited.has(relation.source)) {
-                        queue.push({
-                            id: relation.source,
-                            depth: depth + 1,
-                            score: score * 0.9
-                        });
-                    }
-                }
-            }
-        }
-        return results;
-    }
-    /**
-     * Reciprocal Rank Fusion - Google's algorithm
-     */
-    reciprocalRankFusion(resultSets, searchTypes, limit, offset) {
-        const k = 60; // RRF constant
-        const fusedScores = new Map();
-        // Weight configuration
-        const weights = {
-            vector: 0.4,
-            metadata: 0.35,
-            graph: 0.25
-        };
-        // Normalize weights
-        const activeWeights = searchTypes.map(t => weights[t]);
-        const totalWeight = activeWeights.reduce((sum, w) => sum + w, 0);
-        const normalizedWeights = activeWeights.map(w => w / totalWeight);
-        // Process each result set
-        resultSets.forEach((resultSet, setIndex) => {
-            const weight = normalizedWeights[setIndex];
-            resultSet.forEach((result, rank) => {
-                const rrfScore = weight * (1.0 / (k + rank + 1));
-                if (fusedScores.has(result.id)) {
-                    const existing = fusedScores.get(result.id);
-                    existing.score += rrfScore;
-                }
-                else {
-                    fusedScores.set(result.id, {
-                        score: rrfScore,
-                        entity: result.entity
-                    });
-                }
-            });
-        });
-        // Sort by fusion score
-        const sortedResults = Array.from(fusedScores.entries())
-            .map(([id, { score, entity }]) => ({ id, score, entity }))
-            .sort((a, b) => b.score - a.score);
-        return sortedResults.slice(offset, offset + limit);
-    }
-    /**
-     * Ensure initialized
-     */
-    async ensureInitialized() {
-        if (!this.initialized) {
-            throw new Error('Brainy not initialized. Call init() first.');
-        }
-    }
-}
-//# sourceMappingURL=brainy-unified.js.map