@soulcraft/brainy 1.5.0 → 2.0.1

package/dist/augmentations/monitoringAugmentation.js

@@ -0,0 +1,227 @@
+/**
+ * Monitoring Augmentation - Optional Health & Performance Monitoring
+ *
+ * Replaces the hardcoded HealthMonitor in BrainyData with an optional augmentation.
+ * Provides health checks, performance monitoring, and distributed system tracking.
+ *
+ * Zero-config: Automatically enabled for distributed deployments
+ * Can be disabled or customized via augmentation registry
+ */
+import { BaseAugmentation } from './brainyAugmentation.js';
+import { HealthMonitor } from '../distributed/healthMonitor.js';
+import { DistributedConfigManager as ConfigManager } from '../distributed/configManager.js';
+/**
+ * MonitoringAugmentation - Makes health monitoring optional and pluggable
+ *
+ * Features:
+ * - Health status tracking
+ * - Performance monitoring
+ * - Error rate tracking
+ * - Distributed system health
+ * - Zero-config with smart defaults
+ */
+export class MonitoringAugmentation extends BaseAugmentation {
+    constructor(config = {}) {
+        super();
+        this.name = 'monitoring';
+        this.timing = 'after';
+        this.operations = ['search', 'add', 'delete', 'all'];
+        this.priority = 30; // Low priority, observability layer
+        this.healthMonitor = null;
+        this.configManager = null;
+        this.requestStartTimes = new Map();
+        this.config = {
+            enabled: true,
+            healthCheckInterval: 30000, // 30 seconds
+            metricsInterval: 60000, // 1 minute
+            trackLatency: true,
+            trackErrors: true,
+            trackCacheMetrics: true,
+            exposeHealthEndpoint: true,
+            ...config
+        };
+    }
+    async onInitialize() {
+        if (!this.config.enabled) {
+            this.log('Monitoring augmentation disabled by configuration');
+            return;
+        }
+        // Initialize config manager and health monitor (requires storage)
+        if (this.context?.storage) {
+            this.configManager = new ConfigManager(this.context.storage);
+            this.healthMonitor = new HealthMonitor(this.configManager);
+            this.healthMonitor.start();
+        }
+        else {
+            this.log('Storage not available - health monitoring disabled', 'warn');
+        }
+        this.log('Monitoring augmentation initialized');
+    }
+    async onShutdown() {
+        if (this.healthMonitor) {
+            this.healthMonitor.stop();
+            this.healthMonitor = null;
+        }
+        this.configManager = null;
+        this.requestStartTimes.clear();
+        this.log('Monitoring augmentation shut down');
+    }
+    /**
+     * Execute augmentation - track health metrics
+     */
+    async execute(operation, params, next) {
+        // If monitoring disabled, just pass through
+        if (!this.healthMonitor || !this.config.enabled) {
+            return next();
+        }
+        // Generate request ID for tracking
+        const requestId = `${operation}-${Date.now()}-${Math.random()}`;
+        // Track request start time
+        if (this.config.trackLatency) {
+            this.requestStartTimes.set(requestId, Date.now());
+        }
+        try {
+            // Execute operation
+            const result = await next();
+            // Track successful operation
+            if (this.config.trackLatency) {
+                const startTime = this.requestStartTimes.get(requestId);
+                if (startTime) {
+                    const latency = Date.now() - startTime;
+                    this.healthMonitor.recordRequest(latency, false);
+                    this.requestStartTimes.delete(requestId);
+                }
+            }
+            // Update vector count for 'add' operations
+            if (operation === 'add' && this.context?.brain) {
+                try {
+                    const count = await this.context.brain.getNounCount();
+                    this.healthMonitor.updateVectorCount(count);
+                }
+                catch (e) {
+                    // Ignore count update errors
+                }
+            }
+            // Track cache metrics for search operations
+            if (operation === 'search' && this.config.trackCacheMetrics) {
+                // Check if result came from cache (would be set by cache augmentation)
+                const fromCache = params._fromCache || false;
+                this.healthMonitor.recordCacheAccess(fromCache);
+            }
+            return result;
+        }
+        catch (error) {
+            // Track error
+            if (this.config.trackErrors) {
+                const startTime = this.requestStartTimes.get(requestId);
+                if (startTime) {
+                    const latency = Date.now() - startTime;
+                    this.healthMonitor.recordRequest(latency, true);
+                    this.requestStartTimes.delete(requestId);
+                }
+                else {
+                    this.healthMonitor.recordRequest(0, true);
+                }
+            }
+            throw error;
+        }
+    }
+    /**
+     * Get health status
+     */
+    getHealthStatus() {
+        if (!this.healthMonitor) {
+            return {
+                status: 'disabled',
+                enabled: false,
+                uptime: 0,
+                vectorCount: 0,
+                requestRate: 0,
+                errorRate: 0,
+                cacheHitRate: 0
+            };
+        }
+        return {
+            status: 'healthy',
+            enabled: true,
+            ...this.healthMonitor.getHealthEndpointData()
+        };
+    }
+    /**
+     * Get health endpoint data (for API exposure)
+     */
+    getHealthEndpointData() {
+        if (!this.healthMonitor) {
+            return {
+                status: 'disabled',
+                timestamp: new Date().toISOString()
+            };
+        }
+        return this.healthMonitor.getHealthEndpointData();
+    }
+    /**
+     * Update vector count manually
+     */
+    updateVectorCount(count) {
+        if (this.healthMonitor) {
+            this.healthMonitor.updateVectorCount(count);
+        }
+    }
+    /**
+     * Record custom health metric
+     */
+    recordCustomMetric(name, value) {
+        if (this.healthMonitor) {
+            // Health monitor could be extended to track custom metrics
+            this.log(`Custom metric recorded: ${name}=${value}`, 'info');
+        }
+    }
+    /**
+     * Check if system is healthy
+     */
+    isHealthy() {
+        if (!this.healthMonitor)
+            return true; // If disabled, assume healthy
+        const data = this.healthMonitor.getHealthEndpointData();
+        // Define health criteria
+        const errorRateThreshold = 0.05; // 5% error rate
+        const minUptime = 60000; // 1 minute
+        return (data.errorRate < errorRateThreshold &&
+            data.uptime > minUptime);
+    }
+    /**
+     * Get uptime in milliseconds
+     */
+    getUptime() {
+        if (!this.healthMonitor)
+            return 0;
+        const data = this.healthMonitor.getHealthEndpointData();
+        return data.uptime || 0;
+    }
+    /**
+     * Force health check
+     */
+    async checkHealth() {
+        if (!this.healthMonitor)
+            return true;
+        // Perform active health check
+        try {
+            // Could ping storage, check memory, etc.
+            if (this.context?.storage) {
+                await this.context.storage.getStatistics?.();
+            }
+            return true;
+        }
+        catch (error) {
+            this.log('Health check failed', 'warn');
+            return false;
+        }
+    }
+}
+/**
+ * Factory function for zero-config monitoring augmentation
+ */
+export function createMonitoringAugmentation(config) {
+    return new MonitoringAugmentation(config);
+}
+//# sourceMappingURL=monitoringAugmentation.js.map

package/dist/augmentations/neuralImport.d.ts

@@ -4,11 +4,9 @@
  * 🧠 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.
+ * Now using the unified BrainyAugmentation interface!
  */
-import { ISenseAugmentation, AugmentationResponse } from '../types/augmentations.js';
-import { BrainyData } from '../brainyData.js';
+import { BaseAugmentation } from './brainyAugmentation.js';
 export interface NeuralAnalysisResult {
     detectedEntities: DetectedEntity[];
     detectedRelationships: DetectedRelationship[];
@@ -48,85 +46,40 @@ export interface NeuralImportConfig {
     enableWeights: boolean;
     skipDuplicates: boolean;
     categoryFilter?: string[];
+    dataType?: string;
 }
 /**
- * Neural Import SENSE Augmentation - The Brain's Perceptual System
+ * Neural Import Augmentation - Unified Implementation
+ * Processes data with AI before storage operations
  */
-export declare class NeuralImportAugmentation implements ISenseAugmentation {
-    readonly name: string;
-    readonly description: string;
-    enabled: boolean;
-    private brainy;
+export declare class NeuralImportAugmentation extends BaseAugmentation {
+    readonly name = "neural-import";
+    readonly timing: "before";
+    operations: ("add" | "addNoun" | "addVerb" | "all")[];
+    readonly priority = 80;
     private config;
-    constructor(brainy: BrainyData, config?: Partial<NeuralImportConfig>);
-    initialize(): Promise<void>;
-    shutDown(): Promise<void>;
-    getStatus(): Promise<'active' | 'inactive' | 'error'>;
+    private analysisCache;
+    constructor(config?: Partial<NeuralImportConfig>);
+    protected onInitialize(): Promise<void>;
+    protected onShutdown(): Promise<void>;
     /**
-     * Process raw data into structured nouns and verbs using neural analysis
+     * Execute augmentation - process data with AI before storage
      */
-    processRawData(rawData: Buffer | string, dataType: string, options?: Record<string, unknown>): Promise<AugmentationResponse<{
-        nouns: string[];
-        verbs: string[];
-        confidence?: number;
-        insights?: Array<{
-            type: string;
-            description: string;
-            confidence: number;
-        }>;
-        metadata?: Record<string, unknown>;
-    }>>;
+    execute<T = any>(operation: string, params: any, next: () => Promise<T>): Promise<T>;
     /**
-     * Listen to real-time data feeds and process them
+     * Extract raw data from operation params
      */
-    listenToFeed(feedUrl: string, callback: (data: {
-        nouns: string[];
-        verbs: string[];
-        confidence?: number;
-    }) => void): Promise<void>;
+    private extractRawData;
     /**
-     * Analyze data structure without processing (preview mode)
+     * Get the full neural analysis result (for external use)
      */
-    analyzeStructure(rawData: Buffer | string, dataType: string, options?: Record<string, unknown>): Promise<AugmentationResponse<{
-        entityTypes: Array<{
-            type: string;
-            count: number;
-            confidence: number;
-        }>;
-        relationshipTypes: Array<{
-            type: string;
-            count: number;
-            confidence: number;
-        }>;
-        dataQuality: {
-            completeness: number;
-            consistency: number;
-            accuracy: number;
-        };
-        recommendations: string[];
-    }>>;
-    /**
-     * Validate data compatibility with current knowledge base
-     */
-    validateCompatibility(rawData: Buffer | string, dataType: string): Promise<AugmentationResponse<{
-        compatible: boolean;
-        issues: Array<{
-            type: string;
-            description: string;
-            severity: 'low' | 'medium' | 'high';
-        }>;
-        suggestions: string[];
-    }>>;
-    /**
-     * Get the full neural analysis result (custom method for Cortex integration)
-     */
-    getNeuralAnalysis(rawData: Buffer | string, dataType: string): Promise<NeuralAnalysisResult>;
+    getNeuralAnalysis(rawData: Buffer | string, dataType?: string): Promise<NeuralAnalysisResult>;
     /**
      * Parse raw data based on type
      */
     private parseRawData;
     /**
-     * Basic CSV parser
+     * Parse CSV data
      */
     private parseCSV;
     /**
@@ -134,66 +87,46 @@ export declare class NeuralImportAugmentation implements ISenseAugmentation {
      */
     private performNeuralAnalysis;
     /**
-     * Neural Entity Detection - The Core AI Engine
-     */
-    private detectEntitiesWithNeuralAnalysis;
-    /**
-     * Calculate entity type confidence using AI
-     */
-    private calculateEntityTypeConfidence;
-    /**
-     * Field-based confidence calculation
-     */
-    private calculateFieldBasedConfidence;
-    /**
-     * Pattern-based confidence calculation
-     */
-    private calculatePatternBasedConfidence;
-    /**
-     * Generate reasoning for entity type selection
-     */
-    private generateEntityReasoning;
-    /**
-     * Neural Relationship Detection
+     * Infer noun type from object structure
      */
-    private detectRelationshipsWithNeuralAnalysis;
+    private inferNounType;
     /**
-     * Calculate relationship confidence
+     * Detect relationships from object references
      */
-    private calculateRelationshipConfidence;
+    private detectRelationships;
     /**
-     * Calculate relationship weight/strength
+     * Infer verb type from field name
      */
-    private calculateRelationshipWeight;
+    private inferVerbType;
     /**
-     * Generate Neural Insights - The Intelligence Layer
+     * Group entities by type
      */
-    private generateNeuralInsights;
+    private groupByType;
     /**
-     * Helper methods for the neural system
+     * Store neural analysis results
      */
-    private extractMainText;
-    private generateSmartId;
-    private extractRelationshipContext;
-    private calculateTypeCompatibility;
-    private getVerbSpecificity;
-    private getRelevantFields;
-    private getMatchedPatterns;
-    private pruneRelationships;
-    private detectHierarchies;
-    private detectClusters;
-    private detectPatterns;
-    private calculateOverallConfidence;
     private storeNeuralAnalysis;
-    private getDataTypeFromPath;
-    private generateRelationshipReasoning;
-    private extractRelationshipMetadata;
     /**
-     * Assess data quality metrics
+     * Helper to get data type from file path
      */
-    private assessDataQuality;
+    private getDataTypeFromPath;
     /**
-     * Generate recommendations based on analysis
-     */
-    private generateRecommendations;
+     * PUBLIC API: Process raw data (for external use, like Synapses)
+     * This maintains compatibility with code that wants to use Neural Import directly
+     */
+    processRawData(rawData: Buffer | string, dataType: string, options?: Record<string, unknown>): Promise<{
+        success: boolean;
+        data: {
+            nouns: string[];
+            verbs: string[];
+            confidence?: number;
+            insights?: Array<{
+                type: string;
+                description: string;
+                confidence: number;
+            }>;
+            metadata?: Record<string, unknown>;
+        };
+        error?: string;
+    }>;
 }