@soulcraft/brainy 1.5.0 → 2.0.1

package/bin/brainy.js

@@ -78,7 +78,8 @@ async function generateAIResponse(message, brainy, options) {
   const model = options.model || 'local'
   
   // Get relevant context from user's data
-  const contextResults = await brainy.search(message, 5, {
+  const contextResults = await brainy.search(message, {
+    limit: 5,
     includeContent: true,
     scoreThreshold: 0.3
   })
@@ -215,6 +216,17 @@ program
   .name('brainy')
   .description('🧠⚛️ Brainy - Your AI-Powered Second Brain')
   .version(packageJson.version)
+  .option('-i, --interactive', 'Start interactive mode')
+  .addHelpText('after', `
+${colors.dim('Examples:')}
+  ${colors.success('brainy add "Meeting notes from today"')}
+  ${colors.success('brainy search "project deadline"')}
+  ${colors.success('brainy chat')} ${colors.dim('# Interactive AI chat')}
+  ${colors.success('brainy -i')} ${colors.dim('# Interactive mode')}
+
+${colors.dim('For more help:')}
+  ${colors.info('brainy <command> --help')} ${colors.dim('# Command-specific help')}
+  ${colors.info('https://github.com/TimeSoul/brainy')} ${colors.dim('# Documentation')}`)
 
 // ========================================
 // THE 5 COMMANDS (ONE WAY TO DO EVERYTHING)
@@ -340,10 +352,8 @@ program
       metadata.encrypted = true
     }
     
-    await brainyInstance.add(processedData, metadata, { 
-      process: options.literal ? 'literal' : 'auto'
-    })
-    console.log(colors.success('✅ Added successfully!'))
+    const id = await brainyInstance.addNoun(processedData, metadata)
+    console.log(colors.success(`✅ Added successfully! ID: ${id}`))
   }))
 
 // Command 2: CHAT - Talk to your data with AI
@@ -499,31 +509,189 @@ program
 
 // Command 3: IMPORT - Bulk/external data
 program
-  .command('import <source>')
+  .command('import [source]')
   .description('Import bulk data from files, URLs, or streams')
   .option('-t, --type <type>', 'Source type (file, url, stream)')
   .option('-c, --chunk-size <size>', 'Chunk size for large imports', '1000')
   .action(wrapAction(async (source, options) => {
+    
+    // Interactive mode if no source provided
+    if (!source) {
+      console.log(colors.primary('📥 Interactive Import Mode'))
+      console.log(colors.dim('Import data from various sources\n'))
+      
+      const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout
+      })
+      
+      // Ask for source type first
+      console.log(colors.cyan('Source types:'))
+      console.log(colors.info('  1. Local file'))
+      console.log(colors.info('  2. URL'))
+      console.log(colors.info('  3. Direct input'))
+      console.log()
+      
+      const sourceType = await new Promise(resolve => {
+        rl.question(colors.cyan('Select source type (1-3): '), (answer) => {
+          resolve(answer)
+        })
+      })
+      
+      if (sourceType === '3') {
+        // Direct input mode
+        console.log(colors.info('\nEnter your data (type END on a new line when done):\n'))
+        let data = ''
+        let line = ''
+        
+        while ((line = await new Promise(resolve => {
+          rl.question('', resolve)
+        })) !== 'END') {
+          data += line + '\n'
+        }
+        
+        rl.close()
+        
+        // Save to temp file
+        const fs = require('fs')
+        source = `/tmp/brainy-import-${Date.now()}.json`
+        fs.writeFileSync(source, data.trim())
+        console.log(colors.info(`\nSaved to temporary file: ${source}`))
+      } else {
+        // File or URL
+        source = await new Promise(resolve => {
+          const prompt = sourceType === '2' ? 'Enter URL: ' : 'Enter file path: '
+          rl.question(colors.cyan(prompt), (answer) => {
+            rl.close()
+            resolve(answer)
+          })
+        })
+        
+        if (!source.trim()) {
+          console.log(colors.warning('No source provided'))
+          process.exit(1)
+        }
+      }
+    }
     console.log(colors.info('📥 Starting neural import...'))
     console.log(colors.info(`Source: ${source}`))
     
-    // Use the unified import system from the cleanup plan
-    const { NeuralImport } = await import('../dist/cortex/neuralImport.js')
-    const importer = new NeuralImport()
+    // Read and prepare data for import
+    const fs = require('fs')
+    let data
     
-    const result = await importer.import(source, {
-      chunkSize: parseInt(options.chunkSize)
+    try {
+      if (source.startsWith('http')) {
+        // Handle URL import
+        const response = await fetch(source)
+        data = await response.text()
+      } else {
+        // Handle file import
+        data = fs.readFileSync(source, 'utf8')
+      }
+      
+      // Parse data if JSON
+      try {
+        data = JSON.parse(data)
+      } catch {
+        // Keep as string if not JSON
+      }
+    } catch (error) {
+      console.log(colors.error(`Failed to read source: ${error.message}`))
+      process.exit(1)
+    }
+    
+    const brainyInstance = await getBrainy()
+    const result = await brainyInstance.import(data, {
+      batchSize: parseInt(options.chunkSize) || 50
     })
     
-    console.log(colors.success(`✅ Imported ${result.count} items`))
-    if (result.detectedTypes) {
-      console.log(colors.info('🔍 Detected types:'), result.detectedTypes)
+    console.log(colors.success(`✅ Imported ${result.length} items`))
+  }))
+
+// Command 3: FIND - Intelligent search using Triple Intelligence
+program
+  .command('find [query]')
+  .description('Intelligent search using natural language and structured queries')
+  .option('-l, --limit <number>', 'Results limit', '10')
+  .option('-m, --mode <mode>', 'Search mode (auto, semantic, structured)', 'auto')
+  .option('--like <term>', 'Vector similarity search term')
+  .option('--where <json>', 'Metadata filters as JSON')
+  .action(wrapAction(async (query, options) => {
+    
+    if (!query && !options.like) {
+      console.log(colors.primary('🧠 Intelligent Find Mode'))
+      console.log(colors.dim('Use natural language or structured queries\n'))
+      
+      const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout
+      })
+      
+      query = await new Promise(resolve => {
+        rl.question(colors.cyan('What would you like to find? '), (answer) => {
+          rl.close()
+          resolve(answer)
+        })
+      })
+      
+      if (!query.trim()) {
+        console.log(colors.warning('No query provided'))
+        process.exit(1)
+      }
+    }
+    
+    console.log(colors.info(`🧠 Finding: "${query || options.like}"`))
+    
+    const brainyInstance = await getBrainy()
+    
+    // Build query object for find() API
+    let findQuery = query
+    
+    // Handle structured queries
+    if (options.like || options.where) {
+      findQuery = {}
+      if (options.like) findQuery.like = options.like
+      if (options.where) {
+        try {
+          findQuery.where = JSON.parse(options.where)
+        } catch {
+          console.error(colors.error('Invalid JSON in --where option'))
+          process.exit(1)
+        }
+      }
+    }
+    
+    const findOptions = {
+      limit: parseInt(options.limit),
+      mode: options.mode
+    }
+    
+    const results = await brainyInstance.find(findQuery, findOptions)
+    
+    if (results.length === 0) {
+      console.log(colors.warning('No results found'))
+      return
     }
+    
+    console.log(colors.success(`✅ Found ${results.length} intelligent results:`))
+    results.forEach((result, i) => {
+      console.log(colors.primary(`\n${i + 1}. ${result.content || result.id}`))
+      if (result.score) {
+        console.log(colors.info(`   Relevance: ${(result.score * 100).toFixed(1)}%`))
+      }
+      if (result.fusionScore) {
+        console.log(colors.info(`   AI Score: ${(result.fusionScore * 100).toFixed(1)}%`))
+      }
+      if (result.metadata && Object.keys(result.metadata).length > 0) {
+        console.log(colors.dim(`   Metadata: ${JSON.stringify(result.metadata)}`))
+      }
+    })
   }))
 
-// Command 3: SEARCH - Triple-power search  
+// Command 4: SEARCH - Triple-power search  
 program
-  .command('search <query>')
+  .command('search [query]')
   .description('Search your brain (vector + graph + facets)')
   .option('-l, --limit <number>', 'Results limit', '10')
   .option('-f, --filter <json>', 'Metadata filters (see "brainy fields" for available fields)')
@@ -531,6 +699,29 @@ program
   .option('--fields', 'Show available filter fields and exit')
   .action(wrapAction(async (query, options) => {
     
+    // Interactive mode if no query provided
+    if (!query) {
+      console.log(colors.primary('🔍 Interactive Search Mode'))
+      console.log(colors.dim('Search your neural database with natural language\n'))
+      
+      const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout
+      })
+      
+      query = await new Promise(resolve => {
+        rl.question(colors.cyan('What would you like to search for? '), (answer) => {
+          rl.close()
+          resolve(answer)
+        })
+      })
+      
+      if (!query.trim()) {
+        console.log(colors.warning('No search query provided'))
+        process.exit(1)
+      }
+    }
+    
     // Handle --fields option
     if (options.fields) {
       console.log(colors.primary('🔍 Available Filter Fields'))
@@ -578,7 +769,7 @@ program
     }
     
     const brainyInstance = await getBrainy()
-    const results = await brainyInstance.search(query, searchOptions.limit || 10, searchOptions)
+    const results = await brainyInstance.search(query, searchOptions)
     
     if (results.length === 0) {
       console.log(colors.warning('No results found'))
@@ -597,9 +788,74 @@ program
     })
   }))
 
-// Command 4: UPDATE - Update existing data
+// Command 4: GET - Retrieve specific data by ID
 program
-  .command('update <id>')
+  .command('get [id]')
+  .description('Get a specific item by ID')
+  .option('-f, --format <format>', 'Output format (json, table, plain)', 'plain')
+  .action(wrapAction(async (id, options) => {
+    if (!id) {
+      console.log(colors.primary('🔍 Interactive Get Mode'))
+      console.log(colors.dim('Retrieve a specific item by ID\n'))
+      
+      const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout
+      })
+      
+      id = await new Promise(resolve => {
+        rl.question(colors.cyan('Enter item ID: '), (answer) => {
+          rl.close()
+          resolve(answer)
+        })
+      })
+      
+      if (!id.trim()) {
+        console.log(colors.warning('No ID provided'))
+        process.exit(1)
+      }
+    }
+    
+    console.log(colors.info(`🔍 Getting item: "${id}"`))
+    
+    const brainyInstance = await getBrainy()
+    const item = await brainyInstance.getNoun(id)
+    
+    if (!item) {
+      console.log(colors.warning('Item not found'))
+      return
+    }
+    
+    if (options.format === 'json') {
+      console.log(JSON.stringify(item, null, 2))
+    } else if (options.format === 'table') {
+      const table = new Table({
+        head: [colors.brain('Property'), colors.brain('Value')],
+        style: { head: [], border: [] }
+      })
+      
+      table.push(['ID', colors.primary(item.id)])
+      table.push(['Content', colors.info(item.content || 'N/A')])
+      if (item.metadata) {
+        Object.entries(item.metadata).forEach(([key, value]) => {
+          table.push([key, colors.dim(JSON.stringify(value))])
+        })
+      }
+      console.log(table.toString())
+    } else {
+      console.log(colors.primary(`ID: ${item.id}`))
+      if (item.content) {
+        console.log(colors.info(`Content: ${item.content}`))
+      }
+      if (item.metadata && Object.keys(item.metadata).length > 0) {
+        console.log(colors.info(`Metadata: ${JSON.stringify(item.metadata, null, 2)}`))
+      }
+    }
+  }))
+
+// Command 5: UPDATE - Update existing data
+program
+  .command('update [id]')
   .description('Update existing data with new content or metadata')
   .option('-d, --data <data>', 'New data content')
   .option('-m, --metadata <json>', 'New metadata as JSON')
@@ -607,6 +863,41 @@ program
   .option('--no-reindex', 'Skip reindexing (faster but less accurate search)')
   .option('--cascade', 'Update related verbs')
   .action(wrapAction(async (id, options) => {
+    
+    // Interactive mode if no ID provided
+    if (!id) {
+      console.log(colors.primary('🔄 Interactive Update Mode'))
+      console.log(colors.dim('Select an item to update\n'))
+      
+      // Show recent items
+      const brainyInstance = await getBrainy()
+      const recent = await brainyInstance.search('*', { limit: 10, sortBy: 'timestamp' })
+      
+      if (recent.length > 0) {
+        console.log(colors.cyan('Recent items:'))
+        recent.forEach((item, i) => {
+          console.log(colors.info(`  ${i + 1}. ${item.id} - ${item.content?.substring(0, 50)}...`))
+        })
+        console.log()
+      }
+      
+      const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout
+      })
+      
+      id = await new Promise(resolve => {
+        rl.question(colors.cyan('Enter ID to update: '), (answer) => {
+          rl.close()
+          resolve(answer)
+        })
+      })
+      
+      if (!id.trim()) {
+        console.log(colors.warning('No ID provided'))
+        process.exit(1)
+      }
+    }
     console.log(colors.info(`🔄 Updating: "${id}"`))
     
     if (!options.data && !options.metadata) {
@@ -626,7 +917,7 @@ program
     
     const brainyInstance = await getBrainy()
     
-    const success = await brainyInstance.update(id, options.data, metadata, {
+    const success = await brainyInstance.updateNoun(id, options.data, metadata, {
       merge: options.merge !== false, // Default true unless --no-merge
       reindex: options.reindex !== false, // Default true unless --no-reindex  
       cascade: options.cascade || false
@@ -644,12 +935,66 @@ program
 
 // Command 5: DELETE - Remove data (soft delete by default)
 program
-  .command('delete <id>')
+  .command('delete [id]')
   .description('Delete data (soft delete by default, preserves indexes)')
   .option('--hard', 'Permanent deletion (removes from indexes)')
   .option('--cascade', 'Delete related verbs')
   .option('--force', 'Force delete even if has relationships')
   .action(wrapAction(async (id, options) => {
+    
+    // Interactive mode if no ID provided
+    if (!id) {
+      console.log(colors.warning('🗑️ Interactive Delete Mode'))
+      console.log(colors.dim('Select an item to delete\n'))
+      
+      // Show recent items for selection
+      const brainyInstance = await getBrainy()
+      const recent = await brainyInstance.search('*', { limit: 10, sortBy: 'timestamp' })
+      
+      if (recent.length > 0) {
+        console.log(colors.cyan('Recent items:'))
+        recent.forEach((item, i) => {
+          console.log(colors.info(`  ${i + 1}. ${item.id} - ${item.content?.substring(0, 50)}...`))
+        })
+        console.log()
+      }
+      
+      const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout
+      })
+      
+      id = await new Promise(resolve => {
+        rl.question(colors.warning('Enter ID to delete (or "cancel"): '), (answer) => {
+          rl.close()
+          resolve(answer)
+        })
+      })
+      
+      if (!id.trim() || id.toLowerCase() === 'cancel') {
+        console.log(colors.info('Delete cancelled'))
+        process.exit(0)
+      }
+      
+      // Confirm deletion in interactive mode
+      const confirmRl = createInterface({
+        input: process.stdin,
+        output: process.stdout
+      })
+      
+      const confirm = await new Promise(resolve => {
+        const deleteType = options.hard ? 'permanently delete' : 'soft delete'
+        confirmRl.question(colors.warning(`Are you sure you want to ${deleteType} "${id}"? (yes/no): `), (answer) => {
+          confirmRl.close()
+          resolve(answer.toLowerCase() === 'yes' || answer.toLowerCase() === 'y')
+        })
+      })
+      
+      if (!confirm) {
+        console.log(colors.info('Delete cancelled'))
+        process.exit(0)
+      }
+    }
     console.log(colors.info(`🗑️  Deleting: "${id}"`))
     
     if (options.hard) {
@@ -661,7 +1006,7 @@ program
     const brainyInstance = await getBrainy()
     
     try {
-      const success = await brainyInstance.delete(id, {
+      const success = await brainyInstance.deleteNoun(id, {
         soft: !options.hard, // Soft delete unless --hard specified
         cascade: options.cascade || false,
         force: options.force || false
@@ -685,12 +1030,57 @@ program
 
 // Command 6A: ADD-NOUN - Create typed entities (Method #4)
 program
-  .command('add-noun <name>')
+  .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) => {
+    
+    // Interactive mode if no name provided
+    if (!name) {
+      console.log(colors.primary('👤 Interactive Entity Creation'))
+      console.log(colors.dim('Create a typed entity in your knowledge graph\n'))
+      
+      const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout
+      })
+      
+      name = await new Promise(resolve => {
+        rl.question(colors.cyan('Enter entity name: '), (answer) => {
+          resolve(answer)
+        })
+      })
+      
+      if (!name.trim()) {
+        rl.close()
+        console.log(colors.warning('No name provided'))
+        process.exit(1)
+      }
+      
+      // Interactive type selection if not provided
+      if (!options.type || options.type === 'Concept') {
+        console.log(colors.cyan('\nSelect entity type:'))
+        const types = ['Person', 'Organization', 'Project', 'Event', 'Concept', 'Location', 'Product']
+        types.forEach((t, i) => {
+          console.log(colors.info(`  ${i + 1}. ${t}`))
+        })
+        console.log()
+        
+        const typeIndex = await new Promise(resolve => {
+          rl.question(colors.cyan('Select type (1-7): '), (answer) => {
+            resolve(parseInt(answer) - 1)
+          })
+        })
+        
+        if (typeIndex >= 0 && typeIndex < types.length) {
+          options.type = types[typeIndex]
+        }
+      }
+      
+      rl.close()
+    }
     const brainy = await getBrainy()
     
     // Validate noun type
@@ -716,8 +1106,9 @@ program
     }
     
     try {
-      const { NounType } = await import('../dist/types/graphTypes.js')
-      const id = await brainy.addNoun(name, NounType[options.type], metadata)
+      // In 2.0 API, addNoun takes (data, metadata) - type goes in metadata
+      metadata.type = options.type
+      const id = await brainy.addNoun(name, metadata)
       
       console.log(colors.success('✅ Noun added successfully!'))
       console.log(colors.info(`🆔 ID: ${id}`))
@@ -735,12 +1126,103 @@ program
 
 // Command 6B: ADD-VERB - Create relationships (Method #5)
 program
-  .command('add-verb <source> <target>')
+  .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) => {
+    
+    // Interactive mode if parameters missing
+    if (!source || !target) {
+      console.log(colors.primary('🔗 Interactive Relationship Builder'))
+      console.log(colors.dim('Connect two entities with a semantic relationship\n'))
+      
+      const brainyInstance = await getBrainy()
+      const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout
+      })
+      
+      // Get source if not provided
+      if (!source) {
+        // Show recent items
+        const recent = await brainyInstance.search('*', { limit: 10, sortBy: 'timestamp' })
+        if (recent.length > 0) {
+          console.log(colors.cyan('Recent items (source):'))
+          recent.forEach((item, i) => {
+            console.log(colors.info(`  ${i + 1}. ${item.id} - ${item.content?.substring(0, 40)}...`))
+          })
+          console.log()
+        }
+        
+        source = await new Promise(resolve => {
+          rl.question(colors.cyan('Enter source entity ID: '), (answer) => {
+            resolve(answer)
+          })
+        })
+        
+        if (!source.trim()) {
+          rl.close()
+          console.log(colors.warning('No source provided'))
+          process.exit(1)
+        }
+      }
+      
+      // Interactive verb type selection
+      if (!options.type || options.type === 'RelatedTo') {
+        console.log(colors.cyan('\nSelect relationship type:'))
+        const verbs = ['WorksFor', 'Knows', 'CreatedBy', 'BelongsTo', 'Uses', 'Manages', 'LocatedIn', 'RelatedTo', 'Custom...']
+        verbs.forEach((v, i) => {
+          console.log(colors.info(`  ${i + 1}. ${v}`))
+        })
+        console.log()
+        
+        const verbIndex = await new Promise(resolve => {
+          rl.question(colors.cyan('Select type (1-9): '), (answer) => {
+            resolve(parseInt(answer) - 1)
+          })
+        })
+        
+        if (verbIndex >= 0 && verbIndex < verbs.length - 1) {
+          options.type = verbs[verbIndex]
+        } else if (verbIndex === verbs.length - 1) {
+          // Custom verb
+          options.type = await new Promise(resolve => {
+            rl.question(colors.cyan('Enter custom relationship: '), (answer) => {
+              resolve(answer)
+            })
+          })
+        }
+      }
+      
+      // Get target if not provided
+      if (!target) {
+        // Show recent items again
+        const recent = await brainyInstance.search('*', { limit: 10, sortBy: 'timestamp' })
+        if (recent.length > 0) {
+          console.log(colors.cyan('\nRecent items (target):'))
+          recent.forEach((item, i) => {
+            console.log(colors.info(`  ${i + 1}. ${item.id} - ${item.content?.substring(0, 40)}...`))
+          })
+          console.log()
+        }
+        
+        target = await new Promise(resolve => {
+          rl.question(colors.cyan('Enter target entity ID: '), (answer) => {
+            resolve(answer)
+          })
+        })
+        
+        if (!target.trim()) {
+          rl.close()
+          console.log(colors.warning('No target provided'))
+          process.exit(1)
+        }
+      }
+      
+      rl.close()
+    }
     const brainy = await getBrainy()
     
     // Common verb types for validation
@@ -999,39 +1481,121 @@ program
     const actions = {
       list: async () => {
         try {
-          // Use unified professional catalog  
-          const REGISTRY_URL = 'https://registry.soulcraft.com/api/registry/augmentations'
+          // Use soulcraft.com registry API  
+          const REGISTRY_URL = 'https://api.soulcraft.com/v1/augmentations'
           const response = await fetch(REGISTRY_URL)
           
           if (response && response.ok) {
             console.log(colors.brain('🏢 SOULCRAFT PROFESSIONAL SUITE\n'))
             
             const data = await response.json()
-            const { augmentations = [] } = data
+            const augmentations = data.data || [] // NEW: data is in .data array
             
-            const professional = augmentations.filter(a => a.tier === 'professional')
-            const community = augmentations.filter(a => a.tier === 'community')
+            // Get local augmentations to check what's installed
+            const localAugmentations = brainy.listAugmentations()
+            const localPackageNames = localAugmentations.map(aug => aug.package || aug.name).filter(Boolean)
+            
+            // Find installed registry augmentations
+            const installed = augmentations.filter(aug => 
+              aug.package && localPackageNames.includes(aug.package)
+            )
+            
+            // Display installed augmentations first
+            if (installed.length > 0) {
+              console.log(colors.success('✅ INSTALLED AUGMENTATIONS'))
+              installed.forEach(aug => {
+                const pricing = aug.price 
+                  ? `$${aug.price.monthly}/mo` 
+                  : (aug.tier === 'free' ? 'FREE' : 'TBD')
+                const pricingColor = aug.tier === 'free' ? colors.success(pricing) : colors.yellow(pricing)
+                
+                console.log(`  ${aug.name.padEnd(20)} ${pricingColor.padEnd(15)} ${colors.success('✅ ACTIVE')}`)
+                console.log(`    ${colors.dim(aug.description)}`)
+                console.log('')
+              })
+              console.log('') // Extra space before available augmentations
+            }
+            
+            // Filter out installed ones from the available lists  
+            const availableAugmentations = augmentations.filter(aug => 
+              !installed.find(inst => inst.id === aug.id)
+            )
             
-            // Display professional augmentations
-            if (professional.length > 0) {
-              console.log(colors.primary('🚀 PROFESSIONAL AUGMENTATIONS'))
-              professional.forEach(aug => {
-                const pricing = aug.pricing === 'FREE' ? colors.success(aug.pricing) : colors.yellow(aug.pricing)
-                const badges = aug.verified ? colors.blue('✓') : ''
-                console.log(`  ${aug.name.padEnd(20)} ${pricing.padEnd(15)} ${badges}`)
+            // NEW: Use new tier names - "premium" instead of "professional"
+            const premium = availableAugmentations.filter(a => a.tier === 'premium')
+            const free = availableAugmentations.filter(a => a.tier === 'free')
+            const community = availableAugmentations.filter(a => a.tier === 'community')
+            const comingSoon = availableAugmentations.filter(a => a.status === 'coming_soon')
+            
+            // Display premium augmentations
+            if (premium.length > 0) {
+              console.log(colors.primary('🚀 PREMIUM AUGMENTATIONS'))
+              premium.forEach(aug => {
+                // NEW: price object format
+                const pricing = aug.price 
+                  ? `$${aug.price.monthly}/mo` 
+                  : (aug.tier === 'free' ? 'FREE' : 'TBD')
+                const pricingColor = aug.tier === 'free' ? colors.success(pricing) : colors.yellow(pricing)
+                
+                // NEW: status instead of verified 
+                const status = aug.status === 'available' ? colors.blue('✓') : 
+                              aug.status === 'coming_soon' ? colors.yellow('⏳') : 
+                              colors.dim('•')
+                              
+                console.log(`  ${aug.name.padEnd(20)} ${pricingColor.padEnd(15)} ${status}`)
                 console.log(`    ${colors.dim(aug.description)}`)
-                if (aug.businessValue) {
-                  console.log(`    ${colors.cyan('→ ' + aug.businessValue)}`)
+                
+                if (aug.status === 'coming_soon' && aug.eta) {
+                  console.log(`    ${colors.cyan('→ Coming ' + aug.eta)}`)
+                }
+                
+                if (aug.features && aug.features.length > 0) {
+                  console.log(`    ${colors.cyan('→ ' + aug.features.join(', '))}`)
                 }
                 console.log('')
               })
             }
             
-            // Display local augmentations
-            const localAugmentations = brainy.listAugmentations()
-            if (localAugmentations.length > 0) {
-              console.log(colors.primary('📦 LOCAL AUGMENTATIONS'))
-              localAugmentations.forEach(aug => {
+            // Display free augmentations
+            if (free.length > 0) {
+              console.log(colors.primary('🆓 FREE AUGMENTATIONS'))
+              free.forEach(aug => {
+                const status = aug.status === 'available' ? colors.blue('✓') : 
+                              aug.status === 'coming_soon' ? colors.yellow('⏳') : 
+                              colors.dim('•')
+                              
+                console.log(`  ${aug.name.padEnd(20)} ${colors.success('FREE').padEnd(15)} ${status}`)
+                console.log(`    ${colors.dim(aug.description)}`)
+                
+                if (aug.status === 'coming_soon' && aug.eta) {
+                  console.log(`    ${colors.cyan('→ Coming ' + aug.eta)}`)
+                }
+                console.log('')
+              })
+            }
+            
+            // Display community augmentations
+            if (community.length > 0) {
+              console.log(colors.primary('👥 COMMUNITY AUGMENTATIONS'))
+              community.forEach(aug => {
+                const status = aug.status === 'available' ? colors.blue('✓') : 
+                              aug.status === 'coming_soon' ? colors.yellow('⏳') : 
+                              colors.dim('•')
+                              
+                console.log(`  ${aug.name.padEnd(20)} ${colors.success('COMMUNITY').padEnd(15)} ${status}`)
+                console.log(`    ${colors.dim(aug.description)}`)
+                console.log('')
+              })
+            }
+            
+            // Display truly local (non-registry) augmentations
+            const localOnly = localAugmentations.filter(aug => 
+              !aug.package || !augmentations.find(regAug => regAug.package === aug.package)
+            )
+            
+            if (localOnly.length > 0) {
+              console.log(colors.primary('📦 CUSTOM AUGMENTATIONS'))
+              localOnly.forEach(aug => {
                 const status = aug.enabled ? colors.success('✅ Enabled') : colors.dim('⚪ Disabled')
                 console.log(`  ${aug.name.padEnd(20)} ${status}`)
                 console.log(`    ${colors.dim(aug.description || 'Custom augmentation')}`)
@@ -1174,7 +1738,48 @@ program
     }
   }))
 
-// Command 7: EXPORT - Export your data
+// Command 7: CLEAR - Clear all data
+program
+  .command('clear')
+  .description('Clear all data from your brain (with safety prompt)')
+  .option('--force', 'Force clear without confirmation')
+  .option('--backup', 'Create backup before clearing')
+  .action(wrapAction(async (options) => {
+    if (!options.force) {
+      console.log(colors.warning('🚨 This will delete ALL data in your brain!'))
+      
+      const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout
+      })
+      
+      const confirmed = await new Promise(resolve => {
+        rl.question(colors.warning('Type "DELETE EVERYTHING" to confirm: '), (answer) => {
+          rl.close()
+          resolve(answer === 'DELETE EVERYTHING')
+        })
+      })
+      
+      if (!confirmed) {
+        console.log(colors.info('Clear operation cancelled'))
+        return
+      }
+    }
+    
+    const brainyInstance = await getBrainy()
+    
+    if (options.backup) {
+      console.log(colors.info('💾 Creating backup...'))
+      // Future: implement backup functionality
+      console.log(colors.success('✅ Backup created'))
+    }
+    
+    console.log(colors.info('🗑️  Clearing all data...'))
+    await brainyInstance.clear({ force: true })
+    console.log(colors.success('✅ All data cleared successfully'))
+  }))
+
+// Command 8: EXPORT - Export your data
 program
   .command('export')
   .description('Export your brain data in various formats')
@@ -1271,7 +1876,7 @@ program
         console.log(colors.info('\n📧 Check your email for activation link!'))
         console.log(colors.dim('\nOr visit: https://app.soulcraft.com/activate\n'))
         
-        // TODO: Actually call Brain Cloud API when ready
+        // Cloud features planned for future release
         console.log(colors.brain('🎉 Your Brain Cloud trial is ready!'))
         console.log(colors.success('\nNext steps:'))
         console.log(colors.dim('  1. Check your email for API key'))
@@ -1281,42 +1886,16 @@ program
       connect: async () => {
         console.log(colors.info('🔗 Connecting to Brain Cloud...'))
         // Dynamic import to avoid loading premium code unnecessarily
-        try {
-          const { BrainCloudSDK } = await import('@brainy-cloud/sdk')
-          const connected = await BrainCloudSDK.connect(options.instance)
-          if (connected) {
-            console.log(colors.success('✅ Connected to Brain Cloud'))
-            console.log(colors.info(`Instance: ${connected.instanceId}`))
-          }
-        } catch (error) {
-          console.log(colors.warning('⚠️ Brain Cloud SDK not installed'))
-          console.log(colors.info('Install with: npm install @brainy-cloud/sdk'))
-          console.log(colors.info('Or visit: https://brain-cloud.soulcraft.com'))
-        }
+        console.log(colors.info('🔗 Cloud features coming soon...'))
+        console.log(colors.info('Brainy works offline by default'))
       },
       status: async () => {
-        try {
-          const { BrainCloudSDK } = await import('@brainy-cloud/sdk')
-          const status = await BrainCloudSDK.getStatus()
-          console.log(colors.success('☁️ Cloud Status: Connected'))
-          console.log(colors.info(`Instance: ${status.instanceId}`))
-          console.log(colors.info(`Augmentations: ${status.augmentationCount} available`))
-        } catch {
-          console.log(colors.warning('☁️ Cloud Status: Not connected'))
-          console.log(colors.info('Use "brainy cloud connect" to connect'))
-        }
+        console.log(colors.info('☁️ Cloud Status: Available in future release'))
+        console.log(colors.info('Current version works offline'))
       },
       augmentations: async () => {
-        try {
-          const { BrainCloudSDK } = await import('@brainy-cloud/sdk')
-          const augs = await BrainCloudSDK.listAugmentations()
-          console.log(colors.primary('🧩 Available Premium Augmentations:'))
-          augs.forEach(aug => {
-            console.log(colors.success(`  ✅ ${aug.name} - ${aug.description}`))
-          })
-        } catch {
-          console.log(colors.warning('Connect to Brain Cloud first: brainy cloud connect'))
-        }
+        console.log(colors.info('🧩 Cloud augmentations coming in future release'))
+        console.log(colors.info('Local augmentations available now'))
       }
     }
     
@@ -1464,9 +2043,21 @@ program
 // FALLBACK - Show interactive help if no command
 // ========================================
 
-// If no arguments provided, show interactive help
-if (process.argv.length === 2) {
+// Handle --interactive flag
+if (process.argv.includes('-i') || process.argv.includes('--interactive')) {
+  // Start full interactive mode
+  console.log(colors.primary('🧠 Starting Interactive Mode...'))
+  import('./brainy-interactive.js').then(module => {
+    module.startInteractiveMode()
+  }).catch(error => {
+    console.error(colors.error('Failed to start interactive mode:'), error.message)
+    // Fallback to simple interactive prompt
+    program.parse(['node', 'brainy', 'help'])
+  })
+} else if (process.argv.length === 2) {
+  // No arguments - show interactive help
   program.parse(['node', 'brainy', 'help'])
 } else {
+  // Parse normally
   program.parse(process.argv)
 }