0xray 2.0.0

package/dist/integrations/base/types.js

@@ -0,0 +1,118 @@
+/**
+ * Integration Base Types
+ *
+ * Common TypeScript interfaces for 0xRay integrations.
+ * Provides a standardized foundation for all integration types.
+ *
+ * @version 1.0.0
+ * @since 2026-03-15
+ */
+/**
+ * Default integration configuration
+ */
+export const DEFAULT_INTEGRATION_CONFIG = {
+    enabled: true,
+    debug: false,
+    logLevel: "info",
+};
+/**
+ * Default healthy result
+ */
+export const HEALTHY_RESULT = {
+    healthy: true,
+    message: "Integration is healthy",
+};
+/**
+ * Default unhealthy result
+ */
+export function createUnhealthyResult(message, details) {
+    if (details && Object.keys(details).length > 0) {
+        return {
+            healthy: false,
+            message,
+            details,
+        };
+    }
+    return {
+        healthy: false,
+        message,
+    };
+}
+/**
+ * Creates a default integration stats object
+ */
+export function createIntegrationStats() {
+    return {
+        uptime: 0,
+        errors: 0,
+    };
+}
+// ============================================================================
+// Error Types
+// ============================================================================
+/**
+ * Base error class for integration errors
+ */
+export class IntegrationError extends Error {
+    code;
+    recoverable;
+    context;
+    constructor(message, code, recoverable, context) {
+        super(message);
+        this.code = code;
+        this.recoverable = recoverable;
+        this.context = context;
+        this.name = "IntegrationError";
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+/**
+ * Error thrown when integration is not initialized
+ */
+export class IntegrationNotInitializedError extends IntegrationError {
+    constructor(integrationName) {
+        super(`Integration '${integrationName}' is not initialized. Call initialize() first.`, "NOT_INITIALIZED", false, { integrationName });
+        this.name = "IntegrationNotInitializedError";
+    }
+}
+/**
+ * Error thrown when integration is already initialized
+ */
+export class IntegrationAlreadyInitializedError extends IntegrationError {
+    constructor(integrationName) {
+        super(`Integration '${integrationName}' is already initialized.`, "ALREADY_INITIALIZED", false, { integrationName });
+        this.name = "IntegrationAlreadyInitializedError";
+    }
+}
+/**
+ * Error thrown during integration initialization
+ */
+export class IntegrationInitializationError extends IntegrationError {
+    constructor(integrationName, originalError) {
+        super(`Failed to initialize integration '${integrationName}': ${originalError.message}`, "INITIALIZATION_FAILED", true, { integrationName, originalError: originalError.message });
+        this.name = "IntegrationInitializationError";
+    }
+}
+// ============================================================================
+// Utility Types
+// ============================================================================
+/**
+ * Type guard to check if an object is an integration
+ */
+export function isIntegration(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "name" in value &&
+        "version" in value &&
+        "status" in value &&
+        "initialize" in value &&
+        "shutdown" in value &&
+        "healthCheck" in value &&
+        "getStats" in value);
+}
+/**
+ * Type guard to check if an object is a health result
+ */
+export function isHealthy(result) {
+    return result.healthy === true;
+}

package/dist/integrations/governance/governance-client.js

@@ -0,0 +1,316 @@
+/**
+ * Governance HTTP Client
+ *
+ * Client for calling the chrono-warp-drive Dynamo governance endpoint.
+ * Handles HTTP requests, retries, and response validation.
+ *
+ * @version 1.0.0
+ * @since 2026-05-11
+ */
+import { GovernanceError, GovernanceErrorCode, GovernanceTimeoutError, GovernanceNetworkError, } from './types.js';
+import { frameworkLogger } from '../../core/framework-logger.js';
+/**
+ * HTTP client for governance endpoint
+ */
+export class GovernanceClient {
+    config;
+    stats;
+    constructor(config = {}) {
+        this.config = {
+            baseUrl: process.env.GOVERNANCE_ENDPOINT || '',
+            timeoutMs: 10000,
+            retryAttempts: 3,
+            retryDelayMs: 1000,
+            ...config,
+        };
+        this.stats = {
+            requestsTotal: 0,
+            requestsSucceeded: 0,
+            requestsFailed: 0,
+            averageResponseTimeMs: 0,
+            errors: 0,
+        };
+    }
+    /**
+     * Call any Dynamo MCP tool via call_connected_tool proxy
+     */
+    async callTool(toolName, params) {
+        const url = `${this.config.baseUrl}/call_connected_tool`;
+        return this.makeJsonRequest(url, { tool_name: toolName, params });
+    }
+    /**
+     * Check a proposal with solar-enhanced governance (govern_with_solar tool)
+     *
+     * Brings real-time solar context from NOAA GOES into governance decisions,
+     * automatically adjusting vote weight and adding warnings based on current
+     * solar activity (quiet / moderate / active / storm).
+     */
+    async governWithSolar(request) {
+        const startTime = Date.now();
+        this.stats.requestsTotal++;
+        frameworkLogger.log('governance-client', 'solar-check-start', 'info', {
+            proposalPreview: request.proposal.slice(0, 80),
+            baseVoteWeight: request.baseVoteWeight ?? 1.0,
+        });
+        try {
+            const raw = await this.callTool('govern_with_solar', {
+                proposal: request.proposal,
+                baseVoteWeight: request.baseVoteWeight ?? 1.0,
+                ...(request.sharePublicly !== undefined && { sharePublicly: request.sharePublicly }),
+                ...(request.spectralQuality !== undefined && { spectralQuality: request.spectralQuality }),
+            });
+            const result = raw.result;
+            frameworkLogger.log('governance-client', 'solar-governance-raw', 'debug', { rawResponse: JSON.stringify(raw) });
+            const response = {
+                originalRecommendation: result.originalRecommendation,
+                solarContext: result.solarContext,
+                adjustedVoteWeight: result.adjustedVoteWeight,
+                finalRecommendation: result.finalRecommendation,
+                confidenceAdjustment: result.confidenceAdjustment,
+                trinitariumMoralScore: result.trinitariumMoralScore,
+                moralTension: result.moralNumerologicalTension,
+                trinitariumGematriaFusion: result.trinitariumGematriaFusion,
+                detectedVirtues: Array.isArray(result.trinitariumDetectedVirtues) ? result.trinitariumDetectedVirtues : undefined,
+                detectedConcerns: Array.isArray(result.trinitariumDetectedConcerns) ? result.trinitariumDetectedConcerns : undefined,
+                ...(result.recommendation !== undefined && { recommendation: result.recommendation }),
+                ...(result.confidence !== undefined && { confidence: result.confidence }),
+                ...(result.resonanceScore !== undefined && { resonanceScore: result.resonanceScore }),
+                ...(result.structuralResonance !== undefined && { structuralResonance: result.structuralResonance }),
+                ...(result.proximity !== undefined && { proximity: result.proximity }),
+                ...(result.phaseAlignment !== undefined && { phaseAlignment: result.phaseAlignment }),
+                ...(result.vortexAlignment !== undefined && { vortexAlignment: result.vortexAlignment }),
+                ...(result.synchronization !== undefined && { synchronization: result.synchronization }),
+                ...(result.signalTiming !== undefined && { signalTiming: result.signalTiming }),
+                ...(result.hammerReason !== undefined && { hammerReason: result.hammerReason }),
+                ...(result.neuralContextUsed !== undefined && { neuralContextUsed: result.neuralContextUsed }),
+                ...(result.spectralQuality !== undefined && { spectralQuality: result.spectralQuality }),
+            };
+            if (!this.isValidSolarResponse(response)) {
+                throw new GovernanceError('Invalid solar governance response structure', GovernanceErrorCode.INVALID_RESPONSE, false, { response });
+            }
+            const duration = Date.now() - startTime;
+            this.updateResponseTime(duration);
+            this.stats.requestsSucceeded++;
+            this.stats.lastRequestAt = Date.now();
+            frameworkLogger.log('governance-client', 'solar-check-success', 'info', {
+                solarActivityLevel: response.solarContext.solarActivityLevel,
+                adjustedVoteWeight: response.adjustedVoteWeight,
+                confidenceAdjustment: response.confidenceAdjustment,
+                durationMs: duration,
+            });
+            return response;
+        }
+        catch (error) {
+            this.stats.requestsFailed++;
+            this.stats.errors++;
+            frameworkLogger.log('governance-client', 'solar-check-error', 'error', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    /**
+     * Evaluate a proposal with standard governance (evaluate_governance tool)
+     *
+     * For purely technical or low-level protocol decisions where external
+     * solar modifiers are undesired.
+     */
+    async evaluateGovernance(params) {
+        const startTime = Date.now();
+        this.stats.requestsTotal++;
+        frameworkLogger.log('governance-client', 'evaluate-start', 'info', {
+            proposalId: params.proposalId,
+            proposalPreview: params.proposalText.slice(0, 80),
+            agentReviewCount: params.agentReviews.length,
+        });
+        try {
+            const raw = await this.callTool('evaluate_governance', {
+                proposalId: params.proposalId,
+                proposalText: params.proposalText,
+                agentReviews: params.agentReviews,
+                ...(params.codeDiff ? { codeDiff: params.codeDiff } : {}),
+                ...(params.historicalSignalIds ? { historicalSignalIds: params.historicalSignalIds } : {}),
+            });
+            const result = raw.result;
+            const diagnostics = result.diagnostics;
+            const response = {
+                success: true,
+                proposalId: result.proposalId || '',
+                governanceIsotopeId: result.governanceIsotopeId || `evaluate-${Date.now()}`,
+                resonanceScore: result.resonanceScore ?? 0,
+                isotopicRatio: diagnostics?.isotopicRatio ?? result.isotopicRatio ?? 0,
+                vortexVolume: diagnostics?.vortexVolume ?? result.vortexVolume ?? 0,
+                historicalCoherence: diagnostics?.historicalCoherence ?? result.historicalCoherence ?? 0,
+                recommendation: result.recommendation,
+                confidence: result.confidence,
+                voteWeight: result.voteWeight,
+                reasons: Array.isArray(result.reasons)
+                    ? result.reasons
+                    : [result.reason, result.reasoning].filter(Boolean),
+            };
+            if (!this.isValidResponse(response)) {
+                throw new GovernanceError('Invalid evaluate governance response structure', GovernanceErrorCode.INVALID_RESPONSE, false, { response });
+            }
+            const duration = Date.now() - startTime;
+            this.updateResponseTime(duration);
+            this.stats.requestsSucceeded++;
+            this.stats.lastRequestAt = Date.now();
+            frameworkLogger.log('governance-client', 'evaluate-success', 'info', {
+                recommendation: response.recommendation,
+                confidence: response.confidence,
+                voteWeight: response.voteWeight,
+                durationMs: duration,
+            });
+            return response;
+        }
+        catch (error) {
+            this.stats.requestsFailed++;
+            this.stats.errors++;
+            frameworkLogger.log('governance-client', 'evaluate-error', 'error', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    /**
+     * Make HTTP request with retries and exponential backoff
+     */
+    async makeJsonRequest(url, body) {
+        let lastError;
+        if (!this.config.baseUrl) {
+            throw new GovernanceError('Governance endpoint not configured. Set GOVERNANCE_ENDPOINT environment variable.', GovernanceErrorCode.CONFIG_INVALID, false, { hint: 'export GOVERNANCE_ENDPOINT=https://your-governance-endpoint.com' });
+        }
+        for (let attempt = 0; attempt < (this.config.retryAttempts || 1); attempt++) {
+            try {
+                return await this.doJsonRequest(url, body);
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                if (error instanceof GovernanceError && !error.recoverable) {
+                    throw error;
+                }
+                if (attempt < (this.config.retryAttempts || 1) - 1) {
+                    const delay = (this.config.retryDelayMs || 1000) * Math.pow(2, attempt);
+                    await this.delay(delay);
+                }
+            }
+        }
+        throw lastError || new GovernanceError('All request attempts failed', GovernanceErrorCode.REQUEST_FAILED, false);
+    }
+    /**
+     * Validate solar governance response structure with range checks
+     */
+    isValidSolarResponse(response) {
+        if (typeof response !== 'object' || response === null)
+            return false;
+        const r = response;
+        const hasSolarContext = typeof r.solarContext === 'object' && r.solarContext !== null;
+        if (!hasSolarContext)
+            return false;
+        const sc = r.solarContext;
+        const validLevels = ['quiet', 'moderate', 'active', 'storm'];
+        return (typeof r.originalRecommendation === 'string' &&
+            typeof sc.solarActivityLevel === 'string' &&
+            validLevels.includes(sc.solarActivityLevel) &&
+            ((typeof sc.solarIsotopicResonance === 'number' &&
+                sc.solarIsotopicResonance >= 0 &&
+                sc.solarIsotopicResonance <= 1) ||
+                typeof sc.solarResonance === 'number') &&
+            typeof sc.solarActivityModifier === 'number' &&
+            sc.solarActivityModifier >= -1 &&
+            sc.solarActivityModifier <= 1 &&
+            typeof sc.recommendation === 'string' &&
+            typeof r.adjustedVoteWeight === 'number' &&
+            r.adjustedVoteWeight >= 0.5 &&
+            r.adjustedVoteWeight <= 1.5 &&
+            typeof r.finalRecommendation === 'string' &&
+            typeof r.confidenceAdjustment === 'number');
+    }
+    async doJsonRequest(url, body) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.config.timeoutMs);
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Accept': 'application/json',
+                },
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                throw new GovernanceError(`HTTP ${response.status}: ${response.statusText}`, GovernanceErrorCode.REQUEST_FAILED, response.status >= 500, { status: response.status, statusText: response.statusText });
+            }
+            return await response.json();
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof GovernanceError)
+                throw error;
+            if (error instanceof Error) {
+                if (error.name === 'AbortError') {
+                    throw new GovernanceTimeoutError(this.config.timeoutMs);
+                }
+                throw new GovernanceNetworkError(url, error);
+            }
+            throw new GovernanceError(String(error), GovernanceErrorCode.REQUEST_FAILED, true);
+        }
+    }
+    /**
+     * Validate governance response structure
+     */
+    isValidResponse(response) {
+        if (typeof response !== 'object' || response === null)
+            return false;
+        const r = response;
+        return (typeof r.proposalId === 'string' &&
+            typeof r.governanceIsotopeId === 'string' &&
+            typeof r.resonanceScore === 'number' &&
+            typeof r.recommendation === 'string' &&
+            ['PASS', 'NEEDS_REVISION', 'REJECT'].includes(r.recommendation) &&
+            typeof r.confidence === 'number' &&
+            typeof r.voteWeight === 'number' &&
+            Array.isArray(r.reasons) &&
+            r.reasons.every((r) => typeof r === 'string'));
+    }
+    /**
+     * Update average response time
+     */
+    updateResponseTime(durationMs) {
+        const total = this.stats.requestsSucceeded;
+        this.stats.averageResponseTimeMs =
+            (this.stats.averageResponseTimeMs * (total - 1) + durationMs) / total;
+    }
+    /**
+     * Delay utility
+     */
+    delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * Get client statistics
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Update client configuration
+     */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+    /**
+     * Reset statistics
+     */
+    resetStats() {
+        this.stats = {
+            requestsTotal: 0,
+            requestsSucceeded: 0,
+            requestsFailed: 0,
+            averageResponseTimeMs: 0,
+            errors: 0,
+        };
+    }
+}