zeropoint-node 1.0.1 → 1.0.3

package/dist/api/ProductionAPI.js

@@ -1,313 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.globalProductionAPI = exports.ProductionAPI = void 0;
-const express_1 = __importDefault(require("express"));
-const Logger_1 = require("../utils/Logger");
-const HealthMonitor_1 = require("../monitoring/HealthMonitor");
-const Cache_1 = require("../utils/Cache");
-/**
- * Production API endpoints for ZeroPoint
- *
- * Provides monitoring, health checks, metrics, and management
- * endpoints for production deployment.
- */
-class ProductionAPI {
-    constructor(port = 3001) {
-        this.isRunning = false;
-        this.port = port;
-        this.app = (0, express_1.default)();
-        this.setupMiddleware();
-        this.setupRoutes();
-    }
-    /**
-     * Setup middleware
-     */
-    setupMiddleware() {
-        this.app.use(express_1.default.json());
-        this.app.use(express_1.default.urlencoded({ extended: true }));
-        // Request logging middleware
-        this.app.use((req, res, next) => {
-            const startTime = Date.now();
-            res.on("finish", () => {
-                const duration = Date.now() - startTime;
-                Logger_1.globalLogger.info("API Request", {
-                    method: req.method,
-                    path: req.path,
-                    statusCode: res.statusCode,
-                    duration,
-                    userAgent: req.get("User-Agent"),
-                });
-            });
-            next();
-        });
-        // Error handling middleware
-        this.app.use((error, _req, res) => {
-            Logger_1.globalLogger.error("API Error", {
-                method: _req.method,
-                path: _req.path,
-                error: error.message,
-            }, error);
-            res.status(500).json({
-                error: "Internal Server Error",
-                message: error.message,
-                timestamp: new Date().toISOString(),
-            });
-        });
-    }
-    /**
-     * Setup API routes
-     */
-    setupRoutes() {
-        // Health check endpoint
-        this.app.get("/health", async (_req, res) => {
-            try {
-                const healthStatus = await HealthMonitor_1.globalHealthMonitor.getHealthStatus();
-                const statusCode = healthStatus.status === "healthy"
-                    ? 200
-                    : healthStatus.status === "degraded"
-                        ? 200
-                        : 503;
-                res.status(statusCode).json(healthStatus);
-            }
-            catch {
-                res.status(503).json({
-                    status: "unhealthy",
-                    error: "Health check failed",
-                    timestamp: new Date().toISOString(),
-                });
-            }
-        });
-        // Metrics endpoint
-        this.app.get("/metrics", (_req, res) => {
-            try {
-                const metrics = {
-                    health: HealthMonitor_1.globalHealthMonitor.getCurrentMetrics(),
-                    cache: Cache_1.globalCache.getStats(),
-                    logging: Logger_1.globalLogger.getMetrics(),
-                    system: {
-                        uptime: process.uptime(),
-                        memory: process.memoryUsage(),
-                        cpu: process.cpuUsage(),
-                        pid: process.pid,
-                        version: process.version,
-                    },
-                };
-                res.json(metrics);
-            }
-            catch (error) {
-                res.status(500).json({
-                    error: "Failed to get metrics",
-                    message: error instanceof Error ? error.message : "Unknown error",
-                });
-            }
-        });
-        // Cache management endpoints
-        this.app.get("/cache/stats", (_req, res) => {
-            res.json(Cache_1.globalCache.getStats());
-        });
-        this.app.post("/cache/clear", (_req, res) => {
-            Cache_1.globalCache.clear();
-            Logger_1.globalLogger.info("Cache cleared via API");
-            res.json({ message: "Cache cleared successfully" });
-        });
-        this.app.get("/cache/keys", (_req, res) => {
-            res.json({
-                keys: Cache_1.globalCache.keys(),
-                count: Cache_1.globalCache.size(),
-            });
-        });
-        // Logging management endpoints
-        this.app.get("/logs/level", (_req, res) => {
-            res.json({
-                currentLevel: Logger_1.globalLogger.getLevel() || "INFO",
-                availableLevels: ["ERROR", "WARN", "INFO", "DEBUG", "TRACE"],
-            });
-        });
-        this.app.post("/logs/level", (req, res) => {
-            const { level } = req.body;
-            if (level &&
-                ["ERROR", "WARN", "INFO", "DEBUG", "TRACE"].includes(level)) {
-                // Update log level (this would need to be implemented in Logger)
-                Logger_1.globalLogger.info("Log level changed via API", { newLevel: level });
-                res.json({ message: "Log level updated", level });
-            }
-            else {
-                res.status(400).json({ error: "Invalid log level" });
-            }
-        });
-        // System information endpoint
-        this.app.get("/system/info", (_req, res) => {
-            res.json({
-                nodeVersion: process.version,
-                platform: process.platform,
-                arch: process.arch,
-                pid: process.pid,
-                uptime: process.uptime(),
-                memory: process.memoryUsage(),
-                cpu: process.cpuUsage(),
-                env: {
-                    NODE_ENV: process.env["NODE_ENV"],
-                    PORT: process.env["PORT"],
-                },
-            });
-        });
-        // Performance endpoint
-        this.app.get("/performance", (_req, res) => {
-            const performanceStats = Logger_1.globalLogger.getPerformanceStats();
-            res.json({
-                performance: performanceStats,
-                cache: Cache_1.globalCache.getStats(),
-                system: {
-                    memory: process.memoryUsage(),
-                    cpu: process.cpuUsage(),
-                    uptime: process.uptime(),
-                },
-            });
-        });
-        // ZeroPoint specific endpoints
-        this.app.get("/zeropoint/status", (_req, res) => {
-            // This would need access to the ZeroPoint instance
-            res.json({
-                message: "ZeroPoint status endpoint - implement with device instance",
-                timestamp: new Date().toISOString(),
-            });
-        });
-        // API documentation endpoint
-        this.app.get("/api/docs", (_req, res) => {
-            res.json({
-                name: "ZeroPoint Production API",
-                version: "1.0.0",
-                description: "Production monitoring and management API for ZeroPoint devices",
-                endpoints: {
-                    "/health": {
-                        method: "GET",
-                        description: "Health check endpoint",
-                        response: "HealthStatus object",
-                    },
-                    "/metrics": {
-                        method: "GET",
-                        description: "System metrics endpoint",
-                        response: "Metrics object",
-                    },
-                    "/cache/stats": {
-                        method: "GET",
-                        description: "Cache statistics",
-                        response: "CacheStats object",
-                    },
-                    "/cache/clear": {
-                        method: "POST",
-                        description: "Clear all caches",
-                        response: "Success message",
-                    },
-                    "/logs/level_get": {
-                        method: "GET",
-                        description: "Get current log level",
-                        response: "Log level information",
-                    },
-                    "/logs/level_post": {
-                        method: "POST",
-                        description: "Set log level",
-                        body: '{ "level": "INFO" }',
-                        response: "Success message",
-                    },
-                    "/system/info": {
-                        method: "GET",
-                        description: "System information",
-                        response: "System information object",
-                    },
-                    "/performance": {
-                        method: "GET",
-                        description: "Performance statistics",
-                        response: "Performance object",
-                    },
-                },
-            });
-        });
-        // Root endpoint
-        this.app.get("/", (_req, res) => {
-            res.json({
-                name: "ZeroPoint Production API",
-                version: "1.0.0",
-                status: "running",
-                timestamp: new Date().toISOString(),
-                endpoints: [
-                    "/health",
-                    "/metrics",
-                    "/cache/stats",
-                    "/logs/level",
-                    "/system/info",
-                    "/performance",
-                    "/api/docs",
-                ],
-            });
-        });
-    }
-    /**
-     * Start the API server
-     */
-    start() {
-        return new Promise((resolve, reject) => {
-            if (this.isRunning) {
-                resolve();
-                return;
-            }
-            const server = this.app.listen(this.port, () => {
-                this.isRunning = true;
-                Logger_1.globalLogger.info("Production API started", {
-                    port: this.port,
-                    endpointCount: 6,
-                    endpoints: "/health,/metrics,/cache/stats,/logs/level,/system/info,/performance",
-                });
-                resolve();
-            });
-            server.on("error", (error) => {
-                Logger_1.globalLogger.error("Production API failed to start", { port: this.port }, error);
-                reject(error);
-            });
-        });
-    }
-    /**
-     * Stop the API server
-     */
-    stop() {
-        return new Promise((resolve) => {
-            if (!this.isRunning) {
-                resolve();
-                return;
-            }
-            // Find and close the server
-            const server = this.app.listen();
-            if (server) {
-                server.close(() => {
-                    this.isRunning = false;
-                    Logger_1.globalLogger.info("Production API stopped");
-                    resolve();
-                });
-            }
-            else {
-                this.isRunning = false;
-                resolve();
-            }
-        });
-    }
-    /**
-     * Get the Express app instance
-     */
-    getApp() {
-        return this.app;
-    }
-    /**
-     * Check if the API is running
-     */
-    isActive() {
-        return this.isRunning;
-    }
-}
-exports.ProductionAPI = ProductionAPI;
-/**
- * Global production API instance
- */
-exports.globalProductionAPI = new ProductionAPI();

package/dist/artifacts/ArtifactRegistry.js

@@ -1,122 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArtifactRegistry = void 0;
-const MetaphysicalLawRegistry_1 = require("../laws/MetaphysicalLawRegistry");
-const CrystalArtifacts_1 = require("./CrystalArtifacts");
-/**
- * Registry for metaphysical artifacts
- * Manages artifacts and ensures they comply with metaphysical laws
- */
-class ArtifactRegistry {
-    constructor() {
-        this.artifacts = new Map();
-        this.lawRegistry = MetaphysicalLawRegistry_1.MetaphysicalLawRegistry.getInstance();
-        this.initializeDefaultArtifacts();
-    }
-    static getInstance() {
-        if (!ArtifactRegistry.instance) {
-            ArtifactRegistry.instance = new ArtifactRegistry();
-        }
-        return ArtifactRegistry.instance;
-    }
-    /**
-     * Initialize default artifacts
-     */
-    initializeDefaultArtifacts() {
-        this.registerArtifact(new CrystalArtifacts_1.CrystalOfUnity());
-        this.registerArtifact(new CrystalArtifacts_1.CrystalOfCorrespondence());
-        this.registerArtifact(new CrystalArtifacts_1.CrystalOfVibration());
-    }
-    /**
-     * Register a new artifact
-     */
-    registerArtifact(artifact) {
-        // Apply all metaphysical laws to the artifact
-        const laws = this.lawRegistry.getAllLaws();
-        laws.forEach(law => {
-            law.apply(artifact);
-        });
-        this.artifacts.set(artifact.name, artifact);
-    }
-    /**
-     * Get an artifact by name
-     */
-    getArtifact(name) {
-        return this.artifacts.get(name);
-    }
-    /**
-     * Get all artifacts
-     */
-    getAllArtifacts() {
-        return Array.from(this.artifacts.values());
-    }
-    /**
-     * Get artifacts by type
-     */
-    getArtifactsByType(type) {
-        return Array.from(this.artifacts.values()).filter(artifact => artifact.type === type);
-    }
-    /**
-     * Activate all artifacts
-     */
-    activateAllArtifacts() {
-        this.artifacts.forEach(artifact => {
-            artifact.activate();
-        });
-    }
-    /**
-     * Get artifacts with high consciousness resonance
-     */
-    getHighResonanceArtifacts(threshold = 0.7) {
-        return Array.from(this.artifacts.values()).filter(artifact => artifact.consciousnessResonance >= threshold);
-    }
-    /**
-     * Get artifacts that resonate with a target
-     */
-    getResonatingArtifacts(target, threshold = 0.5) {
-        return Array.from(this.artifacts.values()).filter(artifact => {
-            const resonance = artifact.resonateWith(target);
-            return resonance >= threshold;
-        });
-    }
-    /**
-     * Get artifact signatures for analysis
-     */
-    getArtifactSignatures() {
-        return Array.from(this.artifacts.values()).map(artifact => ({
-            name: artifact.name,
-            type: artifact.type,
-            signature: artifact.getMetaphysicalSignature()
-        }));
-    }
-    /**
-     * Create a resonance network between artifacts
-     */
-    createResonanceNetwork() {
-        const artifacts = Array.from(this.artifacts.values());
-        const network = {
-            nodes: artifacts.map(artifact => ({
-                name: artifact.name,
-                type: artifact.type,
-                powerLevel: artifact.powerLevel,
-                consciousnessResonance: artifact.consciousnessResonance
-            })),
-            connections: []
-        };
-        // Create connections based on resonance
-        for (let i = 0; i < artifacts.length; i++) {
-            for (let j = i + 1; j < artifacts.length; j++) {
-                const resonance = artifacts[i].resonateWith(artifacts[j]);
-                if (resonance > 0.3) {
-                    network.connections.push({
-                        from: artifacts[i].name,
-                        to: artifacts[j].name,
-                        strength: resonance
-                    });
-                }
-            }
-        }
-        return network;
-    }
-}
-exports.ArtifactRegistry = ArtifactRegistry;

package/dist/artifacts/CrystalArtifacts.js

@@ -1,106 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CrystalOfVibration = exports.CrystalOfCorrespondence = exports.CrystalOfUnity = void 0;
-const MetaphysicalArtifact_1 = require("./MetaphysicalArtifact");
-/**
- * Crystal of Unity - Embodies the principle of oneness
- */
-class CrystalOfUnity extends MetaphysicalArtifact_1.MetaphysicalArtifact {
-    constructor() {
-        super('Crystal of Unity', 'A crystal that embodies the principle of oneness and interconnection', 'consciousness_amplifier');
-    }
-    performFunction(context) {
-        // Unify disparate elements
-        if (context && Array.isArray(context.elements)) {
-            return {
-                unified: true,
-                elements: context.elements,
-                unityLevel: this.powerLevel,
-                interconnections: this.identifyInterconnections(context.elements)
-            };
-        }
-        return { unified: true, consciousnessLevel: this.consciousnessResonance };
-    }
-    resonateWith(target) {
-        const targetUnity = target.unityLevel || 0;
-        const resonance = Math.min(this.powerLevel * targetUnity, 1);
-        return resonance;
-    }
-    identifyInterconnections(elements) {
-        return elements.map((element, index) => ({
-            element,
-            connections: elements.filter((_, i) => i !== index),
-            connectionStrength: this.powerLevel
-        }));
-    }
-}
-exports.CrystalOfUnity = CrystalOfUnity;
-/**
- * Crystal of Correspondence - Embodies fractal patterns
- */
-class CrystalOfCorrespondence extends MetaphysicalArtifact_1.MetaphysicalArtifact {
-    constructor() {
-        super('Crystal of Correspondence', 'A crystal that embodies fractal patterns and scale invariance', 'pattern_amplifier');
-    }
-    performFunction(context) {
-        // Amplify fractal patterns
-        if (context && context.pattern) {
-            return {
-                fractal: true,
-                pattern: context.pattern,
-                scaleLevels: this.generateScaleLevels(context.pattern),
-                correspondenceStrength: this.powerLevel
-            };
-        }
-        return { fractal: true, patternAmplification: this.consciousnessResonance };
-    }
-    resonateWith(target) {
-        const targetFractal = target.isFractal || false;
-        const resonance = targetFractal ? this.powerLevel : this.powerLevel * 0.5;
-        return resonance;
-    }
-    generateScaleLevels(pattern) {
-        return [0.1, 1, 10, 100].map(scale => ({
-            scale,
-            pattern: { ...pattern, scale },
-            strength: this.powerLevel / (1 + Math.log10(scale))
-        }));
-    }
-}
-exports.CrystalOfCorrespondence = CrystalOfCorrespondence;
-/**
- * Crystal of Vibration - Embodies vibrational frequencies
- */
-class CrystalOfVibration extends MetaphysicalArtifact_1.MetaphysicalArtifact {
-    constructor() {
-        super('Crystal of Vibration', 'A crystal that embodies vibrational frequencies and resonance', 'frequency_amplifier');
-    }
-    performFunction(context) {
-        // Amplify vibrational frequencies
-        if (context && context.frequency) {
-            return {
-                amplified: true,
-                frequency: context.frequency * this.powerLevel,
-                harmonics: this.generateHarmonics(context.frequency),
-                resonanceField: this.createResonanceField()
-            };
-        }
-        return { vibrational: true, frequencyAmplification: this.consciousnessResonance };
-    }
-    resonateWith(target) {
-        const targetFrequency = target.vibrationalFrequency || 1;
-        const frequencyMatch = Math.abs(targetFrequency - this.vibrationalFrequency) < 100;
-        return frequencyMatch ? this.powerLevel : this.powerLevel * 0.3;
-    }
-    generateHarmonics(baseFrequency) {
-        return [1, 2, 3, 5, 8].map(mult => baseFrequency * mult);
-    }
-    createResonanceField() {
-        return {
-            radius: this.powerLevel * 10,
-            strength: this.consciousnessResonance,
-            frequency: this.vibrationalFrequency
-        };
-    }
-}
-exports.CrystalOfVibration = CrystalOfVibration;

package/dist/artifacts/MetaphysicalArtifact.js

@@ -1,75 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MetaphysicalArtifact = void 0;
-const MetaphysicalLawRegistry_1 = require("../laws/MetaphysicalLawRegistry");
-/**
- * Base class for metaphysical artifacts
- * Artifacts are physical or energetic objects that embody metaphysical principles
- */
-class MetaphysicalArtifact {
-    constructor(name, description, type) {
-        this.name = name;
-        this.description = description;
-        this.type = type;
-        this.powerLevel = 0;
-        this.consciousnessResonance = 0;
-        this.lawCompliance = new Map();
-        // Apply all metaphysical laws to this artifact
-        this.applyMetaphysicalLaws();
-    }
-    /**
-     * Apply all metaphysical laws to this artifact
-     */
-    applyMetaphysicalLaws() {
-        const registry = MetaphysicalLawRegistry_1.MetaphysicalLawRegistry.getInstance();
-        const laws = registry.getAllLaws();
-        laws.forEach(law => {
-            const result = law.apply(this);
-            this.lawCompliance.set(law.name, true);
-        });
-    }
-    /**
-     * Activate the artifact's metaphysical properties
-     */
-    activate() {
-        this.powerLevel = this.calculatePowerLevel();
-        this.consciousnessResonance = this.calculateConsciousnessResonance();
-    }
-    /**
-     * Calculate the artifact's power level based on its properties
-     */
-    calculatePowerLevel() {
-        const complexity = JSON.stringify(this).length;
-        const lawCompliance = Array.from(this.lawCompliance.values()).filter(Boolean).length;
-        return Math.min((complexity * lawCompliance) / 100, 1);
-    }
-    /**
-     * Calculate consciousness resonance based on metaphysical alignment
-     */
-    calculateConsciousnessResonance() {
-        const unityLevel = this.unityLevel || 0;
-        const vibrationalFrequency = this.vibrationalFrequency || 1;
-        return Math.min((unityLevel * vibrationalFrequency) / 1000, 1);
-    }
-    /**
-     * Get the artifact's metaphysical signature
-     */
-    getMetaphysicalSignature() {
-        return {
-            name: this.name,
-            type: this.type,
-            powerLevel: this.powerLevel,
-            consciousnessResonance: this.consciousnessResonance,
-            lawCompliance: Object.fromEntries(this.lawCompliance),
-            vibrationalFrequency: this.vibrationalFrequency,
-            polarity: this.polarity,
-            rhythm: this.rhythm,
-            causes: this.causes,
-            effects: this.effects,
-            masculinePrinciple: this.masculinePrinciple,
-            femininePrinciple: this.femininePrinciple,
-            consciousnessLevel: this.consciousnessLevel
-        };
-    }
-}
-exports.MetaphysicalArtifact = MetaphysicalArtifact;