@soulcraft/brainy 0.62.3 → 1.0.0-rc.1

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/{cortexSense.d.ts → neuralImport.d.ts}

@@ -1,16 +1,19 @@
 /**
- * Cortex SENSE Augmentation - Atomic Age AI-Powered Data Understanding
+ * Neural Import Augmentation - AI-Powered Data Understanding
  *
- * 🧠 The cerebral cortex layer for intelligent data processing
- * ⚛️ Complete with confidence scoring and relationship weight calculation
+ * 🧠 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 CortexAnalysisResult {
+export interface NeuralAnalysisResult {
     detectedEntities: DetectedEntity[];
     detectedRelationships: DetectedRelationship[];
     confidence: number;
-    insights: CortexInsight[];
+    insights: NeuralInsight[];
 }
 export interface DetectedEntity {
     originalData: any;
@@ -33,14 +36,14 @@ export interface DetectedRelationship {
     context: string;
     metadata?: Record<string, any>;
 }
-export interface CortexInsight {
+export interface NeuralInsight {
     type: 'hierarchy' | 'cluster' | 'pattern' | 'anomaly' | 'opportunity';
     description: string;
     confidence: number;
     affectedEntities: string[];
     recommendation?: string;
 }
-export interface CortexSenseConfig {
+export interface NeuralImportConfig {
     confidenceThreshold: number;
     enableWeights: boolean;
     skipDuplicates: boolean;
@@ -49,13 +52,13 @@ export interface CortexSenseConfig {
 /**
  * Neural Import SENSE Augmentation - The Brain's Perceptual System
  */
-export declare class CortexSenseAugmentation implements ISenseAugmentation {
+export declare class NeuralImportAugmentation implements ISenseAugmentation {
     readonly name: string;
     readonly description: string;
     enabled: boolean;
     private brainy;
     private config;
-    constructor(brainy: BrainyData, config?: Partial<CortexSenseConfig>);
+    constructor(brainy: BrainyData, config?: Partial<NeuralImportConfig>);
     initialize(): Promise<void>;
     shutDown(): Promise<void>;
     getStatus(): Promise<'active' | 'inactive' | 'error'>;
@@ -117,7 +120,7 @@ export declare class CortexSenseAugmentation implements ISenseAugmentation {
     /**
      * Get the full neural analysis result (custom method for Cortex integration)
      */
-    getNeuralAnalysis(rawData: Buffer | string, dataType: string): Promise<CortexAnalysisResult>;
+    getNeuralAnalysis(rawData: Buffer | string, dataType: string): Promise<NeuralAnalysisResult>;
     /**
      * Parse raw data based on type
      */
@@ -165,7 +168,7 @@ export declare class CortexSenseAugmentation implements ISenseAugmentation {
     /**
      * Generate Neural Insights - The Intelligence Layer
      */
-    private generateCortexInsights;
+    private generateNeuralInsights;
     /**
      * Helper methods for the neural system
      */

package/dist/augmentations/{cortexSense.js → neuralImport.js}

@@ -1,8 +1,11 @@
 /**
- * Cortex SENSE Augmentation - Atomic Age AI-Powered Data Understanding
+ * Neural Import Augmentation - AI-Powered Data Understanding
  *
- * 🧠 The cerebral cortex layer for intelligent data processing
- * ⚛️ Complete with confidence scoring and relationship weight calculation
+ * 🧠 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 { NounType, VerbType } from '../types/graphTypes.js';
 import * as fs from '../universal/fs.js';
@@ -10,10 +13,10 @@ import * as path from '../universal/path.js';
 /**
  * Neural Import SENSE Augmentation - The Brain's Perceptual System
  */
-export class CortexSenseAugmentation {
+export class NeuralImportAugmentation {
     constructor(brainy, config = {}) {
-        this.name = 'cortex-sense';
-        this.description = 'AI-powered cortex for intelligent data understanding';
+        this.name = 'neural-import';
+        this.description = 'Built-in AI-powered data understanding and entity detection';
         this.enabled = true;
         this.brainy = brainy;
         this.config = {
@@ -25,7 +28,7 @@ export class CortexSenseAugmentation {
     }
     async initialize() {
         // Initialize the cortex analysis system
-        console.log('🧠 Cortex SENSE augmentation initialized');
+        console.log('🧠 Neural Import augmentation initialized');
     }
     async shutDown() {
         console.log('🧠 Neural Import SENSE augmentation shut down');
@@ -307,7 +310,7 @@ export class CortexSenseAugmentation {
         // Phase 2: Neural Relationship Detection  
         const detectedRelationships = await this.detectRelationshipsWithNeuralAnalysis(detectedEntities, parsedData, config);
         // Phase 3: Neural Insights Generation
-        const insights = await this.generateCortexInsights(detectedEntities, detectedRelationships);
+        const insights = await this.generateNeuralInsights(detectedEntities, detectedRelationships);
         // Phase 4: Confidence Scoring
         const overallConfidence = this.calculateOverallConfidence(detectedEntities, detectedRelationships);
         return {
@@ -516,7 +519,7 @@ export class CortexSenseAugmentation {
     /**
      * Generate Neural Insights - The Intelligence Layer
      */
-    async generateCortexInsights(entities, relationships) {
+    async generateNeuralInsights(entities, relationships) {
         const insights = [];
         // Detect hierarchies
         const hierarchies = this.detectHierarchies(relationships);
@@ -646,7 +649,7 @@ export class CortexSenseAugmentation {
         return (entityConfidence + relationshipConfidence) / 2;
     }
     async storeNeuralAnalysis(analysis) {
-        // Store the full analysis result for later retrieval by Cortex or other systems
+        // Store the full analysis result for later retrieval by Neural Import or other systems
         // This could be stored in the brainy instance metadata or a separate analysis store
     }
     getDataTypeFromPath(filePath) {
@@ -744,4 +747,4 @@ export class CortexSenseAugmentation {
         return recommendations;
     }
 }
-//# sourceMappingURL=cortexSense.js.map
+//# sourceMappingURL=neuralImport.js.map

package/dist/brainyData.d.ts

@@ -532,18 +532,31 @@ 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 with intelligent processing
+     *
      * @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 for processing
+     * @returns The ID of the added data
+     *
+     * @example
+     * // Auto mode - intelligently decides processing
+     * await brainy.add("Customer feedback: Great product!")
+     *
+     * @example
+     * // Explicit literal mode for sensitive data
+     * await brainy.add("API_KEY=secret123", null, { process: 'literal' })
+     *
+     * @example
+     * // Force neural processing
+     * await brainy.add("John works at Acme Corp", null, { process: 'neural' })
      */
     add(vectorOrData: Vector | any, metadata?: T, options?: {
         forceEmbed?: boolean;
         addToRemote?: boolean;
         id?: string;
         service?: string;
+        process?: 'auto' | 'literal' | 'neural';
     }): Promise<string>;
     /**
      * Add a text item to the database with automatic embedding
@@ -766,6 +779,9 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
      */
     delete(id: string, options?: {
         service?: string;
+        soft?: boolean;
+        cascade?: boolean;
+        force?: boolean;
     }): Promise<boolean>;
     /**
      * Update metadata for a vector
@@ -808,17 +824,7 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
      *
      * @throws Error if source or target nouns don't exist and autoCreateMissingNouns is false or auto-creation fails
      */
-    addVerb(sourceId: string, targetId: string, vector?: Vector, options?: {
-        type?: string;
-        weight?: number;
-        metadata?: any;
-        forceEmbed?: boolean;
-        id?: string;
-        autoCreateMissingNouns?: boolean;
-        missingNounMetadata?: any;
-        service?: string;
-        writeOnlyMode?: boolean;
-    }): Promise<string>;
+    private _addVerbInternal;
     /**
      * Get a verb by ID
      * This is a direct storage operation that works in write-only mode when allowDirectReads is enabled
@@ -929,6 +935,11 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
      * @private
      */
     private adaptCacheConfiguration;
+    /**
+     * @deprecated Use add() instead - it's smart by default now
+     * @hidden
+     */
+    addSmart(vectorOrData: Vector | any, metadata?: T, options?: any): 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
@@ -1309,7 +1320,7 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
      */
     loadEnvironment(): Promise<void>;
     /**
-     * Set a configuration value in Cortex
+     * Set a configuration value with optional encryption
      * @param key Configuration key
      * @param value Configuration value
      * @param options Options including encryption
@@ -1318,11 +1329,132 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
         encrypt?: boolean;
     }): Promise<void>;
     /**
-     * Get a configuration value from Cortex
+     * Get a configuration value with automatic decryption
      * @param key Configuration key
      * @returns Configuration value or undefined
      */
     getConfig(key: string): Promise<any>;
+    /**
+     * Encrypt data using universal crypto utilities
+     */
+    encryptData(data: string): Promise<string>;
+    /**
+     * Decrypt data using universal crypto utilities
+     */
+    decryptData(encryptedData: string): Promise<string>;
+    /**
+     * Neural Import - Smart bulk data import with semantic type detection
+     * Uses transformer embeddings to automatically detect and classify data types
+     * @param data Array of data items or single item to import
+     * @param options Import options including type hints and processing mode
+     * @returns Array of created IDs
+     */
+    import(data: any[] | any, options?: {
+        typeHint?: NounType;
+        autoDetect?: boolean;
+        batchSize?: number;
+        process?: 'auto' | 'guided' | 'explicit' | 'literal';
+    }): Promise<string[]>;
+    /**
+     * Add Noun - Explicit noun creation with strongly-typed NounType
+     * For when you know exactly what type of noun you're creating
+     * @param data The noun data
+     * @param nounType The explicit noun type from NounType enum
+     * @param metadata Additional metadata
+     * @returns Created noun ID
+     */
+    addNoun(data: any, nounType: NounType, metadata?: any): Promise<string>;
+    /**
+     * Add Verb - Unified relationship creation between nouns
+     * Creates typed relationships with proper vector embeddings from metadata
+     * @param sourceId Source noun ID
+     * @param targetId Target noun ID
+     * @param verbType Relationship type from VerbType enum
+     * @param metadata Additional metadata for the relationship (will be embedded for searchability)
+     * @param weight Relationship weight/strength (0-1, default: 0.5)
+     * @returns Created verb ID
+     */
+    addVerb(sourceId: string, targetId: string, verbType: VerbType, metadata?: any, weight?: number): Promise<string>;
+    /**
+     * Auto-detect whether to use neural processing for data
+     * @private
+     */
+    private shouldAutoProcessNeurally;
+    /**
+     * Detect noun type using semantic analysis
+     * @private
+     */
+    private detectNounType;
+    /**
+     * Get Noun with Connected Verbs - Retrieve noun and all its relationships
+     * Provides complete traversal view of a noun and its connections using existing searchVerbs
+     * @param nounId The noun ID to retrieve
+     * @param options Traversal options
+     * @returns Noun data with connected verbs and related nouns
+     */
+    getNounWithVerbs(nounId: string, options?: {
+        includeIncoming?: boolean;
+        includeOutgoing?: boolean;
+        verbLimit?: number;
+        verbTypes?: string[];
+    }): Promise<{
+        noun: {
+            id: string;
+            data: any;
+            metadata: any;
+            nounType?: NounType;
+        };
+        incomingVerbs: any[];
+        outgoingVerbs: any[];
+        totalConnections: number;
+    } | null>;
+    /**
+     * Update - Smart noun update with automatic index synchronization
+     * Updates both data and metadata while maintaining search index integrity
+     * @param id The noun ID to update
+     * @param data New data (optional - if not provided, only metadata is updated)
+     * @param metadata New metadata (merged with existing)
+     * @param options Update options
+     * @returns Success boolean
+     */
+    update(id: string, data?: any, metadata?: any, options?: {
+        merge?: boolean;
+        reindex?: boolean;
+        cascade?: boolean;
+    }): Promise<boolean>;
+    /**
+     * Preload Transformer Model - Essential for container deployments
+     * Downloads and caches models during initialization to avoid runtime delays
+     * @param options Preload options
+     * @returns Success boolean and model info
+     */
+    static preloadModel(options?: {
+        model?: string;
+        cacheDir?: string;
+        device?: string;
+        force?: boolean;
+    }): Promise<{
+        success: boolean;
+        modelPath: string;
+        modelSize: number;
+        device: string;
+    }>;
+    /**
+     * Warmup - Initialize BrainyData with preloaded models (container-optimized)
+     * For production deployments where models should be ready immediately
+     * @param config BrainyData configuration
+     * @param options Warmup options
+     */
+    static warmup(config?: BrainyDataConfig, options?: {
+        preloadModel?: boolean;
+        modelOptions?: Parameters<typeof BrainyData.preloadModel>[0];
+        testEmbedding?: boolean;
+    }): Promise<BrainyData>;
+    /**
+     * Get model size for deployment info
+     * @private
+     */
+    private static getModelSize;
     /**
      * Coordinate storage migration across distributed services
      * @param options Migration options
@@ -1342,5 +1474,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';