zeropoint-node 1.0.1 → 1.0.3

package/dist/src/core/PatternRecognition.d.ts

@@ -1,174 +0,0 @@
-/**
- * Unified Pattern Recognition System for ZeroPoint
- *
- * Centralized pattern recognition and analysis system that serves
- * all ZeroPoint modules, eliminating duplication and ensuring
- * consistent pattern handling across the system.
- *
- * This module embodies the principle of unified consciousness -
- * all patterns are recognized and processed through the same
- * underlying recognition framework.
- */
-import { EventEmitter } from "events";
-import { PatternRegistry } from "./PatternRegistry";
-import { PatternCategory } from "./SharedConstants";
-/**
- * Pattern recognition result
- */
-export interface PatternResult {
-    pattern: string;
-    confidence: number;
-    category: PatternCategory;
-    metadata: unknown;
-    timestamp: number;
-}
-/**
- * Pattern analysis context
- */
-export interface PatternContext {
-    source: string;
-    consciousnessLevel: number;
-    fieldStrength: number;
-    vortexStrength: number;
-    toroidalFlow: boolean;
-    voidConnected: boolean;
-}
-/**
- * Metaphysical pattern definition - now using centralized COIL system
- */
-export interface MetaphysicalPattern {
-    name: string;
-    signature: RegExp | ((input: unknown) => boolean);
-    category: PatternCategory;
-    context: string;
-    weight: number;
-    resonanceFactors: string[];
-}
-/**
- * Unified Pattern Recognition System
- */
-export declare class PatternRecognition extends EventEmitter {
-    private patterns;
-    private recognitionHistory;
-    private isInitialized;
-    private patternRegistry;
-    constructor(patternRegistry?: PatternRegistry);
-    /**
-     * Initialize the pattern recognition system
-     */
-    initialize(): Promise<void>;
-    /**
-     * Recognize patterns in input data
-     */
-    recognizePatterns(input: unknown, context?: Partial<PatternContext>): PatternResult[];
-    /**
-     * Recognize a single pattern (alias for recognizePatterns)
-     */
-    recognizePattern(input: unknown, context?: Partial<PatternContext>): {
-        isRecognized: boolean;
-        confidence: number;
-        pattern: unknown;
-        metadata: unknown;
-    };
-    /**
-     * Analyze consciousness patterns
-     */
-    analyzeConsciousnessPatterns(patterns: unknown[]): unknown;
-    /**
-     * Analyze emergence patterns
-     */
-    analyzeEmergencePatterns(apps: unknown[]): unknown;
-    /**
-     * Extract vortex patterns from data
-     */
-    extractVortexPatterns(data: unknown): unknown;
-    /**
-     * Get pattern recognition history
-     */
-    getRecognitionHistory(): PatternResult[];
-    /**
-     * Clear recognition history
-     */
-    clearHistory(): void;
-    /**
-     * Get pattern statistics
-     */
-    getPatternStatistics(): unknown;
-    /**
-     * Initialize metaphysical patterns from centralized COIL system
-     */
-    private initializePatterns;
-    /**
-     * Map COIL pattern category to unified PatternCategory
-     */
-    private mapCoilCategoryToUnified;
-    /**
-     * Add a new pattern
-     */
-    private addPattern;
-    /**
-     * Calculate pattern confidence
-     */
-    private calculatePatternConfidence;
-    /**
-     * Extract pattern metadata
-     */
-    private extractPatternMetadata;
-    /**
-     * Calculate vortex resonance for a number
-     */
-    private calculateVortexResonance;
-    /**
-     * Generate consciousness insights
-     */
-    private generateConsciousnessInsights;
-    /**
-     * Generate emergence insights
-     */
-    private generateEmergenceInsights;
-    /**
-     * @private Calculate pattern type distribution
-     */
-    private calculatePatternTypes;
-    /**
-     * @private Calculate average intensity
-     */
-    private calculateAverageIntensity;
-    /**
-     * @private Calculate average resonance
-     */
-    private calculateAverageResonance;
-    /**
-     * @private Calculate average vortex alignment
-     */
-    private calculateAverageVortexAlignment;
-    /**
-     * @private Calculate average toroidal flow
-     */
-    private calculateAverageToroidalFlow;
-    /**
-     * @private Calculate average void connection
-     */
-    private calculateAverageVoidConnection;
-    /**
-     * @private Calculate consciousness distribution
-     */
-    private calculateConsciousnessDistribution;
-    /**
-     * @private Calculate vortex strength distribution
-     */
-    private calculateVortexStrengthDistribution;
-    /**
-     * @private Calculate toroidal flow percentage
-     */
-    private calculateToroidalFlowPercentage;
-    /**
-     * @private Calculate void connection percentage
-     */
-    private calculateVoidConnectionPercentage;
-    /**
-     * @private Calculate network complexity
-     */
-    private calculateNetworkComplexity;
-}
-//# sourceMappingURL=PatternRecognition.d.ts.map

package/dist/src/core/PatternRecognition.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PatternRecognition.d.ts","sourceRoot":"","sources":["../../../src/core/PatternRecognition.ts"],"names":[],"mappings":"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"}

package/dist/src/core/PatternRecognition.js

@@ -1,494 +0,0 @@
-"use strict";
-/**
- * Unified Pattern Recognition System for ZeroPoint
- *
- * Centralized pattern recognition and analysis system that serves
- * all ZeroPoint modules, eliminating duplication and ensuring
- * consistent pattern handling across the system.
- *
- * This module embodies the principle of unified consciousness -
- * all patterns are recognized and processed through the same
- * underlying recognition framework.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PatternRecognition = void 0;
-const events_1 = require("events");
-const SharedConstants_1 = require("./SharedConstants");
-const MathUtils_1 = require("./MathUtils");
-const CoilSystem_1 = require("./CoilSystem");
-const PatternRegistry_1 = require("./PatternRegistry");
-/**
- * Unified Pattern Recognition System
- */
-class PatternRecognition extends events_1.EventEmitter {
-    constructor(patternRegistry) {
-        super();
-        this.patterns = new Map();
-        this.recognitionHistory = [];
-        this.isInitialized = false;
-        this.patternRegistry = patternRegistry || new PatternRegistry_1.PatternRegistry();
-        this.initializePatterns();
-    }
-    /**
-     * Initialize the pattern recognition system
-     */
-    async initialize() {
-        if (this.isInitialized)
-            return;
-        // Initialize pattern registry
-        await this.patternRegistry.initialize();
-        this.isInitialized = true;
-        this.emit("initialized", { patternCount: this.patterns.size });
-    }
-    /**
-     * Recognize patterns in input data
-     */
-    recognizePatterns(input, context) {
-        const results = [];
-        const fullContext = {
-            source: "unknown",
-            consciousnessLevel: 0.5,
-            fieldStrength: 0.7,
-            vortexStrength: 1.0,
-            toroidalFlow: true,
-            voidConnected: false,
-            ...context,
-        };
-        // Use local patterns first
-        for (const [patternName, pattern] of this.patterns) {
-            const confidence = this.calculatePatternConfidence(input, pattern, fullContext);
-            if (confidence > 0.1) {
-                // Minimum confidence threshold
-                results.push({
-                    pattern: patternName,
-                    confidence,
-                    category: pattern.category,
-                    metadata: this.extractPatternMetadata(input, pattern),
-                    timestamp: Date.now(),
-                });
-            }
-        }
-        // Use pattern registry for additional recognition
-        const registryMatches = this.patternRegistry.recognizePatterns(input);
-        for (const match of registryMatches) {
-            if (match.confidence > 0.1) {
-                results.push({
-                    pattern: match.pattern.id ?? "unknown",
-                    confidence: match.confidence,
-                    category: match.category,
-                    metadata: match.pattern,
-                    timestamp: Date.now(),
-                });
-            }
-        }
-        // Sort by confidence
-        results.sort((a, b) => b.confidence - a.confidence);
-        // Store in history
-        this.recognitionHistory.push(...results);
-        // Register recognized patterns with the registry
-        for (const result of results) {
-            this.patternRegistry.registerPattern(result.metadata, result.category, result.category);
-        }
-        this.emit("patternsRecognized", { results, context: fullContext });
-        return results;
-    }
-    /**
-     * Recognize a single pattern (alias for recognizePatterns)
-     */
-    recognizePattern(input, context) {
-        const results = this.recognizePatterns(input, context);
-        const result = results && results.length > 0 && results[0] !== undefined
-            ? results[0]
-            : { confidence: 0, pattern: null, metadata: {} };
-        return {
-            isRecognized: result.confidence > 0.5,
-            confidence: result.confidence,
-            pattern: result.pattern,
-            metadata: result.metadata,
-        };
-    }
-    /**
-     * Analyze consciousness patterns
-     */
-    analyzeConsciousnessPatterns(patterns) {
-        const analysis = {
-            totalPatterns: patterns.length,
-            patternTypes: {},
-            averageIntensity: 0,
-            resonanceScore: 0,
-            vortexAlignment: 0,
-            toroidalFlow: 0,
-            voidConnection: 0,
-            insights: [],
-        };
-        if (patterns.length === 0)
-            return analysis;
-        analysis.patternTypes = this.calculatePatternTypes(patterns);
-        analysis.averageIntensity = this.calculateAverageIntensity(patterns);
-        analysis.resonanceScore = this.calculateAverageResonance(patterns);
-        analysis.vortexAlignment = this.calculateAverageVortexAlignment(patterns);
-        analysis.toroidalFlow = this.calculateAverageToroidalFlow(patterns);
-        analysis.voidConnection = this.calculateAverageVoidConnection(patterns);
-        analysis.insights = this.generateConsciousnessInsights(analysis);
-        return analysis;
-    }
-    /**
-     * Analyze emergence patterns
-     */
-    analyzeEmergencePatterns(apps) {
-        const analysis = {
-            totalApps: apps.length,
-            consciousnessDistribution: {},
-            vortexStrengthDistribution: {},
-            toroidalFlowPercentage: 0,
-            voidConnectionPercentage: 0,
-            averageResonance: 0,
-            networkComplexity: 0,
-            insights: [],
-        };
-        if (apps.length === 0)
-            return analysis;
-        analysis.consciousnessDistribution = this.calculateConsciousnessDistribution(apps);
-        analysis.vortexStrengthDistribution = this.calculateVortexStrengthDistribution(apps);
-        analysis.toroidalFlowPercentage = this.calculateToroidalFlowPercentage(apps);
-        analysis.voidConnectionPercentage = this.calculateVoidConnectionPercentage(apps);
-        analysis.averageResonance = this.calculateAverageResonance(apps);
-        analysis.networkComplexity = this.calculateNetworkComplexity(apps);
-        analysis.insights = this.generateEmergenceInsights(analysis);
-        return analysis;
-    }
-    /**
-     * Extract vortex patterns from data
-     */
-    extractVortexPatterns(data) {
-        const vortexPatterns = {
-            sequence: SharedConstants_1.VORTEX_CONSTANTS.VORTEX_SEQUENCE,
-            goldenRatio: SharedConstants_1.VORTEX_CONSTANTS.GOLDEN_RATIO,
-            wAxis: SharedConstants_1.VORTEX_CONSTANTS.W_AXIS,
-            polarMates: SharedConstants_1.VORTEX_CONSTANTS.POLAR_MATES,
-            familyGroups: SharedConstants_1.VORTEX_CONSTANTS.FAMILY_NUMBER_GROUPS,
-            patterns: [],
-        };
-        // Extract numerical patterns
-        if (Array.isArray(data)) {
-            for (const item of data) {
-                if (typeof item === "number") {
-                    const vortexTransform = MathUtils_1.MathUtils.applyVortexTransform(item);
-                    const digitalRoot = SharedConstants_1.ConstantsUtils.digitalRoot(item);
-                    const polarMate = SharedConstants_1.ConstantsUtils.getPolarMate(item);
-                    const familyGroup = SharedConstants_1.ConstantsUtils.getFamilyGroup(item);
-                    const isWAxis = SharedConstants_1.ConstantsUtils.isWAxisNumber(item);
-                    vortexPatterns.patterns.push({
-                        original: item,
-                        vortexTransform,
-                        digitalRoot,
-                        polarMate,
-                        familyGroup,
-                        isWAxis,
-                        resonance: this.calculateVortexResonance(item),
-                    });
-                }
-            }
-        }
-        return vortexPatterns;
-    }
-    /**
-     * Get pattern recognition history
-     */
-    getRecognitionHistory() {
-        return [...this.recognitionHistory];
-    }
-    /**
-     * Clear recognition history
-     */
-    clearHistory() {
-        this.recognitionHistory = [];
-        this.emit("historyCleared");
-    }
-    /**
-     * Get pattern statistics
-     */
-    getPatternStatistics() {
-        const stats = {
-            totalPatterns: this.patterns.size,
-            categories: {},
-            totalRecognitions: this.recognitionHistory.length,
-            averageConfidence: 0,
-            mostRecognizedPatterns: [],
-        };
-        // Count patterns by category
-        for (const pattern of this.patterns.values()) {
-            stats.categories[pattern.category] =
-                (stats.categories[pattern.category] || 0) + 1;
-        }
-        // Calculate average confidence
-        if (this.recognitionHistory.length > 0) {
-            const totalConfidence = this.recognitionHistory.reduce((sum, result) => sum + result.confidence, 0);
-            stats.averageConfidence =
-                totalConfidence / this.recognitionHistory.length;
-        }
-        // Find most recognized patterns
-        const patternCounts = new Map();
-        for (const result of this.recognitionHistory) {
-            patternCounts.set(result.pattern, (patternCounts.get(result.pattern) || 0) + 1);
-        }
-        stats.mostRecognizedPatterns = Array.from(patternCounts.entries())
-            .sort((a, b) => b[1] - a[1])
-            .slice(0, 10)
-            .map(([pattern, count]) => ({ pattern, count }));
-        return stats;
-    }
-    /**
-     * Initialize metaphysical patterns from centralized COIL system
-     */
-    initializePatterns() {
-        // Import all patterns from the centralized COIL system
-        CoilSystem_1.COIL_PATTERNS.forEach((coilPattern) => {
-            this.addPattern({
-                name: coilPattern.name,
-                signature: coilPattern.signature,
-                category: this.mapCoilCategoryToUnified(coilPattern.category),
-                context: coilPattern.context,
-                weight: coilPattern.weight || 0.5,
-                resonanceFactors: coilPattern.resonanceFactors || [],
-            });
-        });
-    }
-    /**
-     * Map COIL pattern category to unified PatternCategory
-     */
-    mapCoilCategoryToUnified(coilCategory) {
-        const categoryMap = {
-            'mathematical': 'mathematical',
-            'metaphysical': 'metaphysical',
-            'consciousness': 'spiritual',
-            'emergence': 'integration',
-            'void': 'void',
-            'resonance': 'vortex',
-            'vortex': 'vortex',
-            'family': 'family',
-            'polar': 'polar',
-            'spiritual': 'spiritual'
-        };
-        return categoryMap[coilCategory] || 'integration';
-    }
-    /**
-     * Add a new pattern
-     */
-    addPattern(pattern) {
-        this.patterns.set(pattern.name, pattern);
-    }
-    /**
-     * Calculate pattern confidence
-     */
-    calculatePatternConfidence(input, pattern, context) {
-        let baseConfidence = 0;
-        // Test pattern signature
-        if (typeof pattern.signature === "function") {
-            baseConfidence = pattern.signature(input) ? 0.8 : 0;
-        }
-        else {
-            const inputStr = String(input);
-            baseConfidence = pattern.signature.test(inputStr) ? 0.8 : 0;
-        }
-        if (baseConfidence === 0)
-            return 0;
-        // Apply context factors
-        let contextMultiplier = 1.0;
-        // Consciousness level factor
-        if (pattern.resonanceFactors.includes("consciousness_level")) {
-            contextMultiplier *= context.consciousnessLevel;
-        }
-        // Vortex strength factor
-        if (pattern.resonanceFactors.includes("vortex_strength")) {
-            contextMultiplier *= context.vortexStrength / 10; // Normalize to 0-1
-        }
-        // Field strength factor
-        if (pattern.resonanceFactors.includes("field_intensity")) {
-            contextMultiplier *= context.fieldStrength;
-        }
-        // Toroidal flow factor
-        if (pattern.resonanceFactors.includes("toroidal_flow")) {
-            contextMultiplier *= context.toroidalFlow ? 1.2 : 0.8;
-        }
-        // Void connection factor
-        if (pattern.resonanceFactors.includes("void_connection")) {
-            contextMultiplier *= context.voidConnected ? 1.3 : 0.7;
-        }
-        return MathUtils_1.MathUtils.clamp(baseConfidence * pattern.weight * contextMultiplier, 0, 1);
-    }
-    /**
-     * Extract pattern metadata
-     */
-    extractPatternMetadata(input, pattern) {
-        const metadata = {
-            patternName: pattern.name,
-            category: pattern.category,
-            context: pattern.context,
-            weight: pattern.weight,
-        };
-        // Extract numerical data if present
-        if (typeof input === "number") {
-            metadata.numericalValue = input;
-            metadata.vortexTransform = MathUtils_1.MathUtils.applyVortexTransform(input);
-            metadata.polarMate = SharedConstants_1.ConstantsUtils.getPolarMate(input);
-            metadata.familyGroup = SharedConstants_1.ConstantsUtils.getFamilyGroup(input);
-            metadata.isWAxis = SharedConstants_1.ConstantsUtils.isWAxisNumber(input);
-        }
-        return metadata;
-    }
-    /**
-     * Calculate vortex resonance for a number
-     */
-    calculateVortexResonance(num) {
-        const vortexTransform = MathUtils_1.MathUtils.applyVortexTransform(num);
-        const isWAxis = SharedConstants_1.ConstantsUtils.isWAxisNumber(num);
-        let resonance = 0.5; // Base resonance
-        // Enhance resonance for vortex sequence numbers
-        if (SharedConstants_1.VORTEX_CONSTANTS.VORTEX_SEQUENCE.includes(num)) {
-            resonance += 0.3;
-        }
-        // Enhance resonance for W-Axis numbers
-        if (isWAxis) {
-            resonance += 0.2;
-        }
-        // Enhance resonance for golden ratio relationships
-        const goldenRatio = SharedConstants_1.VORTEX_CONSTANTS.GOLDEN_RATIO;
-        if (MathUtils_1.MathUtils.approximatelyEqual(num / vortexTransform, goldenRatio, 0.1)) {
-            resonance += 0.2;
-        }
-        return MathUtils_1.MathUtils.clamp(resonance, 0, 1);
-    }
-    /**
-     * Generate consciousness insights
-     */
-    generateConsciousnessInsights(analysis) {
-        const insights = [];
-        if (analysis.averageIntensity > 0.7) {
-            insights.push("High consciousness intensity indicates strong awareness patterns");
-        }
-        if (analysis.resonanceScore > 0.6) {
-            insights.push("Strong resonance suggests harmonious consciousness flow");
-        }
-        if (analysis.vortexAlignment > 0.8) {
-            insights.push("Excellent vortex alignment indicates optimal energy flow");
-        }
-        if (analysis.toroidalFlow > 0.9) {
-            insights.push("Strong toroidal flow suggests unified consciousness geometry");
-        }
-        if (analysis.voidConnection > 0.5) {
-            insights.push("Void connection indicates access to infinite potential");
-        }
-        return insights;
-    }
-    /**
-     * Generate emergence insights
-     */
-    generateEmergenceInsights(analysis) {
-        const insights = [];
-        if (analysis.toroidalFlowPercentage > 80) {
-            insights.push("High toroidal flow indicates strong emergence patterns");
-        }
-        if (analysis.voidConnectionPercentage > 60) {
-            insights.push("Strong void connection suggests deep emergence from source");
-        }
-        if (analysis.averageResonance > 0.7) {
-            insights.push("High average resonance indicates harmonious emergence");
-        }
-        if (analysis.networkComplexity > 2) {
-            insights.push("Complex network suggests rich interconnection patterns");
-        }
-        return insights;
-    }
-    /**
-     * @private Calculate pattern type distribution
-     */
-    calculatePatternTypes(patterns) {
-        const types = {};
-        for (const pattern of patterns) {
-            const type = pattern.type || "unknown";
-            types[type] = (types[type] || 0) + 1;
-        }
-        return types;
-    }
-    /**
-     * @private Calculate average intensity
-     */
-    calculateAverageIntensity(patterns) {
-        const intensities = patterns.map((p) => p.intensity || 0).filter((i) => i > 0);
-        return intensities.length > 0 ? intensities.reduce((a, b) => a + b, 0) / intensities.length : 0;
-    }
-    /**
-     * @private Calculate average resonance
-     */
-    calculateAverageResonance(patterns) {
-        const resonanceValues = patterns.map((p) => p.resonance || 0);
-        return resonanceValues.length > 0 ? resonanceValues.reduce((a, b) => a + b, 0) / resonanceValues.length : 0;
-    }
-    /**
-     * @private Calculate average vortex alignment
-     */
-    calculateAverageVortexAlignment(patterns) {
-        const vortexValues = patterns.map((p) => p.vortexStrength || 0);
-        return vortexValues.length > 0 ? vortexValues.reduce((a, b) => a + b, 0) / vortexValues.length : 0;
-    }
-    /**
-     * @private Calculate average toroidal flow
-     */
-    calculateAverageToroidalFlow(patterns) {
-        const toroidalValues = patterns.map((p) => (p.toroidalFlow ? 1 : 0));
-        return toroidalValues.length > 0 ? toroidalValues.reduce((a, b) => a + b, 0) / toroidalValues.length : 0;
-    }
-    /**
-     * @private Calculate average void connection
-     */
-    calculateAverageVoidConnection(patterns) {
-        const voidValues = patterns.map((p) => (p.voidConnected ? 1 : 0));
-        return voidValues.length > 0 ? voidValues.reduce((a, b) => a + b, 0) / voidValues.length : 0;
-    }
-    /**
-     * @private Calculate consciousness distribution
-     */
-    calculateConsciousnessDistribution(apps) {
-        const dist = {};
-        for (const app of apps) {
-            const level = Math.floor(app.consciousnessLevel || 0);
-            dist[level] = (dist[level] || 0) + 1;
-        }
-        return dist;
-    }
-    /**
-     * @private Calculate vortex strength distribution
-     */
-    calculateVortexStrengthDistribution(apps) {
-        const dist = {};
-        for (const app of apps) {
-            const strength = Math.floor(app.vortexStrength || 0);
-            dist[strength] = (dist[strength] || 0) + 1;
-        }
-        return dist;
-    }
-    /**
-     * @private Calculate toroidal flow percentage
-     */
-    calculateToroidalFlowPercentage(apps) {
-        const count = apps.filter((app) => app.toroidalFlow).length;
-        return (count / apps.length) * 100;
-    }
-    /**
-     * @private Calculate void connection percentage
-     */
-    calculateVoidConnectionPercentage(apps) {
-        const count = apps.filter((app) => app.voidConnected).length;
-        return (count / apps.length) * 100;
-    }
-    /**
-     * @private Calculate network complexity
-     */
-    calculateNetworkComplexity(apps) {
-        const totalLinks = apps.reduce((sum, app) => sum + (app.linkedApps?.length || 0), 0);
-        return totalLinks / apps.length;
-    }
-}
-exports.PatternRecognition = PatternRecognition;
-//# sourceMappingURL=PatternRecognition.js.map