@soulcraft/brainy 3.20.1 → 3.20.3

package/dist/demo.d.ts

@@ -1,106 +0,0 @@
-/**
- * Demo-specific entry point for browser environments
- * This excludes all Node.js-specific functionality to avoid import issues
- */
-import { MemoryStorage } from './storage/adapters/memoryStorage.js';
-import { OPFSStorage } from './storage/adapters/opfsStorage.js';
-export interface Vector extends Array<number> {
-}
-export interface SearchResult {
-    id: string;
-    score: number;
-    metadata: any;
-    text?: string;
-}
-export interface VerbData {
-    id: string;
-    source: string;
-    target: string;
-    verb: string;
-    metadata: any;
-    timestamp: number;
-}
-/**
- * Simplified Brainy class for demo purposes
- * Only includes browser-compatible functionality
- */
-export declare class DemoBrainy {
-    private storage;
-    private embedder;
-    private initialized;
-    private vectors;
-    private metadata;
-    private verbs;
-    constructor();
-    /**
-     * Initialize the database
-     */
-    init(): Promise<void>;
-    /**
-     * Add a document to the database
-     */
-    add(text: string, metadata?: any): Promise<string>;
-    /**
-     * Search for similar documents
-     */
-    searchText(query: string, limit?: number): Promise<SearchResult[]>;
-    /**
-     * Add a relationship between two documents
-     */
-    addVerb(sourceId: string, targetId: string, verb: string, metadata?: any): Promise<string>;
-    /**
-     * Get relationships from a source document
-     */
-    getVerbsBySource(sourceId: string): Promise<VerbData[]>;
-    /**
-     * Get a document by ID
-     */
-    get(id: string): Promise<any | null>;
-    /**
-     * Delete a document
-     */
-    delete(id: string): Promise<boolean>;
-    /**
-     * Update document metadata
-     */
-    updateMetadata(id: string, newMetadata: any): Promise<boolean>;
-    /**
-     * Get the number of documents
-     */
-    size(): number;
-    /**
-     * Generate a random ID
-     */
-    private generateId;
-    /**
-     * Get storage info
-     */
-    getStorage(): MemoryStorage | OPFSStorage;
-}
-export declare const NounType: {
-    readonly Person: "Person";
-    readonly Organization: "Organization";
-    readonly Location: "Location";
-    readonly Thing: "Thing";
-    readonly Concept: "Concept";
-    readonly Event: "Event";
-    readonly Document: "Document";
-    readonly Media: "Media";
-    readonly File: "File";
-    readonly Message: "Message";
-    readonly Content: "Content";
-};
-export declare const VerbType: {
-    readonly RelatedTo: "related_to";
-    readonly Contains: "contains";
-    readonly PartOf: "part_of";
-    readonly LocatedAt: "located_at";
-    readonly References: "references";
-    readonly Owns: "owns";
-    readonly CreatedBy: "created_by";
-    readonly BelongsTo: "belongs_to";
-    readonly Likes: "likes";
-    readonly Follows: "follows";
-};
-export { DemoBrainy as Brainy };
-export default DemoBrainy;

package/dist/demo.js

@@ -1,201 +0,0 @@
-/**
- * Demo-specific entry point for browser environments
- * This excludes all Node.js-specific functionality to avoid import issues
- */
-// Import only browser-compatible modules
-import { MemoryStorage } from './storage/adapters/memoryStorage.js';
-import { TransformerEmbedding } from './utils/embedding.js';
-import { cosineDistance } from './utils/distance.js';
-/**
- * Simplified Brainy class for demo purposes
- * Only includes browser-compatible functionality
- */
-export class DemoBrainy {
-    constructor() {
-        this.embedder = null;
-        this.initialized = false;
-        this.vectors = new Map();
-        this.metadata = new Map();
-        this.verbs = new Map();
-        // Always use memory storage for demo simplicity
-        this.storage = new MemoryStorage();
-    }
-    /**
-     * Initialize the database
-     */
-    async init() {
-        if (this.initialized)
-            return;
-        try {
-            await this.storage.init();
-            // Initialize the embedder
-            this.embedder = new TransformerEmbedding({ verbose: false });
-            await this.embedder.init();
-            this.initialized = true;
-            console.log('✅ Demo Brainy initialized successfully');
-        }
-        catch (error) {
-            console.error('Failed to initialize demo Brainy:', error);
-            throw error;
-        }
-    }
-    /**
-     * Add a document to the database
-     */
-    async add(text, metadata = {}) {
-        if (!this.initialized || !this.embedder) {
-            throw new Error('Database not initialized');
-        }
-        const id = this.generateId();
-        try {
-            // Generate embedding
-            const vector = await this.embedder.embed(text);
-            // Store data
-            this.vectors.set(id, vector);
-            this.metadata.set(id, { text, ...metadata, timestamp: Date.now() });
-            return id;
-        }
-        catch (error) {
-            console.error('Failed to add document:', error);
-            throw error;
-        }
-    }
-    /**
-     * Search for similar documents
-     */
-    async searchText(query, limit = 10) {
-        if (!this.initialized || !this.embedder) {
-            throw new Error('Database not initialized');
-        }
-        try {
-            // Generate query embedding
-            const queryVector = await this.embedder.embed(query);
-            // Calculate similarities
-            const results = [];
-            for (const [id, vector] of this.vectors.entries()) {
-                const score = 1 - cosineDistance(queryVector, vector); // Convert distance to similarity
-                const metadata = this.metadata.get(id);
-                results.push({
-                    id,
-                    score,
-                    metadata,
-                    text: metadata?.text
-                });
-            }
-            // Sort by score (highest first) and limit
-            return results
-                .sort((a, b) => b.score - a.score)
-                .slice(0, limit);
-        }
-        catch (error) {
-            console.error('Search failed:', error);
-            throw error;
-        }
-    }
-    /**
-     * Add a relationship between two documents
-     */
-    async addVerb(sourceId, targetId, verb, metadata = {}) {
-        const verbId = this.generateId();
-        const verbData = {
-            id: verbId,
-            source: sourceId,
-            target: targetId,
-            verb,
-            metadata,
-            timestamp: Date.now()
-        };
-        if (!this.verbs.has(sourceId)) {
-            this.verbs.set(sourceId, []);
-        }
-        this.verbs.get(sourceId).push(verbData);
-        return verbId;
-    }
-    /**
-     * Get relationships from a source document
-     */
-    async getVerbsBySource(sourceId) {
-        return this.verbs.get(sourceId) || [];
-    }
-    /**
-     * Get a document by ID
-     */
-    async get(id) {
-        const metadata = this.metadata.get(id);
-        const vector = this.vectors.get(id);
-        if (!metadata || !vector)
-            return null;
-        return {
-            id,
-            vector,
-            ...metadata
-        };
-    }
-    /**
-     * Delete a document
-     */
-    async delete(id) {
-        const deleted = this.vectors.delete(id) && this.metadata.delete(id);
-        this.verbs.delete(id);
-        return deleted;
-    }
-    /**
-     * Update document metadata
-     */
-    async updateMetadata(id, newMetadata) {
-        const metadata = this.metadata.get(id);
-        if (!metadata)
-            return false;
-        this.metadata.set(id, { ...metadata, ...newMetadata });
-        return true;
-    }
-    /**
-     * Get the number of documents
-     */
-    size() {
-        return this.vectors.size;
-    }
-    /**
-     * Generate a random ID
-     */
-    generateId() {
-        return 'id-' + Math.random().toString(36).substr(2, 9) + '-' + Date.now();
-    }
-    /**
-     * Get storage info
-     */
-    getStorage() {
-        return this.storage;
-    }
-}
-// Export noun and verb types for compatibility
-export const NounType = {
-    Person: 'Person',
-    Organization: 'Organization',
-    Location: 'Location',
-    Thing: 'Thing',
-    Concept: 'Concept',
-    Event: 'Event',
-    Document: 'Document',
-    Media: 'Media',
-    File: 'File',
-    Message: 'Message',
-    Content: 'Content'
-};
-export const VerbType = {
-    RelatedTo: 'related_to',
-    Contains: 'contains',
-    PartOf: 'part_of',
-    LocatedAt: 'located_at',
-    References: 'references',
-    Owns: 'owns',
-    CreatedBy: 'created_by',
-    BelongsTo: 'belongs_to',
-    Likes: 'likes',
-    Follows: 'follows'
-};
-// Export the main class as Brainy for compatibility
-export { DemoBrainy as Brainy };
-// Default export
-export default DemoBrainy;
-//# sourceMappingURL=demo.js.map

package/dist/embeddings/SingletonModelManager.d.ts

@@ -1,95 +0,0 @@
-/**
- * Singleton Model Manager - THE ONLY SOURCE OF EMBEDDING MODELS
- *
- * This is the SINGLE, UNIFIED model initialization system that ensures:
- * - Only ONE model instance exists across the entire system
- * - Precision is configured once and locked
- * - All components share the same model
- * - No possibility of mixed precisions
- *
- * CRITICAL: This manager is used by EVERYTHING:
- * - Storage operations (add, update)
- * - Search operations (search, find)
- * - Public API (embed, cluster)
- * - Neural API (all neural.* methods)
- * - Internal operations (deduplication, indexing)
- */
-import { TransformerEmbedding } from '../utils/embedding.js';
-import { EmbeddingFunction, Vector } from '../coreTypes.js';
-/**
- * Statistics for monitoring
- */
-interface ModelStats {
-    initialized: boolean;
-    precision: string;
-    initCount: number;
-    embedCount: number;
-    lastUsed: Date | null;
-    memoryFootprint?: number;
-}
-/**
- * The ONE TRUE model manager
- */
-export declare class SingletonModelManager {
-    private static instance;
-    private stats;
-    private constructor();
-    /**
-     * Get the singleton instance
-     */
-    static getInstance(): SingletonModelManager;
-    /**
-     * Get the model instance - creates if needed, reuses if exists
-     * This is THE ONLY way to get a model in the entire system
-     */
-    getModel(): Promise<TransformerEmbedding>;
-    /**
-     * Initialize the model - happens exactly once
-     */
-    private initializeModel;
-    /**
-     * Get embedding function that uses the singleton model
-     */
-    getEmbeddingFunction(): Promise<EmbeddingFunction>;
-    /**
-     * Direct embed method for convenience
-     */
-    embed(data: string | string[]): Promise<Vector>;
-    /**
-     * Check if model is initialized
-     */
-    isInitialized(): boolean;
-    /**
-     * Get current statistics
-     */
-    getStats(): ModelStats;
-    /**
-     * Validate precision consistency
-     * Throws error if attempting to use different precision
-     */
-    validatePrecision(requestedPrecision?: string): void;
-    /**
-     * Force cleanup (for testing only)
-     * WARNING: This will break consistency - use only in tests
-     */
-    _testOnlyCleanup(): Promise<void>;
-}
-export declare const singletonModelManager: SingletonModelManager;
-/**
- * THE ONLY embedding function that should be used anywhere
- * This ensures all operations use the same model instance
- */
-export declare function getUnifiedEmbeddingFunction(): Promise<EmbeddingFunction>;
-/**
- * Direct embed function for convenience
- */
-export declare function unifiedEmbed(data: string | string[]): Promise<Vector>;
-/**
- * Check if model is ready
- */
-export declare function isModelReady(): boolean;
-/**
- * Get model statistics
- */
-export declare function getModelStats(): ModelStats;
-export {};

package/dist/embeddings/SingletonModelManager.js

@@ -1,220 +0,0 @@
-/**
- * Singleton Model Manager - THE ONLY SOURCE OF EMBEDDING MODELS
- *
- * This is the SINGLE, UNIFIED model initialization system that ensures:
- * - Only ONE model instance exists across the entire system
- * - Precision is configured once and locked
- * - All components share the same model
- * - No possibility of mixed precisions
- *
- * CRITICAL: This manager is used by EVERYTHING:
- * - Storage operations (add, update)
- * - Search operations (search, find)
- * - Public API (embed, cluster)
- * - Neural API (all neural.* methods)
- * - Internal operations (deduplication, indexing)
- */
-import { TransformerEmbedding } from '../utils/embedding.js';
-import { getModelPrecision, lockModelPrecision } from '../config/modelPrecisionManager.js';
-// Global state - ensures true singleton across entire process
-let globalModelInstance = null;
-let globalInitPromise = null;
-let globalInitialized = false;
-/**
- * The ONE TRUE model manager
- */
-export class SingletonModelManager {
-    constructor() {
-        this.stats = {
-            initialized: false,
-            precision: 'unknown',
-            initCount: 0,
-            embedCount: 0,
-            lastUsed: null
-        };
-        // Private constructor enforces singleton
-        this.stats.precision = getModelPrecision();
-        console.log(`🔐 SingletonModelManager initialized with ${this.stats.precision.toUpperCase()} precision`);
-    }
-    /**
-     * Get the singleton instance
-     */
-    static getInstance() {
-        if (!SingletonModelManager.instance) {
-            SingletonModelManager.instance = new SingletonModelManager();
-        }
-        return SingletonModelManager.instance;
-    }
-    /**
-     * Get the model instance - creates if needed, reuses if exists
-     * This is THE ONLY way to get a model in the entire system
-     */
-    async getModel() {
-        // If already initialized, return immediately
-        if (globalModelInstance && globalInitialized) {
-            this.stats.lastUsed = new Date();
-            return globalModelInstance;
-        }
-        // If initialization is in progress, wait for it
-        if (globalInitPromise) {
-            console.log('⏳ Model initialization already in progress, waiting...');
-            return await globalInitPromise;
-        }
-        // Start initialization (only happens once ever)
-        globalInitPromise = this.initializeModel();
-        try {
-            const model = await globalInitPromise;
-            globalInitialized = true;
-            return model;
-        }
-        catch (error) {
-            // Reset on error to allow retry
-            globalInitPromise = null;
-            throw error;
-        }
-    }
-    /**
-     * Initialize the model - happens exactly once
-     */
-    async initializeModel() {
-        console.log('🚀 Initializing singleton model instance...');
-        // Get precision from central manager
-        const precision = getModelPrecision();
-        console.log(`📊 Using ${precision.toUpperCase()} precision (${precision === 'q8' ? '23MB, 99% accuracy' : '90MB, 100% accuracy'})`);
-        // Detect environment for optimal settings
-        const isNode = typeof process !== 'undefined' && process.versions?.node;
-        const isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined';
-        const isServerless = typeof process !== 'undefined' && (process.env.VERCEL ||
-            process.env.NETLIFY ||
-            process.env.AWS_LAMBDA_FUNCTION_NAME ||
-            process.env.FUNCTIONS_WORKER_RUNTIME);
-        const isTest = globalThis.__BRAINY_TEST_ENV__ || process.env.NODE_ENV === 'test';
-        // Create optimized options based on environment
-        const options = {
-            precision: precision,
-            verbose: !isTest && !isServerless && !isBrowser,
-            device: 'cpu', // CPU is most compatible
-            localFilesOnly: process.env.BRAINY_ALLOW_REMOTE_MODELS === 'false',
-            model: 'Xenova/all-MiniLM-L6-v2'
-        };
-        try {
-            // Create the ONE model instance
-            globalModelInstance = new TransformerEmbedding(options);
-            // Initialize it
-            await globalModelInstance.init();
-            // CRITICAL: Lock the precision after successful initialization
-            // This prevents any future changes to precision
-            lockModelPrecision();
-            console.log('🔒 Model precision locked at:', precision.toUpperCase());
-            // Update stats
-            this.stats.initialized = true;
-            this.stats.initCount++;
-            this.stats.lastUsed = new Date();
-            // Log memory usage if available
-            if (isNode && process.memoryUsage) {
-                const usage = process.memoryUsage();
-                this.stats.memoryFootprint = Math.round(usage.heapUsed / 1024 / 1024);
-                console.log(`💾 Model loaded, memory usage: ${this.stats.memoryFootprint}MB`);
-            }
-            console.log('✅ Singleton model initialized successfully');
-            return globalModelInstance;
-        }
-        catch (error) {
-            console.error('❌ Failed to initialize singleton model:', error);
-            globalModelInstance = null;
-            throw new Error(`Singleton model initialization failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Get embedding function that uses the singleton model
-     */
-    async getEmbeddingFunction() {
-        const model = await this.getModel();
-        return async (data) => {
-            this.stats.embedCount++;
-            this.stats.lastUsed = new Date();
-            return await model.embed(data);
-        };
-    }
-    /**
-     * Direct embed method for convenience
-     */
-    async embed(data) {
-        const model = await this.getModel();
-        this.stats.embedCount++;
-        this.stats.lastUsed = new Date();
-        return await model.embed(data);
-    }
-    /**
-     * Check if model is initialized
-     */
-    isInitialized() {
-        return globalInitialized && globalModelInstance !== null;
-    }
-    /**
-     * Get current statistics
-     */
-    getStats() {
-        return {
-            ...this.stats,
-            precision: getModelPrecision()
-        };
-    }
-    /**
-     * Validate precision consistency
-     * Throws error if attempting to use different precision
-     */
-    validatePrecision(requestedPrecision) {
-        const currentPrecision = getModelPrecision();
-        if (requestedPrecision && requestedPrecision !== currentPrecision) {
-            throw new Error(`❌ Precision mismatch! System is using ${currentPrecision.toUpperCase()} ` +
-                `but ${requestedPrecision.toUpperCase()} was requested. ` +
-                `All operations must use the same precision.`);
-        }
-    }
-    /**
-     * Force cleanup (for testing only)
-     * WARNING: This will break consistency - use only in tests
-     */
-    async _testOnlyCleanup() {
-        if (process.env.NODE_ENV !== 'test') {
-            throw new Error('Cleanup only allowed in test environment');
-        }
-        if (globalModelInstance && 'dispose' in globalModelInstance) {
-            await globalModelInstance.dispose();
-        }
-        globalModelInstance = null;
-        globalInitPromise = null;
-        globalInitialized = false;
-        this.stats.initialized = false;
-        console.log('🧹 Singleton model cleaned up (test only)');
-    }
-}
-// Export the singleton instance getter
-export const singletonModelManager = SingletonModelManager.getInstance();
-/**
- * THE ONLY embedding function that should be used anywhere
- * This ensures all operations use the same model instance
- */
-export async function getUnifiedEmbeddingFunction() {
-    return await singletonModelManager.getEmbeddingFunction();
-}
-/**
- * Direct embed function for convenience
- */
-export async function unifiedEmbed(data) {
-    return await singletonModelManager.embed(data);
-}
-/**
- * Check if model is ready
- */
-export function isModelReady() {
-    return singletonModelManager.isInitialized();
-}
-/**
- * Get model statistics
- */
-export function getModelStats() {
-    return singletonModelManager.getStats();
-}
-//# sourceMappingURL=SingletonModelManager.js.map

package/dist/embeddings/lightweight-embedder.d.ts

@@ -1,22 +0,0 @@
-/**
- * Lightweight Embedding Alternative
- *
- * Uses pre-computed embeddings for common terms
- * Falls back to ONNX for unknown terms
- *
- * This reduces memory usage by 90% for typical queries
- */
-import { Vector } from '../coreTypes.js';
-export declare class LightweightEmbedder {
-    private stats;
-    embed(text: string | string[]): Promise<Vector | Vector[]>;
-    private embedSingle;
-    getStats(): {
-        totalEmbeddings: number;
-        cacheHitRate: number;
-        precomputedHits: number;
-        simpleComputes: number;
-        onnxComputes: number;
-    };
-    loadPrecomputed(filePath?: string): Promise<void>;
-}