@aleph-ai/tinyaleph 1.3.0 → 1.4.0

package/core/logger.js

@@ -0,0 +1,350 @@
+/**
+ * Structured Logger for TinyAleph
+ * 
+ * Provides structured logging with:
+ * - Multiple log levels (TRACE through FATAL)
+ * - JSON and text output formats
+ * - Child logger namespaces
+ * - Log history for analysis
+ * - Event emission for log aggregation
+ * 
+ * Browser-compatible: Uses console API instead of Node.js streams.
+ * Extracted from apps/sentient/lib/error-handler.js for library reuse.
+ */
+
+const { LogLevel, LogLevelNames, SimpleEventEmitter } = require('./errors');
+
+// ============================================================================
+// LOGGER
+// ============================================================================
+
+/**
+ * Structured Logger
+ */
+class Logger extends SimpleEventEmitter {
+    constructor(options = {}) {
+        super();
+        
+        this.name = options.name || 'aleph';
+        this.level = options.level ?? LogLevel.INFO;
+        this.format = options.format || 'text'; // text, json
+        this.colorize = options.colorize ?? true;
+        this.includeTimestamp = options.includeTimestamp ?? true;
+        this.includeLevel = options.includeLevel ?? true;
+        
+        // Custom output functions (defaults to console)
+        this.output = options.output || {
+            log: (...args) => console.log(...args),
+            error: (...args) => console.error(...args),
+            warn: (...args) => console.warn(...args),
+            info: (...args) => console.info(...args),
+            debug: (...args) => console.debug(...args)
+        };
+        
+        // Log history for error aggregation
+        this.history = [];
+        this.maxHistory = options.maxHistory || 1000;
+        
+        // Child loggers
+        this.children = new Map();
+        
+        // Colors (browser console supports CSS, Node uses ANSI)
+        this.isBrowser = typeof window !== 'undefined';
+        this.ansiColors = {
+            trace: '\x1b[90m',
+            debug: '\x1b[36m',
+            info: '\x1b[32m',
+            warn: '\x1b[33m',
+            error: '\x1b[31m',
+            fatal: '\x1b[35m',
+            reset: '\x1b[0m'
+        };
+        this.cssColors = {
+            trace: 'color: #888',
+            debug: 'color: #0aa',
+            info: 'color: #0a0',
+            warn: 'color: #aa0',
+            error: 'color: #a00',
+            fatal: 'color: #a0a'
+        };
+    }
+    
+    /**
+     * Create a child logger with a specific namespace
+     * @param {string} namespace - Child namespace
+     * @returns {Logger}
+     */
+    child(namespace) {
+        if (this.children.has(namespace)) {
+            return this.children.get(namespace);
+        }
+        
+        const child = new Logger({
+            name: `${this.name}:${namespace}`,
+            level: this.level,
+            format: this.format,
+            colorize: this.colorize,
+            output: this.output
+        });
+        
+        // Forward events to parent
+        child.on('log', (entry) => {
+            this.history.push(entry);
+            if (this.history.length > this.maxHistory) {
+                this.history.shift();
+            }
+            this.emit('log', entry);
+        });
+        
+        this.children.set(namespace, child);
+        return child;
+    }
+    
+    /**
+     * Log at a specific level
+     * @param {number} level - Log level
+     * @param {string} message - Log message
+     * @param {Object} data - Additional data
+     */
+    log(level, message, data = {}) {
+        if (level < this.level) return;
+        
+        const entry = {
+            timestamp: new Date().toISOString(),
+            level: LogLevelNames[level].toLowerCase(),
+            name: this.name,
+            message,
+            data: Object.keys(data).length > 0 ? data : undefined
+        };
+        
+        // Add to history
+        this.history.push(entry);
+        if (this.history.length > this.maxHistory) {
+            this.history.shift();
+        }
+        
+        // Format and output
+        this.writeOutput(entry, level);
+        
+        // Emit event
+        this.emit('log', entry);
+        
+        return entry;
+    }
+    
+    /**
+     * Write log entry to output
+     * @param {Object} entry - Log entry
+     * @param {number} level - Log level number
+     */
+    writeOutput(entry, level) {
+        if (this.format === 'json') {
+            const output = JSON.stringify(entry);
+            if (level >= LogLevel.ERROR) {
+                this.output.error(output);
+            } else {
+                this.output.log(output);
+            }
+            return;
+        }
+        
+        // Text format
+        if (this.isBrowser && this.colorize) {
+            this.writeBrowserColorized(entry, level);
+        } else if (this.colorize) {
+            this.writeAnsiColorized(entry, level);
+        } else {
+            this.writePlain(entry, level);
+        }
+    }
+    
+    /**
+     * Write colorized output for browser console
+     */
+    writeBrowserColorized(entry, level) {
+        const parts = [];
+        const styles = [];
+        
+        if (this.includeTimestamp) {
+            parts.push(`%c[${entry.timestamp}]`);
+            styles.push('color: #666');
+        }
+        
+        if (this.includeLevel) {
+            const levelStr = entry.level.toUpperCase().padEnd(5);
+            parts.push(`%c${levelStr}`);
+            styles.push(this.cssColors[entry.level] || '');
+        }
+        
+        parts.push(`%c[${entry.name}]`);
+        styles.push('color: #888');
+        
+        parts.push(`%c${entry.message}`);
+        styles.push('color: inherit');
+        
+        const formatStr = parts.join(' ');
+        const args = [formatStr, ...styles];
+        
+        if (entry.data) {
+            args.push(entry.data);
+        }
+        
+        if (level >= LogLevel.ERROR) {
+            this.output.error(...args);
+        } else if (level >= LogLevel.WARN) {
+            this.output.warn(...args);
+        } else if (level >= LogLevel.INFO) {
+            this.output.info(...args);
+        } else {
+            this.output.debug(...args);
+        }
+    }
+    
+    /**
+     * Write ANSI colorized output for Node.js terminal
+     */
+    writeAnsiColorized(entry, level) {
+        const parts = [];
+        
+        if (this.includeTimestamp) {
+            parts.push(`[${entry.timestamp}]`);
+        }
+        
+        if (this.includeLevel) {
+            const levelStr = entry.level.toUpperCase().padEnd(5);
+            const color = this.ansiColors[entry.level] || '';
+            parts.push(`${color}${levelStr}${this.ansiColors.reset}`);
+        }
+        
+        parts.push(`[${entry.name}]`);
+        parts.push(entry.message);
+        
+        if (entry.data) {
+            parts.push(JSON.stringify(entry.data));
+        }
+        
+        const output = parts.join(' ');
+        
+        if (level >= LogLevel.ERROR) {
+            this.output.error(output);
+        } else {
+            this.output.log(output);
+        }
+    }
+    
+    /**
+     * Write plain text output
+     */
+    writePlain(entry, level) {
+        const parts = [];
+        
+        if (this.includeTimestamp) {
+            parts.push(`[${entry.timestamp}]`);
+        }
+        
+        if (this.includeLevel) {
+            parts.push(entry.level.toUpperCase().padEnd(5));
+        }
+        
+        parts.push(`[${entry.name}]`);
+        parts.push(entry.message);
+        
+        if (entry.data) {
+            parts.push(JSON.stringify(entry.data));
+        }
+        
+        const output = parts.join(' ');
+        
+        if (level >= LogLevel.ERROR) {
+            this.output.error(output);
+        } else {
+            this.output.log(output);
+        }
+    }
+    
+    // Convenience methods
+    trace(message, data) { return this.log(LogLevel.TRACE, message, data); }
+    debug(message, data) { return this.log(LogLevel.DEBUG, message, data); }
+    info(message, data) { return this.log(LogLevel.INFO, message, data); }
+    warn(message, data) { return this.log(LogLevel.WARN, message, data); }
+    error(message, data) { return this.log(LogLevel.ERROR, message, data); }
+    fatal(message, data) { return this.log(LogLevel.FATAL, message, data); }
+    
+    /**
+     * Set log level
+     * @param {number|string} level - New level
+     */
+    setLevel(level) {
+        if (typeof level === 'string') {
+            this.level = LogLevel[level.toUpperCase()] ?? LogLevel.INFO;
+        } else {
+            this.level = level;
+        }
+    }
+    
+    /**
+     * Get recent log entries
+     * @param {number} count - Number of entries
+     * @param {string} level - Optional level filter
+     * @returns {Array}
+     */
+    getRecent(count = 100, level = null) {
+        let entries = this.history.slice(-count);
+        if (level) {
+            entries = entries.filter(e => e.level === level);
+        }
+        return entries;
+    }
+    
+    /**
+     * Get error summary
+     * @returns {Object}
+     */
+    getErrorSummary() {
+        const errors = this.history.filter(e => e.level === 'error' || e.level === 'fatal');
+        const categories = {};
+        
+        for (const error of errors) {
+            const cat = error.data?.category || 'unknown';
+            categories[cat] = (categories[cat] || 0) + 1;
+        }
+        
+        return {
+            totalErrors: errors.length,
+            byCategory: categories,
+            recentErrors: errors.slice(-10)
+        };
+    }
+    
+    /**
+     * Clear log history
+     */
+    clearHistory() {
+        this.history = [];
+    }
+}
+
+/**
+ * Create a namespaced logger
+ * @param {string} namespace - Logger namespace
+ * @param {Object} options - Logger options
+ * @returns {Logger}
+ */
+function createLogger(namespace, options = {}) {
+    return new Logger({
+        name: namespace,
+        ...options
+    });
+}
+
+// ============================================================================
+// EXPORTS
+// ============================================================================
+
+module.exports = {
+    Logger,
+    createLogger,
+    // Re-export LogLevel for convenience
+    LogLevel,
+    LogLevelNames
+};

package/core/prime.js

@@ -175,10 +175,145 @@ function firstNPrimes(n) {
 // Default prime list (first 100 primes)
 const DEFAULT_PRIMES = firstNPrimes(100);
 
+// ============================================================================
+// 108 INVARIANT (from 108bio.pdf - Twist Eigenstates and Topological Morphogenesis)
+// ============================================================================
+
+/**
+ * The 108 Invariant - The minimal self-referential twist cavity
+ *
+ * 108 = 2² × 3³ is identified as the fundamental invariant for:
+ * - Standard Model gauge groups (SU(3) × SU(2) × U(1))
+ * - Biological self-organization (pentagon angle 108°)
+ * - Consciousness as free energy minimization
+ *
+ * Key relationships:
+ * - Trefoil complexity (17) × 108 = 1836 (proton/electron mass ratio)
+ * - 108 + 29 (mod-30 prime sieve boundary) = 137 (fine structure constant inverse)
+ * - 5³ = 125 GeV (Higgs mass prediction)
+ */
+const TWIST_108 = {
+    // Fundamental value
+    value: 108,
+    
+    // Prime factorization: 2² × 3³
+    binary: 4,        // 2²
+    ternary: 27,      // 3³
+    
+    // Gauge symmetry angles
+    su3Angle: 120,    // SU(3) color symmetry: 360°/3 = 120° (ternary)
+    su2Angle: 180,    // SU(2) weak symmetry: 360°/2 = 180° (binary)
+    u1Angle: 360,     // U(1) electromagnetic: full rotation
+    
+    // Biological resonance
+    pentagonAngle: 108,           // Internal angle of regular pentagon
+    phyllotaxisComplement: 137.5, // Golden angle in phyllotaxis
+    
+    // Physical constants derived
+    trefoilComplexity: 17,        // Trefoil knot complexity number
+    protonElectronRatio: 1836,    // 17 × 108 = proton/electron mass ratio
+    fineStructureInverse: 137,    // 108 + 29 = α⁻¹
+    higgsMass: 125,               // 5³ GeV (first prime outside minimal twist set)
+    mod30Boundary: 29,            // Prime sieve boundary
+    
+    // Twist eigenstate formula: |n⟩τ = e^(i·2π/n)
+    twistEigenstate(n) {
+        const angle = (2 * Math.PI) / n;
+        return { re: Math.cos(angle), im: Math.sin(angle) };
+    },
+    
+    // Check if n exhibits 108-resonance (divides cleanly with 108)
+    resonates(n) {
+        if (n === 0) return false;
+        const ratio = 108 / n;
+        return Math.abs(ratio - Math.round(ratio)) < 0.001 ||
+               Math.abs(n / 108 - Math.round(n / 108)) < 0.001;
+    },
+    
+    // Get gauge group contribution from factorization
+    gaugeDecomposition(n) {
+        const factors = factorize(n);
+        return {
+            su3Contribution: factors[3] || 0,  // Powers of 3
+            su2Contribution: factors[2] || 0,  // Powers of 2
+            u1Contribution: Object.keys(factors)
+                .filter(p => p !== '2' && p !== '3')
+                .reduce((sum, p) => sum + factors[p], 0)
+        };
+    },
+    
+    // Derive mass ratio from topological integers
+    deriveMassRatio(crossings, sticks, bridge, unknotting) {
+        const trefoilComplexity = sticks * crossings - bridge + unknotting;
+        return trefoilComplexity * 108;
+    }
+};
+
+/**
+ * Twist angle for a prime (from Enochian layer and 108bio.pdf)
+ * κ(p) = 360°/p
+ * @param {number} p - Prime number
+ * @returns {number} Twist angle in degrees
+ */
+function twistAngle(p) {
+    return 360 / p;
+}
+
+/**
+ * Total twist for a sequence of primes
+ * T(P) = Σᵢ κ(pᵢ)
+ * @param {Array<number>} primes - Sequence of primes
+ * @returns {number} Total twist in degrees
+ */
+function totalTwist(primes) {
+    return primes.reduce((sum, p) => sum + twistAngle(p), 0);
+}
+
+/**
+ * Check twist closure (from discrete.pdf equation 18)
+ * A sequence is twist-closed when T(P) mod 360 ∈ [0,ε) ∪ (360-ε, 360]
+ * @param {Array<number>} primes - Sequence of primes
+ * @param {number} epsilon - Tolerance in degrees (default 1.0)
+ * @returns {boolean} True if twist-closed
+ */
+function isTwistClosed(primes, epsilon = 1.0) {
+    const twist = totalTwist(primes);
+    const mod = ((twist % 360) + 360) % 360;
+    return mod < epsilon || mod > (360 - epsilon);
+}
+
+/**
+ * Find primes that would close a twist sequence
+ * @param {Array<number>} currentPrimes - Current prime sequence
+ * @param {number} epsilon - Closure tolerance
+ * @returns {Array<Object>} Candidate primes with closure errors
+ */
+function findClosingPrimes(currentPrimes, epsilon = 1.0) {
+    const currentTwist = totalTwist(currentPrimes);
+    const mod = ((currentTwist % 360) + 360) % 360;
+    
+    const candidates = [];
+    const testPrimes = primesUpTo(100);
+    
+    for (const p of testPrimes) {
+        const newMod = ((mod + twistAngle(p)) % 360);
+        const error = Math.min(newMod, 360 - newMod);
+        candidates.push({ prime: p, error, closesAt: error < epsilon });
+    }
+    
+    return candidates.sort((a, b) => a.error - b.error);
+}
+
 module.exports = {
   primeGenerator, nthPrime, primesUpTo, isPrime,
   factorize, primeSignature, firstNPrimes,
   GaussianInteger, EisensteinInteger,
   primeToFrequency, primeToAngle, sumOfTwoSquares,
-  DEFAULT_PRIMES
+  DEFAULT_PRIMES,
+  // 108 Invariant exports
+  TWIST_108,
+  twistAngle,
+  totalTwist,
+  isTwistClosed,
+  findClosingPrimes
 };