@soulcraft/brainy 0.62.3 → 0.63.0

package/dist/brainyData.d.ts

@@ -532,18 +532,34 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
      */
     connectToRemoteServer(serverUrl: string, protocols?: string | string[]): Promise<WebSocketConnection>;
     /**
-     * Add a vector or data to the database
-     * If the input is not a vector, it will be converted using the embedding function
+     * Add data to the database (literal storage by default)
+     *
+     * 🔒 Safe by default: Only stores your data literally without AI processing
+     * 🧠 AI processing: Set { process: true } or use addSmart() for Neural Import
+     *
      * @param vectorOrData Vector or data to add
-     * @param metadata Optional metadata to associate with the vector
-     * @param options Additional options
-     * @returns The ID of the added vector
+     * @param metadata Optional metadata to associate with the data
+     * @param options Additional options - use { process: true } for AI analysis
+     * @returns The ID of the added data
+     *
+     * @example
+     * // Literal storage (safe, no AI processing)
+     * await brainy.add("API_KEY=secret123")
+     *
+     * @example
+     * // With AI processing (explicit opt-in)
+     * await brainy.add("John works at Acme Corp", null, { process: true })
+     *
+     * @example
+     * // Smart processing (recommended for data analysis)
+     * await brainy.addSmart("Customer feedback: Great product!")
      */
     add(vectorOrData: Vector | any, metadata?: T, options?: {
         forceEmbed?: boolean;
         addToRemote?: boolean;
         id?: string;
         service?: string;
+        process?: boolean;
     }): Promise<string>;
     /**
      * Add a text item to the database with automatic embedding
@@ -929,6 +945,26 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
      * @private
      */
     private adaptCacheConfiguration;
+    /**
+     * Add data with AI processing enabled by default
+     *
+     * 🧠 This method automatically enables Neural Import and other AI augmentations
+     * for intelligent data understanding, entity detection, and relationship analysis.
+     *
+     * Use this when you want AI to understand and process your data.
+     * Use regular add() when you want literal storage only.
+     *
+     * @param vectorOrData The data to add (any format)
+     * @param metadata Optional metadata to associate with the data
+     * @param options Additional options (process defaults to true)
+     * @returns The ID of the added data
+     */
+    addSmart(vectorOrData: Vector | any, metadata?: T, options?: {
+        forceEmbed?: boolean;
+        addToRemote?: boolean;
+        id?: string;
+        service?: string;
+    }): Promise<string>;
     /**
      * Get the number of nouns in the database (excluding verbs)
      * This is used for statistics reporting to match the expected behavior in tests
@@ -1342,5 +1378,54 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
      * Exposed for Cortex reindex command
      */
     rebuildMetadataIndex(): Promise<void>;
+    /**
+     * Enable an augmentation by name
+     * Universal control for built-in, community, and premium augmentations
+     *
+     * @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
+     * Universal control for built-in, community, and premium augmentations
+     *
+     * @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
+     * Shows built-in, community, and premium augmentations
+     *
+     * @returns Array of augmentations with name, type, and enabled status
+     */
+    listAugmentations(): Array<{
+        name: string;
+        type: string;
+        enabled: boolean;
+        description: string;
+    }>;
+    /**
+     * Enable all augmentations of a specific type
+     *
+     * @param type The type of augmentations to enable (sense, conduit, cognition, etc.)
+     * @returns Number of augmentations enabled
+     */
+    enableAugmentationType(type: 'sense' | 'conduit' | 'cognition' | 'memory' | 'perception' | 'dialog' | 'activation' | 'webSocket'): number;
+    /**
+     * Disable all augmentations of a specific type
+     *
+     * @param type The type of augmentations to disable (sense, conduit, cognition, etc.)
+     * @returns Number of augmentations disabled
+     */
+    disableAugmentationType(type: 'sense' | 'conduit' | 'cognition' | 'memory' | 'perception' | 'dialog' | 'activation' | 'webSocket'): number;
 }
 export { euclideanDistance, cosineDistance, manhattanDistance, dotProductDistance } from './utils/index.js';

package/dist/brainyData.js

@@ -4,6 +4,7 @@
  */
 import { v4 as uuidv4 } from './universal/uuid.js';
 import { HNSWIndex } from './hnsw/hnswIndex.js';
+import { ExecutionMode } from './augmentationPipeline.js';
 import { HNSWIndexOptimized } from './hnsw/hnswIndexOptimized.js';
 import { createStorage } from './storage/storageFactory.js';
 import { cosineDistance, defaultEmbeddingFunction, cleanupWorkerPools, batchEmbed } from './utils/index.js';
@@ -983,12 +984,27 @@ export class BrainyData {
         }
     }
     /**
-     * Add a vector or data to the database
-     * If the input is not a vector, it will be converted using the embedding function
+     * Add data to the database (literal storage by default)
+     *
+     * 🔒 Safe by default: Only stores your data literally without AI processing
+     * 🧠 AI processing: Set { process: true } or use addSmart() for Neural Import
+     *
      * @param vectorOrData Vector or data to add
-     * @param metadata Optional metadata to associate with the vector
-     * @param options Additional options
-     * @returns The ID of the added vector
+     * @param metadata Optional metadata to associate with the data
+     * @param options Additional options - use { process: true } for AI analysis
+     * @returns The ID of the added data
+     *
+     * @example
+     * // Literal storage (safe, no AI processing)
+     * await brainy.add("API_KEY=secret123")
+     *
+     * @example
+     * // With AI processing (explicit opt-in)
+     * await brainy.add("John works at Acme Corp", null, { process: true })
+     *
+     * @example
+     * // Smart processing (recommended for data analysis)
+     * await brainy.addSmart("Customer feedback: Great product!")
      */
     async add(vectorOrData, metadata, options = {}) {
         await this.ensureInitialized();
@@ -1246,6 +1262,20 @@ export class BrainyData {
             }
             // Invalidate search cache since data has changed
             this.searchCache.invalidateOnDataChange('add');
+            // 🧠 AI Processing (Neural Import) - Only if explicitly requested
+            if (options.process === true) {
+                try {
+                    // Execute SENSE pipeline (includes Neural Import and other AI augmentations)
+                    await augmentationPipeline.executeSensePipeline('processRawData', [vectorOrData, typeof vectorOrData === 'string' ? 'text' : 'data'], { mode: ExecutionMode.SEQUENTIAL });
+                    if (this.loggingConfig?.verbose) {
+                        console.log(`🧠 AI processing completed for data: ${id}`);
+                    }
+                }
+                catch (processingError) {
+                    // Don't fail the add operation if processing fails
+                    console.warn(`🧠 AI processing failed for ${id}:`, processingError);
+                }
+            }
             return id;
         }
         catch (error) {
@@ -3145,6 +3175,24 @@ export class BrainyData {
             }
         }
     }
+    /**
+     * Add data with AI processing enabled by default
+     *
+     * 🧠 This method automatically enables Neural Import and other AI augmentations
+     * for intelligent data understanding, entity detection, and relationship analysis.
+     *
+     * Use this when you want AI to understand and process your data.
+     * Use regular add() when you want literal storage only.
+     *
+     * @param vectorOrData The data to add (any format)
+     * @param metadata Optional metadata to associate with the data
+     * @param options Additional options (process defaults to true)
+     * @returns The ID of the added data
+     */
+    async addSmart(vectorOrData, metadata, options = {}) {
+        // Call add() with process=true by default
+        return this.add(vectorOrData, metadata, { ...options, process: true });
+    }
     /**
      * Get the number of nouns in the database (excluding verbs)
      * This is used for statistics reporting to match the expected behavior in tests
@@ -4817,6 +4865,63 @@ export class BrainyData {
             await this.metadataIndex.rebuild();
         }
     }
+    // ===== Augmentation Control Methods =====
+    /**
+     * Enable an augmentation by name
+     * Universal control for built-in, community, and premium augmentations
+     *
+     * @param name The name of the augmentation to enable
+     * @returns True if augmentation was found and enabled
+     */
+    enableAugmentation(name) {
+        return augmentationPipeline.enableAugmentation(name);
+    }
+    /**
+     * Disable an augmentation by name
+     * Universal control for built-in, community, and premium augmentations
+     *
+     * @param name The name of the augmentation to disable
+     * @returns True if augmentation was found and disabled
+     */
+    disableAugmentation(name) {
+        return augmentationPipeline.disableAugmentation(name);
+    }
+    /**
+     * 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) {
+        return augmentationPipeline.isAugmentationEnabled(name);
+    }
+    /**
+     * Get all augmentations with their enabled status
+     * Shows built-in, community, and premium augmentations
+     *
+     * @returns Array of augmentations with name, type, and enabled status
+     */
+    listAugmentations() {
+        return augmentationPipeline.listAugmentationsWithStatus();
+    }
+    /**
+     * Enable all augmentations of a specific type
+     *
+     * @param type The type of augmentations to enable (sense, conduit, cognition, etc.)
+     * @returns Number of augmentations enabled
+     */
+    enableAugmentationType(type) {
+        return augmentationPipeline.enableAugmentationType(type);
+    }
+    /**
+     * Disable all augmentations of a specific type
+     *
+     * @param type The type of augmentations to disable (sense, conduit, cognition, etc.)
+     * @returns Number of augmentations disabled
+     */
+    disableAugmentationType(type) {
+        return augmentationPipeline.disableAugmentationType(type);
+    }
 }
 // Export distance functions for convenience
 export { euclideanDistance, cosineDistance, manhattanDistance, dotProductDistance } from './utils/index.js';

package/dist/chat/BrainyChat.d.ts

@@ -0,0 +1,113 @@
+/**
+ * BrainyChat - Magical Chat Command Center
+ *
+ * A smart chat system that leverages Brainy's standard noun/verb types
+ * to create intelligent, persistent conversations with automatic context loading.
+ *
+ * Key Features:
+ * - Uses standard NounType.Message for all chat messages
+ * - Employs VerbType.Communicates and VerbType.Precedes for conversation flow
+ * - Auto-discovery of previous sessions using Brainy's search capabilities
+ * - Hybrid architecture: basic chat (open source) + premium memory sync
+ */
+import { BrainyData } from '../brainyData.js';
+export interface ChatMessage {
+    id: string;
+    content: string;
+    speaker: 'user' | 'assistant' | string;
+    sessionId: string;
+    timestamp: Date;
+    metadata?: {
+        model?: string;
+        usage?: {
+            prompt_tokens?: number;
+            completion_tokens?: number;
+        };
+        context?: Record<string, any>;
+    };
+}
+export interface ChatSession {
+    id: string;
+    title?: string;
+    createdAt: Date;
+    lastMessageAt: Date;
+    messageCount: number;
+    participants: string[];
+    metadata?: {
+        tags?: string[];
+        summary?: string;
+        archived?: boolean;
+        premium?: boolean;
+    };
+}
+/**
+ * Enhanced BrainyChat with automatic context loading and intelligent memory
+ *
+ * This extends basic chat functionality with premium features when available
+ */
+export declare class BrainyChat {
+    private brainy;
+    private currentSessionId;
+    private sessionCache;
+    constructor(brainy: BrainyData);
+    /**
+     * Initialize chat system and auto-discover last session
+     * Uses Brainy's advanced search to find the most recent conversation
+     */
+    initialize(): Promise<ChatSession | null>;
+    /**
+     * Start a new chat session
+     * Automatically generates a session ID and stores session metadata
+     */
+    startNewSession(title?: string, participants?: string[]): Promise<ChatSession>;
+    /**
+     * Add a message to the current session
+     * Stores using standard NounType.Message and creates conversation flow relationships
+     */
+    addMessage(content: string, speaker?: string, metadata?: ChatMessage['metadata']): Promise<ChatMessage>;
+    /**
+     * Get conversation history for current session
+     * Uses Brainy's graph traversal to get messages in chronological order
+     */
+    getHistory(limit?: number): Promise<ChatMessage[]>;
+    /**
+     * Search across all chat sessions and messages
+     * Leverages Brainy's powerful vector and semantic search
+     */
+    searchMessages(query: string, options?: {
+        sessionId?: string;
+        speaker?: string;
+        limit?: number;
+        semanticSearch?: boolean;
+    }): Promise<ChatMessage[]>;
+    /**
+     * Get all chat sessions
+     * Uses Brainy's search to find all conversation sessions
+     */
+    getSessions(limit?: number): Promise<ChatSession[]>;
+    /**
+     * Switch to a different session
+     * Automatically loads context and history
+     */
+    switchToSession(sessionId: string): Promise<ChatSession | null>;
+    /**
+     * Archive a session (premium feature)
+     * Maintains full searchability while organizing conversations
+     */
+    archiveSession(sessionId: string): Promise<boolean>;
+    /**
+     * Generate session summary using AI (premium feature)
+     * Intelligently summarizes long conversations
+     */
+    generateSessionSummary(sessionId: string): Promise<string | null>;
+    private createMessageRelationships;
+    private loadSession;
+    private getHistoryForSession;
+    private updateSessionMetadata;
+    private nounToChatMessage;
+    private nounToChatSession;
+    private toTimestamp;
+    private isPremiumEnabled;
+    getCurrentSessionId(): string | null;
+    getCurrentSession(): ChatSession | null;
+}