zeropoint-node 1.0.0 → 1.0.1

package/dist/api/ProductionAPI.js

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

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

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

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