@soulcraft/brainy 0.54.7 → 0.56.0

package/dist/augmentations/neuralImportSense.d.ts

@@ -0,0 +1,196 @@
+/**
+ * Neural Import SENSE Augmentation - Atomic Age AI-Powered Data Understanding
+ *
+ * 🧠 The brain-in-jar's sensory system for perceiving and structuring data
+ * ⚛️ Complete with confidence scoring and relationship weight calculation
+ */
+import { ISenseAugmentation, AugmentationResponse } from '../types/augmentations.js';
+import { BrainyData } from '../brainyData.js';
+export interface NeuralAnalysisResult {
+    detectedEntities: DetectedEntity[];
+    detectedRelationships: DetectedRelationship[];
+    confidence: number;
+    insights: NeuralInsight[];
+}
+export interface DetectedEntity {
+    originalData: any;
+    nounType: string;
+    confidence: number;
+    suggestedId: string;
+    reasoning: string;
+    alternativeTypes: Array<{
+        type: string;
+        confidence: number;
+    }>;
+}
+export interface DetectedRelationship {
+    sourceId: string;
+    targetId: string;
+    verbType: string;
+    confidence: number;
+    weight: number;
+    reasoning: string;
+    context: string;
+    metadata?: Record<string, any>;
+}
+export interface NeuralInsight {
+    type: 'hierarchy' | 'cluster' | 'pattern' | 'anomaly' | 'opportunity';
+    description: string;
+    confidence: number;
+    affectedEntities: string[];
+    recommendation?: string;
+}
+export interface NeuralImportSenseConfig {
+    confidenceThreshold: number;
+    enableWeights: boolean;
+    skipDuplicates: boolean;
+    categoryFilter?: string[];
+}
+/**
+ * Neural Import SENSE Augmentation - The Brain's Perceptual System
+ */
+export declare class NeuralImportSenseAugmentation implements ISenseAugmentation {
+    readonly name: string;
+    readonly description: string;
+    enabled: boolean;
+    private brainy;
+    private config;
+    constructor(brainy: BrainyData, config?: Partial<NeuralImportSenseConfig>);
+    initialize(): Promise<void>;
+    shutDown(): Promise<void>;
+    getStatus(): Promise<'active' | 'inactive' | 'error'>;
+    /**
+     * Process raw data into structured nouns and verbs using neural analysis
+     */
+    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>;
+    }>>;
+    /**
+     * Listen to real-time data feeds and process them
+     */
+    listenToFeed(feedUrl: string, callback: (data: {
+        nouns: string[];
+        verbs: string[];
+        confidence?: number;
+    }) => void): Promise<void>;
+    /**
+     * Analyze data structure without processing (preview mode)
+     */
+    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>;
+    /**
+     * Parse raw data based on type
+     */
+    private parseRawData;
+    /**
+     * Basic CSV parser
+     */
+    private parseCSV;
+    /**
+     * Perform neural analysis on parsed data
+     */
+    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
+     */
+    private detectRelationshipsWithNeuralAnalysis;
+    /**
+     * Calculate relationship confidence
+     */
+    private calculateRelationshipConfidence;
+    /**
+     * Calculate relationship weight/strength
+     */
+    private calculateRelationshipWeight;
+    /**
+     * Generate Neural Insights - The Intelligence Layer
+     */
+    private generateNeuralInsights;
+    /**
+     * Helper methods for the neural system
+     */
+    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
+     */
+    private assessDataQuality;
+    /**
+     * Generate recommendations based on analysis
+     */
+    private generateRecommendations;
+}