@soulcraft/brainy 0.61.1 → 0.61.3

package/dist/cortex/cliWrapper.js

@@ -0,0 +1,209 @@
+/**
+ * CLI Wrapper for Cortex
+ *
+ * Provides CLI-specific functionality that wraps the core Cortex orchestrator
+ * Following our philosophy: "Simple for beginners, powerful for experts"
+ */
+import { BrainyData } from '../brainyData.js';
+import { Cortex } from '../cortex.js';
+import { NeuralImport } from './neuralImport.js';
+// @ts-ignore
+import chalk from 'chalk';
+// @ts-ignore
+import ora from 'ora';
+// @ts-ignore
+import prompts from 'prompts';
+export class CortexCLI {
+    constructor() {
+        this.brainy = new BrainyData();
+        this.cortex = new Cortex();
+    }
+    /**
+     * Initialize the brain and cortex
+     */
+    async init(options = {}) {
+        const spinner = ora('Initializing brain...').start();
+        try {
+            // Initialize BrainyData
+            await this.brainy.init();
+            // Set up Neural Import as default augmentation
+            this.neuralImport = new NeuralImport(this.brainy);
+            this.cortex.register(this.neuralImport);
+            spinner.succeed('Brain initialized!');
+            return true;
+        }
+        catch (error) {
+            spinner.fail('Initialization failed');
+            throw error;
+        }
+    }
+    /**
+     * Add data - with Neural Import processing by default
+     */
+    async add(data, metadata) {
+        // If no data provided, go interactive
+        if (!data) {
+            const input = await prompts([
+                {
+                    type: 'text',
+                    name: 'data',
+                    message: 'What would you like to add?',
+                    validate: (value) => value.length > 0 || 'Please enter something'
+                }
+            ]);
+            if (!input.data)
+                return;
+            data = input.data;
+        }
+        // Check if it's a file path
+        const fs = await import('fs');
+        if (fs.existsSync(data)) {
+            // Use Neural Import for files
+            if (this.neuralImport) {
+                console.log(chalk.cyan('🧠 Using Neural Import to understand your data...'));
+                const result = await this.neuralImport.neuralImport(data, {
+                    autoApply: true,
+                    previewOnly: false
+                });
+                console.log(chalk.green(`✅ Imported ${result.detectedEntities.length} entities`));
+                console.log(chalk.gray(`   ${result.detectedRelationships.length} relationships detected`));
+                console.log(chalk.gray(`   Confidence: ${(result.confidence * 100).toFixed(1)}%`));
+                if (result.insights.length > 0) {
+                    console.log(chalk.cyan('\n💡 Insights:'));
+                    result.insights.forEach(insight => {
+                        console.log(chalk.gray(`   • ${insight.description}`));
+                    });
+                }
+            }
+        }
+        else {
+            // Plain text - add directly
+            const id = await this.brainy.add(data, metadata);
+            console.log(chalk.green('✅ Added!'));
+            console.log(chalk.gray(`   ID: ${id}`));
+        }
+    }
+    /**
+     * Search with helpful display
+     */
+    async search(query, options = {}) {
+        // Interactive mode if no query
+        if (!query) {
+            const input = await prompts({
+                type: 'text',
+                name: 'query',
+                message: 'What are you looking for?',
+                validate: (value) => value.length > 0 || 'Please enter a search term'
+            });
+            if (!input.query)
+                return;
+            query = input.query;
+        }
+        const results = await this.brainy.search(query, options.limit || 5);
+        if (results.length === 0) {
+            console.log(chalk.yellow('No results found'));
+            console.log(chalk.gray('Try different keywords or add more data'));
+        }
+        else {
+            console.log(chalk.cyan(`\nFound ${results.length} results:\n`));
+            results.forEach((result, i) => {
+                const content = result.content || result.text || result.data;
+                console.log(chalk.white(`${i + 1}. ${content}`));
+                console.log(chalk.gray(`   Score: ${(result.score * 100).toFixed(1)}%`));
+                if (result.metadata) {
+                    const keys = Object.keys(result.metadata).slice(0, 3);
+                    if (keys.length > 0) {
+                        const preview = keys.map(k => `${k}: ${result.metadata[k]}`).join(', ');
+                        console.log(chalk.gray(`   ${preview}`));
+                    }
+                }
+                console.log();
+            });
+        }
+    }
+    /**
+     * Show statistics
+     */
+    async stats(detailed = false) {
+        const stats = await this.brainy.getStats();
+        console.log(chalk.cyan('\n🧠 Brain Statistics\n'));
+        console.log(chalk.white('Capacity:'));
+        console.log(`  Memories: ${stats.totalNouns || 0}`);
+        console.log(`  Connections: ${stats.totalVerbs || 0}`);
+        if (detailed) {
+            console.log(chalk.white('\nBreakdown:'));
+            if (stats.nounTypes) {
+                console.log('  Entity Types:');
+                Object.entries(stats.nounTypes).forEach(([type, count]) => {
+                    console.log(`    ${type}: ${count}`);
+                });
+            }
+            if (stats.verbTypes) {
+                console.log('  Relationship Types:');
+                Object.entries(stats.verbTypes).forEach(([type, count]) => {
+                    console.log(`    ${type}: ${count}`);
+                });
+            }
+        }
+        console.log(chalk.white('\nAugmentations:'));
+        const augmentations = this.cortex.getAugmentationsByType('sense');
+        console.log(`  Active: ${augmentations.length}`);
+        if (augmentations.length > 0) {
+            augmentations.forEach(aug => {
+                console.log(`    • ${aug.name || 'unnamed'}`);
+            });
+        }
+    }
+    /**
+     * Interactive chat interface
+     */
+    async chat(initialMessage) {
+        console.log(chalk.cyan('\n🧠 Brain Chat'));
+        console.log(chalk.gray('I can help you explore your data. Type "exit" to quit.\n'));
+        // Note: Full chat would integrate with BrainyChat
+        // For now, we use search as a simple implementation
+        const readline = (await import('readline')).createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            prompt: chalk.cyan('You: ')
+        });
+        if (initialMessage) {
+            console.log(chalk.cyan('You: ') + initialMessage);
+            const results = await this.brainy.search(initialMessage, 3);
+            if (results.length > 0) {
+                console.log(chalk.green('Brain: ') + 'Based on what I know:');
+                results.forEach(r => {
+                    console.log(chalk.gray(`  • ${r.content || r.text}`));
+                });
+            }
+            else {
+                console.log(chalk.green('Brain: ') + "I don't have information about that yet.");
+            }
+            console.log();
+        }
+        readline.prompt();
+        readline.on('line', async (line) => {
+            const input = line.trim();
+            if (input.toLowerCase() === 'exit') {
+                console.log(chalk.gray('\nGoodbye! 👋'));
+                readline.close();
+                process.exit(0);
+            }
+            if (input) {
+                const results = await this.brainy.search(input, 3);
+                if (results.length > 0) {
+                    console.log(chalk.green('Brain: ') + 'I found:');
+                    results.forEach(r => {
+                        console.log(chalk.gray(`  • ${r.content || r.text}`));
+                    });
+                }
+                else {
+                    console.log(chalk.green('Brain: ') + "I don't know about that yet.");
+                }
+                console.log();
+            }
+            readline.prompt();
+        });
+    }
+}
+//# sourceMappingURL=cliWrapper.js.map

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

@@ -0,0 +1,264 @@
+/**
+ * Cortex - Beautiful CLI Command Center for Brainy
+ *
+ * Configuration, data management, search, and chat - all in one place!
+ */
+export declare class Cortex {
+    private brainy?;
+    private chatInstance?;
+    private performanceMonitor?;
+    private healthCheck?;
+    private licensingSystem?;
+    private configPath;
+    private config;
+    private encryptionKey?;
+    private masterKeySource?;
+    private emojis;
+    private colors;
+    constructor();
+    /**
+     * Load configuration
+     */
+    private loadConfig;
+    /**
+     * Ensure Brainy is initialized
+     */
+    private ensureBrainy;
+    /**
+     * Master Key Management - Atomic Age Security Protocols
+     */
+    private initializeMasterKey;
+    /**
+     * Load master key from stored salt + passphrase
+     */
+    private loadPassphraseKey;
+    /**
+     * Reset master key - for key rotation
+     */
+    resetMasterKey(): Promise<void>;
+    /**
+     * Get all decrypted secrets (for key rotation)
+     */
+    private getAllSecrets;
+    /**
+     * Initialize Cortex with beautiful prompts
+     */
+    init(options?: InitOptions): Promise<void>;
+    /**
+     * Beautiful welcome message
+     */
+    private showWelcome;
+    /**
+     * Chat with your data - beautiful interactive mode
+     */
+    chat(question?: string): Promise<void>;
+    /**
+     * Add data with beautiful prompts
+     */
+    add(data?: string, metadata?: any): Promise<void>;
+    /**
+     * Search with beautiful results display and advanced options
+     */
+    search(query: string, options?: SearchOptions): Promise<void>;
+    /**
+     * Advanced search with interactive prompts
+     */
+    advancedSearch(): Promise<void>;
+    /**
+     * Add or update graph connections (verbs)
+     */
+    addVerb(subject: string, verb: string, object: string, metadata?: any): Promise<void>;
+    /**
+     * Interactive graph exploration
+     */
+    explore(startId?: string): Promise<void>;
+    /**
+     * Configuration management with encryption
+     */
+    configSet(key: string, value: string, options?: {
+        encrypt?: boolean;
+    }): Promise<void>;
+    /**
+     * Get configuration value
+     */
+    configGet(key: string): Promise<string | null>;
+    /**
+     * List all configuration
+     */
+    configList(): Promise<void>;
+    /**
+     * Storage migration with beautiful progress
+     */
+    migrate(options: MigrateOptions): Promise<void>;
+    /**
+     * Show comprehensive statistics and database info
+     */
+    stats(detailed?: boolean): Promise<void>;
+    /**
+     * List all searchable fields with statistics
+     */
+    listFields(): Promise<void>;
+    /**
+     * Setup LLM progressively with auto-download
+     */
+    setupLLM(provider?: string): Promise<void>;
+    private setupLocalLLM;
+    private setupClaudeLLM;
+    private setupOpenAILLM;
+    private setupOllamaLLM;
+    private setupClaudeDesktop;
+    /**
+     * Use the embedding model for other tasks
+     */
+    embed(text: string): Promise<void>;
+    /**
+     * Calculate similarity between two texts
+     */
+    similarity(text1: string, text2: string): Promise<void>;
+    private getSimilarityInterpretation;
+    /**
+     * Import .env file with automatic encryption of secrets
+     */
+    importEnv(filePath: string): Promise<void>;
+    /**
+     * Export configuration to .env file
+     */
+    exportEnv(filePath: string): Promise<void>;
+    /**
+     * Delete data by ID
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Update data by ID
+     */
+    update(id: string, data: string, metadata?: any): Promise<void>;
+    /**
+     * Helpers
+     */
+    private ensureInitialized;
+    /**
+     * Load master key from various sources
+     */
+    private loadMasterKey;
+    private isInitialized;
+    private initBrainy;
+    private saveConfig;
+    /**
+     * Configuration categories for enhanced secret management
+     */
+    static readonly CONFIG_CATEGORIES: {
+        readonly SECRET: "secret";
+        readonly SENSITIVE: "sensitive";
+        readonly CONFIG: "config";
+        readonly PUBLIC: "public";
+    };
+    private customSecretPatterns;
+    /**
+     * Enhanced secret detection with custom patterns and categories
+     */
+    private isSecret;
+    /**
+     * Add custom secret detection patterns
+     */
+    addSecretPattern(pattern: string): Promise<void>;
+    /**
+     * Remove custom secret detection pattern
+     */
+    removeSecretPattern(pattern: string): Promise<void>;
+    /**
+     * List all secret detection patterns
+     */
+    listSecretPatterns(): Promise<void>;
+    /**
+     * Save custom patterns to disk
+     */
+    private saveCustomPatterns;
+    /**
+     * Load custom patterns from disk
+     */
+    private loadCustomPatterns;
+    /**
+     * Determine config category for enhanced management
+     */
+    private getConfigCategory;
+    /**
+     * Cortex Augmentation System - AI-Powered Data Understanding
+     */
+    neuralImport(filePath: string, options?: any): Promise<void>;
+    neuralAnalyze(filePath: string): Promise<void>;
+    neuralValidate(filePath: string): Promise<void>;
+    neuralTypes(): Promise<void>;
+    /**
+     * Augmentation Pipeline Management - Control the Neural Enhancement System
+     */
+    listAugmentations(): Promise<void>;
+    addAugmentation(type: string, position?: number, config?: any): Promise<void>;
+    removeAugmentation(type: string): Promise<void>;
+    configureAugmentation(type: string, config: any): Promise<void>;
+    resetPipeline(): Promise<void>;
+    executePipelineStep(step: string, data: any): Promise<void>;
+    /**
+     * Backup & Restore System - Atomic Data Preservation
+     */
+    backup(options?: any): Promise<void>;
+    restore(file: string): Promise<void>;
+    listBackups(directory?: string): Promise<void>;
+    /**
+     * Show augmentation status and management
+     */
+    augmentations(options?: any): Promise<void>;
+    /**
+     * Performance Monitoring & Health Check System - Atomic Age Intelligence Observatory
+     */
+    monitor(options?: any): Promise<void>;
+    health(options?: any): Promise<void>;
+    performance(options?: any): Promise<void>;
+    /**
+     * Premium Features - Redirect to Brain Cloud
+     */
+    licenseCatalog(): Promise<void>;
+    licenseStatus(licenseId?: string): Promise<void>;
+    licenseTrial(featureId: string, customerName?: string, customerEmail?: string): Promise<void>;
+    licenseValidate(featureId: string): Promise<boolean>;
+    /**
+     * Check if a premium feature is available
+     */
+    requirePremiumFeature(featureId: string, silent?: boolean): Promise<boolean>;
+    /**
+     * Brain Jar AI Coordination Methods
+     */
+    brainJarInstall(mode: string): Promise<void>;
+    brainJarStart(options: any): Promise<void>;
+    brainJarDashboard(shouldOpen?: boolean): Promise<void>;
+    brainJarStatus(): Promise<void>;
+    brainJarStop(): Promise<void>;
+    brainJarAgents(): Promise<void>;
+    brainJarMessage(text: string): Promise<void>;
+    brainJarSearch(query: string, limit: number): Promise<void>;
+    /**
+     * Brain Cloud Super Command - One command to rule them all
+     */
+    setupBrainCloud(options: any): Promise<void>;
+    /**
+     * Helper method to determine data type from file path
+     */
+    private getDataTypeFromPath;
+}
+interface InitOptions {
+    storage?: string;
+    encryption?: boolean;
+    chat?: boolean;
+    llm?: string;
+}
+interface MigrateOptions {
+    to: string;
+    bucket?: string;
+    strategy?: 'immediate' | 'gradual';
+}
+interface SearchOptions {
+    limit?: number;
+    filter?: any;
+    verbs?: string[];
+    depth?: number;
+}
+export {};