zeropoint-node 1.0.1 → 1.0.3

package/dist/utils/Cache.js

@@ -1,263 +0,0 @@
-"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

@@ -1,127 +0,0 @@
-"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

@@ -1,249 +0,0 @@
-"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,
-});