@soulcraft/brainy 3.20.2 → 3.20.4

package/CHANGELOG.md

@@ -12,6 +12,15 @@ All notable changes to this project will be documented in this file. See [standa
   - Adds mutex-based concurrency control for mkdir operations
   - Adds explicit compression tracking for file reads
 
+### BREAKING CHANGES (Deprecated API Removal)
+
+* **removed BrainyData**: The deprecated `BrainyData` class has been completely removed
+  - `BrainyData` was never part of the official Brainy 3.0 API
+  - All users should migrate to the `Brainy` class
+  - Migration is simple: Replace `new BrainyData()` with `new Brainy()` and add `await brain.init()`
+  - See `.strategy/NEURAL_API_RESPONSE.md` for complete migration guide
+  - Renamed `brainyDataInterface.ts` to `brainyInterface.ts` for clarity
+
 ### [3.19.1](https://github.com/soulcraftlabs/brainy/compare/v3.19.0...v3.19.1) (2025-09-29)
 
 ## [3.19.0](https://github.com/soulcraftlabs/brainy/compare/v3.18.0...v3.19.0) (2025-09-29)

package/bin/brainy-interactive.js

@@ -7,7 +7,7 @@
  */
 
 import { program } from 'commander'
-import { BrainyData } from '../dist/brainyData.js'
+import { Brainy } from '../dist/index.js'
 import chalk from 'chalk'
 import inquirer from 'inquirer'
 import ora from 'ora'
@@ -61,7 +61,7 @@ async function getBrainy() {
   if (!brainyInstance) {
     const spinner = ora('Initializing Brainy...').start()
     try {
-      brainyInstance = new BrainyData()
+      brainyInstance = new Brainy()
       await brainyInstance.init()
       spinner.succeed('Brainy initialized')
     } catch (error) {

package/dist/brainy.d.ts

@@ -12,7 +12,7 @@ import { TripleIntelligenceSystem } from './triple/TripleIntelligenceSystem.js';
 import { VirtualFileSystem } from './vfs/VirtualFileSystem.js';
 import { Entity, Relation, Result, AddParams, UpdateParams, RelateParams, FindParams, SimilarParams, GetRelationsParams, AddManyParams, DeleteManyParams, RelateManyParams, BatchResult, BrainyConfig } from './types/brainy.types.js';
 import { NounType } from './types/graphTypes.js';
-import { BrainyInterface } from './types/brainyDataInterface.js';
+import { BrainyInterface } from './types/brainyInterface.js';
 /**
  * The main Brainy class - Clean, Beautiful, Powerful
  * REAL IMPLEMENTATION - No stubs, no mocks

package/dist/mcp/brainyMCPAdapter.d.ts

@@ -5,7 +5,7 @@
  * It wraps a Brainy instance and exposes methods for getting vectors, searching similar items,
  * and getting relationships.
  */
-import { BrainyInterface } from '../types/brainyDataInterface.js';
+import { BrainyInterface } from '../types/brainyInterface.js';
 import { MCPResponse, MCPDataAccessRequest } from '../types/mcpTypes.js';
 export declare class BrainyMCPAdapter {
     private brainyData;

package/dist/mcp/brainyMCPService.d.ts

@@ -6,7 +6,7 @@
  * MCPAugmentationToolset classes and provides WebSocket and REST server implementations
  * for external model access.
  */
-import { BrainyInterface } from '../types/brainyDataInterface.js';
+import { BrainyInterface } from '../types/brainyInterface.js';
 import { MCPRequest, MCPResponse, MCPServiceOptions } from '../types/mcpTypes.js';
 export declare class BrainyMCPService {
     private dataAdapter;

package/dist/neural/embeddedPatterns.d.ts

@@ -2,7 +2,7 @@
  * 🧠 BRAINY EMBEDDED PATTERNS
  *
  * AUTO-GENERATED - DO NOT EDIT
- * Generated: 2025-09-29T17:05:30.153Z
+ * Generated: 2025-09-30T23:01:33.167Z
  * Patterns: 220
  * Coverage: 94-98% of all queries
  *

package/dist/neural/embeddedPatterns.js

@@ -2,7 +2,7 @@
  * 🧠 BRAINY EMBEDDED PATTERNS
  *
  * AUTO-GENERATED - DO NOT EDIT
- * Generated: 2025-09-29T17:05:30.153Z
+ * Generated: 2025-09-30T23:01:33.167Z
  * Patterns: 220
  * Coverage: 94-98% of all queries
  *

package/dist/shared/default-augmentations.d.ts

@@ -4,7 +4,7 @@
  * 🧠⚛️ Pre-installed augmentations that come with every Brainy installation
  * These are the core "sensory organs" of the atomic age brain-in-jar system
  */
-import { BrainyInterface } from '../types/brainyDataInterface.js';
+import { BrainyInterface } from '../types/brainyInterface.js';
 /**
  * Default augmentations that ship with Brainy
  * These are automatically registered on startup

package/dist/storage/adapters/fileSystemStorage.js

@@ -897,26 +897,32 @@ export class FileSystemStorage extends BaseStorage {
         const limit = options.limit || 100;
         const startIndex = options.cursor ? parseInt(options.cursor, 10) : 0;
         try {
-            // Production-scale optimization: Use persisted count for total instead of scanning
-            const totalCount = this.totalVerbCount || 0;
+            // Get actual verb files first (critical for accuracy)
+            const verbFiles = await this.getAllShardedFiles(this.verbsDir);
+            verbFiles.sort(); // Consistent ordering for pagination
+            // Use actual file count - don't trust cached totalVerbCount
+            // This prevents accessing undefined array elements
+            const actualFileCount = verbFiles.length;
             // For large datasets, warn about performance
-            if (totalCount > 1000000) {
-                console.warn(`Very large verb dataset detected (${totalCount} verbs). Performance may be degraded. Consider database storage for optimal performance.`);
+            if (actualFileCount > 1000000) {
+                console.warn(`Very large verb dataset detected (${actualFileCount} verbs). Performance may be degraded. Consider database storage for optimal performance.`);
             }
-            // Calculate pagination bounds
-            const endIndex = Math.min(startIndex + limit, totalCount);
-            const hasMore = endIndex < totalCount;
             // For production-scale datasets, use streaming approach
-            if (totalCount > 50000) {
+            if (actualFileCount > 50000) {
                 return await this.getVerbsWithPaginationStreaming(options, startIndex, limit);
             }
-            // For smaller datasets, use the current approach (with optimizations)
-            const verbFiles = await this.getAllShardedFiles(this.verbsDir);
-            verbFiles.sort(); // This is still acceptable for <50k files
+            // Calculate pagination bounds using ACTUAL file count
+            const endIndex = Math.min(startIndex + limit, actualFileCount);
             // Load the requested page of verbs
             const verbs = [];
+            let successfullyLoaded = 0;
             for (let i = startIndex; i < endIndex; i++) {
                 const file = verbFiles[i];
+                // CRITICAL: Null-safety check for undefined array elements
+                if (!file) {
+                    console.warn(`Unexpected undefined file at index ${i}, skipping`);
+                    continue;
+                }
                 const id = file.replace('.json', '');
                 try {
                     // Read the verb data (HNSWVerb stored as edge) - use sharded path
@@ -1003,14 +1009,18 @@ export class FileSystemStorage extends BaseStorage {
                         }
                     }
                     verbs.push(verb);
+                    successfullyLoaded++;
                 }
                 catch (error) {
                     console.warn(`Failed to read verb ${id}:`, error);
                 }
             }
+            // CRITICAL FIX: hasMore based on actual file count, not cached totalVerbCount
+            // Also verify we successfully loaded items (prevents infinite loops on corrupted storage)
+            const hasMore = (endIndex < actualFileCount) && (successfullyLoaded > 0 || startIndex === 0);
             return {
                 items: verbs,
-                totalCount,
+                totalCount: actualFileCount, // Return actual count, not cached value
                 hasMore,
                 nextCursor: hasMore ? String(endIndex) : undefined
             };
@@ -1587,14 +1597,14 @@ export class FileSystemStorage extends BaseStorage {
      */
     async getVerbsWithPaginationStreaming(options, startIndex, limit) {
         const verbs = [];
-        const totalCount = this.totalVerbCount || 0;
         let processedCount = 0;
         let skippedCount = 0;
         let resultCount = 0;
         const depth = this.cachedShardingDepth ?? this.getOptimalShardingDepth();
         try {
             // Stream through sharded directories efficiently
-            const hasMore = await this.streamShardedFiles(this.verbsDir, depth, async (filename, filePath) => {
+            // hasMore=false means we reached the end of files, hasMore=true means streaming stopped early
+            const streamingHasMore = await this.streamShardedFiles(this.verbsDir, depth, async (filename, filePath) => {
                 // Skip files until we reach start index
                 if (skippedCount < startIndex) {
                     skippedCount++;
@@ -1602,7 +1612,7 @@ export class FileSystemStorage extends BaseStorage {
                 }
                 // Stop if we have enough results
                 if (resultCount >= limit) {
-                    return false; // stop streaming
+                    return false; // stop streaming - more files exist
                 }
                 try {
                     const id = filename.replace('.json', '');
@@ -1666,10 +1676,13 @@ export class FileSystemStorage extends BaseStorage {
                     return true; // continue
                 }
             });
-            const finalHasMore = (startIndex + resultCount) < totalCount;
+            // CRITICAL FIX: Use streaming result for hasMore, not cached totalVerbCount
+            // streamingHasMore=false means we exhausted all files
+            // Also verify we loaded items to prevent infinite loops
+            const finalHasMore = streamingHasMore && (resultCount > 0 || startIndex === 0);
             return {
                 items: verbs,
-                totalCount,
+                totalCount: this.totalVerbCount || undefined, // Return cached count as hint only
                 hasMore: finalHasMore,
                 nextCursor: finalHasMore ? String(startIndex + resultCount) : undefined
             };

package/dist/types/{brainyDataInterface.js → brainyInterface.js}

@@ -7,4 +7,4 @@
  * NO DEPRECATED METHODS - Only clean, modern API patterns.
  */
 export {};
-//# sourceMappingURL=brainyDataInterface.js.map
+//# sourceMappingURL=brainyInterface.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soulcraft/brainy",
-  "version": "3.20.2",
+  "version": "3.20.4",
   "description": "Universal Knowledge Protocol™ - World's first Triple Intelligence database unifying vector, graph, and document search in one API. 31 nouns × 40 verbs for infinite expressiveness.",
   "main": "dist/index.js",
   "module": "dist/index.js",

package/dist/augmentationFactory.d.ts

@@ -1,86 +0,0 @@
-/**
- * Augmentation Factory
- *
- * This module provides a simplified factory for creating augmentations with minimal boilerplate.
- * It reduces the complexity of creating and using augmentations by providing a fluent API
- * and handling common patterns automatically.
- */
-import { IAugmentation, AugmentationResponse, ISenseAugmentation, IConduitAugmentation, IMemoryAugmentation, IWebSocketSupport, WebSocketConnection } from './types/augmentations.js';
-/**
- * Options for creating an augmentation
- */
-export interface AugmentationOptions {
-    name: string;
-    description?: string;
-    enabled?: boolean;
-    autoRegister?: boolean;
-    autoInitialize?: boolean;
-}
-/**
- * Factory for creating sense augmentations
- */
-export declare function createSenseAugmentation(options: AugmentationOptions & {
-    processRawData?: (rawData: Buffer | string, dataType: string) => Promise<AugmentationResponse<{
-        nouns: string[];
-        verbs: string[];
-    }>> | AugmentationResponse<{
-        nouns: string[];
-        verbs: string[];
-    }>;
-    listenToFeed?: (feedUrl: string, callback: (data: {
-        nouns: string[];
-        verbs: string[];
-    }) => void) => Promise<void>;
-}): ISenseAugmentation;
-/**
- * Factory for creating conduit augmentations
- */
-export declare function createConduitAugmentation(options: AugmentationOptions & {
-    establishConnection?: (targetSystemId: string, config: Record<string, unknown>) => Promise<AugmentationResponse<WebSocketConnection>> | AugmentationResponse<WebSocketConnection>;
-    readData?: (query: Record<string, unknown>, options?: Record<string, unknown>) => Promise<AugmentationResponse<unknown>> | AugmentationResponse<unknown>;
-    writeData?: (data: Record<string, unknown>, options?: Record<string, unknown>) => Promise<AugmentationResponse<unknown>> | AugmentationResponse<unknown>;
-    monitorStream?: (streamId: string, callback: (data: unknown) => void) => Promise<void>;
-}): IConduitAugmentation;
-/**
- * Factory for creating memory augmentations
- */
-export declare function createMemoryAugmentation(options: AugmentationOptions & {
-    storeData?: (key: string, data: unknown, options?: Record<string, unknown>) => Promise<AugmentationResponse<boolean>> | AugmentationResponse<boolean>;
-    retrieveData?: (key: string, options?: Record<string, unknown>) => Promise<AugmentationResponse<unknown>> | AugmentationResponse<unknown>;
-    updateData?: (key: string, data: unknown, options?: Record<string, unknown>) => Promise<AugmentationResponse<boolean>> | AugmentationResponse<boolean>;
-    deleteData?: (key: string, options?: Record<string, unknown>) => Promise<AugmentationResponse<boolean>> | AugmentationResponse<boolean>;
-    listDataKeys?: (pattern?: string, options?: Record<string, unknown>) => Promise<AugmentationResponse<string[]>> | AugmentationResponse<string[]>;
-    search?: (query: unknown, k?: number, options?: Record<string, unknown>) => Promise<AugmentationResponse<Array<{
-        id: string;
-        score: number;
-        data: unknown;
-    }>>> | AugmentationResponse<Array<{
-        id: string;
-        score: number;
-        data: unknown;
-    }>>;
-}): IMemoryAugmentation;
-/**
- * Factory for creating WebSocket-enabled augmentations
- * This can be combined with other augmentation factories to create WebSocket-enabled versions
- */
-export declare function addWebSocketSupport<T extends IAugmentation>(augmentation: T, options: {
-    connectWebSocket?: (url: string, protocols?: string | string[]) => Promise<WebSocketConnection>;
-    sendWebSocketMessage?: (connectionId: string, data: unknown) => Promise<void>;
-    onWebSocketMessage?: (connectionId: string, callback: (data: unknown) => void) => Promise<void>;
-    offWebSocketMessage?: (connectionId: string, callback: (data: unknown) => void) => Promise<void>;
-    closeWebSocket?: (connectionId: string, code?: number, reason?: string) => Promise<void>;
-}): T & IWebSocketSupport;
-/**
- * Simplified function to execute an augmentation method with automatic error handling
- * This provides a more concise way to execute augmentation methods compared to the full pipeline
- */
-export declare function executeAugmentation<T, R>(augmentation: IAugmentation, method: string, ...args: any[]): Promise<AugmentationResponse<R>>;
-/**
- * Dynamically load augmentations from a module at runtime
- * This allows for lazy-loading augmentations when needed instead of at build time
- */
-export declare function loadAugmentationModule(modulePromise: Promise<any>, options?: {
-    autoRegister?: boolean;
-    autoInitialize?: boolean;
-}): Promise<IAugmentation[]>;

package/dist/augmentationFactory.js

@@ -1,342 +0,0 @@
-/**
- * Augmentation Factory
- *
- * This module provides a simplified factory for creating augmentations with minimal boilerplate.
- * It reduces the complexity of creating and using augmentations by providing a fluent API
- * and handling common patterns automatically.
- */
-import { registerAugmentation } from './augmentationRegistry.js';
-/**
- * Base class for all augmentations created with the factory
- * Handles common functionality like initialization, shutdown, and status
- */
-class BaseAugmentation {
-    constructor(options) {
-        this.enabled = true;
-        this.isInitialized = false;
-        this.name = options.name;
-        this.description = options.description || `${options.name} augmentation`;
-        this.enabled = options.enabled !== false;
-    }
-    async initialize() {
-        if (this.isInitialized)
-            return;
-        this.isInitialized = true;
-    }
-    async shutDown() {
-        this.isInitialized = false;
-    }
-    async getStatus() {
-        return this.isInitialized ? 'active' : 'inactive';
-    }
-    async ensureInitialized() {
-        if (!this.isInitialized) {
-            await this.initialize();
-        }
-    }
-}
-/**
- * Factory for creating sense augmentations
- */
-export function createSenseAugmentation(options) {
-    const augmentation = new BaseAugmentation(options);
-    // Implement the sense augmentation methods
-    augmentation.processRawData = async (rawData, dataType) => {
-        await augmentation.ensureInitialized();
-        if (options.processRawData) {
-            const result = options.processRawData(rawData, dataType);
-            return result instanceof Promise ? await result : result;
-        }
-        return {
-            success: false,
-            data: { nouns: [], verbs: [] },
-            error: 'processRawData not implemented'
-        };
-    };
-    augmentation.listenToFeed = async (feedUrl, callback) => {
-        await augmentation.ensureInitialized();
-        if (options.listenToFeed) {
-            return options.listenToFeed(feedUrl, callback);
-        }
-        throw new Error('listenToFeed not implemented');
-    };
-    // Auto-register if requested
-    if (options.autoRegister) {
-        registerAugmentation(augmentation);
-        // Auto-initialize if requested
-        if (options.autoInitialize) {
-            augmentation.initialize().catch((error) => {
-                console.error(`Failed to initialize augmentation ${augmentation.name}:`, error);
-            });
-        }
-    }
-    return augmentation;
-}
-/**
- * Factory for creating conduit augmentations
- */
-export function createConduitAugmentation(options) {
-    const augmentation = new BaseAugmentation(options);
-    // Implement the conduit augmentation methods
-    augmentation.establishConnection = async (targetSystemId, config) => {
-        await augmentation.ensureInitialized();
-        if (options.establishConnection) {
-            const result = options.establishConnection(targetSystemId, config);
-            return result instanceof Promise ? await result : result;
-        }
-        return {
-            success: false,
-            data: null,
-            error: 'establishConnection not implemented'
-        };
-    };
-    augmentation.readData = async (query, opts) => {
-        await augmentation.ensureInitialized();
-        if (options.readData) {
-            const result = options.readData(query, opts);
-            return result instanceof Promise ? await result : result;
-        }
-        return {
-            success: false,
-            data: null,
-            error: 'readData not implemented'
-        };
-    };
-    augmentation.writeData = async (data, opts) => {
-        await augmentation.ensureInitialized();
-        if (options.writeData) {
-            const result = options.writeData(data, opts);
-            return result instanceof Promise ? await result : result;
-        }
-        return {
-            success: false,
-            data: null,
-            error: 'writeData not implemented'
-        };
-    };
-    augmentation.monitorStream = async (streamId, callback) => {
-        await augmentation.ensureInitialized();
-        if (options.monitorStream) {
-            return options.monitorStream(streamId, callback);
-        }
-        throw new Error('monitorStream not implemented');
-    };
-    // Auto-register if requested
-    if (options.autoRegister) {
-        registerAugmentation(augmentation);
-        // Auto-initialize if requested
-        if (options.autoInitialize) {
-            augmentation.initialize().catch((error) => {
-                console.error(`Failed to initialize augmentation ${augmentation.name}:`, error);
-            });
-        }
-    }
-    return augmentation;
-}
-/**
- * Factory for creating memory augmentations
- */
-export function createMemoryAugmentation(options) {
-    const augmentation = new BaseAugmentation(options);
-    // Implement the memory augmentation methods
-    augmentation.storeData = async (key, data, opts) => {
-        await augmentation.ensureInitialized();
-        if (options.storeData) {
-            const result = options.storeData(key, data, opts);
-            return result instanceof Promise ? await result : result;
-        }
-        return {
-            success: false,
-            data: false,
-            error: 'storeData not implemented'
-        };
-    };
-    augmentation.retrieveData = async (key, opts) => {
-        await augmentation.ensureInitialized();
-        if (options.retrieveData) {
-            const result = options.retrieveData(key, opts);
-            return result instanceof Promise ? await result : result;
-        }
-        return {
-            success: false,
-            data: null,
-            error: 'retrieveData not implemented'
-        };
-    };
-    augmentation.updateData = async (key, data, opts) => {
-        await augmentation.ensureInitialized();
-        if (options.updateData) {
-            const result = options.updateData(key, data, opts);
-            return result instanceof Promise ? await result : result;
-        }
-        return {
-            success: false,
-            data: false,
-            error: 'updateData not implemented'
-        };
-    };
-    augmentation.deleteData = async (key, opts) => {
-        await augmentation.ensureInitialized();
-        if (options.deleteData) {
-            const result = options.deleteData(key, opts);
-            return result instanceof Promise ? await result : result;
-        }
-        return {
-            success: false,
-            data: false,
-            error: 'deleteData not implemented'
-        };
-    };
-    augmentation.listDataKeys = async (pattern, opts) => {
-        await augmentation.ensureInitialized();
-        if (options.listDataKeys) {
-            const result = options.listDataKeys(pattern, opts);
-            return result instanceof Promise ? await result : result;
-        }
-        return {
-            success: false,
-            data: [],
-            error: 'listDataKeys not implemented'
-        };
-    };
-    augmentation.search = async (query, k, opts) => {
-        await augmentation.ensureInitialized();
-        if (options.search) {
-            const result = options.search(query, k, opts);
-            return result instanceof Promise ? await result : result;
-        }
-        return {
-            success: false,
-            data: [],
-            error: 'search not implemented'
-        };
-    };
-    // Auto-register if requested
-    if (options.autoRegister) {
-        registerAugmentation(augmentation);
-        // Auto-initialize if requested
-        if (options.autoInitialize) {
-            augmentation.initialize().catch((error) => {
-                console.error(`Failed to initialize augmentation ${augmentation.name}:`, error);
-            });
-        }
-    }
-    return augmentation;
-}
-/**
- * Factory for creating WebSocket-enabled augmentations
- * This can be combined with other augmentation factories to create WebSocket-enabled versions
- */
-export function addWebSocketSupport(augmentation, options) {
-    const wsAugmentation = augmentation;
-    // Add WebSocket methods
-    wsAugmentation.connectWebSocket = async (url, protocols) => {
-        await augmentation.ensureInitialized?.();
-        if (options.connectWebSocket) {
-            return options.connectWebSocket(url, protocols);
-        }
-        throw new Error('connectWebSocket not implemented');
-    };
-    wsAugmentation.sendWebSocketMessage = async (connectionId, data) => {
-        await augmentation.ensureInitialized?.();
-        if (options.sendWebSocketMessage) {
-            return options.sendWebSocketMessage(connectionId, data);
-        }
-        throw new Error('sendWebSocketMessage not implemented');
-    };
-    wsAugmentation.onWebSocketMessage = async (connectionId, callback) => {
-        await augmentation.ensureInitialized?.();
-        if (options.onWebSocketMessage) {
-            return options.onWebSocketMessage(connectionId, callback);
-        }
-        throw new Error('onWebSocketMessage not implemented');
-    };
-    wsAugmentation.offWebSocketMessage = async (connectionId, callback) => {
-        await augmentation.ensureInitialized?.();
-        if (options.offWebSocketMessage) {
-            return options.offWebSocketMessage(connectionId, callback);
-        }
-        throw new Error('offWebSocketMessage not implemented');
-    };
-    wsAugmentation.closeWebSocket = async (connectionId, code, reason) => {
-        await augmentation.ensureInitialized?.();
-        if (options.closeWebSocket) {
-            return options.closeWebSocket(connectionId, code, reason);
-        }
-        throw new Error('closeWebSocket not implemented');
-    };
-    return wsAugmentation;
-}
-/**
- * Simplified function to execute an augmentation method with automatic error handling
- * This provides a more concise way to execute augmentation methods compared to the full pipeline
- */
-export async function executeAugmentation(augmentation, method, ...args) {
-    try {
-        if (!augmentation.enabled) {
-            return {
-                success: false,
-                data: null,
-                error: `Augmentation ${augmentation.name} is disabled`
-            };
-        }
-        if (typeof augmentation[method] !== 'function') {
-            return {
-                success: false,
-                data: null,
-                error: `Method ${method} not found on augmentation ${augmentation.name}`
-            };
-        }
-        const result = await augmentation[method](...args);
-        return result;
-    }
-    catch (error) {
-        console.error(`Error executing ${method} on ${augmentation.name}:`, error);
-        return {
-            success: false,
-            data: null,
-            error: error instanceof Error ? error.message : String(error)
-        };
-    }
-}
-/**
- * Dynamically load augmentations from a module at runtime
- * This allows for lazy-loading augmentations when needed instead of at build time
- */
-export async function loadAugmentationModule(modulePromise, options = {}) {
-    try {
-        const module = await modulePromise;
-        const augmentations = [];
-        // Extract augmentations from the module
-        for (const key in module) {
-            const exported = module[key];
-            // Skip non-objects and null
-            if (!exported || typeof exported !== 'object') {
-                continue;
-            }
-            // Check if it's an augmentation
-            if (typeof exported.name === 'string' &&
-                typeof exported.initialize === 'function' &&
-                typeof exported.shutDown === 'function' &&
-                typeof exported.getStatus === 'function') {
-                augmentations.push(exported);
-                // Auto-register if requested
-                if (options.autoRegister) {
-                    registerAugmentation(exported);
-                    // Auto-initialize if requested
-                    if (options.autoInitialize) {
-                        exported.initialize().catch((error) => {
-                            console.error(`Failed to initialize augmentation ${exported.name}:`, error);
-                        });
-                    }
-                }
-            }
-        }
-        return augmentations;
-    }
-    catch (error) {
-        console.error('Error loading augmentation module:', error);
-        return [];
-    }
-}
-//# sourceMappingURL=augmentationFactory.js.map