@soulcraft/brainy 0.62.3 → 0.63.0

package/bin/brainy.js

@@ -76,9 +76,10 @@ program
 
 program
   .command('add [data]')
-  .description('Add data across multiple dimensions (vector, graph, facets)')
+  .description('🔒 Add data literally (safe, no AI processing)')
   .option('-m, --metadata <json>', 'Metadata facets as JSON')
   .option('-i, --id <id>', 'Custom ID')
+  .option('--smart', 'Enable AI processing (same as smart-add command)')
   .action(wrapAction(async (data, options) => {
     let metadata = {}
     if (options.metadata) {
@@ -92,7 +93,38 @@ program
     if (options.id) {
       metadata.id = options.id
     }
-    await cortex.add(data, metadata)
+    
+    // Use smart processing if --smart flag is provided
+    if (options.smart) {
+      console.log(chalk.dim('🧠 AI processing enabled'))
+      await cortex.addSmart(data, metadata)
+    } else {
+      console.log(chalk.dim('🔒 Literal storage (safe for secrets/API keys)'))
+      await cortex.add(data, metadata)
+    }
+  }))
+
+program
+  .command('smart-add [data]')
+  .description('🧠 Add data with AI processing (Neural Import, entity detection)')
+  .option('-m, --metadata <json>', 'Metadata facets as JSON')  
+  .option('-i, --id <id>', 'Custom ID')
+  .action(wrapAction(async (data, options) => {
+    let metadata = {}
+    if (options.metadata) {
+      try {
+        metadata = JSON.parse(options.metadata)
+      } catch {
+        console.error(chalk.red('Invalid JSON metadata'))
+        process.exit(1)
+      }
+    }
+    if (options.id) {
+      metadata.id = options.id
+    }
+    
+    console.log(chalk.dim('🧠 AI processing enabled (Neural Import + entity detection)'))
+    await cortex.addSmart(data, metadata)
   }))
 
 program
@@ -124,10 +156,125 @@ program
 
 program
   .command('chat [question]')
-  .description('AI-powered chat with multi-dimensional context')
-  .option('-l, --llm <model>', 'LLM model to use')
+  .description('🧠 Beautiful AI chat with local memory')
+  .option('-l, --list', 'List all chat sessions')
+  .option('-s, --search <query>', 'Search all conversations')
+  .option('-h, --history [limit]', 'Show conversation history (default: 10)')
+  .option('--session <id>', 'Use specific chat session')
+  .option('--new', 'Start a new session')
+  .option('--role <name>', 'Agent role (premium feature preview)', 'assistant')
+  .option('--ui <mode>', 'UI mode: terminal (default) or web (premium)', 'terminal')
   .action(wrapInteractive(async (question, options) => {
-    await cortex.chat(question)
+    const { BrainyData } = await import('../dist/brainyData.js')
+    
+    const brainy = new BrainyData()
+    await brainy.init()
+    
+    // Handle web UI mode (premium feature)
+    if (options.ui === 'web') {
+      console.log(chalk.cyan('🌐 Starting Brain Cloud Coordination Interface...'))
+      console.log()
+      
+      try {
+        // Check if Brain Cloud is available
+        const hasLicense = process.env.BRAINY_LICENSE_KEY || await checkBrainCloudAuth()
+        
+        if (!hasLicense) {
+          console.log(chalk.yellow('🔐 Brain Cloud Authentication Required'))
+          console.log('The web coordination UI requires Brain Cloud authentication.')
+          console.log()
+          console.log('Get started:')
+          console.log('  1. ' + chalk.green('brainy cloud auth') + ' - Authenticate with Brain Cloud')
+          console.log('  2. ' + chalk.cyan('https://app.soulcraft.com') + ' - Sign up for Brain Cloud')
+          console.log()
+          console.log('Falling back to terminal chat...')
+          console.log()
+          options.ui = 'terminal'
+        } else {
+          // Import and start coordination server
+          const { createCoordinationServer } = await import('@soulcraft/brain-cloud/coordination/server.js')
+          
+          const server = createCoordinationServer({
+            brainy,
+            port: 3001
+          })
+          
+          await server.start()
+          
+          console.log(chalk.green('✅ Brain Cloud coordination interface started!'))
+          console.log()
+          console.log('🤝 Multi-agent coordination available at:')
+          console.log('   ' + chalk.cyan('http://localhost:3001/coordination'))
+          console.log()
+          console.log('💡 Features available:')
+          console.log('   • Visual agent coordination')
+          console.log('   • Real-time multi-agent handoffs')
+          console.log('   • Session management')
+          console.log('   • Premium Brain Cloud integration')
+          console.log()
+          
+          // Try to open browser
+          try {
+            const { exec } = await import('child_process')
+            const { promisify } = await import('util')
+            const execAsync = promisify(exec)
+            
+            const command = process.platform === 'win32' ? 'start' : 
+                           process.platform === 'darwin' ? 'open' : 'xdg-open'
+            
+            await execAsync(`${command} "http://localhost:3001/coordination"`)
+            console.log(chalk.green('🌐 Opening coordination interface in your browser...'))
+          } catch (error) {
+            console.log(chalk.yellow('💡 Copy the URL above to open in your browser'))
+          }
+          
+          console.log()
+          console.log(chalk.dim('Press Ctrl+C to stop the server'))
+          
+          // Keep server running
+          process.on('SIGINT', async () => {
+            console.log('\n🛑 Stopping coordination server...')
+            await server.stop()
+            process.exit(0)
+          })
+          
+          // Wait indefinitely
+          return new Promise(() => {})
+        }
+      } catch (error) {
+        console.log(chalk.red('❌ Failed to start web coordination interface:'), error.message)
+        console.log(chalk.yellow('Falling back to terminal chat...'))
+        console.log()
+        options.ui = 'terminal'
+      }
+    }
+    
+    // Terminal chat mode (default)
+    const { ChatCLI } = await import('../dist/chat/ChatCLI.js')
+    const chatCLI = new ChatCLI(brainy)
+    
+    // Handle different modes
+    if (options.list) {
+      await chatCLI.listSessions()
+    } else if (options.search) {
+      await chatCLI.searchConversations(options.search)
+    } else if (options.history) {
+      const limit = typeof options.history === 'string' ? parseInt(options.history) : 10
+      await chatCLI.showHistory(limit)
+    } else if (question) {
+      // Single message mode
+      await chatCLI.sendMessage(question, {
+        sessionId: options.session,
+        speaker: options.role
+      })
+    } else {
+      // Interactive chat mode
+      await chatCLI.startInteractiveChat({
+        sessionId: options.session,
+        speaker: options.role,
+        newSession: options.new
+      })
+    }
   }))
 
 program
@@ -176,6 +323,8 @@ program
     await cortex.restore(file)
   }))
 
+// Chat commands moved to main chat command above
+
 // ========================================
 // BRAIN CLOUD INTEGRATION
 // ========================================
@@ -857,6 +1006,99 @@ program
     await cortex.chat()
   }))
 
+// ========================================
+// AUGMENTATION CONTROL COMMANDS
+// ========================================
+
+program
+  .command('augment')
+  .description('List all augmentations with their status')
+  .action(wrapAction(async () => {
+    const { BrainyData } = await import('../dist/brainyData.js')
+    const brainy = new BrainyData()
+    await brainy.init()
+    
+    const augmentations = brainy.listAugmentations()
+    
+    if (augmentations.length === 0) {
+      console.log(chalk.yellow('No augmentations registered'))
+      return
+    }
+    
+    console.log(chalk.cyan('🔧 Augmentations Status\n'))
+    
+    const grouped = augmentations.reduce((acc, aug) => {
+      if (!acc[aug.type]) acc[aug.type] = []
+      acc[aug.type].push(aug)
+      return acc
+    }, {})
+    
+    for (const [type, augs] of Object.entries(grouped)) {
+      console.log(chalk.bold(`${type.toUpperCase()}:`))
+      for (const aug of augs) {
+        const status = aug.enabled ? chalk.green('✅ enabled') : chalk.red('❌ disabled')
+        console.log(`  ${aug.name} - ${status}`)
+        console.log(chalk.dim(`    ${aug.description}`))
+      }
+      console.log('')
+    }
+  }))
+
+program
+  .command('augment enable <name>')
+  .description('Enable an augmentation by name')
+  .action(wrapAction(async (name) => {
+    const { BrainyData } = await import('../dist/brainyData.js')
+    const brainy = new BrainyData()
+    await brainy.init()
+    
+    const success = brainy.enableAugmentation(name)
+    
+    if (success) {
+      console.log(chalk.green(`✅ Enabled augmentation: ${name}`))
+    } else {
+      console.log(chalk.red(`❌ Augmentation not found: ${name}`))
+      console.log(chalk.dim('Use "brainy augment" to see available augmentations'))
+    }
+  }))
+
+program
+  .command('augment disable <name>')
+  .description('Disable an augmentation by name')
+  .action(wrapAction(async (name) => {
+    const { BrainyData } = await import('../dist/brainyData.js')
+    const brainy = new BrainyData()
+    await brainy.init()
+    
+    const success = brainy.disableAugmentation(name)
+    
+    if (success) {
+      console.log(chalk.green(`✅ Disabled augmentation: ${name}`))
+    } else {
+      console.log(chalk.red(`❌ Augmentation not found: ${name}`))
+      console.log(chalk.dim('Use "brainy augment" to see available augmentations'))
+    }
+  }))
+
+program
+  .command('augment status <name>')
+  .description('Check if an augmentation is enabled')
+  .action(wrapAction(async (name) => {
+    const { BrainyData } = await import('../dist/brainyData.js')
+    const brainy = new BrainyData()
+    await brainy.init()
+    
+    const enabled = brainy.isAugmentationEnabled(name)
+    
+    if (enabled !== undefined) {
+      const status = enabled ? chalk.green('✅ enabled') : chalk.red('❌ disabled')
+      console.log(`${name}: ${status}`)
+    } else {
+      console.log(chalk.red(`❌ Augmentation not found: ${name}`))
+      console.log(chalk.dim('Use "brainy augment" to see available augmentations'))
+    }
+  }))
+
 // ========================================
 // PARSE AND HANDLE
 // ========================================
@@ -872,7 +1114,15 @@ if (!process.argv.slice(2).length) {
   console.log('  brainy init                    # Initialize project')
   console.log('  brainy add "some data"         # Add multi-dimensional data')
   console.log('  brainy search "query"          # Search across all dimensions')
-  console.log('  brainy chat                    # AI chat with full context')
+  console.log('  brainy chat                    # 🧠 Magical AI chat with perfect memory')
+  console.log('')
+  console.log(chalk.bold('Chat & Memory:'))
+  console.log('  brainy chat                    # Interactive chat with local memory')
+  console.log('  brainy chat "question"         # Single question with context')
+  console.log('  brainy chat --list             # List all chat sessions')
+  console.log('  brainy chat --search "query"   # Search all conversations')
+  console.log('  brainy chat --history          # Show conversation history')
+  console.log('  brainy chat --ui=web           # 🌐 Premium web coordination interface')
   console.log('')
   console.log(chalk.bold('Brain Cloud (Premium):'))
   console.log(chalk.green('  brainy cloud setup             # Auto-setup with provisioning'))
@@ -892,6 +1142,26 @@ if (!process.argv.slice(2).length) {
 // BRAIN CLOUD MEMORY SETUP FUNCTIONS
 // ========================================
 
+async function checkBrainCloudAuth() {
+  try {
+    // Check for license file
+    const { readFile } = await import('fs/promises')
+    const { join } = await import('path')
+    const { homedir } = await import('os')
+    
+    try {
+      const licensePath = join(homedir(), '.brainy', 'license')
+      const license = await readFile(licensePath, 'utf8')
+      return license.trim().startsWith('lic_')
+    } catch {}
+    
+    // Check for existing customer ID
+    return await detectCustomerId() !== null
+  } catch {
+    return false
+  }
+}
+
 async function detectCustomerId() {
   try {
     // Method 1: Check for existing brainy config

package/dist/augmentationPipeline.d.ts

@@ -10,6 +10,19 @@
  * @deprecated AugmentationPipeline - Use Cortex instead
  */
 import { BrainyAugmentations, IAugmentation, IWebSocketSupport, AugmentationResponse, AugmentationType } from './types/augmentations.js';
+/**
+ * Type definitions for the augmentation registry
+ */
+type AugmentationRegistry = {
+    sense: BrainyAugmentations.ISenseAugmentation[];
+    conduit: BrainyAugmentations.IConduitAugmentation[];
+    cognition: BrainyAugmentations.ICognitionAugmentation[];
+    memory: BrainyAugmentations.IMemoryAugmentation[];
+    perception: BrainyAugmentations.IPerceptionAugmentation[];
+    dialog: BrainyAugmentations.IDialogAugmentation[];
+    activation: BrainyAugmentations.IActivationAugmentation[];
+    webSocket: IWebSocketSupport[];
+};
 /**
  * Execution mode for the pipeline
  */
@@ -205,7 +218,54 @@ export declare class Cortex {
      * @returns A promise that resolves with the results from all augmentations
      */
     private executeTypedPipeline;
+    /**
+     * Enable an augmentation by name
+     *
+     * @param name The name of the augmentation to enable
+     * @returns True if augmentation was found and enabled
+     */
+    enableAugmentation(name: string): boolean;
+    /**
+     * Disable an augmentation by name
+     *
+     * @param name The name of the augmentation to disable
+     * @returns True if augmentation was found and disabled
+     */
+    disableAugmentation(name: string): boolean;
+    /**
+     * Check if an augmentation is enabled
+     *
+     * @param name The name of the augmentation to check
+     * @returns True if augmentation is found and enabled, false otherwise
+     */
+    isAugmentationEnabled(name: string): boolean;
+    /**
+     * Get all augmentations with their enabled status
+     *
+     * @returns Array of augmentations with name, type, and enabled status
+     */
+    listAugmentationsWithStatus(): Array<{
+        name: string;
+        type: keyof AugmentationRegistry;
+        enabled: boolean;
+        description: string;
+    }>;
+    /**
+     * Enable all augmentations of a specific type
+     *
+     * @param type The type of augmentations to enable
+     * @returns Number of augmentations enabled
+     */
+    enableAugmentationType(type: keyof AugmentationRegistry): number;
+    /**
+     * Disable all augmentations of a specific type
+     *
+     * @param type The type of augmentations to disable
+     * @returns Number of augmentations disabled
+     */
+    disableAugmentationType(type: keyof AugmentationRegistry): number;
 }
 export declare const cortex: Cortex;
 export declare const AugmentationPipeline: typeof Cortex;
 export declare const augmentationPipeline: Cortex;
+export {};

package/dist/augmentationPipeline.js

@@ -471,6 +471,100 @@ export class Cortex {
                 return results;
         }
     }
+    /**
+     * Enable an augmentation by name
+     *
+     * @param name The name of the augmentation to enable
+     * @returns True if augmentation was found and enabled
+     */
+    enableAugmentation(name) {
+        for (const type of Object.keys(this.registry)) {
+            const augmentation = this.registry[type].find(aug => aug.name === name);
+            if (augmentation) {
+                augmentation.enabled = true;
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Disable an augmentation by name
+     *
+     * @param name The name of the augmentation to disable
+     * @returns True if augmentation was found and disabled
+     */
+    disableAugmentation(name) {
+        for (const type of Object.keys(this.registry)) {
+            const augmentation = this.registry[type].find(aug => aug.name === name);
+            if (augmentation) {
+                augmentation.enabled = false;
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if an augmentation is enabled
+     *
+     * @param name The name of the augmentation to check
+     * @returns True if augmentation is found and enabled, false otherwise
+     */
+    isAugmentationEnabled(name) {
+        for (const type of Object.keys(this.registry)) {
+            const augmentation = this.registry[type].find(aug => aug.name === name);
+            if (augmentation) {
+                return augmentation.enabled;
+            }
+        }
+        return false;
+    }
+    /**
+     * Get all augmentations with their enabled status
+     *
+     * @returns Array of augmentations with name, type, and enabled status
+     */
+    listAugmentationsWithStatus() {
+        const result = [];
+        for (const [type, augmentations] of Object.entries(this.registry)) {
+            for (const aug of augmentations) {
+                result.push({
+                    name: aug.name,
+                    type: type,
+                    enabled: aug.enabled,
+                    description: aug.description
+                });
+            }
+        }
+        return result;
+    }
+    /**
+     * Enable all augmentations of a specific type
+     *
+     * @param type The type of augmentations to enable
+     * @returns Number of augmentations enabled
+     */
+    enableAugmentationType(type) {
+        let count = 0;
+        for (const aug of this.registry[type]) {
+            aug.enabled = true;
+            count++;
+        }
+        return count;
+    }
+    /**
+     * Disable all augmentations of a specific type
+     *
+     * @param type The type of augmentations to disable
+     * @returns Number of augmentations disabled
+     */
+    disableAugmentationType(type) {
+        let count = 0;
+        for (const aug of this.registry[type]) {
+            aug.enabled = false;
+            count++;
+        }
+        return count;
+    }
 }
 // Create and export a default instance of the cortex
 export const cortex = new Cortex();

package/dist/augmentations/neuralImport.d.ts

@@ -0,0 +1,199 @@
+/**
+ * Neural Import Augmentation - AI-Powered Data Understanding
+ *
+ * 🧠 Built-in AI augmentation for intelligent data processing
+ * ⚛️ Always free, always included, always enabled
+ *
+ * This is the default AI-powered augmentation that comes with every Brainy installation.
+ * It provides intelligent data understanding, entity detection, and relationship analysis.
+ */
+import { ISenseAugmentation, AugmentationResponse } from '../types/augmentations.js';
+import { BrainyData } from '../brainyData.js';
+export interface NeuralAnalysisResult {
+    detectedEntities: DetectedEntity[];
+    detectedRelationships: DetectedRelationship[];
+    confidence: number;
+    insights: NeuralInsight[];
+}
+export interface DetectedEntity {
+    originalData: any;
+    nounType: string;
+    confidence: number;
+    suggestedId: string;
+    reasoning: string;
+    alternativeTypes: Array<{
+        type: string;
+        confidence: number;
+    }>;
+}
+export interface DetectedRelationship {
+    sourceId: string;
+    targetId: string;
+    verbType: string;
+    confidence: number;
+    weight: number;
+    reasoning: string;
+    context: string;
+    metadata?: Record<string, any>;
+}
+export interface NeuralInsight {
+    type: 'hierarchy' | 'cluster' | 'pattern' | 'anomaly' | 'opportunity';
+    description: string;
+    confidence: number;
+    affectedEntities: string[];
+    recommendation?: string;
+}
+export interface NeuralImportConfig {
+    confidenceThreshold: number;
+    enableWeights: boolean;
+    skipDuplicates: boolean;
+    categoryFilter?: string[];
+}
+/**
+ * Neural Import SENSE Augmentation - The Brain's Perceptual System
+ */
+export declare class NeuralImportAugmentation implements ISenseAugmentation {
+    readonly name: string;
+    readonly description: string;
+    enabled: boolean;
+    private brainy;
+    private config;
+    constructor(brainy: BrainyData, config?: Partial<NeuralImportConfig>);
+    initialize(): Promise<void>;
+    shutDown(): Promise<void>;
+    getStatus(): Promise<'active' | 'inactive' | 'error'>;
+    /**
+     * Process raw data into structured nouns and verbs using neural analysis
+     */
+    processRawData(rawData: Buffer | string, dataType: string, options?: Record<string, unknown>): Promise<AugmentationResponse<{
+        nouns: string[];
+        verbs: string[];
+        confidence?: number;
+        insights?: Array<{
+            type: string;
+            description: string;
+            confidence: number;
+        }>;
+        metadata?: Record<string, unknown>;
+    }>>;
+    /**
+     * Listen to real-time data feeds and process them
+     */
+    listenToFeed(feedUrl: string, callback: (data: {
+        nouns: string[];
+        verbs: string[];
+        confidence?: number;
+    }) => void): Promise<void>;
+    /**
+     * Analyze data structure without processing (preview mode)
+     */
+    analyzeStructure(rawData: Buffer | string, dataType: string, options?: Record<string, unknown>): Promise<AugmentationResponse<{
+        entityTypes: Array<{
+            type: string;
+            count: number;
+            confidence: number;
+        }>;
+        relationshipTypes: Array<{
+            type: string;
+            count: number;
+            confidence: number;
+        }>;
+        dataQuality: {
+            completeness: number;
+            consistency: number;
+            accuracy: number;
+        };
+        recommendations: string[];
+    }>>;
+    /**
+     * Validate data compatibility with current knowledge base
+     */
+    validateCompatibility(rawData: Buffer | string, dataType: string): Promise<AugmentationResponse<{
+        compatible: boolean;
+        issues: Array<{
+            type: string;
+            description: string;
+            severity: 'low' | 'medium' | 'high';
+        }>;
+        suggestions: string[];
+    }>>;
+    /**
+     * Get the full neural analysis result (custom method for Cortex integration)
+     */
+    getNeuralAnalysis(rawData: Buffer | string, dataType: string): Promise<NeuralAnalysisResult>;
+    /**
+     * Parse raw data based on type
+     */
+    private parseRawData;
+    /**
+     * Basic CSV parser
+     */
+    private parseCSV;
+    /**
+     * Perform neural analysis on parsed data
+     */
+    private performNeuralAnalysis;
+    /**
+     * Neural Entity Detection - The Core AI Engine
+     */
+    private detectEntitiesWithNeuralAnalysis;
+    /**
+     * Calculate entity type confidence using AI
+     */
+    private calculateEntityTypeConfidence;
+    /**
+     * Field-based confidence calculation
+     */
+    private calculateFieldBasedConfidence;
+    /**
+     * Pattern-based confidence calculation
+     */
+    private calculatePatternBasedConfidence;
+    /**
+     * Generate reasoning for entity type selection
+     */
+    private generateEntityReasoning;
+    /**
+     * Neural Relationship Detection
+     */
+    private detectRelationshipsWithNeuralAnalysis;
+    /**
+     * Calculate relationship confidence
+     */
+    private calculateRelationshipConfidence;
+    /**
+     * Calculate relationship weight/strength
+     */
+    private calculateRelationshipWeight;
+    /**
+     * Generate Neural Insights - The Intelligence Layer
+     */
+    private generateNeuralInsights;
+    /**
+     * Helper methods for the neural system
+     */
+    private extractMainText;
+    private generateSmartId;
+    private extractRelationshipContext;
+    private calculateTypeCompatibility;
+    private getVerbSpecificity;
+    private getRelevantFields;
+    private getMatchedPatterns;
+    private pruneRelationships;
+    private detectHierarchies;
+    private detectClusters;
+    private detectPatterns;
+    private calculateOverallConfidence;
+    private storeNeuralAnalysis;
+    private getDataTypeFromPath;
+    private generateRelationshipReasoning;
+    private extractRelationshipMetadata;
+    /**
+     * Assess data quality metrics
+     */
+    private assessDataQuality;
+    /**
+     * Generate recommendations based on analysis
+     */
+    private generateRecommendations;
+}