@soulcraft/brainy 0.63.0 → 1.0.0-rc.2

package/dist/chat/BrainyChat.js

@@ -260,12 +260,9 @@ export class BrainyChat {
     }
     // Private helper methods
     async createMessageRelationships(messageId) {
-        // Link message to session using BrainyData addVerb() method
-        await this.brainy.addVerb(messageId, this.currentSessionId, undefined, {
-            type: VerbType.PartOf,
-            metadata: {
-                relationship: 'message-in-session'
-            }
+        // Link message to session using unified addVerb API
+        await this.brainy.addVerb(messageId, this.currentSessionId, VerbType.PartOf, {
+            relationship: 'message-in-session'
         });
         // Find previous message to create conversation flow using VerbType.Precedes
         const previousMessages = await this.brainy.search('', 1, {
@@ -276,11 +273,8 @@ export class BrainyChat {
             }
         });
         if (previousMessages.length > 0 && previousMessages[0].id !== messageId) {
-            await this.brainy.addVerb(previousMessages[0].id, messageId, undefined, {
-                type: VerbType.Precedes,
-                metadata: {
-                    relationship: 'message-sequence'
-                }
+            await this.brainy.addVerb(previousMessages[0].id, messageId, VerbType.Precedes, {
+                relationship: 'message-sequence'
             });
         }
     }

package/dist/cortex/neuralImport.js

@@ -585,9 +585,7 @@ export class NeuralImport {
             }
             // Add relationships to Brainy
             for (const relationship of result.detectedRelationships) {
-                await this.brainy.addVerb(relationship.sourceId, relationship.targetId, undefined, // no custom vector
-                {
-                    type: relationship.verbType,
+                await this.brainy.addVerb(relationship.sourceId, relationship.targetId, relationship.verbType, {
                     weight: relationship.weight,
                     metadata: {
                         confidence: relationship.confidence,

package/dist/index.d.ts

@@ -29,11 +29,10 @@ export { UniversalSentenceEncoder, TransformerEmbedding, createEmbeddingFunction
 import { OPFSStorage, MemoryStorage, R2Storage, S3CompatibleStorage, createStorage } from './storage/storageFactory.js';
 export { OPFSStorage, MemoryStorage, R2Storage, S3CompatibleStorage, createStorage };
 export { FileSystemStorage } from './storage/adapters/fileSystemStorage.js';
-import { Pipeline, pipeline, augmentationPipeline, ExecutionMode, PipelineOptions, PipelineResult, executeStreamlined, executeByType, executeSingle, processStaticData, processStreamingData, createPipeline, createStreamingPipeline, StreamlinedExecutionMode, StreamlinedPipelineOptions, StreamlinedPipelineResult } from './pipeline.js';
-import { SequentialPipeline, sequentialPipeline, SequentialPipelineOptions } from './sequentialPipeline.js';
+import { Pipeline, pipeline, augmentationPipeline, ExecutionMode, PipelineOptions, PipelineResult, createPipeline, createStreamingPipeline, StreamlinedExecutionMode, StreamlinedPipelineOptions, StreamlinedPipelineResult } from './pipeline.js';
 import { createSenseAugmentation, addWebSocketSupport, executeAugmentation, loadAugmentationModule, AugmentationOptions } from './augmentationFactory.js';
-export { Pipeline, pipeline, augmentationPipeline, ExecutionMode, SequentialPipeline, sequentialPipeline, executeStreamlined, executeByType, executeSingle, processStaticData, processStreamingData, createPipeline, createStreamingPipeline, StreamlinedExecutionMode, createSenseAugmentation, addWebSocketSupport, executeAugmentation, loadAugmentationModule };
-export type { PipelineOptions, PipelineResult, SequentialPipelineOptions, StreamlinedPipelineOptions, StreamlinedPipelineResult, AugmentationOptions };
+export { Pipeline, pipeline, augmentationPipeline, ExecutionMode, createPipeline, createStreamingPipeline, StreamlinedExecutionMode, createSenseAugmentation, addWebSocketSupport, executeAugmentation, loadAugmentationModule };
+export type { PipelineOptions, PipelineResult, StreamlinedPipelineOptions, StreamlinedPipelineResult, AugmentationOptions };
 import { availableAugmentations, registerAugmentation, initializeAugmentationPipeline, setAugmentationEnabled, getAugmentationsByType } from './augmentationRegistry.js';
 export { availableAugmentations, registerAugmentation, initializeAugmentationPipeline, setAugmentationEnabled, getAugmentationsByType };
 import { loadAugmentationsFromModules, createAugmentationRegistryPlugin, createAugmentationRegistryRollupPlugin } from './augmentationRegistryLoader.js';

package/dist/index.js

@@ -51,16 +51,15 @@ export { OPFSStorage, MemoryStorage, R2Storage, S3CompatibleStorage, createStora
 // FileSystemStorage is exported separately to avoid browser build issues
 export { FileSystemStorage } from './storage/adapters/fileSystemStorage.js';
 // Export unified pipeline
-import { Pipeline, pipeline, augmentationPipeline, ExecutionMode, executeStreamlined, executeByType, executeSingle, processStaticData, processStreamingData, createPipeline, createStreamingPipeline, StreamlinedExecutionMode } from './pipeline.js';
-// Export sequential pipeline (for backward compatibility)
-import { SequentialPipeline, sequentialPipeline } from './sequentialPipeline.js';
+import { Pipeline, pipeline, augmentationPipeline, ExecutionMode, createPipeline, createStreamingPipeline, StreamlinedExecutionMode } from './pipeline.js';
+// Sequential pipeline removed - use unified pipeline instead
 // Export augmentation factory
 import { createSenseAugmentation, addWebSocketSupport, executeAugmentation, loadAugmentationModule } from './augmentationFactory.js';
 export { 
 // Unified pipeline exports
-Pipeline, pipeline, augmentationPipeline, ExecutionMode, SequentialPipeline, sequentialPipeline, 
-// Streamlined pipeline exports (now part of unified pipeline)
-executeStreamlined, executeByType, executeSingle, processStaticData, processStreamingData, createPipeline, createStreamingPipeline, StreamlinedExecutionMode, 
+Pipeline, pipeline, augmentationPipeline, ExecutionMode, 
+// Factory functions
+createPipeline, createStreamingPipeline, StreamlinedExecutionMode, 
 // Augmentation factory exports
 createSenseAugmentation, addWebSocketSupport, executeAugmentation, loadAugmentationModule };
 // Export augmentation registry for build-time loading

package/dist/pipeline.d.ts

@@ -1,280 +1,24 @@
 /**
- * Unified Pipeline
+ * Pipeline - Clean Re-export of Cortex
  *
- * This module combines the functionality of the primary augmentation pipeline and the streamlined pipeline
- * into a single, unified pipeline system. It provides both the registry functionality of the primary pipeline
- * and the simplified execution API of the streamlined pipeline.
+ * After the Great Cleanup: Pipeline IS Cortex. No delegation, no complexity.
+ * ONE way to do everything.
  */
-import { IAugmentation, AugmentationType, AugmentationResponse, IWebSocketSupport, BrainyAugmentations } from './types/augmentations.js';
-import { IPipeline } from './types/pipelineTypes.js';
-/**
- * Execution mode for the pipeline
- */
-export declare enum ExecutionMode {
+export { Cortex as Pipeline, cortex as pipeline, ExecutionMode, PipelineOptions } from './augmentationPipeline.js';
+export { cortex as augmentationPipeline, Cortex } from './augmentationPipeline.js';
+export declare const createPipeline: () => Promise<import("./augmentationPipeline.js").Cortex>;
+export declare const createStreamingPipeline: () => Promise<import("./augmentationPipeline.js").Cortex>;
+export type { PipelineOptions as StreamlinedPipelineOptions } from './augmentationPipeline.js';
+export type PipelineResult<T> = {
+    success: boolean;
+    data: T;
+    error?: string;
+};
+export type StreamlinedPipelineResult<T> = PipelineResult<T>;
+export declare enum StreamlinedExecutionMode {
     SEQUENTIAL = "sequential",
     PARALLEL = "parallel",
     FIRST_SUCCESS = "firstSuccess",
     FIRST_RESULT = "firstResult",
     THREADED = "threaded"
 }
-/**
- * Options for pipeline execution
- */
-export interface PipelineOptions {
-    mode?: ExecutionMode;
-    timeout?: number;
-    stopOnError?: boolean;
-    forceThreading?: boolean;
-    disableThreading?: boolean;
-}
-/**
- * Result of a pipeline execution
- */
-export interface PipelineResult<T> {
-    results: AugmentationResponse<T>[];
-    errors: Error[];
-    successful: AugmentationResponse<T>[];
-}
-/**
- * Pipeline class
- *
- * Manages multiple augmentations of each type and provides methods to execute them.
- * Implements the IPipeline interface to avoid circular dependencies.
- */
-export declare class Pipeline implements IPipeline {
-    private registry;
-    /**
-     * Register an augmentation with the pipeline
-     *
-     * @param augmentation The augmentation to register
-     * @returns The pipeline instance for chaining
-     */
-    register<T extends IAugmentation>(augmentation: T): Pipeline;
-    /**
-     * Unregister an augmentation from the pipeline
-     *
-     * @param augmentationName The name of the augmentation to unregister
-     * @returns The pipeline instance for chaining
-     */
-    unregister(augmentationName: string): Pipeline;
-    /**
-     * Initialize all registered augmentations
-     *
-     * @returns A promise that resolves when all augmentations are initialized
-     */
-    initialize(): Promise<void>;
-    /**
-     * Shut down all registered augmentations
-     *
-     * @returns A promise that resolves when all augmentations are shut down
-     */
-    shutDown(): Promise<void>;
-    /**
-     * Get all registered augmentations
-     *
-     * @returns An array of all registered augmentations
-     */
-    getAllAugmentations(): IAugmentation[];
-    /**
-     * Get all augmentations of a specific type
-     *
-     * @param type The type of augmentation to get
-     * @returns An array of all augmentations of the specified type
-     */
-    getAugmentationsByType(type: AugmentationType): IAugmentation[];
-    /**
-     * Get all available augmentation types
-     *
-     * @returns An array of all augmentation types that have at least one registered augmentation
-     */
-    getAvailableAugmentationTypes(): AugmentationType[];
-    /**
-     * Get all WebSocket-supporting augmentations
-     *
-     * @returns An array of all augmentations that support WebSocket connections
-     */
-    getWebSocketAugmentations(): IWebSocketSupport[];
-    /**
-     * Check if an augmentation is of a specific type
-     *
-     * @param augmentation The augmentation to check
-     * @param methods The methods that should be present on the augmentation
-     * @returns True if the augmentation is of the specified type
-     */
-    private isAugmentationType;
-    /**
-     * Determines if threading should be used based on options and environment
-     *
-     * @param options The pipeline options
-     * @returns True if threading should be used, false otherwise
-     */
-    private shouldUseThreading;
-    /**
-     * Executes a method on multiple augmentations using the specified execution mode
-     *
-     * @param augmentations The augmentations to execute the method on
-     * @param method The method to execute
-     * @param args The arguments to pass to the method
-     * @param options Options for the execution
-     * @returns A promise that resolves with the results
-     */
-    execute<T>(augmentations: IAugmentation[], method: string, args?: any[], options?: PipelineOptions): Promise<PipelineResult<T>>;
-    /**
-     * Executes a method on augmentations of a specific type
-     *
-     * @param type The type of augmentations to execute the method on
-     * @param method The method to execute
-     * @param args The arguments to pass to the method
-     * @param options Options for the execution
-     * @returns A promise that resolves with the results
-     */
-    executeByType<T>(type: AugmentationType, method: string, args?: any[], options?: PipelineOptions): Promise<PipelineResult<T>>;
-    /**
-     * Executes a method on a single augmentation with automatic error handling
-     *
-     * @param augmentation The augmentation to execute the method on
-     * @param method The method to execute
-     * @param args The arguments to pass to the method
-     * @returns A promise that resolves with the result
-     */
-    executeSingle<T>(augmentation: IAugmentation, method: string, ...args: any[]): Promise<AugmentationResponse<T>>;
-    /**
-     * Process static data through a pipeline of augmentations
-     *
-     * @param data The data to process
-     * @param pipeline An array of processing steps, each with an augmentation, method, and optional args transformer
-     * @param options Options for the execution
-     * @returns A promise that resolves with the final result
-     */
-    processStaticData<T, R = any>(data: T, pipeline: Array<{
-        augmentation: IAugmentation;
-        method: string;
-        transformArgs?: (data: any, prevResult?: any) => any[];
-    }>, options?: PipelineOptions): Promise<AugmentationResponse<R>>;
-    /**
-     * Process streaming data through a pipeline of augmentations
-     *
-     * @param source The source augmentation that provides the data stream
-     * @param sourceMethod The method on the source augmentation that provides the data stream
-     * @param sourceArgs The arguments to pass to the source method
-     * @param pipeline An array of processing steps, each with an augmentation, method, and optional args transformer
-     * @param callback Function to call with the results of processing each data item
-     * @param options Options for the execution
-     * @returns A promise that resolves when the pipeline is set up
-     */
-    processStreamingData<T>(source: IAugmentation, sourceMethod: string, sourceArgs: any[], pipeline: Array<{
-        augmentation: IAugmentation;
-        method: string;
-        transformArgs?: (data: any, prevResult?: any) => any[];
-    }>, callback: (result: AugmentationResponse<T>) => void, options?: PipelineOptions): Promise<void>;
-    /**
-     * Create a reusable pipeline for processing data
-     *
-     * @param pipeline An array of processing steps
-     * @param options Options for the execution
-     * @returns A function that processes data through the pipeline
-     */
-    createPipeline<T, R>(pipeline: Array<{
-        augmentation: IAugmentation;
-        method: string;
-        transformArgs?: (data: any, prevResult?: any) => any[];
-    }>, options?: PipelineOptions): (data: T) => Promise<AugmentationResponse<R>>;
-    /**
-     * Create a reusable streaming pipeline
-     *
-     * @param source The source augmentation
-     * @param sourceMethod The method on the source augmentation
-     * @param pipeline An array of processing steps
-     * @param options Options for the execution
-     * @returns A function that sets up the streaming pipeline
-     */
-    createStreamingPipeline<T, R>(source: IAugmentation, sourceMethod: string, pipeline: Array<{
-        augmentation: IAugmentation;
-        method: string;
-        transformArgs?: (data: any, prevResult?: any) => any[];
-    }>, options?: PipelineOptions): (sourceArgs: any[], callback: (result: AugmentationResponse<R>) => void) => Promise<void>;
-    /**
-     * Execute a sense pipeline (legacy method)
-     */
-    executeSensePipeline<M extends keyof BrainyAugmentations.ISenseAugmentation & string, R extends BrainyAugmentations.ISenseAugmentation[M] extends (...args: any[]) => AugmentationResponse<infer U> ? U : never>(method: M & (BrainyAugmentations.ISenseAugmentation[M] extends (...args: any[]) => any ? M : never), args: Parameters<Extract<BrainyAugmentations.ISenseAugmentation[M], (...args: any[]) => any>>, options?: PipelineOptions): Promise<Promise<{
-        success: boolean;
-        data: R;
-        error?: string;
-    }>[]>;
-    /**
-     * Execute a conduit pipeline (legacy method)
-     */
-    executeConduitPipeline<M extends keyof BrainyAugmentations.IConduitAugmentation & string, R extends BrainyAugmentations.IConduitAugmentation[M] extends (...args: any[]) => AugmentationResponse<infer U> ? U : never>(method: M & (BrainyAugmentations.IConduitAugmentation[M] extends (...args: any[]) => any ? M : never), args: Parameters<Extract<BrainyAugmentations.IConduitAugmentation[M], (...args: any[]) => any>>, options?: PipelineOptions): Promise<Promise<{
-        success: boolean;
-        data: R;
-        error?: string;
-    }>[]>;
-    /**
-     * Execute a cognition pipeline (legacy method)
-     */
-    executeCognitionPipeline<M extends keyof BrainyAugmentations.ICognitionAugmentation & string, R extends BrainyAugmentations.ICognitionAugmentation[M] extends (...args: any[]) => AugmentationResponse<infer U> ? U : never>(method: M & (BrainyAugmentations.ICognitionAugmentation[M] extends (...args: any[]) => any ? M : never), args: Parameters<Extract<BrainyAugmentations.ICognitionAugmentation[M], (...args: any[]) => any>>, options?: PipelineOptions): Promise<Promise<{
-        success: boolean;
-        data: R;
-        error?: string;
-    }>[]>;
-    /**
-     * Execute a memory pipeline (legacy method)
-     */
-    executeMemoryPipeline<M extends keyof BrainyAugmentations.IMemoryAugmentation & string, R extends BrainyAugmentations.IMemoryAugmentation[M] extends (...args: any[]) => AugmentationResponse<infer U> ? U : never>(method: M & (BrainyAugmentations.IMemoryAugmentation[M] extends (...args: any[]) => any ? M : never), args: Parameters<Extract<BrainyAugmentations.IMemoryAugmentation[M], (...args: any[]) => any>>, options?: PipelineOptions): Promise<Promise<{
-        success: boolean;
-        data: R;
-        error?: string;
-    }>[]>;
-    /**
-     * Execute a perception pipeline (legacy method)
-     */
-    executePerceptionPipeline<M extends keyof BrainyAugmentations.IPerceptionAugmentation & string, R extends BrainyAugmentations.IPerceptionAugmentation[M] extends (...args: any[]) => AugmentationResponse<infer U> ? U : never>(method: M & (BrainyAugmentations.IPerceptionAugmentation[M] extends (...args: any[]) => any ? M : never), args: Parameters<Extract<BrainyAugmentations.IPerceptionAugmentation[M], (...args: any[]) => any>>, options?: PipelineOptions): Promise<Promise<{
-        success: boolean;
-        data: R;
-        error?: string;
-    }>[]>;
-    /**
-     * Execute a dialog pipeline (legacy method)
-     */
-    executeDialogPipeline<M extends keyof BrainyAugmentations.IDialogAugmentation & string, R extends BrainyAugmentations.IDialogAugmentation[M] extends (...args: any[]) => AugmentationResponse<infer U> ? U : never>(method: M & (BrainyAugmentations.IDialogAugmentation[M] extends (...args: any[]) => any ? M : never), args: Parameters<Extract<BrainyAugmentations.IDialogAugmentation[M], (...args: any[]) => any>>, options?: PipelineOptions): Promise<Promise<{
-        success: boolean;
-        data: R;
-        error?: string;
-    }>[]>;
-    /**
-     * Execute an activation pipeline (legacy method)
-     */
-    executeActivationPipeline<M extends keyof BrainyAugmentations.IActivationAugmentation & string, R extends BrainyAugmentations.IActivationAugmentation[M] extends (...args: any[]) => AugmentationResponse<infer U> ? U : never>(method: M & (BrainyAugmentations.IActivationAugmentation[M] extends (...args: any[]) => any ? M : never), args: Parameters<Extract<BrainyAugmentations.IActivationAugmentation[M], (...args: any[]) => any>>, options?: PipelineOptions): Promise<Promise<{
-        success: boolean;
-        data: R;
-        error?: string;
-    }>[]>;
-}
-export declare const pipeline: Pipeline;
-export declare const augmentationPipeline: Pipeline;
-export declare const executeStreamlined: <T>(augmentations: IAugmentation[], method: string, args?: any[], options?: PipelineOptions) => Promise<PipelineResult<T>>;
-export declare const executeByType: <T>(type: AugmentationType, method: string, args?: any[], options?: PipelineOptions) => Promise<PipelineResult<T>>;
-export declare const executeSingle: <T>(augmentation: IAugmentation, method: string, ...args: any[]) => Promise<AugmentationResponse<T>>;
-export declare const processStaticData: <T, R = any>(data: T, pipelineSteps: Array<{
-    augmentation: IAugmentation;
-    method: string;
-    transformArgs?: (data: any, prevResult?: any) => any[];
-}>, options?: PipelineOptions) => Promise<AugmentationResponse<R>>;
-export declare const processStreamingData: <T>(source: IAugmentation, sourceMethod: string, sourceArgs: any[], pipelineSteps: Array<{
-    augmentation: IAugmentation;
-    method: string;
-    transformArgs?: (data: any, prevResult?: any) => any[];
-}>, callback: (result: AugmentationResponse<T>) => void, options?: PipelineOptions) => Promise<void>;
-export declare const createPipeline: <T, R>(pipelineSteps: Array<{
-    augmentation: IAugmentation;
-    method: string;
-    transformArgs?: (data: any, prevResult?: any) => any[];
-}>, options?: PipelineOptions) => (data: T) => Promise<AugmentationResponse<R>>;
-export declare const createStreamingPipeline: <T, R>(source: IAugmentation, sourceMethod: string, pipelineSteps: Array<{
-    augmentation: IAugmentation;
-    method: string;
-    transformArgs?: (data: any, prevResult?: any) => any[];
-}>, options?: PipelineOptions) => (sourceArgs: any[], callback: (result: AugmentationResponse<R>) => void) => Promise<void>;
-export declare const StreamlinedExecutionMode: typeof ExecutionMode;
-export type StreamlinedPipelineOptions = PipelineOptions;
-export type StreamlinedPipelineResult<T> = PipelineResult<T>;