@soulcraft/brainy 1.0.0 → 1.1.0

package/README.md

@@ -59,12 +59,17 @@ await brain.addNoun("John", NounType.Person)    // 4. Typed entities
 await brain.addVerb(id1, id2, VerbType.Knows)   // 5. Relationships
 await brain.update(id, "new data")              // 6. Smart updates
 await brain.delete(id)                          // 7. Soft delete
-brain.augment(myAugmentation)                   // 8. Extend capabilities
-await brain.export({ format: 'json' })          // 9. Export data
+await brain.export({ format: 'json' })          // 8. Export data
+brain.augment(myAugmentation)                   // 9. Extend infinitely! ♾️
+
+// NEW: Type-safe augmentation management via brain.augmentations
+brain.augmentations.list()       // See all augmentations
+brain.augmentations.enable(name) // Enable/disable dynamically
 ```
 
 ### ✨ **What's New in 1.0:**
 - **🔥 40+ methods consolidated** → 9 unified methods
+- **♾️ The 9th method** - `augment()` lets you extend Brainy infinitely!
 - **🧠 Smart by default** - `add()` auto-detects and processes intelligently
 - **🔐 Universal encryption** - Built-in encryption for sensitive data
 - **🐳 Container ready** - Model preloading for production deployments
@@ -87,7 +92,7 @@ Every feature you see here works without any payment or registration:
 - ✓ Complete API
 - ✓ Forever free
 
-> 🌩️ **Brain Cloud** is an optional add-on for teams who want cloud sync and enterprise connectors.
+> 🌩️ **Brain Cloud** is our optional cloud service that helps sustain Brainy's development. Currently in early access at [soulcraft.com](https://soulcraft.com).
 
 ---
 
@@ -117,7 +122,9 @@ supabase.insert(), mongodb.find(), redis.set()
 // After: 9 methods handle EVERYTHING
 brain.add(), brain.search(), brain.import()
 brain.addNoun(), brain.addVerb(), brain.update()
-brain.delete(), brain.augment(), brain.export()
+brain.delete(), brain.export(), brain.augment()
+
+// Why 9? The 9th method (augment) gives you methods 10 → ∞!
 ```
 
 #### **🤯 Mind-Blowing Features Out of the Box**
@@ -300,12 +307,12 @@ const brain = new BrainyData()
 await brain.init()
 
 // Add any data - text, objects, relationships
-await brain.add("Elon Musk founded SpaceX in 2002")
-await brain.add({ company: "Tesla", ceo: "Elon Musk", founded: 2003 })
-await brain.addVerb("Elon Musk", "founded", "Tesla")
+await brain.add("Satya Nadella became CEO of Microsoft in 2014")
+await brain.add({ company: "Anthropic", ceo: "Dario Amodei", founded: 2021 })
+await brain.addVerb("Sundar Pichai", "leads", "Google")
 
 // Search naturally
-const results = await brain.search("companies founded by Elon")
+const results = await brain.search("tech companies and their leaders")
 ```
 
 ### ☁️ Brain Cloud (AI Memory + Agent Coordination)
@@ -332,11 +339,11 @@ brain.register(new AgentCoordinator())
 // Now your AI remembers everything across all sessions!
 await brain.add("User prefers TypeScript over JavaScript")
 // This memory persists and syncs across all devices
-// Returns: SpaceX and Tesla with relevance scores
+// Returns: Microsoft and Anthropic with relevance scores
 
 // Query relationships
-const companies = await brain.getRelated("Elon Musk", { verb: "founded" })
-// Returns: SpaceX, Tesla
+const companies = await brain.getRelated("Sundar Pichai", { verb: "leads" })
+// Returns: Google, Alphabet
 
 // Filter with metadata
 const recent = await brain.search("companies", 10, {
@@ -389,53 +396,51 @@ await neural.neuralImport('data.csv')  // Automatically extracts entities & rela
 **Be the First!** Create an augmentation and we'll feature it here.
 [See how to build augmentations →](UNIFIED-API.md#creating-your-own-augmentation)
 
-### ☁️ **Brain Cloud** - Power Up Your Brain! 🚀
-**Try it FREE:** Get persistent memory, team sync, and enterprise connectors!
+### ☁️ **Brain Cloud** - Optional Cloud Services (Early Access) 🎆
 
-```bash
-# Coming Soon! Brain Cloud is in development
-# Join the waitlist:
-# Visit: soulcraft.com
-```
+**Currently in Early Access** - Join at [soulcraft.com](https://soulcraft.com)
 
-**Why Brain Cloud?**
-- 🧠 **AI Memory That Never Forgets** - Conversations persist across sessions
-- 🤝 **Multi-Agent Coordination** - AI agents work together seamlessly
-- 💾 **Automatic Backups** - Never lose your brain's knowledge
-- 🔄 **Team Sync** - Share knowledge across your organization
-- 🔌 **Premium Connectors** - Notion, Slack, Salesforce, and more!
+**Available Tiers:**
 
-**Special Offer:** First 100GB FREE, then just $9/month for individuals, $49/team
+#### 🆓 **Free Forever** - Local Database
+- ✓ Full multi-dimensional database
+- ✓ Works offline
+- ✓ No API keys required
+- ✓ Your data stays private
 
-```javascript
-// Brain Cloud features are in the main package
-// But require API key to activate cloud services
-import { BrainyVectorDB } from '@soulcraft/brainy'
+#### ☁️ **Cloud Sync** - $19/month
+- ✓ Everything in Free tier
+- ✓ Team collaboration
+- ✓ Cross-device synchronization
+- ✓ Automatic backups
+- ✓ Real-time sync
+
+#### 🏢 **Enterprise** - $99/month
+- ✓ Everything in Cloud Sync
+- ✓ Dedicated infrastructure
+- ✓ Service Level Agreement (SLA)
+- ✓ Priority support
+- ✓ Custom integrations
 
-// Activate Brain Cloud features with API key
-const brain = new BrainyVectorDB({
-  cloud: { apiKey: process.env.BRAIN_CLOUD_KEY }  // Optional
+```javascript
+// Brain Cloud integration (when available):
+const brain = new BrainyData({
+  cloud: { 
+    enabled: true,  // Enable cloud sync
+    apiKey: process.env.BRAIN_CLOUD_KEY  // Optional for premium features
+  }
 })
 
-brain.register(aiMemory)  // AI remembers everything
+// Works perfectly without cloud too:
+const brain = new BrainyData()
+await brain.init()
+// Full database functionality, locally!
 ```
 
-**AI Memory & Coordination:**
-- 🧠 **AI Memory** - Persistent across sessions
-- 🤝 **Agent Coordinator** - Multi-agent handoffs
-- 👥 **Team Sync** - Real-time collaboration
-- 💾 **Cloud Backup** - Automatic backups
-
-**Enterprise Connectors:**
-- 📝 **Notion Sync** - Bidirectional sync
-- 💼 **Salesforce** - CRM integration
-- 📊 **Airtable** - Database sync
-- 🔄 **Postgres** - Real-time replication
-- 🏢 **Slack** - Team knowledge base
 
+### 🌐 **Why Brain Cloud?**
 
-### ☁️ **Brain Cloud** (Managed Service)
-For teams that want zero-ops:
+Brain Cloud adds optional cloud services to sustain Brainy's development:
 
 ```javascript
 // Connect to Brain Cloud - your brain in the cloud

package/bin/brainy.js

@@ -669,7 +669,108 @@ program
     }
   }))
 
-// Command 6: STATUS - Database health & info
+// Command 6A: ADD-NOUN - Create typed entities (Method #4)
+program
+  .command('add-noun <name>')
+  .description('Add a typed entity to your knowledge graph')
+  .option('-t, --type <type>', 'Noun type (Person, Organization, Project, Event, Concept, Location, Product)', 'Concept')
+  .option('-m, --metadata <json>', 'Metadata as JSON')
+  .option('--encrypt', 'Encrypt this entity')
+  .action(wrapAction(async (name, options) => {
+    const brainy = await getBrainy()
+    
+    // Validate noun type
+    const validTypes = ['Person', 'Organization', 'Project', 'Event', 'Concept', 'Location', 'Product']
+    if (!validTypes.includes(options.type)) {
+      console.log(colors.error(`❌ Invalid noun type: ${options.type}`))
+      console.log(colors.info(`Valid types: ${validTypes.join(', ')}`))
+      process.exit(1)
+    }
+    
+    let metadata = {}
+    if (options.metadata) {
+      try {
+        metadata = JSON.parse(options.metadata)
+      } catch {
+        console.error(colors.error('❌ Invalid JSON metadata'))
+        process.exit(1)
+      }
+    }
+    
+    if (options.encrypt) {
+      metadata.encrypted = true
+    }
+    
+    try {
+      const { NounType } = await import('../dist/types/graphTypes.js')
+      const id = await brainy.addNoun(name, NounType[options.type], metadata)
+      
+      console.log(colors.success('✅ Noun added successfully!'))
+      console.log(colors.info(`🆔 ID: ${id}`))
+      console.log(colors.info(`👤 Name: ${name}`))
+      console.log(colors.info(`🏷️ Type: ${options.type}`))
+      if (Object.keys(metadata).length > 0) {
+        console.log(colors.info(`📝 Metadata: ${JSON.stringify(metadata, null, 2)}`))
+      }
+    } catch (error) {
+      console.log(colors.error('❌ Failed to add noun:'))
+      console.log(colors.error(error.message))
+      process.exit(1)
+    }
+  }))
+
+// Command 6B: ADD-VERB - Create relationships (Method #5)
+program
+  .command('add-verb <source> <target>')
+  .description('Create a relationship between two entities')
+  .option('-t, --type <type>', 'Verb type (WorksFor, Knows, CreatedBy, BelongsTo, Uses, etc.)', 'RelatedTo')
+  .option('-m, --metadata <json>', 'Relationship metadata as JSON')
+  .option('--encrypt', 'Encrypt this relationship')
+  .action(wrapAction(async (source, target, options) => {
+    const brainy = await getBrainy()
+    
+    // Common verb types for validation
+    const commonTypes = ['WorksFor', 'Knows', 'CreatedBy', 'BelongsTo', 'Uses', 'LeadsProject', 'MemberOf', 'RelatedTo', 'InteractedWith']
+    if (!commonTypes.includes(options.type)) {
+      console.log(colors.warning(`⚠️ Uncommon verb type: ${options.type}`))
+      console.log(colors.info(`Common types: ${commonTypes.join(', ')}`))
+    }
+    
+    let metadata = {}
+    if (options.metadata) {
+      try {
+        metadata = JSON.parse(options.metadata)
+      } catch {
+        console.error(colors.error('❌ Invalid JSON metadata'))
+        process.exit(1)
+      }
+    }
+    
+    if (options.encrypt) {
+      metadata.encrypted = true
+    }
+    
+    try {
+      const { VerbType } = await import('../dist/types/graphTypes.js')
+      
+      // Use the provided type or fall back to RelatedTo
+      const verbType = VerbType[options.type] || options.type
+      const id = await brainy.addVerb(source, target, verbType, metadata)
+      
+      console.log(colors.success('✅ Relationship added successfully!'))
+      console.log(colors.info(`🆔 ID: ${id}`))
+      console.log(colors.info(`🔗 ${source} --[${options.type}]--> ${target}`))
+      if (Object.keys(metadata).length > 0) {
+        console.log(colors.info(`📝 Metadata: ${JSON.stringify(metadata, null, 2)}`))
+      }
+    } catch (error) {
+      console.log(colors.error('❌ Failed to add relationship:'))
+      console.log(colors.error(error.message))
+      process.exit(1)
+    }
+  }))
+
+// Command 7: STATUS - Database health & info
 program
   .command('status')
   .description('Show brain status and comprehensive statistics')

package/dist/augmentationManager.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Type-safe augmentation management system for Brainy
+ * Provides a clean API for managing augmentations without string literals
+ */
+import { IAugmentation, AugmentationType } from './types/augmentations.js';
+export interface AugmentationInfo {
+    name: string;
+    type: string;
+    enabled: boolean;
+    description: string;
+}
+/**
+ * Type-safe augmentation manager
+ * Accessed via brain.augmentations for all management operations
+ */
+export declare class AugmentationManager {
+    private pipeline;
+    /**
+     * List all registered augmentations with their status
+     * @returns Array of augmentation information
+     */
+    list(): AugmentationInfo[];
+    /**
+     * Get information about a specific augmentation
+     * @param name The augmentation name
+     * @returns Augmentation info or undefined if not found
+     */
+    get(name: string): AugmentationInfo | undefined;
+    /**
+     * Check if an augmentation is enabled
+     * @param name The augmentation name
+     * @returns True if enabled, false otherwise
+     */
+    isEnabled(name: string): boolean;
+    /**
+     * Enable a specific augmentation
+     * @param name The augmentation name
+     * @returns True if successfully enabled
+     */
+    enable(name: string): boolean;
+    /**
+     * Disable a specific augmentation
+     * @param name The augmentation name
+     * @returns True if successfully disabled
+     */
+    disable(name: string): boolean;
+    /**
+     * Remove an augmentation from the pipeline
+     * @param name The augmentation name
+     * @returns True if successfully removed
+     */
+    remove(name: string): boolean;
+    /**
+     * Enable all augmentations of a specific type
+     * @param type The augmentation type
+     * @returns Number of augmentations enabled
+     */
+    enableType(type: AugmentationType): number;
+    /**
+     * Disable all augmentations of a specific type
+     * @param type The augmentation type
+     * @returns Number of augmentations disabled
+     */
+    disableType(type: AugmentationType): number;
+    /**
+     * Get all augmentations of a specific type
+     * @param type The augmentation type
+     * @returns Array of augmentations of that type
+     */
+    listByType(type: AugmentationType): AugmentationInfo[];
+    /**
+     * Get all enabled augmentations
+     * @returns Array of enabled augmentations
+     */
+    listEnabled(): AugmentationInfo[];
+    /**
+     * Get all disabled augmentations
+     * @returns Array of disabled augmentations
+     */
+    listDisabled(): AugmentationInfo[];
+    /**
+     * Register a new augmentation (internal use)
+     * @param augmentation The augmentation to register
+     */
+    register(augmentation: IAugmentation): void;
+}
+export { AugmentationType } from './types/augmentations.js';

package/dist/augmentationManager.js

@@ -0,0 +1,112 @@
+/**
+ * Type-safe augmentation management system for Brainy
+ * Provides a clean API for managing augmentations without string literals
+ */
+import { augmentationPipeline } from './augmentationPipeline.js';
+/**
+ * Type-safe augmentation manager
+ * Accessed via brain.augmentations for all management operations
+ */
+export class AugmentationManager {
+    constructor() {
+        this.pipeline = augmentationPipeline;
+    }
+    /**
+     * List all registered augmentations with their status
+     * @returns Array of augmentation information
+     */
+    list() {
+        return this.pipeline.listAugmentationsWithStatus();
+    }
+    /**
+     * Get information about a specific augmentation
+     * @param name The augmentation name
+     * @returns Augmentation info or undefined if not found
+     */
+    get(name) {
+        const all = this.list();
+        return all.find(a => a.name === name);
+    }
+    /**
+     * Check if an augmentation is enabled
+     * @param name The augmentation name
+     * @returns True if enabled, false otherwise
+     */
+    isEnabled(name) {
+        const aug = this.get(name);
+        return aug?.enabled ?? false;
+    }
+    /**
+     * Enable a specific augmentation
+     * @param name The augmentation name
+     * @returns True if successfully enabled
+     */
+    enable(name) {
+        return this.pipeline.enableAugmentation(name);
+    }
+    /**
+     * Disable a specific augmentation
+     * @param name The augmentation name
+     * @returns True if successfully disabled
+     */
+    disable(name) {
+        return this.pipeline.disableAugmentation(name);
+    }
+    /**
+     * Remove an augmentation from the pipeline
+     * @param name The augmentation name
+     * @returns True if successfully removed
+     */
+    remove(name) {
+        this.pipeline.unregister(name);
+        return true;
+    }
+    /**
+     * Enable all augmentations of a specific type
+     * @param type The augmentation type
+     * @returns Number of augmentations enabled
+     */
+    enableType(type) {
+        return this.pipeline.enableAugmentationType(type);
+    }
+    /**
+     * Disable all augmentations of a specific type
+     * @param type The augmentation type
+     * @returns Number of augmentations disabled
+     */
+    disableType(type) {
+        return this.pipeline.disableAugmentationType(type);
+    }
+    /**
+     * Get all augmentations of a specific type
+     * @param type The augmentation type
+     * @returns Array of augmentations of that type
+     */
+    listByType(type) {
+        return this.list().filter(a => a.type === type);
+    }
+    /**
+     * Get all enabled augmentations
+     * @returns Array of enabled augmentations
+     */
+    listEnabled() {
+        return this.list().filter(a => a.enabled);
+    }
+    /**
+     * Get all disabled augmentations
+     * @returns Array of disabled augmentations
+     */
+    listDisabled() {
+        return this.list().filter(a => !a.enabled);
+    }
+    /**
+     * Register a new augmentation (internal use)
+     * @param augmentation The augmentation to register
+     */
+    register(augmentation) {
+        this.pipeline.register(augmentation);
+    }
+}
+// Export types for external use
+export { AugmentationType } from './types/augmentations.js';
+//# sourceMappingURL=augmentationManager.js.map

package/dist/brainyData.d.ts

@@ -11,6 +11,7 @@ import { WebSocketConnection, IAugmentation } from './types/augmentations.js';
 import { BrainyDataInterface } from './types/brainyDataInterface.js';
 import { DistributedConfig } from './types/distributedTypes.js';
 import { SearchCacheConfig } from './utils/searchCache.js';
+import { AugmentationManager } from './augmentationManager.js';
 export interface BrainyDataConfig {
     /**
      * HNSW index configuration
@@ -369,6 +370,11 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
     private loggingConfig;
     private defaultService;
     private searchCache;
+    /**
+     * Type-safe augmentation management
+     * Access all augmentation operations through this property
+     */
+    readonly augmentations: AugmentationManager;
     private cacheAutoConfigurator;
     private timeoutConfig;
     private retryConfig;
@@ -1475,12 +1481,16 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
      */
     rebuildMetadataIndex(): Promise<void>;
     /**
-     * UNIFIED API METHOD #8: Augment - Complete augmentation management
-     * Register, enable, disable, list, and manage augmentations
+     * UNIFIED API METHOD #9: Augment - Register new augmentations
+     *
+     * For registration: brain.augment(new MyAugmentation())
+     * For management: Use brain.augmentations.enable(), .disable(), .list() etc.
+     *
+     * @param action The augmentation to register OR legacy string command
+     * @param options Legacy options for string commands (deprecated)
+     * @returns this for chaining when registering, various for legacy commands
      *
-     * @param action The action to perform or augmentation to register
-     * @param options Additional options for the action
-     * @returns Various return types based on action
+     * @deprecated String-based commands are deprecated. Use brain.augmentations.* instead
      */
     augment(action: IAugmentation | 'list' | 'enable' | 'disable' | 'unregister' | 'enable-type' | 'disable-type', options?: string | {
         name?: string;

package/dist/brainyData.js

@@ -21,6 +21,7 @@ import { DistributedConfigManager, HashPartitioner, OperationalModeFactory, Doma
 import { SearchCache } from './utils/searchCache.js';
 import { CacheAutoConfigurator } from './utils/cacheAutoConfig.js';
 import { StatisticsCollector } from './utils/statisticsCollector.js';
+import { AugmentationManager } from './augmentationManager.js';
 export class BrainyData {
     /**
      * Get the vector dimensions
@@ -204,6 +205,8 @@ export class BrainyData {
         }
         // Initialize search cache with final configuration
         this.searchCache = new SearchCache(finalSearchCacheConfig);
+        // Initialize augmentation manager
+        this.augmentations = new AugmentationManager();
         // Initialize intelligent verb scoring if enabled
         if (config.intelligentVerbScoring?.enabled) {
             this.intelligentVerbScoring = new IntelligentVerbScoring(config.intelligentVerbScoring);
@@ -5345,79 +5348,66 @@ export class BrainyData {
     }
     // ===== Augmentation Control Methods =====
     /**
-     * UNIFIED API METHOD #8: Augment - Complete augmentation management
-     * Register, enable, disable, list, and manage augmentations
+     * UNIFIED API METHOD #9: Augment - Register new augmentations
      *
-     * @param action The action to perform or augmentation to register
-     * @param options Additional options for the action
-     * @returns Various return types based on action
+     * For registration: brain.augment(new MyAugmentation())
+     * For management: Use brain.augmentations.enable(), .disable(), .list() etc.
+     *
+     * @param action The augmentation to register OR legacy string command
+     * @param options Legacy options for string commands (deprecated)
+     * @returns this for chaining when registering, various for legacy commands
+     *
+     * @deprecated String-based commands are deprecated. Use brain.augmentations.* instead
      */
     augment(action, options) {
-        // If it's an augmentation object, register it
-        if (typeof action === 'object' && 'name' in action && 'type' in action) {
-            augmentationPipeline.register(action);
+        // PRIMARY USE: Register new augmentation
+        if (typeof action === 'object' && 'name' in action) {
+            this.augmentations.register(action);
             return this;
         }
-        // Handle string actions
+        // LEGACY: Handle string actions (deprecated - use brain.augmentations instead)
+        console.warn(`Deprecated: brain.augment('${action}') - Use brain.augmentations.${action}() instead`);
         switch (action) {
             case 'list':
-                // Return list of all augmentations with status
-                return this.listAugmentations();
+                return this.augmentations.list();
             case 'enable':
-                // Enable specific augmentation by name
                 if (typeof options === 'string') {
-                    this.enableAugmentation(options);
+                    this.augmentations.enable(options);
                 }
                 else if (options?.name) {
-                    this.enableAugmentation(options.name);
+                    this.augmentations.enable(options.name);
                 }
                 return this;
             case 'disable':
-                // Disable specific augmentation by name
                 if (typeof options === 'string') {
-                    this.disableAugmentation(options);
+                    this.augmentations.disable(options);
                 }
                 else if (options?.name) {
-                    this.disableAugmentation(options.name);
+                    this.augmentations.disable(options.name);
                 }
                 return this;
             case 'unregister':
-                // Remove augmentation from pipeline
                 if (typeof options === 'string') {
-                    this.unregister(options);
+                    this.augmentations.remove(options);
                 }
                 else if (options?.name) {
-                    this.unregister(options.name);
+                    this.augmentations.remove(options.name);
                 }
                 return this;
             case 'enable-type':
-                // Enable all augmentations of a type
                 if (typeof options === 'string') {
-                    const validTypes = ['sense', 'conduit', 'cognition', 'memory', 'perception', 'dialog', 'activation', 'webSocket'];
-                    if (validTypes.includes(options)) {
-                        return this.enableAugmentationType(options);
-                    }
+                    return this.augmentations.enableType(options);
                 }
                 else if (options?.type) {
-                    const validTypes = ['sense', 'conduit', 'cognition', 'memory', 'perception', 'dialog', 'activation', 'webSocket'];
-                    if (validTypes.includes(options.type)) {
-                        return this.enableAugmentationType(options.type);
-                    }
+                    return this.augmentations.enableType(options.type);
                 }
                 throw new Error('Invalid augmentation type');
             case 'disable-type':
-                // Disable all augmentations of a type
                 if (typeof options === 'string') {
-                    const validTypes = ['sense', 'conduit', 'cognition', 'memory', 'perception', 'dialog', 'activation', 'webSocket'];
-                    if (validTypes.includes(options)) {
-                        return this.disableAugmentationType(options);
-                    }
+                    return this.augmentations.disableType(options);
                 }
                 else if (options?.type) {
-                    const validTypes = ['sense', 'conduit', 'cognition', 'memory', 'perception', 'dialog', 'activation', 'webSocket'];
-                    if (validTypes.includes(options.type)) {
-                        return this.disableAugmentationType(options.type);
-                    }
+                    return this.augmentations.disableType(options.type);
                 }
                 throw new Error('Invalid augmentation type');
             default:

package/dist/index.d.ts

@@ -50,6 +50,7 @@ export { HNSWIndex, HNSWIndexOptimized };
 export type { Vector, VectorDocument, SearchResult, DistanceFunction, EmbeddingFunction, EmbeddingModel, HNSWNoun, HNSWVerb, HNSWConfig, HNSWOptimizedConfig, StorageAdapter };
 import type { IAugmentation, AugmentationResponse, IWebSocketSupport, ISenseAugmentation, IConduitAugmentation, ICognitionAugmentation, IMemoryAugmentation, IPerceptionAugmentation, IDialogAugmentation, IActivationAugmentation } from './types/augmentations.js';
 import { AugmentationType, BrainyAugmentations } from './types/augmentations.js';
+export { AugmentationManager, type AugmentationInfo } from './augmentationManager.js';
 export type { IAugmentation, AugmentationResponse, IWebSocketSupport };
 export { AugmentationType, BrainyAugmentations, ISenseAugmentation, IConduitAugmentation, ICognitionAugmentation, IMemoryAugmentation, IPerceptionAugmentation, IDialogAugmentation, IActivationAugmentation };
 export type { IWebSocketCognitionAugmentation, IWebSocketSenseAugmentation, IWebSocketPerceptionAugmentation, IWebSocketActivationAugmentation, IWebSocketDialogAugmentation, IWebSocketConduitAugmentation, IWebSocketMemoryAugmentation } from './types/augmentations.js';

package/dist/index.js

@@ -79,6 +79,8 @@ import { HNSWIndex } from './hnsw/hnswIndex.js';
 import { HNSWIndexOptimized } from './hnsw/hnswIndexOptimized.js';
 export { HNSWIndex, HNSWIndexOptimized };
 import { AugmentationType } from './types/augmentations.js';
+// Export augmentation manager for type-safe augmentation management
+export { AugmentationManager } from './augmentationManager.js';
 export { AugmentationType };
 import { NounType, VerbType } from './types/graphTypes.js';
 // Export type utility functions

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soulcraft/brainy",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Multi-Dimensional AI Database - Vector similarity, graph relationships, metadata facets with HNSW indexing and OPFS storage",
   "main": "dist/index.js",
   "module": "dist/index.js",