@soulcraft/brainy 3.0.0 → 3.1.0

package/dist/cortex/backupRestore.d.ts

@@ -4,7 +4,7 @@
  * 🧠 Complete backup/restore with compression and verification
  * ⚛️ 1950s retro sci-fi aesthetic maintained throughout
  */
-import { BrainyData } from '../brainyData.js';
+import { Brainy } from '../brainy.js';
 export interface BackupOptions {
     compress?: boolean;
     output?: string;
@@ -42,7 +42,7 @@ export declare class BackupRestore {
     private brainy;
     private colors;
     private emojis;
-    constructor(brainy: BrainyData);
+    constructor(brainy: Brainy);
     /**
      * Create a complete backup of Brainy data
      */

package/dist/cortex/backupRestore.js

@@ -221,12 +221,9 @@ export class BackupRestore {
         if (options.includeMetadata) {
             data.metadata = await this.collectMetadata();
         }
-        // Statistics placeholder
+        // Statistics not yet implemented
         if (options.includeStatistics) {
-            data.statistics = {
-                timestamp: new Date().toISOString(),
-                placeholder: true
-            };
+            console.warn('Statistics collection not yet implemented in backup');
         }
         return data;
     }
@@ -259,20 +256,46 @@ export class BackupRestore {
         return `./brainy-backup-${timestamp}.brainy`;
     }
     async compressData(data) {
-        // Placeholder - would use zlib or similar
-        return data; // For now, no compression
+        // Use zlib gzip compression
+        const { gzip } = await import('zlib');
+        const { promisify } = await import('util');
+        const gzipAsync = promisify(gzip);
+        const compressed = await gzipAsync(Buffer.from(data, 'utf-8'));
+        return compressed.toString('base64');
     }
     async decompressData(data) {
-        // Placeholder - would use zlib or similar
-        return data; // For now, no decompression
+        // Use zlib gunzip decompression
+        const { gunzip } = await import('zlib');
+        const { promisify } = await import('util');
+        const gunzipAsync = promisify(gunzip);
+        const compressed = Buffer.from(data, 'base64');
+        const decompressed = await gunzipAsync(compressed);
+        return decompressed.toString('utf-8');
     }
     async encryptData(data, password) {
-        // Placeholder - would use crypto module
-        return data; // For now, no encryption
+        // Use crypto module for AES-256 encryption
+        const crypto = await import('crypto');
+        // Generate key from password
+        const key = crypto.createHash('sha256').update(password).digest();
+        const iv = crypto.randomBytes(16);
+        const cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
+        let encrypted = cipher.update(data, 'utf8', 'base64');
+        encrypted += cipher.final('base64');
+        // Prepend IV to encrypted data for decryption
+        return iv.toString('base64') + ':' + encrypted;
     }
     async decryptData(data, password) {
-        // Placeholder - would use crypto module
-        return data; // For now, no decryption
+        // Use crypto module for AES-256 decryption
+        const crypto = await import('crypto');
+        // Split IV and encrypted data
+        const [ivString, encrypted] = data.split(':');
+        const iv = Buffer.from(ivString, 'base64');
+        // Generate key from password
+        const key = crypto.createHash('sha256').update(password).digest();
+        const decipher = crypto.createDecipheriv('aes-256-cbc', key, iv);
+        let decrypted = decipher.update(encrypted, 'base64', 'utf8');
+        decrypted += decipher.final('utf8');
+        return decrypted;
     }
     async verifyBackup(backupPath, options) {
         // Placeholder - would verify backup integrity
@@ -284,33 +307,68 @@ export class BackupRestore {
         }
     }
     async executeRestore(data, manifest) {
-        // Placeholder restore implementation
-        console.log(this.colors.warning('Note: Restore system is in beta - limited functionality'));
+        console.log(this.colors.info('🔄 Starting restore process...'));
         // Phase 1: Validate data structure
         if (!data.entities || !Array.isArray(data.entities)) {
             throw new Error('Invalid backup data structure');
         }
-        // Phase 2: Restore entities (placeholder)
-        console.log(this.colors.info(`Would restore ${data.entities.length} entities`));
-        // Phase 3: Restore relationships (placeholder)
-        console.log(this.colors.info(`Would restore ${data.relationships.length} relationships`));
-        // Phase 4: Restore metadata (placeholder)
+        // Phase 2: Clear existing data if overwriting
+        console.log(this.colors.dim('Clearing existing data...'));
+        const dataAPI = await this.brainy.data();
+        await dataAPI.clear();
+        // Phase 3: Restore entities
+        console.log(this.colors.dim(`Restoring ${data.entities.length} entities...`));
+        const entityMap = new Map(); // old ID -> new ID mapping
+        for (const entity of data.entities) {
+            const newId = await this.brainy.add({
+                data: entity.metadata || entity.data,
+                type: entity.type,
+                metadata: entity.metadata,
+                vector: entity.vector, // Preserve original vectors if available
+                service: entity.service
+            });
+            entityMap.set(entity.id, newId);
+        }
+        // Phase 4: Restore relationships if they exist
+        if (data.relationships && Array.isArray(data.relationships)) {
+            console.log(this.colors.dim(`Restoring ${data.relationships.length} relationships...`));
+            for (const rel of data.relationships) {
+                // Map old IDs to new IDs
+                const fromId = entityMap.get(rel.from) || rel.from;
+                const toId = entityMap.get(rel.to) || rel.to;
+                await this.brainy.relate({
+                    from: fromId,
+                    to: toId,
+                    type: rel.type,
+                    metadata: rel.metadata || {}
+                });
+            }
+        }
+        // Phase 5: Restore metadata if present
         if (data.metadata) {
             await this.restoreMetadata(data.metadata);
         }
-        // Phase 5: Simulate successful restore
-        console.log(this.colors.success('Backup structure validated - restore would be successful'));
+        console.log(this.colors.success('✅ Restore completed successfully'));
     }
     async collectMetadata() {
-        // Collect global metadata
-        return {};
+        // Collect global metadata like statistics, configuration, etc.
+        const dataApi = await this.brainy.data();
+        const stats = await dataApi.getStats();
+        return {
+            totalEntities: stats.entities || 0,
+            timestamp: new Date().toISOString(),
+            version: '3.0.0'
+        };
     }
     async restoreMetadata(metadata) {
-        // Restore global metadata
+        // Store restored metadata for reference
+        // Could be saved to a config store or logged
+        console.log(this.colors.dim(`Restored from backup created at: ${metadata.timestamp}`));
     }
     async calculateChecksum(data) {
-        // Placeholder - would calculate SHA-256 hash
-        return 'checksum-placeholder';
+        // Use crypto module for SHA-256 checksum
+        const crypto = await import('crypto');
+        return crypto.createHash('sha256').update(data).digest('hex');
     }
     formatFileSize(bytes) {
         const units = ['B', 'KB', 'MB', 'GB'];

package/dist/cortex/healthCheck.d.ts

@@ -5,7 +5,7 @@
  * ⚛️ Auto-repair capabilities with 1950s retro sci-fi aesthetics
  * 🚀 Scalable health monitoring for high-performance databases
  */
-import { BrainyData } from '../brainyData.js';
+import { Brainy } from '../brainy.js';
 export interface HealthCheckResult {
     component: string;
     status: 'healthy' | 'warning' | 'critical' | 'offline';
@@ -44,7 +44,7 @@ export declare class HealthCheck {
     private brainy;
     private colors;
     private emojis;
-    constructor(brainy: BrainyData);
+    constructor(brainy: Brainy);
     /**
      * Run comprehensive system health check
      */

package/dist/cortex/neuralImport.d.ts

@@ -4,7 +4,7 @@
  * 🧠 Leveraging the brain-in-jar to understand and automatically structure data
  * ⚛️ Complete with confidence scoring and relationship weight calculation
  */
-import { BrainyData } from '../brainyData.js';
+import { Brainy } from '../brainy.js';
 export interface NeuralAnalysisResult {
     detectedEntities: DetectedEntity[];
     detectedRelationships: DetectedRelationship[];
@@ -67,7 +67,7 @@ export declare class NeuralImport {
     private brainy;
     private colors;
     private emojis;
-    constructor(brainy: BrainyData);
+    constructor(brainy: Brainy);
     /**
      * Main Neural Import Function - The Master Controller
      */

package/dist/cortex/neuralImport.js

@@ -188,7 +188,7 @@ export class NeuralImport {
      */
     async calculateEntityTypeConfidence(text, data, nounType) {
         // Base semantic similarity using search instead of similarity method
-        const searchResults = await this.brainy.search(text + ' ' + nounType, { limit: 1 });
+        const searchResults = await this.brainy.find(text + ' ' + nounType);
         const textSimilarity = searchResults.length > 0 ? searchResults[0].score : 0.5;
         // Field-based confidence boost
         const fieldBoost = this.calculateFieldBasedConfidence(data, nounType);
@@ -258,7 +258,7 @@ export class NeuralImport {
     async generateEntityReasoning(text, data, nounType) {
         const reasons = [];
         // Semantic similarity reason using search
-        const searchResults = await this.brainy.search(text + ' ' + nounType, { limit: 1 });
+        const searchResults = await this.brainy.find(text + ' ' + nounType);
         const similarity = searchResults.length > 0 ? searchResults[0].score : 0.5;
         if (similarity > 0.7) {
             reasons.push(`High semantic similarity (${(similarity * 100).toFixed(1)}%)`);
@@ -319,15 +319,14 @@ export class NeuralImport {
     async calculateRelationshipConfidence(source, target, verbType, context) {
         // Semantic similarity between entities and verb type using search
         const relationshipText = `${this.extractMainText(source.originalData)} ${verbType} ${this.extractMainText(target.originalData)}`;
-        const directResults = await this.brainy.search(relationshipText, { limit: 1 });
-        const directSimilarity = directResults.length > 0 ? directResults[0].score : 0.5;
-        // Context-based similarity using search
-        const contextResults = await this.brainy.search(context + ' ' + verbType, { limit: 1 });
+        const directResults = await this.brainy.find(relationshipText);
+        const directScore = directResults.length > 0 ? directResults[0].score : 0.4;
+        const contextResults = await this.brainy.find(context + ' ' + verbType);
         const contextSimilarity = contextResults.length > 0 ? contextResults[0].score : 0.5;
         // Entity type compatibility
         const typeCompatibility = this.calculateTypeCompatibility(source.nounType, target.nounType, verbType);
         // Combine with weights
-        return (directSimilarity * 0.4) + (contextSimilarity * 0.4) + (typeCompatibility * 0.2);
+        return (directScore * 0.4) + (contextSimilarity * 0.4) + (typeCompatibility * 0.2);
     }
     /**
      * Calculate relationship weight/strength
@@ -576,16 +575,22 @@ export class NeuralImport {
         try {
             // Add entities to Brainy
             for (const entity of result.detectedEntities) {
-                await this.brainy.addNoun(this.extractMainText(entity.originalData), {
-                    ...entity.originalData,
-                    nounType: entity.nounType,
-                    confidence: entity.confidence,
-                    id: entity.suggestedId
+                await this.brainy.add({
+                    data: this.extractMainText(entity.originalData),
+                    type: entity.nounType,
+                    metadata: {
+                        ...entity.originalData,
+                        confidence: entity.confidence,
+                        id: entity.suggestedId
+                    }
                 });
             }
             // Add relationships to Brainy
             for (const relationship of result.detectedRelationships) {
-                await this.brainy.addVerb(relationship.sourceId, relationship.targetId, relationship.verbType, {
+                await this.brainy.relate({
+                    from: relationship.sourceId,
+                    to: relationship.targetId,
+                    type: relationship.verbType,
                     weight: relationship.weight,
                     metadata: {
                         confidence: relationship.confidence,

package/dist/cortex/performanceMonitor.d.ts

@@ -5,7 +5,7 @@
  * ⚛️ Monitors query performance, storage usage, and system health
  * 🚀 Scalable performance analytics with atomic age aesthetics
  */
-import { BrainyData } from '../brainyData.js';
+import { Brainy } from '../brainy.js';
 export interface PerformanceMetrics {
     queryLatency: {
         vector: {
@@ -92,7 +92,7 @@ export declare class PerformanceMonitor {
     private monitoringInterval?;
     private colors;
     private emojis;
-    constructor(brainy: BrainyData);
+    constructor(brainy: Brainy);
     /**
      * Start real-time monitoring
      */

package/dist/critical/model-guardian.d.ts

@@ -26,6 +26,10 @@ export declare class ModelGuardian {
      * Verify the local model files exist and are correct
      */
     private verifyLocalModel;
+    /**
+     * Compute SHA256 hash of a file
+     */
+    private computeFileHash;
     /**
      * Download model from a fallback source
      */

package/dist/critical/model-guardian.js

@@ -153,17 +153,36 @@ export class ModelGuardian {
                     return false;
                 }
             }
-            // TODO: Add SHA256 verification for ultimate security
-            // if (CRITICAL_MODEL_CONFIG.modelHash[file]) {
-            //   const hash = await this.computeFileHash(filePath)
-            //   if (hash !== CRITICAL_MODEL_CONFIG.modelHash[file]) {
-            //     console.error('❌ CRITICAL: Model hash mismatch!')
-            //     return false
-            //   }
-            // }
+            // SHA256 verification for ultimate security
+            if (CRITICAL_MODEL_CONFIG.modelHash && CRITICAL_MODEL_CONFIG.modelHash[file]) {
+                const hash = await this.computeFileHash(filePath);
+                if (hash !== CRITICAL_MODEL_CONFIG.modelHash[file]) {
+                    console.error(`❌ CRITICAL: Model hash mismatch for ${file}!\n` +
+                        `Expected: ${CRITICAL_MODEL_CONFIG.modelHash[file]}\n` +
+                        `Got: ${hash}\n` +
+                        `This indicates model tampering or corruption!`);
+                    return false;
+                }
+            }
         }
         return true;
     }
+    /**
+     * Compute SHA256 hash of a file
+     */
+    async computeFileHash(filePath) {
+        try {
+            const { readFile } = await import('fs/promises');
+            const { createHash } = await import('crypto');
+            const fileBuffer = await readFile(filePath);
+            const hash = createHash('sha256').update(fileBuffer).digest('hex');
+            return hash;
+        }
+        catch (error) {
+            console.error(`Failed to compute hash for ${filePath}:`, error);
+            return '';
+        }
+    }
     /**
      * Download model from a fallback source
      */
@@ -183,9 +202,10 @@ export class ModelGuardian {
             }
         }
         else if (source.type === 'tarball') {
-            // Download and extract tarball
-            // This would require implementation with proper tar extraction
-            throw new Error('Tarball extraction not yet implemented');
+            // Tarball extraction would require additional dependencies
+            // Skip this source and try next fallback
+            console.warn(`⚠️ Tarball extraction not available for ${source.name}. Trying next source...`);
+            return; // Will continue to next source in the loop
         }
     }
     /**

package/dist/demo.d.ts

@@ -21,10 +21,10 @@ export interface VerbData {
     timestamp: number;
 }
 /**
- * Simplified BrainyData class for demo purposes
+ * Simplified Brainy class for demo purposes
  * Only includes browser-compatible functionality
  */
-export declare class DemoBrainyData {
+export declare class DemoBrainy {
     private storage;
     private embedder;
     private initialized;
@@ -102,5 +102,5 @@ export declare const VerbType: {
     readonly Likes: "likes";
     readonly Follows: "follows";
 };
-export { DemoBrainyData as BrainyData };
-export default DemoBrainyData;
+export { DemoBrainy as Brainy };
+export default DemoBrainy;

package/dist/demo.js

@@ -7,10 +7,10 @@ import { MemoryStorage } from './storage/adapters/memoryStorage.js';
 import { TransformerEmbedding } from './utils/embedding.js';
 import { cosineDistance } from './utils/distance.js';
 /**
- * Simplified BrainyData class for demo purposes
+ * Simplified Brainy class for demo purposes
  * Only includes browser-compatible functionality
  */
-export class DemoBrainyData {
+export class DemoBrainy {
     constructor() {
         this.embedder = null;
         this.initialized = false;
@@ -32,10 +32,10 @@ export class DemoBrainyData {
             this.embedder = new TransformerEmbedding({ verbose: false });
             await this.embedder.init();
             this.initialized = true;
-            console.log('✅ Demo BrainyData initialized successfully');
+            console.log('✅ Demo Brainy initialized successfully');
         }
         catch (error) {
-            console.error('Failed to initialize demo BrainyData:', error);
+            console.error('Failed to initialize demo Brainy:', error);
             throw error;
         }
     }
@@ -194,8 +194,8 @@ export const VerbType = {
     Likes: 'likes',
     Follows: 'follows'
 };
-// Export the main class as BrainyData for compatibility
-export { DemoBrainyData as BrainyData };
+// Export the main class as Brainy for compatibility
+export { DemoBrainy as Brainy };
 // Default export
-export default DemoBrainyData;
+export default DemoBrainy;
 //# sourceMappingURL=demo.js.map

package/dist/distributed/cacheSync.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Distributed Cache Synchronization
+ * Provides cache coherence across multiple Brainy instances
+ */
+import { EventEmitter } from 'events';
+export interface CacheSyncConfig {
+    nodeId: string;
+    syncInterval?: number;
+    maxSyncBatchSize?: number;
+    compressionEnabled?: boolean;
+}
+export interface CacheEntry {
+    key: string;
+    value: any;
+    version: number;
+    timestamp: number;
+    ttl?: number;
+    nodeId: string;
+}
+export interface SyncMessage {
+    type: 'invalidate' | 'update' | 'delete' | 'batch';
+    entries: CacheEntry[];
+    source: string;
+    timestamp: number;
+}
+/**
+ * Distributed Cache Synchronizer
+ */
+export declare class CacheSync extends EventEmitter {
+    private nodeId;
+    private localCache;
+    private versionVector;
+    private syncQueue;
+    private syncInterval;
+    private maxSyncBatchSize;
+    private syncTimer?;
+    private isRunning;
+    constructor(config: CacheSyncConfig);
+    /**
+     * Start cache synchronization
+     */
+    start(): void;
+    /**
+     * Stop cache synchronization
+     */
+    stop(): void;
+    /**
+     * Get a value from cache
+     */
+    get(key: string): any | undefined;
+    /**
+     * Set a value in cache and propagate
+     */
+    set(key: string, value: any, ttl?: number): void;
+    /**
+     * Delete a value from cache and propagate
+     */
+    delete(key: string): boolean;
+    /**
+     * Invalidate a cache entry across all nodes
+     */
+    invalidate(key: string): void;
+    /**
+     * Clear all cache entries
+     */
+    clear(): void;
+    /**
+     * Handle incoming sync message from another node
+     */
+    handleSyncMessage(message: SyncMessage): void;
+    /**
+     * Handle a remote cache entry
+     */
+    private handleRemoteEntry;
+    /**
+     * Queue a sync message
+     */
+    private queueSync;
+    /**
+     * Start sync timer
+     */
+    private startSyncTimer;
+    /**
+     * Perform sync operation
+     */
+    private performSync;
+    /**
+     * Increment version for a key
+     */
+    private incrementVersion;
+    /**
+     * Get cache statistics
+     */
+    getStats(): {
+        entries: number;
+        pendingSync: number;
+        versionedKeys: number;
+        memoryUsage: number;
+    };
+    /**
+     * Get cache entries for debugging
+     */
+    getEntries(): CacheEntry[];
+    /**
+     * Merge cache state from another node (for recovery)
+     */
+    mergeState(entries: CacheEntry[]): void;
+}
+/**
+ * Create a cache sync instance
+ */
+export declare function createCacheSync(config: CacheSyncConfig): CacheSync;