zeropoint-node 1.0.0 → 1.0.1

package/dist/utils/Cache.js

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resonanceCache = exports.vortexMathCache = exports.globalCache = exports.ResonanceCache = exports.VortexMathCache = exports.Cache = void 0;
+class Cache {
+    constructor(config = {}) {
+        this.cache = new Map();
+        this.stats = {
+            hits: 0,
+            misses: 0,
+            sets: 0,
+            deletes: 0,
+            evictions: 0,
+        };
+        this.config = {
+            maxSize: 1000,
+            defaultTTL: 300000, // 5 minutes
+            cleanupInterval: 60000, // 1 minute
+            enableStats: true,
+            ...config,
+        };
+        // Don't start cleanup automatically - only start when explicitly requested
+        // this.startCleanup();
+    }
+    /**
+     * Set a value in the cache
+     */
+    set(key, value, ttl) {
+        const entry = {
+            key,
+            value,
+            timestamp: Date.now(),
+            ttl: ttl || this.config.defaultTTL,
+            accessCount: 0,
+            lastAccessed: Date.now(),
+        };
+        // Check if we need to evict entries
+        if (this.cache.size >= this.config.maxSize) {
+            this.evictLRU();
+        }
+        this.cache.set(key, entry);
+        this.stats.sets++;
+    }
+    /**
+     * Get a value from the cache
+     */
+    get(key) {
+        const entry = this.cache.get(key);
+        if (!entry) {
+            this.stats.misses++;
+            return null;
+        }
+        // Check if entry has expired
+        if (this.isExpired(entry)) {
+            this.cache.delete(key);
+            this.stats.misses++;
+            return null;
+        }
+        // Update access statistics
+        entry.accessCount++;
+        entry.lastAccessed = Date.now();
+        this.stats.hits++;
+        return entry.value;
+    }
+    /**
+     * Check if a key exists in the cache
+     */
+    has(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return false;
+        if (this.isExpired(entry)) {
+            this.cache.delete(key);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Delete a value from the cache
+     */
+    delete(key) {
+        const deleted = this.cache.delete(key);
+        if (deleted) {
+            this.stats.deletes++;
+        }
+        return deleted;
+    }
+    /**
+     * Clear all entries from the cache
+     */
+    clear() {
+        this.cache.clear();
+        this.stats = {
+            hits: 0,
+            misses: 0,
+            sets: 0,
+            deletes: 0,
+            evictions: 0,
+        };
+    }
+    /**
+     * Get cache statistics
+     */
+    getStats() {
+        const totalRequests = this.stats.hits + this.stats.misses;
+        const hitRate = totalRequests > 0 ? (this.stats.hits / totalRequests) * 100 : 0;
+        return {
+            ...this.stats,
+            hitRate,
+            size: this.cache.size,
+            maxSize: this.config.maxSize,
+        };
+    }
+    /**
+     * Get all cache keys
+     */
+    keys() {
+        return Array.from(this.cache.keys());
+    }
+    /**
+     * Get cache size
+     */
+    size() {
+        return this.cache.size;
+    }
+    /**
+     * Check if cache is full
+     */
+    isFull() {
+        return this.cache.size >= this.config.maxSize;
+    }
+    /**
+     * Get or set a value (atomic operation)
+     */
+    getOrSet(key, factory, ttl) {
+        const cached = this.get(key);
+        if (cached !== null) {
+            return cached;
+        }
+        const value = factory();
+        this.set(key, value, ttl);
+        return value;
+    }
+    /**
+     * Get or set a value asynchronously
+     */
+    async getOrSetAsync(key, factory, ttl) {
+        const cached = this.get(key);
+        if (cached !== null) {
+            return cached;
+        }
+        const value = await factory();
+        this.set(key, value, ttl);
+        return value;
+    }
+    /**
+     * Start cleanup interval
+     */
+    startCleanup() {
+        if (!this.cleanupInterval) {
+            this.cleanupInterval = setInterval(() => {
+                this.cleanup();
+            }, this.config.cleanupInterval);
+        }
+    }
+    /**
+     * Stop cleanup interval
+     */
+    stop() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+        }
+    }
+    /**
+     * Clean up expired entries
+     */
+    cleanup() {
+        let cleaned = 0;
+        for (const [key, entry] of this.cache.entries()) {
+            if (this.isExpired(entry)) {
+                this.cache.delete(key);
+                cleaned++;
+            }
+        }
+        if (cleaned > 0) {
+            console.debug(`Cache cleanup: removed ${cleaned} expired entries`);
+        }
+    }
+    /**
+     * Evict least recently used entry
+     */
+    evictLRU() {
+        let lruKey = null;
+        let lruTime = Date.now();
+        for (const [key, entry] of this.cache.entries()) {
+            if (entry.lastAccessed < lruTime) {
+                lruTime = entry.lastAccessed;
+                lruKey = key;
+            }
+        }
+        if (lruKey) {
+            this.cache.delete(lruKey);
+            this.stats.evictions++;
+        }
+    }
+    /**
+     * Check if an entry has expired
+     */
+    isExpired(entry) {
+        return Date.now() > entry.timestamp + entry.ttl;
+    }
+}
+exports.Cache = Cache;
+/**
+ * Specialized caches for different use cases
+ */
+class VortexMathCache extends Cache {
+    constructor() {
+        super({
+            maxSize: 500,
+            defaultTTL: 600000, // 10 minutes
+            cleanupInterval: 300000, // 5 minutes
+        });
+    }
+    /**
+     * Cache vortex field calculations
+     */
+    getVortexField(x, y, z, strength) {
+        const key = `vortex_field_${x.toFixed(3)}_${y.toFixed(3)}_${z.toFixed(3)}_${strength.toFixed(3)}`;
+        return this.get(key);
+    }
+    setVortexField(x, y, z, strength, value) {
+        const key = `vortex_field_${x.toFixed(3)}_${y.toFixed(3)}_${z.toFixed(3)}_${strength.toFixed(3)}`;
+        this.set(key, value, 300000); // 5 minutes TTL
+    }
+}
+exports.VortexMathCache = VortexMathCache;
+class ResonanceCache extends Cache {
+    constructor() {
+        super({
+            maxSize: 200,
+            defaultTTL: 300000, // 5 minutes
+            cleanupInterval: 300000, // 5 minutes
+        });
+    }
+    /**
+     * Cache resonance calculations
+     */
+    getResonance(level1, level2) {
+        const key = `resonance_${level1.toFixed(3)}_${level2.toFixed(3)}`;
+        return this.get(key);
+    }
+    setResonance(level1, level2, value) {
+        const key = `resonance_${level1.toFixed(3)}_${level2.toFixed(3)}`;
+        this.set(key, value, 300000); // 5 minutes TTL
+    }
+}
+exports.ResonanceCache = ResonanceCache;
+/**
+ * Global cache instances
+ */
+exports.globalCache = new Cache();
+exports.vortexMathCache = new VortexMathCache();
+exports.resonanceCache = new ResonanceCache();

package/dist/utils/GitIntegration.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gitIntegration = exports.GitIntegration = void 0;
+const events_1 = require("events");
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const util_1 = require("util");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+class GitIntegration extends events_1.EventEmitter {
+    constructor() {
+        super();
+        this.watching = false;
+        this.gitDir = ".git";
+        // Increase max listeners to prevent memory leak warnings
+        this.setMaxListeners(20);
+        this.startWatching();
+    }
+    startWatching() {
+        if (this.watching)
+            return;
+        try {
+            this.watcher = (0, fs_1.watch)(this.gitDir, { recursive: true }, () => {
+                this.emitGitStatus();
+                this.emitRecentCommit();
+            });
+            this.watching = true;
+        }
+        catch {
+            console.warn("Git directory not found or not accessible");
+        }
+    }
+    stopWatching() {
+        if (this.watcher) {
+            this.watcher.close();
+            this.watching = false;
+        }
+        // Remove all listeners to prevent memory leaks
+        this.removeAllListeners();
+    }
+    async emitGitStatus() {
+        try {
+            const status = await this.getLiveGitStatus();
+            this.emit("change", { type: "status", data: status });
+        }
+        catch {
+            // Silently handle errors
+        }
+    }
+    async emitRecentCommit() {
+        try {
+            const commits = await this.getRecentCommits(1);
+            if (commits.length > 0) {
+                this.emit("change", { type: "commit", data: commits[0] });
+            }
+        }
+        catch {
+            // Silently handle errors
+        }
+    }
+    async getLiveGitStatus() {
+        try {
+            const { stdout } = await execAsync("git status --porcelain -b", {
+                cwd: process.cwd(),
+            });
+            const lines = stdout.trim().split("\n");
+            let branch = "main";
+            const staged = [];
+            const unstaged = [];
+            const untracked = [];
+            lines.forEach((line) => {
+                if (line.startsWith("## ")) {
+                    const branchLine = line.replace("## ", "").split("...")[0];
+                    if (branchLine) {
+                        branch = branchLine;
+                    }
+                }
+                else if (line.trim()) {
+                    const status = line.substring(0, 2);
+                    const filename = line.substring(3);
+                    if (status.startsWith("A") || status.startsWith("M")) {
+                        staged.push(filename);
+                    }
+                    else if (status.startsWith(" M") || status.startsWith(" D")) {
+                        unstaged.push(filename);
+                    }
+                    else if (status.startsWith("??")) {
+                        untracked.push(filename);
+                    }
+                }
+            });
+            return { branch, staged, unstaged, untracked };
+        }
+        catch {
+            return { branch: "unknown", staged: [], unstaged: [], untracked: [] };
+        }
+    }
+    async getRecentCommits(n) {
+        try {
+            const { stdout } = await execAsync(`git log -n ${n} --pretty=format:"%H|%an|%ad|%s" --date=iso`, { cwd: process.cwd() });
+            if (!stdout.trim())
+                return [];
+            const commits = stdout
+                .trim()
+                .split("\n")
+                .map((line) => {
+                const [hash, author, date, ...messageParts] = line.split("|");
+                const message = messageParts.join("|");
+                return {
+                    hash: hash || "",
+                    author: author || "",
+                    date: date || "",
+                    message: message || "",
+                };
+            });
+            return commits.filter((commit) => commit.hash && commit.author && commit.date);
+        }
+        catch {
+            return [];
+        }
+    }
+    onGitChange(callback) {
+        this.on("change", callback);
+    }
+}
+exports.GitIntegration = GitIntegration;
+// Export singleton instance
+exports.gitIntegration = new GitIntegration();

package/dist/utils/Logger.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalLogger = exports.Logger = exports.LogLevel = void 0;
+const events_1 = require("events");
+/**
+ * Production-ready logging system for ZeroPoint
+ *
+ * Provides structured logging with different levels,
+ * performance monitoring, and error tracking.
+ */
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["ERROR"] = 0] = "ERROR";
+    LogLevel[LogLevel["WARN"] = 1] = "WARN";
+    LogLevel[LogLevel["INFO"] = 2] = "INFO";
+    LogLevel[LogLevel["DEBUG"] = 3] = "DEBUG";
+    LogLevel[LogLevel["TRACE"] = 4] = "TRACE";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+class Logger extends events_1.EventEmitter {
+    constructor(config = {}) {
+        super();
+        this.metrics = new Map();
+        this.performance = new Map();
+        this.config = {
+            level: LogLevel.INFO,
+            enableConsole: true,
+            enableFile: false,
+            maxFileSize: 10,
+            maxFiles: 5,
+            enablePerformance: true,
+            enableMetrics: true,
+            ...config,
+        };
+    }
+    /**
+     * Log an error message
+     */
+    error(message, data, error) {
+        this.log(LogLevel.ERROR, message, data, error);
+    }
+    /**
+     * Log a warning message
+     */
+    warn(message, data) {
+        this.log(LogLevel.WARN, message, data);
+    }
+    /**
+     * Log an info message
+     */
+    info(message, data) {
+        this.log(LogLevel.INFO, message, data);
+    }
+    /**
+     * Log a debug message
+     */
+    debug(message, data) {
+        this.log(LogLevel.DEBUG, message, data);
+    }
+    /**
+     * Log a trace message
+     */
+    trace(message, data) {
+        this.log(LogLevel.TRACE, message, data);
+    }
+    /**
+     * Start performance measurement
+     */
+    startTimer(operation) {
+        if (!this.config.enablePerformance)
+            return "";
+        const timerId = `${operation}_${Date.now()}_${Math.random()}`;
+        this.performance.set(timerId, [Date.now()]);
+        return timerId;
+    }
+    /**
+     * End performance measurement
+     */
+    endTimer(timerId, operation) {
+        if (!this.config.enablePerformance || !timerId)
+            return;
+        const startTime = this.performance.get(timerId);
+        if (startTime && startTime[0] !== undefined) {
+            const duration = Date.now() - startTime[0];
+            this.performance.delete(timerId);
+            this.debug(`Performance: ${operation}`, { duration, operation });
+            // Update metrics
+            if (this.config.enableMetrics) {
+                const key = `perf_${operation}`;
+                const current = this.metrics.get(key) || 0;
+                this.metrics.set(key, current + duration);
+            }
+        }
+    }
+    /**
+     * Increment a metric counter
+     */
+    incrementMetric(name, value = 1) {
+        if (!this.config.enableMetrics)
+            return;
+        const current = this.metrics.get(name) || 0;
+        this.metrics.set(name, current + value);
+    }
+    /**
+     * Set a metric value
+     */
+    setMetric(name, value) {
+        if (!this.config.enableMetrics)
+            return;
+        this.metrics.set(name, value);
+    }
+    /**
+     * Get all metrics
+     */
+    getMetrics() {
+        return Object.fromEntries(this.metrics);
+    }
+    /**
+     * Get performance statistics
+     */
+    getPerformanceStats() {
+        const stats = {};
+        for (const [key, values] of this.performance.entries()) {
+            if (values.length > 1) {
+                // Only completed measurements
+                const durations = values.slice(1); // Skip start time
+                const avg = durations.reduce((a, b) => a + b, 0) / durations.length;
+                const min = Math.min(...durations);
+                const max = Math.max(...durations);
+                stats[key] = { avg, min, max, count: durations.length };
+            }
+        }
+        return stats;
+    }
+    /**
+     * Create a child logger with additional context
+     */
+    child(category, additionalData) {
+        const childLogger = new Logger(this.config);
+        if (this.config.deviceId !== undefined) {
+            childLogger.config.deviceId = this.config.deviceId;
+        }
+        // Override log method to add category context
+        const originalLog = childLogger.log.bind(childLogger);
+        childLogger.log = (level, message, data, error) => {
+            const enhancedData = {
+                ...additionalData,
+                ...data,
+                category,
+            };
+            originalLog(level, message, enhancedData, error);
+        };
+        return childLogger;
+    }
+    /**
+     * Internal logging method
+     */
+    log(level, message, data, error) {
+        if (level > this.config.level)
+            return;
+        const entry = {
+            timestamp: new Date().toISOString(),
+            level,
+            message,
+            deviceId: this.config.deviceId ?? "",
+            category: "general",
+            data,
+        };
+        if (error)
+            entry.error = error;
+        // Add performance data if available
+        if (this.config.enablePerformance) {
+            const memUsage = process.memoryUsage();
+            entry.performance = {
+                memory: memUsage.heapUsed / 1024 / 1024, // MB
+                cpu: process.cpuUsage().user / 1000000, // seconds
+            };
+        }
+        // Emit log event
+        this.emit("log", entry);
+        // Console output
+        if (this.config.enableConsole) {
+            this.writeToConsole(entry);
+        }
+        // File output
+        if (this.config.enableFile && this.config.logFilePath) {
+            this.writeToFile(entry);
+        }
+    }
+    /**
+     * Write log entry to console
+     */
+    writeToConsole(entry) {
+        const levelStr = LogLevel[entry.level];
+        let timestamp = "unknown";
+        if (entry.timestamp) {
+            const splitT = entry.timestamp.split("T");
+            if (splitT.length > 1 && splitT[1]) {
+                const splitDot = splitT[1].split(".");
+                timestamp = splitDot[0] ?? "unknown";
+            }
+        }
+        const prefix = `[${timestamp}] [${levelStr}]`;
+        let output = `${prefix} ${entry.message}`;
+        if (entry.deviceId) {
+            output += ` [Device: ${entry.deviceId}]`;
+        }
+        if (entry.data) {
+            output += ` | Data: ${JSON.stringify(entry.data)}`;
+        }
+        if (entry.error) {
+            output += ` | Error: ${entry.error.message}`;
+        }
+        // Color coding for different levels
+        switch (entry.level) {
+            case LogLevel.ERROR:
+                console.error("\x1b[31m%s\x1b[0m", output); // Red
+                break;
+            case LogLevel.WARN:
+                console.warn("\x1b[33m%s\x1b[0m", output); // Yellow
+                break;
+            case LogLevel.INFO:
+                console.info("\x1b[36m%s\x1b[0m", output); // Cyan
+                break;
+            default:
+                console.log(output);
+        }
+    }
+    /**
+     * Write log entry to file
+     */
+    writeToFile(entry) {
+        // This would implement file rotation and writing
+        // For now, just emit an event for external file handling
+        this.emit("fileLog", entry);
+    }
+    getLevel() {
+        return this.config.level;
+    }
+}
+exports.Logger = Logger;
+/**
+ * Global logger instance
+ */
+exports.globalLogger = new Logger({
+    level: LogLevel.INFO,
+    enableConsole: true,
+    enablePerformance: true,
+    enableMetrics: true,
+});