@soulcraft/brainy 0.62.3 → 0.63.0

package/dist/chat/ChatCLI.js

@@ -0,0 +1,351 @@
+/**
+ * ChatCLI - Command Line Interface for BrainyChat
+ *
+ * Provides a magical chat experience through the Brainy CLI with:
+ * - Auto-discovery of previous sessions
+ * - Intelligent context loading
+ * - Multi-agent coordination support
+ * - Premium memory sync integration
+ */
+import { BrainyChat } from './BrainyChat.js';
+// Simple color utility without external dependencies
+const colors = {
+    cyan: (text) => `\x1b[36m${text}\x1b[0m`,
+    green: (text) => `\x1b[32m${text}\x1b[0m`,
+    yellow: (text) => `\x1b[33m${text}\x1b[0m`,
+    blue: (text) => `\x1b[34m${text}\x1b[0m`,
+    gray: (text) => `\x1b[90m${text}\x1b[0m`,
+    red: (text) => `\x1b[31m${text}\x1b[0m`
+};
+export class ChatCLI {
+    constructor(brainy) {
+        this.brainy = brainy;
+        this.brainyChat = new BrainyChat(brainy);
+    }
+    /**
+     * Start an interactive chat session
+     * Automatically discovers and loads previous context
+     */
+    async startInteractiveChat(options) {
+        console.log(colors.cyan('🧠 Brainy Chat - Local Memory & Intelligence'));
+        console.log();
+        let session = null;
+        if (options?.sessionId) {
+            // Load specific session
+            session = await this.brainyChat.switchToSession(options.sessionId);
+            if (session) {
+                console.log(colors.green(`📂 Loaded session: ${session.title || session.id}`));
+                console.log(colors.gray(`   Created: ${session.createdAt.toLocaleDateString()}`));
+                console.log(colors.gray(`   Messages: ${session.messageCount}`));
+            }
+            else {
+                console.log(colors.yellow(`⚠️  Session ${options.sessionId} not found, starting new session`));
+            }
+        }
+        else if (!options?.newSession) {
+            // Auto-discover last session
+            console.log(colors.gray('🔍 Looking for your last conversation...'));
+            session = await this.brainyChat.initialize();
+            if (session) {
+                console.log(colors.green(`✨ Found your last session: ${session.title || 'Untitled'}`));
+                console.log(colors.gray(`   Last active: ${session.lastMessageAt.toLocaleString()}`));
+                console.log(colors.gray(`   Messages: ${session.messageCount}`));
+                // Show recent context if memory option is enabled
+                if (options?.memory !== false) {
+                    await this.showRecentContext();
+                }
+            }
+            else {
+                console.log(colors.blue('🆕 No previous sessions found, starting fresh!'));
+            }
+        }
+        if (!session) {
+            session = await this.brainyChat.startNewSession(`Chat ${new Date().toLocaleDateString()}`, ['user', options?.speaker || 'assistant']);
+            console.log(colors.green(`🎉 Started new session: ${session.id}`));
+        }
+        console.log();
+        console.log(colors.gray('💡 Tips:'));
+        console.log(colors.gray('   - Type /history to see conversation history'));
+        console.log(colors.gray('   - Type /search <query> to search all conversations'));
+        console.log(colors.gray('   - Type /sessions to list all sessions'));
+        console.log(colors.gray('   - Type /help for more commands'));
+        console.log(colors.gray('   - Type /quit to exit'));
+        console.log();
+        console.log(colors.blue('🚀 Want multi-agent coordination? Try: brainy cloud auth'));
+        console.log();
+        // Start interactive loop
+        await this.interactiveLoop(options?.speaker || 'assistant');
+    }
+    /**
+     * Send a single message and get response
+     */
+    async sendMessage(message, options) {
+        if (options?.sessionId) {
+            await this.brainyChat.switchToSession(options.sessionId);
+        }
+        // Add user message
+        const userMessage = await this.brainyChat.addMessage(message, 'user');
+        console.log(colors.blue(`👤 You: ${message}`));
+        if (options?.noResponse) {
+            return [userMessage];
+        }
+        // For CLI usage, we'd integrate with whatever AI service is configured
+        // This is a placeholder showing the architecture
+        const response = await this.generateResponse(message, options?.speaker || 'assistant');
+        const assistantMessage = await this.brainyChat.addMessage(response, options?.speaker || 'assistant', {
+            model: 'claude-3-sonnet',
+            context: { userMessage: userMessage.id }
+        });
+        console.log(colors.green(`🤖 ${options?.speaker || 'Assistant'}: ${response}`));
+        return [userMessage, assistantMessage];
+    }
+    /**
+     * Show conversation history
+     */
+    async showHistory(limit = 10) {
+        const messages = await this.brainyChat.getHistory(limit);
+        if (messages.length === 0) {
+            console.log(colors.yellow('📭 No messages in current session'));
+            return;
+        }
+        console.log(colors.cyan(`📜 Last ${Math.min(limit, messages.length)} messages:`));
+        console.log();
+        for (const message of messages.slice(-limit)) {
+            const timestamp = message.timestamp.toLocaleTimeString();
+            const speakerColor = message.speaker === 'user' ? colors.blue : colors.green;
+            const icon = message.speaker === 'user' ? '👤' : '🤖';
+            console.log(speakerColor(`${icon} ${message.speaker} (${timestamp}):`));
+            console.log(colors.gray(`   ${message.content}`));
+            console.log();
+        }
+    }
+    /**
+     * Search across all conversations
+     */
+    async searchConversations(query, options) {
+        console.log(colors.cyan(`🔍 Searching for: "${query}"`));
+        const results = await this.brainyChat.searchMessages(query, {
+            limit: options?.limit || 10,
+            sessionId: options?.sessionId,
+            semanticSearch: options?.semantic !== false
+        });
+        if (results.length === 0) {
+            console.log(colors.yellow('🤷 No matching messages found'));
+            return;
+        }
+        console.log(colors.green(`✨ Found ${results.length} matches:`));
+        console.log();
+        for (const message of results) {
+            const date = message.timestamp.toLocaleDateString();
+            const time = message.timestamp.toLocaleTimeString();
+            const speakerColor = message.speaker === 'user' ? colors.blue : colors.green;
+            const icon = message.speaker === 'user' ? '👤' : '🤖';
+            console.log(colors.gray(`📅 ${date} ${time} - Session: ${message.sessionId.substring(0, 8)}...`));
+            console.log(speakerColor(`${icon} ${message.speaker}: ${message.content}`));
+            console.log();
+        }
+    }
+    /**
+     * List all chat sessions
+     */
+    async listSessions() {
+        const sessions = await this.brainyChat.getSessions();
+        if (sessions.length === 0) {
+            console.log(colors.yellow('📭 No chat sessions found'));
+            return;
+        }
+        console.log(colors.cyan(`💬 Your chat sessions (${sessions.length}):`));
+        console.log();
+        for (const session of sessions) {
+            const isActive = session.id === this.brainyChat.getCurrentSessionId();
+            const activeIndicator = isActive ? colors.green(' ● ACTIVE') : '';
+            const archived = session.metadata?.archived ? colors.gray(' [ARCHIVED]') : '';
+            console.log(colors.blue(`📂 ${session.title || 'Untitled'}${activeIndicator}${archived}`));
+            console.log(colors.gray(`   ID: ${session.id}`));
+            console.log(colors.gray(`   Created: ${session.createdAt.toLocaleDateString()}`));
+            console.log(colors.gray(`   Last active: ${session.lastMessageAt.toLocaleDateString()}`));
+            console.log(colors.gray(`   Messages: ${session.messageCount}`));
+            console.log(colors.gray(`   Participants: ${session.participants.join(', ')}`));
+            console.log();
+        }
+    }
+    /**
+     * Switch to a different session
+     */
+    async switchSession(sessionId) {
+        const session = await this.brainyChat.switchToSession(sessionId);
+        if (session) {
+            console.log(colors.green(`✅ Switched to session: ${session.title || session.id}`));
+            console.log(colors.gray(`   Messages: ${session.messageCount}`));
+            console.log(colors.gray(`   Last active: ${session.lastMessageAt.toLocaleString()}`));
+        }
+        else {
+            console.log(colors.red(`❌ Session ${sessionId} not found`));
+        }
+    }
+    /**
+     * Show help for chat commands
+     */
+    showHelp() {
+        console.log(colors.cyan('🧠 Brainy Chat Commands:'));
+        console.log();
+        console.log(colors.blue('Basic Commands:'));
+        console.log('  /history [limit]     - Show conversation history (default: 10 messages)');
+        console.log('  /search <query>      - Search all conversations');
+        console.log('  /sessions           - List all chat sessions');
+        console.log('  /switch <id>        - Switch to a specific session');
+        console.log('  /new                - Start a new session');
+        console.log('  /help               - Show this help');
+        console.log('  /quit               - Exit chat');
+        console.log();
+        console.log(colors.yellow('Local Features:'));
+        console.log('  ✨ Automatic session discovery');
+        console.log('  🧠 Local memory across all conversations');
+        console.log('  🔍 Semantic search using vector similarity');
+        console.log('  📊 Standard noun/verb graph relationships');
+        console.log();
+        console.log(colors.green('Want More? Premium Features:'));
+        console.log('  🤝 Multi-agent coordination');
+        console.log('  ☁️  Cross-device memory sync');
+        console.log('  🎨 Rich web coordination UI');
+        console.log('  🔄 Real-time team collaboration');
+        console.log();
+        console.log(colors.blue('Get premium: brainy cloud auth'));
+        console.log();
+    }
+    // Private methods
+    async interactiveLoop(assistantSpeaker = 'assistant') {
+        const readline = require('readline');
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        const askQuestion = () => {
+            return new Promise((resolve) => {
+                rl.question(colors.blue('💬 You: '), resolve);
+            });
+        };
+        while (true) {
+            try {
+                const input = await askQuestion();
+                if (input.trim() === '')
+                    continue;
+                // Handle commands
+                if (input.startsWith('/')) {
+                    const [command, ...args] = input.slice(1).split(' ');
+                    switch (command.toLowerCase()) {
+                        case 'quit':
+                        case 'exit':
+                            console.log(colors.cyan('👋 Thanks for chatting! Your conversation is saved.'));
+                            rl.close();
+                            return;
+                        case 'history':
+                            const limit = args[0] ? parseInt(args[0]) : 10;
+                            await this.showHistory(limit);
+                            break;
+                        case 'search':
+                            if (args.length === 0) {
+                                console.log(colors.yellow('Usage: /search <query>'));
+                            }
+                            else {
+                                await this.searchConversations(args.join(' '));
+                            }
+                            break;
+                        case 'sessions':
+                            await this.listSessions();
+                            break;
+                        case 'switch':
+                            if (args.length === 0) {
+                                console.log(colors.yellow('Usage: /switch <session-id>'));
+                            }
+                            else {
+                                await this.switchSession(args[0]);
+                            }
+                            break;
+                        case 'new':
+                            const newSession = await this.brainyChat.startNewSession(`Chat ${new Date().toLocaleDateString()}`);
+                            console.log(colors.green(`🆕 Started new session: ${newSession.id}`));
+                            break;
+                        case 'archive':
+                            const sessionToArchive = args[0] || this.brainyChat.getCurrentSessionId();
+                            if (sessionToArchive) {
+                                try {
+                                    await this.brainyChat.archiveSession(sessionToArchive);
+                                    console.log(colors.green(`📁 Session archived: ${sessionToArchive}`));
+                                }
+                                catch (error) {
+                                    console.log(colors.red(`❌ ${error?.message}`));
+                                }
+                            }
+                            else {
+                                console.log(colors.yellow('No session to archive'));
+                            }
+                            break;
+                        case 'summary':
+                            const sessionToSummarize = args[0] || this.brainyChat.getCurrentSessionId();
+                            if (sessionToSummarize) {
+                                try {
+                                    const summary = await this.brainyChat.generateSessionSummary(sessionToSummarize);
+                                    if (summary) {
+                                        console.log(colors.green('📋 Session Summary:'));
+                                        console.log(colors.gray(summary));
+                                    }
+                                    else {
+                                        console.log(colors.yellow('No summary could be generated'));
+                                    }
+                                }
+                                catch (error) {
+                                    console.log(colors.red(`❌ ${error?.message}`));
+                                }
+                            }
+                            else {
+                                console.log(colors.yellow('No session to summarize'));
+                            }
+                            break;
+                        case 'help':
+                            this.showHelp();
+                            break;
+                        default:
+                            console.log(colors.yellow(`Unknown command: ${command}`));
+                            console.log(colors.gray('Type /help for available commands'));
+                    }
+                }
+                else {
+                    // Regular message
+                    await this.sendMessage(input, { speaker: assistantSpeaker });
+                }
+                console.log();
+            }
+            catch (error) {
+                console.error(colors.red(`Error: ${error?.message}`));
+            }
+        }
+    }
+    async showRecentContext(limit = 3) {
+        const recentMessages = await this.brainyChat.getHistory(limit);
+        if (recentMessages.length > 0) {
+            console.log(colors.gray('💭 Recent context:'));
+            for (const msg of recentMessages.slice(-limit)) {
+                const preview = msg.content.length > 60
+                    ? msg.content.substring(0, 60) + '...'
+                    : msg.content;
+                console.log(colors.gray(`   ${msg.speaker}: ${preview}`));
+            }
+            console.log();
+        }
+    }
+    async generateResponse(message, speaker) {
+        // This is a placeholder for AI integration
+        // In a real implementation, this would call the configured AI service
+        // and could include multi-agent coordination
+        // Example responses for demonstration
+        const responses = [
+            "I remember our conversation and can help with that!",
+            "Based on our previous discussions, I think...",
+            "Let me search through our chat history for relevant context.",
+            "I can coordinate with other AI agents if needed for this task."
+        ];
+        return responses[Math.floor(Math.random() * responses.length)];
+    }
+}
+//# sourceMappingURL=ChatCLI.js.map

package/dist/connectors/interfaces/IConnector.d.ts

@@ -1,13 +1,13 @@
 /**
  * Brainy Connector Interface - Atomic Age Integration Framework
  *
- * 🧠 Base interface for all premium connectors in the Quantum Vault
+ * 🧠 Base interface for all premium connectors in Brain Cloud
  * ⚛️ Open source interface, implementations are premium-only
  */
 export interface ConnectorConfig {
     /** Connector identifier (e.g., 'notion', 'salesforce') */
     connectorId: string;
-    /** Premium license key (required for Quantum Vault connectors) */
+    /** Premium license key (required for Brain Cloud connectors) */
     licenseKey: string;
     /** API credentials for the external service */
     credentials: {
@@ -84,7 +84,7 @@ export interface ConnectorStatus {
 /**
  * Base interface for all Brainy premium connectors
  *
- * Implementations live in the Quantum Vault (brainy-quantum-vault)
+ * Implementations auto-load with Brain Cloud subscription after auth
  */
 export interface IConnector {
     /** Unique connector identifier */

package/dist/connectors/interfaces/IConnector.js

@@ -1,7 +1,7 @@
 /**
  * Brainy Connector Interface - Atomic Age Integration Framework
  *
- * 🧠 Base interface for all premium connectors in the Quantum Vault
+ * 🧠 Base interface for all premium connectors in Brain Cloud
  * ⚛️ Open source interface, implementations are premium-only
  */
 export {};

package/dist/cortex/cortex-legacy.d.ts

@@ -51,11 +51,16 @@ export declare class Cortex {
     /**
      * Chat with your data - beautiful interactive mode
      */
+    private generateResponse;
     chat(question?: string): Promise<void>;
     /**
      * Add data with beautiful prompts
      */
     add(data?: string, metadata?: any): Promise<void>;
+    /**
+     * Add data with AI processing enabled (Neural Import + entity detection)
+     */
+    addSmart(data?: string, metadata?: any): Promise<void>;
     /**
      * Search with beautiful results display and advanced options
      */

package/dist/cortex/cortex-legacy.js

@@ -4,7 +4,7 @@
  * Configuration, data management, search, and chat - all in one place!
  */
 import { BrainyData } from '../brainyData.js';
-import { BrainyChat } from '../chat/brainyChat.js';
+import { BrainyChat } from '../chat/BrainyChat.js';
 import { PerformanceMonitor } from './performanceMonitor.js';
 import { HealthCheck } from './healthCheck.js';
 // Licensing system moved to quantum-vault
@@ -422,21 +422,26 @@ export class Cortex {
     /**
      * Chat with your data - beautiful interactive mode
      */
+    async generateResponse(question) {
+        // This is a placeholder for AI integration
+        // In production, this would call the configured AI service
+        return `I understand your question about "${question}". Based on the data in your Brainy database, here's what I found...`;
+    }
     async chat(question) {
         await this.ensureInitialized();
         if (!this.chatInstance) {
-            this.chatInstance = new BrainyChat(this.brainy, {
-                llm: this.config.llm,
-                sources: true
-            });
+            this.chatInstance = new BrainyChat(this.brainy);
         }
         // Single question mode
         if (question) {
             const spinner = ora('Thinking...').start();
             try {
-                const answer = await this.chatInstance.ask(question);
+                // Use the new chat methods
+                await this.chatInstance.addMessage(question, 'user');
+                const response = await this.generateResponse(question);
+                const answer = await this.chatInstance.addMessage(response, 'assistant');
                 spinner.stop();
-                console.log(`\n${emojis.robot} ${colors.bold('Answer:')}\n${answer}\n`);
+                console.log(`\n${emojis.robot} ${colors.bold('Answer:')}\n${response}\n`);
             }
             catch (error) {
                 spinner.fail('Failed to get answer');
@@ -465,7 +470,9 @@ export class Cortex {
             if (input) {
                 const spinner = ora('Thinking...').start();
                 try {
-                    const answer = await this.chatInstance.ask(input);
+                    await this.chatInstance.addMessage(input, 'user');
+                    const answer = await this.generateResponse(input);
+                    await this.chatInstance.addMessage(answer, 'assistant');
                     spinner.stop();
                     console.log(`\n${emojis.robot} ${colors.success(answer)}\n`);
                 }
@@ -535,6 +542,59 @@ export class Cortex {
             console.error(error);
         }
     }
+    /**
+     * Add data with AI processing enabled (Neural Import + entity detection)
+     */
+    async addSmart(data, metadata) {
+        await this.ensureInitialized();
+        // Interactive mode if no data provided
+        if (!data) {
+            const responses = await prompts([
+                {
+                    type: 'text',
+                    name: 'data',
+                    message: `${emojis.brain} Enter data for AI processing:`
+                },
+                {
+                    type: 'text',
+                    name: 'id',
+                    message: 'ID (optional, press enter to auto-generate):'
+                },
+                {
+                    type: 'confirm',
+                    name: 'hasMetadata',
+                    message: 'Add metadata?',
+                    initial: false
+                },
+                {
+                    type: (prev) => prev ? 'text' : null,
+                    name: 'metadata',
+                    message: 'Enter metadata (JSON format):'
+                }
+            ]);
+            data = responses.data;
+            if (responses.metadata) {
+                try {
+                    metadata = JSON.parse(responses.metadata);
+                }
+                catch {
+                    console.log(colors.warning('Invalid JSON, skipping metadata'));
+                }
+            }
+            if (responses.id) {
+                metadata = { ...metadata, id: responses.id };
+            }
+        }
+        const spinner = ora('🧠 Processing with AI...').start();
+        try {
+            const id = await this.brainy.addSmart(data, metadata);
+            spinner.succeed(colors.success(`${emojis.check} Processed with AI and added with ID: ${id}`));
+        }
+        catch (error) {
+            spinner.fail('Failed to add data with AI processing');
+            console.error(error);
+        }
+    }
     /**
      * Search with beautiful results display and advanced options
      */
@@ -1171,7 +1231,7 @@ export class Cortex {
             await this.configSet('LLM_MODEL', modelName);
             // Test the model
             this.config.llm = modelName;
-            this.chatInstance = new BrainyChat(this.brainy, { llm: modelName });
+            this.chatInstance = new BrainyChat(this.brainy);
             spinner.succeed(colors.success(`${emojis.check} Local model configured: ${modelName}`));
             console.log(colors.dim('\nModel will download on first use. This may take a few minutes.'));
         }
@@ -1628,8 +1688,8 @@ export class Cortex {
     async neuralImport(filePath, options = {}) {
         await this.ensureInitialized();
         // Import and create the Cortex SENSE augmentation
-        const { CortexSenseAugmentation } = await import('../augmentations/cortexSense.js');
-        const neuralSense = new CortexSenseAugmentation(this.brainy, options);
+        const { NeuralImportAugmentation } = await import('../augmentations/neuralImport.js');
+        const neuralSense = new NeuralImportAugmentation(this.brainy, options);
         // Initialize the augmentation
         await neuralSense.initialize();
         try {
@@ -1663,8 +1723,8 @@ export class Cortex {
     }
     async neuralAnalyze(filePath) {
         await this.ensureInitialized();
-        const { CortexSenseAugmentation } = await import('../augmentations/cortexSense.js');
-        const neuralSense = new CortexSenseAugmentation(this.brainy);
+        const { NeuralImportAugmentation } = await import('../augmentations/neuralImport.js');
+        const neuralSense = new NeuralImportAugmentation(this.brainy);
         await neuralSense.initialize();
         try {
             const fs = await import('fs/promises');
@@ -1694,8 +1754,8 @@ export class Cortex {
     }
     async neuralValidate(filePath) {
         await this.ensureInitialized();
-        const { CortexSenseAugmentation } = await import('../augmentations/cortexSense.js');
-        const neuralSense = new CortexSenseAugmentation(this.brainy);
+        const { NeuralImportAugmentation } = await import('../augmentations/neuralImport.js');
+        const neuralSense = new NeuralImportAugmentation(this.brainy);
         await neuralSense.initialize();
         try {
             const fs = await import('fs/promises');

package/dist/index.d.ts

@@ -19,9 +19,8 @@ export { euclideanDistance, cosineDistance, manhattanDistance, dotProductDistanc
 import { UniversalSentenceEncoder, TransformerEmbedding, createEmbeddingFunction, defaultEmbeddingFunction, batchEmbed, embeddingFunctions } from './utils/embedding.js';
 import { executeInThread, cleanupWorkerPools } from './utils/workerUtils.js';
 import { logger, LogLevel, configureLogger, createModuleLogger } from './utils/logger.js';
-import { BrainyChat, ChatOptions } from './chat/brainyChat.js';
+import { BrainyChat } from './chat/BrainyChat.js';
 export { BrainyChat };
-export type { ChatOptions };
 import { getGlobalSocketManager, AdaptiveSocketManager } from './utils/adaptiveSocketManager.js';
 import { getGlobalBackpressure, AdaptiveBackpressure } from './utils/adaptiveBackpressure.js';
 import { getGlobalPerformanceMonitor, PerformanceMonitor } from './utils/performanceMonitor.js';

package/dist/index.js

@@ -26,7 +26,7 @@ import { executeInThread, cleanupWorkerPools } from './utils/workerUtils.js';
 // Export logging utilities
 import { logger, LogLevel, configureLogger, createModuleLogger } from './utils/logger.js';
 // Export BrainyChat for conversational AI
-import { BrainyChat } from './chat/brainyChat.js';
+import { BrainyChat } from './chat/BrainyChat.js';
 export { BrainyChat };
 // Export Cortex CLI functionality - commented out for core MIT build
 // export { Cortex } from './cortex/cortex.js'

package/dist/shared/default-augmentations.d.ts

@@ -18,10 +18,10 @@ export declare class DefaultAugmentationRegistry {
      */
     initializeDefaults(): Promise<void>;
     /**
-     * Cortex - Default SENSE Augmentation
-     * AI-powered data understanding and entity extraction
+     * Neural Import - Default SENSE Augmentation
+     * AI-powered data understanding and entity extraction (always free)
      */
-    private registerCortex;
+    private registerNeuralImport;
     /**
      * Check if Cortex is available and working
      */

package/dist/shared/default-augmentations.js

@@ -18,22 +18,22 @@ export class DefaultAugmentationRegistry {
      */
     async initializeDefaults() {
         console.log('🧠⚛️ Initializing default augmentations...');
-        // Register Cortex as default SENSE augmentation
-        await this.registerCortex();
+        // Register Neural Import as default SENSE augmentation
+        await this.registerNeuralImport();
         console.log('🧠⚛️ Default augmentations initialized');
     }
     /**
-     * Cortex - Default SENSE Augmentation
-     * AI-powered data understanding and entity extraction
+     * Neural Import - Default SENSE Augmentation
+     * AI-powered data understanding and entity extraction (always free)
      */
-    async registerCortex() {
+    async registerNeuralImport() {
         try {
-            // Import the Cortex augmentation
-            const { CortexSenseAugmentation } = await import('../augmentations/cortexSense.js');
+            // Import the Neural Import augmentation
+            const { NeuralImportAugmentation } = await import('../augmentations/neuralImport.js');
             // Note: The actual registration is commented out since BrainyData doesn't have addAugmentation method yet
             // This would create instance with default configuration
             /*
-            const cortex = new CortexSenseAugmentation(this.brainy as any, {
+            const neuralImport = new NeuralImportAugmentation(this.brainy as any, {
               confidenceThreshold: 0.7,
               enableWeights: true,
               skipDuplicates: true
@@ -92,8 +92,8 @@ export class DefaultAugmentationRegistry {
               }
             }
             */
-            // Re-register
-            await this.registerCortex();
+            // Re-register (method exists on base class)
+            // await this.registerCortex()
             console.log('🧠⚛️ Cortex reinstalled successfully');
         }
         catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soulcraft/brainy",
-  "version": "0.62.3",
+  "version": "0.63.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",