@soulcraft/brainy 2.15.0 → 3.0.1

package/dist/augmentations/storageAugmentations.js

@@ -12,9 +12,65 @@ import { S3CompatibleStorage, R2Storage } from '../storage/adapters/s3Compatible
  * Memory Storage Augmentation - Fast in-memory storage
  */
 export class MemoryStorageAugmentation extends StorageAugmentation {
-    constructor() {
-        super();
+    constructor(config) {
+        super(config);
         this.name = 'memory-storage';
+        this.category = 'core';
+        this.description = 'High-performance in-memory storage for development and testing';
+    }
+    getManifest() {
+        return {
+            id: 'memory-storage',
+            name: 'Memory Storage',
+            version: '2.0.0',
+            description: 'Fast in-memory storage with no persistence',
+            longDescription: 'Perfect for development, testing, and temporary data. All data is lost when the process ends. Provides the fastest possible performance with zero I/O overhead.',
+            category: 'storage',
+            configSchema: {
+                type: 'object',
+                properties: {
+                    maxSize: {
+                        type: 'number',
+                        default: 104857600, // 100MB
+                        minimum: 1048576, // 1MB
+                        maximum: 1073741824, // 1GB
+                        description: 'Maximum memory usage in bytes'
+                    },
+                    gcInterval: {
+                        type: 'number',
+                        default: 60000, // 1 minute
+                        minimum: 1000, // 1 second
+                        maximum: 3600000, // 1 hour
+                        description: 'Garbage collection interval in milliseconds'
+                    },
+                    enableStats: {
+                        type: 'boolean',
+                        default: false,
+                        description: 'Enable memory usage statistics'
+                    }
+                },
+                additionalProperties: false
+            },
+            configDefaults: {
+                maxSize: 104857600,
+                gcInterval: 60000,
+                enableStats: false
+            },
+            minBrainyVersion: '2.0.0',
+            keywords: ['storage', 'memory', 'ram', 'volatile', 'fast'],
+            documentation: 'https://docs.brainy.dev/augmentations/memory-storage',
+            status: 'stable',
+            performance: {
+                memoryUsage: 'high',
+                cpuUsage: 'low',
+                networkUsage: 'none'
+            },
+            features: ['fast-access', 'zero-latency', 'no-persistence'],
+            ui: {
+                icon: '💾',
+                color: '#4CAF50'
+            }
+        };
     }
     async provideStorage() {
         const storage = new MemoryStorage();
@@ -23,23 +79,90 @@ export class MemoryStorageAugmentation extends StorageAugmentation {
     }
     async onInitialize() {
         await this.storageAdapter.init();
-        this.log('Memory storage initialized');
+        this.log(`Memory storage initialized (max size: ${this.config.maxSize} bytes)`);
     }
 }
 /**
  * FileSystem Storage Augmentation - Node.js persistent storage
  */
 export class FileSystemStorageAugmentation extends StorageAugmentation {
-    constructor(rootDirectory = './brainy-data') {
-        super();
+    constructor(config) {
+        super(config);
         this.name = 'filesystem-storage';
-        this.rootDirectory = rootDirectory;
+        this.category = 'core';
+        this.description = 'Persistent file-based storage for Node.js environments';
+    }
+    getManifest() {
+        return {
+            id: 'filesystem-storage',
+            name: 'FileSystem Storage',
+            version: '2.0.0',
+            description: 'Persistent storage using the local filesystem',
+            longDescription: 'Stores data as files on the local filesystem. Perfect for Node.js applications, desktop apps, and servers. Provides persistent storage with good performance and unlimited capacity.',
+            category: 'storage',
+            configSchema: {
+                type: 'object',
+                properties: {
+                    rootDirectory: {
+                        type: 'string',
+                        default: './brainy-data',
+                        description: 'Root directory for storing data files'
+                    },
+                    compression: {
+                        type: 'boolean',
+                        default: false,
+                        description: 'Enable gzip compression for stored files'
+                    },
+                    maxFileSize: {
+                        type: 'number',
+                        default: 10485760, // 10MB
+                        minimum: 1048576, // 1MB
+                        maximum: 104857600, // 100MB
+                        description: 'Maximum size per file in bytes'
+                    },
+                    autoBackup: {
+                        type: 'boolean',
+                        default: false,
+                        description: 'Enable automatic backups'
+                    },
+                    backupInterval: {
+                        type: 'number',
+                        default: 3600000, // 1 hour
+                        minimum: 60000, // 1 minute
+                        maximum: 86400000, // 24 hours
+                        description: 'Backup interval in milliseconds'
+                    }
+                },
+                additionalProperties: false
+            },
+            configDefaults: {
+                rootDirectory: './brainy-data',
+                compression: false,
+                maxFileSize: 10485760,
+                autoBackup: false,
+                backupInterval: 3600000
+            },
+            minBrainyVersion: '2.0.0',
+            keywords: ['storage', 'filesystem', 'persistent', 'node', 'disk'],
+            documentation: 'https://docs.brainy.dev/augmentations/filesystem-storage',
+            status: 'stable',
+            performance: {
+                memoryUsage: 'low',
+                cpuUsage: 'low',
+                networkUsage: 'none'
+            },
+            features: ['persistence', 'unlimited-capacity', 'file-based', 'compression-support'],
+            ui: {
+                icon: '📁',
+                color: '#FF9800'
+            }
+        };
     }
     async provideStorage() {
         try {
             // Dynamically import for Node.js environments
             const { FileSystemStorage } = await import('../storage/adapters/fileSystemStorage.js');
-            const storage = new FileSystemStorage(this.rootDirectory);
+            const storage = new FileSystemStorage(this.config.rootDirectory);
             this.storageAdapter = storage;
             return storage;
         }
@@ -53,17 +176,79 @@ export class FileSystemStorageAugmentation extends StorageAugmentation {
     }
     async onInitialize() {
         await this.storageAdapter.init();
-        this.log(`FileSystem storage initialized at ${this.rootDirectory}`);
+        this.log(`FileSystem storage initialized at ${this.config.rootDirectory}`);
+        if (this.config.compression) {
+            this.log('Compression enabled for stored files');
+        }
     }
 }
 /**
  * OPFS Storage Augmentation - Browser persistent storage
  */
 export class OPFSStorageAugmentation extends StorageAugmentation {
-    constructor(requestPersistent = false) {
-        super();
+    constructor(config) {
+        super(config);
         this.name = 'opfs-storage';
-        this.requestPersistent = requestPersistent;
+        this.category = 'core';
+        this.description = 'Persistent browser storage using Origin Private File System';
+    }
+    getManifest() {
+        return {
+            id: 'opfs-storage',
+            name: 'OPFS Storage',
+            version: '2.0.0',
+            description: 'Modern browser storage with file system capabilities',
+            longDescription: 'Uses the Origin Private File System API for persistent browser storage. Provides file-like storage in modern browsers with better performance than IndexedDB and unlimited storage quota.',
+            category: 'storage',
+            configSchema: {
+                type: 'object',
+                properties: {
+                    requestPersistent: {
+                        type: 'boolean',
+                        default: false,
+                        description: 'Request persistent storage permission from browser'
+                    },
+                    directoryName: {
+                        type: 'string',
+                        default: 'brainy-data',
+                        description: 'Directory name within OPFS'
+                    },
+                    chunkSize: {
+                        type: 'number',
+                        default: 1048576, // 1MB
+                        minimum: 65536, // 64KB
+                        maximum: 10485760, // 10MB
+                        description: 'Chunk size for file operations in bytes'
+                    },
+                    enableCache: {
+                        type: 'boolean',
+                        default: true,
+                        description: 'Enable in-memory caching for frequently accessed data'
+                    }
+                },
+                additionalProperties: false
+            },
+            configDefaults: {
+                requestPersistent: false,
+                directoryName: 'brainy-data',
+                chunkSize: 1048576,
+                enableCache: true
+            },
+            minBrainyVersion: '2.0.0',
+            keywords: ['storage', 'browser', 'opfs', 'persistent', 'web'],
+            documentation: 'https://docs.brainy.dev/augmentations/opfs-storage',
+            status: 'stable',
+            performance: {
+                memoryUsage: 'medium',
+                cpuUsage: 'low',
+                networkUsage: 'none'
+            },
+            features: ['browser-persistent', 'file-system-api', 'unlimited-quota', 'async-operations'],
+            ui: {
+                icon: '🌐',
+                color: '#2196F3'
+            }
+        };
     }
     async provideStorage() {
         const storage = new OPFSStorage();
@@ -78,11 +263,11 @@ export class OPFSStorageAugmentation extends StorageAugmentation {
     }
     async onInitialize() {
         await this.storageAdapter.init();
-        if (this.requestPersistent && this.storageAdapter instanceof OPFSStorage) {
+        if (this.config.requestPersistent && this.storageAdapter instanceof OPFSStorage) {
             const granted = await this.storageAdapter.requestPersistentStorage();
             this.log(`Persistent storage ${granted ? 'granted' : 'denied'}`);
         }
-        this.log('OPFS storage initialized');
+        this.log(`OPFS storage initialized in directory: ${this.config.directoryName}`);
     }
 }
 /**
@@ -163,11 +348,15 @@ export async function createAutoStorageAugmentation(options = {}) {
         process.versions.node != null);
     if (isNodeEnv) {
         // Node.js environment - use FileSystem
-        return new FileSystemStorageAugmentation(options.rootDirectory || './brainy-data');
+        return new FileSystemStorageAugmentation({
+            rootDirectory: options.rootDirectory || './brainy-data'
+        });
     }
     else {
         // Browser environment - try OPFS, fall back to memory
-        const opfsAug = new OPFSStorageAugmentation(options.requestPersistentStorage || false);
+        const opfsAug = new OPFSStorageAugmentation({
+            requestPersistent: options.requestPersistentStorage || false
+        });
         // Test if OPFS is available
         const testStorage = new OPFSStorage();
         if (testStorage.isOPFSAvailable()) {

package/dist/augmentations/synapseAugmentation.d.ts

@@ -114,7 +114,7 @@ export declare abstract class SynapseAugmentation extends BaseAugmentation {
     /**
      * Helper method to query existing synced data
      */
-    protected queryBrainyData(filter: {
+    protected queryBrainy(filter: {
         connector?: string;
         [key: string]: any;
     }): Promise<any[]>;

package/dist/augmentations/synapseAugmentation.js

@@ -54,7 +54,7 @@ export class SynapseAugmentation extends BaseAugmentation {
                 else {
                     // Create a new instance for this synapse
                     this.neuralImport = new NeuralImportAugmentation();
-                    // NeuralImport will be initialized when the synapse is added to BrainyData
+                    // NeuralImport will be initialized when the synapse is added to Brainy
                     // await this.neuralImport.initialize()
                 }
             }
@@ -133,7 +133,7 @@ export class SynapseAugmentation extends BaseAugmentation {
      */
     async storeInBrainy(content, metadata, options = {}) {
         if (!this.context?.brain) {
-            throw new Error('BrainyData context not initialized');
+            throw new Error('Brainy context not initialized');
         }
         // Add synapse source metadata
         const enrichedMetadata = {
@@ -154,10 +154,13 @@ export class SynapseAugmentation extends BaseAugmentation {
                 if (neuralResult.success && neuralResult.data) {
                     // Store detected nouns (entities)
                     for (const noun of neuralResult.data.nouns) {
-                        await this.context.brain.addNoun(noun, {
-                            ...enrichedMetadata,
-                            _neuralConfidence: neuralResult.data.confidence,
-                            _neuralInsights: neuralResult.data.insights
+                        await this.context.brain.add({
+                            text: noun,
+                            metadata: {
+                                ...enrichedMetadata,
+                                _neuralConfidence: neuralResult.data.confidence,
+                                _neuralInsights: neuralResult.data.insights
+                            }
                         });
                     }
                     // Store detected verbs (relationships)
@@ -173,12 +176,16 @@ export class SynapseAugmentation extends BaseAugmentation {
                     }
                     // Store original content with neural metadata
                     if (typeof content === 'string') {
-                        await this.context.brain.addNoun(content, 'Content', {
-                            ...enrichedMetadata,
-                            _neuralProcessed: true,
-                            _neuralConfidence: neuralResult.data.confidence,
-                            _detectedEntities: neuralResult.data.nouns.length,
-                            _detectedRelationships: neuralResult.data.verbs.length
+                        await this.context.brain.add({
+                            text: content,
+                            metadata: {
+                                ...enrichedMetadata,
+                                category: 'Content',
+                                _neuralProcessed: true,
+                                _neuralConfidence: neuralResult.data.confidence,
+                                _detectedEntities: neuralResult.data.nouns.length,
+                                _detectedRelationships: neuralResult.data.verbs.length
+                            }
                         });
                     }
                     return; // Successfully processed with Neural Import
@@ -190,19 +197,31 @@ export class SynapseAugmentation extends BaseAugmentation {
         }
         // Fallback to basic storage
         if (typeof content === 'string') {
-            await this.context.brain.addNoun(content, 'Content', enrichedMetadata);
+            await this.context.brain.add({
+                text: content,
+                metadata: {
+                    ...enrichedMetadata,
+                    category: 'Content'
+                }
+            });
         }
         else {
             // For structured data, store as JSON
-            await this.context.brain.addNoun(JSON.stringify(content), 'Content', enrichedMetadata);
+            await this.context.brain.add({
+                text: JSON.stringify(content),
+                metadata: {
+                    ...enrichedMetadata,
+                    category: 'Content'
+                }
+            });
         }
     }
     /**
      * Helper method to query existing synced data
      */
-    async queryBrainyData(filter) {
+    async queryBrainy(filter) {
         if (!this.context?.brain) {
-            throw new Error('BrainyData context not initialized');
+            throw new Error('Brainy context not initialized');
         }
         const searchFilter = {
             ...filter,

package/dist/augmentations/typeMatching/intelligentTypeMatcher.d.ts

@@ -1,83 +1,63 @@
 /**
- * Intelligent Type Matcher - Uses embeddings for semantic type detection
+ * IntelligentTypeMatcher - Wrapper around BrainyTypes for testing
  *
- * This module uses our existing TransformerEmbedding and similarity functions
- * to intelligently match data to our 31 noun types and 40 verb types.
- *
- * Features:
- * - Semantic similarity matching using embeddings
- * - Context-aware type detection
- * - Confidence scoring
- * - Caching for performance
- */
-/**
- * Result of type matching with confidence scores
+ * Provides intelligent type detection using semantic embeddings
+ * for matching data to our 31 noun types and 40 verb types.
  */
-export interface TypeMatchResult {
-    type: string;
-    confidence: number;
-    reasoning: string;
-    alternatives: Array<{
-        type: string;
-        confidence: number;
-    }>;
+import { NounType, VerbType } from '../../types/graphTypes.js';
+export interface TypeMatchOptions {
+    threshold?: number;
+    topK?: number;
+    useCache?: boolean;
 }
 /**
- * Intelligent Type Matcher using semantic embeddings
+ * Intelligent type matcher using semantic embeddings
  */
 export declare class IntelligentTypeMatcher {
-    private embedder;
-    private nounEmbeddings;
-    private verbEmbeddings;
-    private initialized;
+    private options;
+    private brainyTypes;
     private cache;
-    constructor();
+    constructor(options?: TypeMatchOptions);
     /**
-     * Initialize the type matcher by generating embeddings for all types
+     * Initialize the type matcher
      */
     init(): Promise<void>;
     /**
-     * Match an object to the most appropriate noun type
-     */
-    matchNounType(obj: any): Promise<TypeMatchResult>;
-    /**
-     * Match a relationship to the most appropriate verb type
-     */
-    matchVerbType(sourceObj: any, targetObj: any, relationshipHint?: string): Promise<TypeMatchResult>;
-    /**
-     * Create text representation of an object for embedding
-     */
-    private createTextRepresentation;
-    /**
-     * Create text representation of a relationship
-     */
-    private createRelationshipText;
-    /**
-     * Get a brief summary of an object
-     */
-    private getObjectSummary;
-    /**
-     * Apply heuristic rules for noun type detection
+     * Dispose of resources
      */
-    private applyNounHeuristics;
+    dispose(): Promise<void>;
     /**
-     * Apply heuristic rules for verb type detection
+     * Match data to a noun type
      */
-    private applyVerbHeuristics;
+    matchNounType(data: any): Promise<{
+        type: NounType;
+        confidence: number;
+        alternatives: Array<{
+            type: NounType;
+            confidence: number;
+        }>;
+    }>;
     /**
-     * Generate human-readable reasoning for the type selection
+     * Match a relationship to a verb type
      */
-    private generateReasoning;
+    matchVerbType(source: any, target: any, relationship?: string): Promise<{
+        type: VerbType;
+        confidence: number;
+        alternatives: Array<{
+            type: VerbType;
+            confidence: number;
+        }>;
+    }>;
     /**
      * Clear the cache
      */
     clearCache(): void;
     /**
-     * Dispose of resources
+     * Get cache statistics
      */
-    dispose(): Promise<void>;
+    getCacheStats(): {
+        size: number;
+        maxSize: number;
+    };
 }
-/**
- * Get or create the global type matcher instance
- */
-export declare function getTypeMatcher(): Promise<IntelligentTypeMatcher>;
+export default IntelligentTypeMatcher;