cli.ts

#!/usr/bin/env node

import { Command } from 'commander';
import { MemoryManager } from './src/ingest/cli-commands.js';
import { MemoryType } from './src/utils/types.js';
import { 
  generatePassphrase, 
  saveEncryptionPassphrase, 
  isEncryptionAvailable 
} from './src/storage/encryption.js';
import { recordVoiceMemoInteractive } from './src/ingest/voice.js';
import dotenv from 'dotenv';

dotenv.config();

const DATA_DIR = process.env.DATA_DIR || './data';
const program = new Command();
const manager = new MemoryManager();

program
  .name('brain')
  .description('Manage your second brain')
  .version('0.1.0');

program
  .command('add <content>')
  .description('Add a new memory')
  .option('-t, --type <type>', 'Memory type (preference|relationship|goal|experience|fact)', 'experience')
  .option('--tags <tags>', 'Comma-separated tags')
  .option('-i, --importance <level>', 'Importance level (1-5)', '3')
  .option('-e, --encrypt', 'Encrypt this memory (requires setup-encryption first)')
  .action(async (content: string, options) => {
    try {
      await manager.initialize();
      
      const memory = await manager.addMemory({
        content,
        type: options.type as MemoryType,
        tags: options.tags?.split(',').map((t: string) => t.trim()) || [],
        importance: parseInt(options.importance),
        encrypt: options.encrypt
      });

      console.log('\n✅ Memory added!');
      console.log(`   ID: ${memory.id}`);
      console.log(`   Type: ${memory.type}`);
      console.log(`   Tags: ${memory.tags.join(', ') || 'none'}`);
      if (options.encrypt) {
        console.log(`   🔒 Encrypted: Yes`);
      }
      console.log('');
      
      manager.close();
      process.exit(0);
    } catch (error) {
      console.error('Error:', error);
      process.exit(1);
    }
  });

program
  .command('search <query>')
  .description('Search memories')
  .option('-l, --limit <number>', 'Number of results', '5')
  .option('-t, --type <type>', 'Filter by type')
  .action(async (query: string, options) => {
    try {
      await manager.initialize();
      
      const results = await manager.searchMemories(
        query,
        parseInt(options.limit),
        options.type as MemoryType
      );

      console.log(`\n🔍 Found ${results.length} results:\n`);
      
      results.forEach((result, index) => {
        console.log(`${index + 1}. [${result.memory.type}] ${result.memory.content}`);
        console.log(`   Score: ${(result.score * 100).toFixed(1)}%`);
        console.log(`   Tags: ${result.memory.tags.join(', ') || 'none'}`);
        console.log('');
      });
      
      manager.close();
      process.exit(0);
    } catch (error) {
      console.error('Error:', error);
      process.exit(1);
    }
  });

program
  .command('list')
  .description('List recent memories')
  .option('-l, --limit <number>', 'Number of memories', '10')
  .option('-t, --type <type>', 'Filter by type')
  .action(async (options) => {
    try {
      await manager.initialize();
      
      const memories = options.type 
        ? manager.getMemoriesByType(options.type as MemoryType)
        : manager.listRecent(parseInt(options.limit));

      console.log(`\n📝 Recent memories:\n`);
      
      memories.forEach((memory, index) => {
        const encryptedFlag = memory.metadata.is_encrypted ? ' 🔒' : '';
        console.log(`${index + 1}. [${memory.type}]${encryptedFlag} ${memory.content}`);
        console.log(`   Tags: ${memory.tags.join(', ') || 'none'}`);
        console.log(`   Created: ${memory.metadata.created_at.toLocaleString()}`);
        console.log('');
      });
      
      manager.close();
      process.exit(0);
    } catch (error) {
      console.error('Error:', error);
      process.exit(1);
    }
  });

program
  .command('setup-encryption')
  .description('Setup encryption for sensitive memories')
  .option('-k, --key <passphrase>', 'Custom passphrase (or auto-generate)')
  .action((options) => {
    try {
      if (isEncryptionAvailable(DATA_DIR)) {
        console.log('⚠️  Encryption is already set up!');
        console.log('Key location: ./data/encrypted/.key');
        process.exit(0);
      }
      
      const passphrase = options.key || generatePassphrase();
      saveEncryptionPassphrase(DATA_DIR, passphrase);
      
      if (!options.key) {
        console.log('\n🔐 Generated encryption key:');
        console.log(`   ${passphrase}`);
        console.log('\n⚠️  IMPORTANT: Save this key somewhere safe!');
        console.log('   Without it, encrypted memories cannot be recovered.\n');
      } else {
        console.log('\n✅ Custom encryption key saved!\n');
      }
      
      console.log('You can now add encrypted memories with:');
      console.log('   yarn cli add "sensitive info" --encrypt\n');
      
      process.exit(0);
    } catch (error) {
      console.error('Error:', error);
      process.exit(1);
    }
  });

program
  .command('edit <id>')
  .description('Edit an existing memory')
  .option('-c, --content <content>', 'New content')
  .option('-t, --type <type>', 'New type')
  .option('--tags <tags>', 'New tags (comma-separated)')
  .option('-i, --importance <level>', 'New importance level (1-5)')
  .action(async (id: string, options) => {
    try {
      await manager.initialize();
      
      const memory = manager.getMemory(id);
      if (!memory) {
        console.error(`\n❌ Memory with ID ${id} not found\n`);
        manager.close();
        process.exit(1);
      }
      
      const updates: any = {};
      if (options.content) updates.content = options.content;
      if (options.type) updates.type = options.type as MemoryType;
      if (options.tags) updates.tags = options.tags.split(',').map((t: string) => t.trim());
      if (options.importance) {
        updates.metadata = { importance: parseInt(options.importance) };
      }
      
      const updated = await manager.updateMemory(id, updates);
      
      if (updated) {
        console.log('\n✅ Memory updated!');
        console.log(`   ID: ${updated.id}`);
        console.log(`   Content: ${updated.content}`);
        console.log(`   Type: ${updated.type}`);
        console.log(`   Tags: ${updated.tags.join(', ') || 'none'}\n`);
      } else {
        console.error('\n❌ Failed to update memory\n');
      }
      
      manager.close();
      process.exit(0);
    } catch (error) {
      console.error('Error:', error);
      manager.close();
      process.exit(1);
    }
  });

program
  .command('delete <id>')
  .description('Delete a memory')
  .option('-y, --yes', 'Skip confirmation')
  .action(async (id: string, options) => {
    try {
      await manager.initialize();
      
      const memory = manager.getMemory(id);
      if (!memory) {
        console.error(`\n❌ Memory with ID ${id} not found\n`);
        manager.close();
        process.exit(1);
      }
      
      console.log('\n🗑️  About to delete:');
      console.log(`   Content: ${memory.content}`);
      console.log(`   Type: ${memory.type}`);
      console.log(`   Created: ${memory.metadata.created_at.toLocaleString()}\n`);
      
      if (!options.yes) {
        const inquirer = await import('inquirer');
        const answer = await inquirer.default.prompt([{
          type: 'confirm',
          name: 'confirm',
          message: 'Are you sure you want to delete this memory?',
          default: false
        }]);
        
        if (!answer.confirm) {
          console.log('\n❌ Deletion cancelled\n');
          manager.close();
          process.exit(0);
        }
      }
      
      const deleted = await manager.deleteMemory(id);
      
      if (deleted) {
        console.log('\n✅ Memory deleted successfully\n');
      } else {
        console.error('\n❌ Failed to delete memory\n');
      }
      
      manager.close();
      process.exit(0);
    } catch (error) {
      console.error('Error:', error);
      manager.close();
      process.exit(1);
    }
  });

program
  .command('tags')
  .description('List all tags')
  .action(async () => {
    try {
      await manager.initialize();
      
      const tags = manager.getAllTags();
      
      console.log(`\n🏷️  All tags (${tags.length}):\n`);
      
      if (tags.length === 0) {
        console.log('   No tags found\n');
      } else {
        tags.forEach(tag => {
          const memories = manager.getMemoriesByTag(tag);
          console.log(`   ${tag} (${memories.length})`);
        });
        console.log('');
      }
      
      manager.close();
      process.exit(0);
    } catch (error) {
      console.error('Error:', error);
      manager.close();
      process.exit(1);
    }
  });

program
  .command('tag <tag>')
  .description('List memories with a specific tag')
  .action(async (tag: string) => {
    try {
      await manager.initialize();
      
      const memories = manager.getMemoriesByTag(tag);
      
      console.log(`\n🏷️  Memories tagged with "${tag}" (${memories.length}):\n`);
      
      if (memories.length === 0) {
        console.log('   No memories found with this tag\n');
      } else {
        memories.forEach((memory, index) => {
          const encryptedFlag = memory.metadata.is_encrypted ? ' 🔒' : '';
          console.log(`${index + 1}. [${memory.type}]${encryptedFlag} ${memory.content}`);
          console.log(`   ID: ${memory.id}`);
          console.log(`   Created: ${memory.metadata.created_at.toLocaleString()}`);
          console.log('');
        });
      }
      
      manager.close();
      process.exit(0);
    } catch (error) {
      console.error('Error:', error);
      manager.close();
      process.exit(1);
    }
  });

program
  .command('export [filename]')
  .description('Export all memories to JSON file')
  .action(async (filename?: string) => {
    try {
      await manager.initialize();
      
      const data = manager.exportMemories();
      const exportFile = filename || `memories-export-${Date.now()}.json`;
      
      const fs = await import('fs');
      fs.writeFileSync(exportFile, JSON.stringify(data, null, 2));
      
      console.log(`\n✅ Exported ${data.metadata.count} memories to ${exportFile}\n`);
      
      manager.close();
      process.exit(0);
    } catch (error) {
      console.error('Error:', error);
      manager.close();
      process.exit(1);
    }
  });

program
  .command('import <filename>')
  .description('Import memories from JSON file')
  .option('--skip-duplicates', 'Skip memories that appear to be duplicates')
  .action(async (filename: string, options) => {
    try {
      await manager.initialize();
      
      const fs = await import('fs');
      
      if (!fs.existsSync(filename)) {
        console.error(`\n❌ File not found: ${filename}\n`);
        manager.close();
        process.exit(1);
      }
      
      const fileContent = fs.readFileSync(filename, 'utf-8');
      const data = JSON.parse(fileContent);
      
      console.log(`\n📥 Importing memories from ${filename}...\n`);
      
      const result = await manager.importMemories(data, {
        skipDuplicates: options.skipDuplicates
      });
      
      console.log(`✅ Import complete!`);
      console.log(`   Imported: ${result.imported}`);
      console.log(`   Skipped: ${result.skipped}`);
      if (result.errors.length > 0) {
        console.log(`   Errors: ${result.errors.length}`);
        result.errors.forEach(err => console.log(`      - ${err}`));
      }
      console.log('');
      
      manager.close();
      process.exit(0);
    } catch (error) {
      console.error('Error:', error);
      manager.close();
      process.exit(1);
    }
  });

program
  .command('check-duplicates <content>')
  .description('Check if similar memories already exist')
  .action(async (content: string) => {
    try {
      await manager.initialize();
      
      console.log('\n🔍 Checking for duplicates...\n');
      
      const duplicates = await manager.checkDuplicates(content, 0.85);
      
      if (duplicates.length === 0) {
        console.log('✅ No similar memories found\n');
      } else {
        console.log(`⚠️  Found ${duplicates.length} similar memories:\n`);
        duplicates.forEach((memory, index) => {
          console.log(`${index + 1}. ${memory.content}`);
          console.log(`   Type: ${memory.type}, Tags: ${memory.tags.join(', ')}`);
          console.log('');
        });
      }
      
      manager.close();
      process.exit(0);
    } catch (error) {
      console.error('Error:', error);
      manager.close();
      process.exit(1);
    }
  });

program
  .command('encryption-status')
  .description('Check encryption status')
  .action(() => {
    try {
      const available = isEncryptionAvailable(DATA_DIR);
      
      console.log('\n🔐 Encryption Status:\n');
      
      if (available) {
        console.log('   ✅ Encryption is enabled');
        console.log('   📁 Key file: ./data/encrypted/.key');
        console.log('\n   You can add encrypted memories with:');
        console.log('      yarn cli add "text" --encrypt\n');
      } else {
        console.log('   ❌ Encryption is not set up');
        console.log('\n   Run this to enable encryption:');
        console.log('      yarn cli setup-encryption\n');
      }
      
      process.exit(0);
    } catch (error) {
      console.error('Error:', error);
      process.exit(1);
    }
  });

program
  .command('import-ai')
  .description('Import learnings from AI conversation (paste conversation, Ctrl+D when done)')
  .option('-t, --type <type>', 'Memory type (default: fact)', 'fact')
  .option('--tags <tags>', 'Tags (comma-separated)', 'ai-learning')
  .option('--analyze', 'Use AI to extract multiple memories (requires ANTHROPIC_API_KEY)')
  .action(async (options) => {
    try {
      await manager.initialize();
      
      console.log('\n📥 Import from AI Conversation\n');
      console.log('Paste your AI conversation below, then press Ctrl+D:\n');
      
      // Read multi-line input from stdin
      let conversation = '';
      
      process.stdin.setEncoding('utf8');
      process.stdin.on('data', (chunk) => {
        conversation += chunk;
      });
      
      await new Promise<void>((resolve) => {
        process.stdin.on('end', () => resolve());
      });
      
      conversation = conversation.trim();
      
      if (!conversation) {
        console.log('\n❌ No input received\n');
        manager.close();
        process.exit(0);
      }
      
      console.log('\n🧠 Processing...\n');
      
      if (options.analyze && process.env.ANTHROPIC_API_KEY) {
        // Use AI to extract memories
        const { analyzeConversation } = await import('./src/utils/conversation-analyzer.js');
        const extracted = await analyzeConversation(conversation);
        
        if (extracted.length === 0) {
          console.log('ℹ️  No distinct memories found. Saving as single memory...\n');
          
          await manager.addMemory({
            content: conversation.substring(0, 1000),
            type: options.type as MemoryType,
            tags: options.tags.split(',').map((t: string) => t.trim()),
            importance: 3,
            source: 'ai'
          });
          
          console.log('✅ Saved as single memory\n');
        } else {
          console.log(`✅ Extracted ${extracted.length} memories:\n`);
          
          for (const mem of extracted) {
            const memory = await manager.addMemory({
              content: mem.content,
              type: mem.type,
              tags: [...mem.tags, 'ai-imported'],
              importance: mem.importance,
              source: 'ai'
            });
            
            console.log(`   ✓ [${mem.type}] ${mem.content.substring(0, 60)}...`);
          }
          console.log('');
        }
      } else {
        // Save as single memory
        const memory = await manager.addMemory({
          content: conversation.substring(0, 10000), // Limit length
          type: options.type as MemoryType,
          tags: options.tags.split(',').map((t: string) => t.trim()),
          importance: 3,
          source: 'ai'
        });
        
        console.log('✅ Conversation imported!');
        console.log(`   ID: ${memory.id}`);
        console.log(`   Type: ${memory.type}`);
        console.log(`   Tags: ${memory.tags.join(', ')}\n`);
      }
      
      console.log('💡 Tip: Use --analyze flag for automatic extraction\n');
      
      manager.close();
      process.exit(0);
    } catch (error) {
      console.error('Error:', error);
      manager.close();
      process.exit(1);
    }
  });

program
  .command('chatgpt [topic]')
  .description('Generate ChatGPT context file (upload to ChatGPT for personalized responses)')
  .option('-l, --limit <number>', 'Number of memories per type', '30')
  .action(async (topic?: string, options) => {
    try {
      await manager.initialize();
      
      let output = '# My Second Brain Context\n\n';
      output += `Generated: ${new Date().toLocaleString()}\n`;
      
      if (topic) {
        output += `Topic: ${topic}\n\n`;
        
        // Search for topic
        console.log(`🔍 Searching for "${topic}"...\n`);
        const results = await manager.searchMemories(topic, parseInt(options.limit));
        const tagResults = manager.getMemoriesByTag(topic.toLowerCase());
        
        // Combine and deduplicate
        const allMemories = [...results.map(r => r.memory)];
        tagResults.forEach(m => {
          if (!allMemories.find(existing => existing.id === m.id)) {
            allMemories.push(m);
          }
        });
        
        output += `## Results for "${topic}" (${allMemories.length} memories)\n\n`;
        allMemories.forEach((m, i) => {
          output += `${i + 1}. [${m.type}] ${m.content}\n`;
          if (m.tags.length > 0) {
            output += `   *Tags: ${m.tags.join(', ')}*\n`;
          }
          output += '\n';
        });
      } else {
        // Export all by type
        console.log('📊 Exporting memories by type...\n');
        
        const types: MemoryType[] = ['preference', 'goal', 'relationship', 'fact', 'experience'];
        
        for (const type of types) {
          const memories = manager.getMemoriesByType(type).slice(0, parseInt(options.limit));
          
          if (memories.length > 0) {
            output += `## ${type.charAt(0).toUpperCase() + type.slice(1)}s (${memories.length})\n\n`;
            
            memories.forEach((m, i) => {
              output += `${i + 1}. ${m.content}\n`;
              if (m.tags.length > 0) {
                output += `   *Tags: ${m.tags.join(', ')}*\n`;
              }
              output += '\n';
            });
          }
        }
      }
      
      // Add usage instructions
      output += '---\n\n';
      output += '## How to use this file\n\n';
      output += '1. Upload this file to ChatGPT\n';
      output += '2. Say: "I\'ve uploaded my personal memories. Use these to give personalized responses."\n';
      output += '3. ChatGPT will use this context in our conversation!\n';
      
      const fs = await import('fs');
      const filename = topic ? `chatgpt-${topic}.md` : 'chatgpt-context.md';
      fs.writeFileSync(filename, output);
      
      console.log(`✅ Created ${filename}`);
      console.log(`📊 Ready to upload to ChatGPT!`);
      console.log(`\n💡 Tip: Re-export weekly for fresh context\n`);
      
      manager.close();
      process.exit(0);
    } catch (error) {
      console.error('Error:', error);
      manager.close();
      process.exit(1);
    }
  });

program
  .command('voice')
  .description('Record a voice memo and save as memory')
  .action(async () => {
    try {
      await manager.initialize();
      
      console.log('\n🎤 Voice Memo\n');
      console.log('This will:');
      console.log('  1. Record audio from your microphone');
      console.log('  2. Transcribe using OpenAI Whisper');
      console.log('  3. Analyze and categorize the memory');
      console.log('  4. Ask for confirmation before saving\n');
      
      // Check for OpenAI API key
      if (!process.env.OPENAI_API_KEY) {
        console.error('❌ OPENAI_API_KEY not set');
        console.error('   Voice features require OpenAI API access.');
        console.error('   Add your key to .env file\n');
        manager.close();
        process.exit(1);
      }
      
      const suggestion = await recordVoiceMemoInteractive();
      
      if (!suggestion) {
        console.log('\n❌ Voice memo cancelled or failed\n');
        manager.close();
        process.exit(1);
      }
      
      // Save the memory
      const memory = await manager.addMemory({
        content: suggestion.content,
        type: suggestion.type,
        tags: suggestion.tags,
        importance: suggestion.importance,
        source: 'voice',
        encrypt: (suggestion as any).encrypt || false
      });
      
      console.log('\n✅ Voice memo saved!');
      console.log(`   ID: ${memory.id}`);
      console.log(`   Type: ${memory.type}`);
      console.log(`   Content: ${memory.content}`);
      if ((suggestion as any).encrypt) {
        console.log(`   🔒 Encrypted: Yes`);
      }
      console.log('');
      
      manager.close();
      process.exit(0);
    } catch (error) {
      console.error('Error:', error);
      manager.close();
      process.exit(1);
    }
  });

program.parse();