0xray 3.4.2 → 3.4.4

package/dist/integrations/base/types.d.ts

@@ -0,0 +1,167 @@
+/**
+ * Integration Base Types
+ *
+ * Common TypeScript interfaces for 0xRay integrations.
+ * Provides a standardized foundation for all integration types.
+ *
+ * @since 2026-03-15
+ */
+import type { EventEmitter } from "events";
+/**
+ * Log levels for integration logging
+ */
+export type LogLevel = "error" | "warn" | "info" | "debug";
+/**
+ * Integration configuration options
+ */
+export interface IntegrationConfig {
+    /** Whether the integration is enabled */
+    enabled: boolean;
+    /** Enable debug mode for additional logging */
+    debug: boolean;
+    /** Log level for the integration */
+    logLevel: LogLevel;
+    /** Optional custom configuration options */
+    custom?: Record<string, unknown>;
+}
+/**
+ * Default integration configuration
+ */
+export declare const DEFAULT_INTEGRATION_CONFIG: IntegrationConfig;
+/**
+ * Integration lifecycle status
+ */
+export type IntegrationStatus = "uninitialized" | "initializing" | "initialized" | "error" | "shutting-down" | "shutdown";
+/**
+ * Health check result
+ */
+export interface HealthResult {
+    /** Whether the integration is healthy */
+    healthy: boolean;
+    /** Human-readable message describing the health status */
+    message: string;
+    /** Optional additional details about the health status */
+    details?: Record<string, unknown> | undefined;
+}
+/**
+ * Default healthy result
+ */
+export declare const HEALTHY_RESULT: HealthResult;
+/**
+ * Default unhealthy result
+ */
+export declare function createUnhealthyResult(message: string, details?: Record<string, unknown>): HealthResult;
+/**
+ * Base integration statistics
+ */
+export interface IntegrationStats {
+    /** Time since initialization in milliseconds */
+    uptime: number;
+    /** Number of errors encountered */
+    errors: number;
+    /** Optional custom statistics */
+    custom?: Record<string, unknown>;
+}
+/**
+ * Creates a default integration stats object
+ */
+export declare function createIntegrationStats(): IntegrationStats;
+/**
+ * Base integration events
+ */
+export type IntegrationEventType = "initialized" | "initializing" | "shutdown" | "shutting-down" | "error" | "health-check" | "stats-updated" | "config-updated";
+/**
+ * Integration event payload
+ */
+export interface IntegrationEvent<T = unknown> {
+    /** Event type */
+    type: IntegrationEventType;
+    /** Timestamp when the event occurred */
+    timestamp: number;
+    /** Event data */
+    data?: T | undefined;
+    /** Optional error if event represents an error */
+    error?: Error | undefined;
+}
+/**
+ * Integration interface
+ * All 0xRay integrations must implement this interface
+ */
+export interface IIntegration {
+    /** Unique name of the integration */
+    readonly name: string;
+    /** Version of the integration */
+    readonly version: string;
+    /** Current lifecycle status */
+    readonly status: IntegrationStatus;
+    /**
+     * Initialize the integration with optional configuration
+     * @param config - Optional partial configuration to merge with defaults
+     */
+    initialize(config?: Partial<IntegrationConfig>): Promise<void>;
+    /**
+     * Gracefully shutdown the integration
+     * Should clean up resources and close connections
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Perform a health check
+     * @returns Promise resolving to health result
+     */
+    healthCheck(): Promise<HealthResult>;
+    /**
+     * Get current integration statistics
+     * @returns Current stats object
+     */
+    getStats(): IntegrationStats;
+}
+/**
+ * Extended integration interface with event support
+ */
+export interface IEventedIntegration extends IIntegration {
+    /** Get the event emitter for this integration */
+    getEventEmitter(): EventEmitter;
+}
+/**
+ * Integration factory function type
+ */
+export type IntegrationFactory<T extends IIntegration = IIntegration> = (config?: Partial<IntegrationConfig>) => T;
+/**
+ * Integration constructor type
+ */
+export type IntegrationConstructor<T extends IIntegration = IIntegration> = new (config?: Partial<IntegrationConfig>) => T;
+/**
+ * Base error class for integration errors
+ */
+export declare class IntegrationError extends Error {
+    readonly code: string;
+    readonly recoverable: boolean;
+    readonly context?: Record<string, unknown> | undefined;
+    constructor(message: string, code: string, recoverable: boolean, context?: Record<string, unknown> | undefined);
+}
+/**
+ * Error thrown when integration is not initialized
+ */
+export declare class IntegrationNotInitializedError extends IntegrationError {
+    constructor(integrationName: string);
+}
+/**
+ * Error thrown when integration is already initialized
+ */
+export declare class IntegrationAlreadyInitializedError extends IntegrationError {
+    constructor(integrationName: string);
+}
+/**
+ * Error thrown during integration initialization
+ */
+export declare class IntegrationInitializationError extends IntegrationError {
+    constructor(integrationName: string, originalError: Error);
+}
+/**
+ * Type guard to check if an object is an integration
+ */
+export declare function isIntegration(value: unknown): value is IIntegration;
+/**
+ * Type guard to check if an object is a health result
+ */
+export declare function isHealthy(result: HealthResult): boolean;

package/dist/integrations/enforcement-gate.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Enforcement Gate — shared v3 pipeline entry point for TUI/CLI integration hooks.
+ *
+ * Provides beforeToolHook (early ValidatorRegistry + block decision) and
+ * afterToolHook (post-tool v3 PostProcessor loop + governance routing) that
+ * all four host integrations (OpenCode, Hermes, Grok, OpenClaw) call from
+ * their programmatic hook surfaces (tool.execute.before/after, onPreToolCall,
+ * PreToolUse, onToolBefore/onToolAfter).
+ *
+ * This is the canonical "how a TUI/CLI tool leverages v3 cleanly."
+ *
+ * @module integrations/enforcement-gate
+ */
+export interface GateViolation {
+    ruleId: string;
+    severity: string;
+    message: string;
+    suggestions?: string[];
+}
+export interface BeforeHookResult {
+    allowed: boolean;
+    blocked: boolean;
+    violations: GateViolation[];
+    resonance: number;
+    duration: number;
+}
+export interface AfterHookResult {
+    processed: boolean;
+    violations: GateViolation[];
+    processorResults: Array<{
+        name: string;
+        success: boolean;
+        error?: string;
+    }>;
+    governanceTriggered: boolean;
+    duration: number;
+}
+export interface GateContext {
+    directory?: string;
+    projectRoot?: string;
+    sessionId?: string;
+}
+export declare function beforeToolHook(tool: string, args: Record<string, unknown> | null, _context?: GateContext): Promise<BeforeHookResult>;
+export declare function afterToolHook(tool: string, args: Record<string, unknown> | null, _result: unknown, _error: string | null, _context?: GateContext): Promise<AfterHookResult>;

package/dist/integrations/governance/governance-client.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Governance HTTP Client
+ *
+ * Client for calling the chrono-warp-drive Dynamo governance endpoint.
+ * Handles HTTP requests, retries, and response validation.
+ *
+ * @since 2026-05-11
+ */
+import type { GovernanceCheckResponse, SolarGovernanceCheckRequest, SolarGovernanceCheckResponse, GovernanceClientConfig, GovernanceClientStats } from './types.js';
+/**
+ * HTTP client for governance endpoint
+ */
+export declare class GovernanceClient {
+    private config;
+    private stats;
+    constructor(config?: Partial<GovernanceClientConfig>);
+    /**
+     * Call any Dynamo MCP tool via call_connected_tool proxy
+     */
+    private callTool;
+    /**
+     * 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).
+     */
+    governWithSolar(request: SolarGovernanceCheckRequest): Promise<SolarGovernanceCheckResponse>;
+    /**
+     * Evaluate a proposal with standard governance (evaluate_governance tool)
+     *
+     * For purely technical or low-level protocol decisions where external
+     * solar modifiers are undesired.
+     */
+    evaluateGovernance(params: {
+        proposalId: string;
+        proposalText: string;
+        agentReviews: string[];
+        codeDiff?: string;
+        historicalSignalIds?: string[];
+    }): Promise<GovernanceCheckResponse>;
+    /**
+     * Make HTTP request with retries and exponential backoff
+     */
+    private makeJsonRequest;
+    /**
+     * Validate solar governance response structure with range checks
+     */
+    private isValidSolarResponse;
+    private doJsonRequest;
+    /**
+     * Validate governance response structure
+     */
+    private isValidResponse;
+    /**
+     * Update average response time
+     */
+    private updateResponseTime;
+    /**
+     * Delay utility
+     */
+    private delay;
+    /**
+     * Get client statistics
+     */
+    getStats(): GovernanceClientStats;
+    /**
+     * Update client configuration
+     */
+    updateConfig(config: Partial<GovernanceClientConfig>): void;
+    /**
+     * Reset statistics
+     */
+    resetStats(): void;
+}

package/dist/integrations/governance/index.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Inference Governance Integration
+ *
+ * Integrates chrono-warp-drive Dynamo governance endpoint for external
+ * inference checking in governance decision-making.
+ *
+ * @since 2026-05-11
+ */
+import { BaseIntegration } from '../base/index.js';
+import type { GovernanceIntegrationConfig, GovernanceVoteResult, BatchGovernanceCheck } from './types.js';
+import type { InferenceProposal } from '../../inference/inference-cycle.js';
+/**
+ * Main Governance Integration class
+ *
+ * Provides external governance checking for inference proposals via the
+ * chrono-warp-drive Dynamo /governance endpoint.
+ */
+export declare class InferenceGovernanceIntegration extends BaseIntegration {
+    private client;
+    private configData;
+    constructor();
+    /**
+     * Perform integration-specific initialization
+     */
+    protected performInitialization(): Promise<void>;
+    /**
+     * Perform integration-specific shutdown
+     */
+    protected performShutdown(): Promise<void>;
+    /**
+     * Perform health check
+     */
+    protected performHealthCheck(): Promise<{
+        healthy: boolean;
+        message: string;
+        details?: Record<string, unknown>;
+    }>;
+    /**
+     * Check if governance is enabled and available
+     */
+    isAvailable(): boolean;
+    /**
+     * Check a single inference proposal via the appropriate governance tool
+     *
+     * Routes to govern_with_solar (strategic proposals) or evaluate_governance
+     * (technical proposals) based on proposal type.
+     */
+    checkProposal(proposal: InferenceProposal, agentReviews?: string[], historicalIds?: string[]): Promise<GovernanceVoteResult>;
+    /**
+     * Route: evaluate_governance — for purely technical proposals (fix, guard)
+     */
+    private evaluateProposal;
+    /**
+     * Route: govern_with_solar — for strategic proposals (refactor, codify, automate)
+     *
+     * Brings real-time NOAA GOES solar context into the decision, adjusting
+     * vote weight and adding warnings based on current solar activity.
+     */
+    private governWithSolarProposal;
+    /**
+     * Check multiple proposals with external governance
+     */
+    checkProposals(proposals: InferenceProposal[], agentReviews?: string[], historicalIds?: string[]): Promise<BatchGovernanceCheck>;
+    /**
+     * Apply decision logic based on governance response
+     */
+    private applyDecisionLogic;
+    /**
+     * Create fallback vote when governance is unavailable
+     */
+    private createFallbackVote;
+    /**
+     * Load configuration from features.json
+     */
+    private loadConfig;
+    /**
+     * Get governance-specific configuration
+     */
+    getGovernanceConfig(): GovernanceIntegrationConfig;
+    /**
+     * Get client statistics
+     */
+    getClientStats(): import("./types.js").GovernanceClientStats;
+}
+/**
+ * Initialize the global governance integration
+ */
+export declare function initializeGovernanceIntegration(): Promise<InferenceGovernanceIntegration>;
+/**
+ * Get the global governance integration
+ */
+export declare function getGovernanceIntegration(): InferenceGovernanceIntegration | null;
+/**
+ * Shutdown the global governance integration
+ */
+export declare function shutdownGovernanceIntegration(): Promise<void>;
+export * from './types.js';
+export * from './governance-client.js';

package/dist/integrations/governance/types.d.ts

@@ -0,0 +1,238 @@
+/**
+ * Inference Governance Integration Types
+ *
+ * Type definitions for the chrono-warp-drive Dynamo governance endpoint integration.
+ * Provides external governance checking for inference-driven proposals.
+ *
+ * @since 2026-05-11
+ */
+import type { InferenceProposal } from '../../inference/inference-cycle.js';
+/**
+ * Governance check request payload
+ * Matches the Dynamo /governance endpoint format
+ */
+export interface GovernanceCheckRequest {
+    proposalId: string;
+    proposalText: string;
+    codeDiff?: string;
+    agentReviews: string[];
+    historicalSignalIds?: string[];
+}
+/**
+ * Governance check response from Dynamo endpoint
+ */
+export interface GovernanceCheckResponse {
+    success: boolean;
+    proposalId: string;
+    governanceIsotopeId: string;
+    resonanceScore: number;
+    isotopicRatio: number;
+    vortexVolume: number;
+    historicalCoherence: number;
+    recommendation: 'PASS' | 'NEEDS_REVISION' | 'REJECT';
+    confidence: number;
+    voteWeight: number;
+    reasons: string[];
+}
+/**
+ * Governance integration configuration
+ */
+export interface GovernanceIntegrationConfig {
+    /** Whether the integration is enabled */
+    enabled: boolean;
+    /** Governance endpoint URL */
+    endpointUrl: string;
+    /** Request timeout in milliseconds */
+    requestTimeoutMs: number;
+    /** Minimum confidence threshold for proposals */
+    minConfidenceThreshold: number;
+    /** Decision logic configuration */
+    decisionLogic: {
+        /** Minimum confidence for PASS recommendation */
+        passConfidenceMin: number;
+        /** Maximum confidence for NEEDS_REVISION (below this is PASS, above is REJECT) */
+        revisionConfidenceMax: number;
+        /** Multiplier for vote weight from governance */
+        voteWeightMultiplier: number;
+    };
+}
+/**
+ * Default governance configuration
+ */
+export declare const DEFAULT_GOVERNANCE_CONFIG: GovernanceIntegrationConfig;
+/**
+ * Solar activity levels from NOAA GOES data
+ */
+export type SolarActivityLevel = 'quiet' | 'moderate' | 'active' | 'storm';
+/**
+ * Solar context returned by govern_with_solar
+ */
+export interface SolarContext {
+    /** Current solar activity level */
+    solarActivityLevel: SolarActivityLevel;
+    /** Solar isotopic resonance score (0-1) — canonical field */
+    solarIsotopicResonance: number;
+    /** Alias for backward compatibility */
+    solarResonance?: number;
+    /** Modifier applied to vote weight based on solar activity */
+    solarActivityModifier: number;
+    /** Human-readable recommendation based on solar conditions */
+    recommendation: string;
+}
+/**
+ * Solar-enhanced governance check request
+ */
+export interface SolarGovernanceCheckRequest {
+    /** The proposal text to evaluate */
+    proposal: string;
+    /** Starting vote weight (0.5 - 1.5) */
+    baseVoteWeight?: number;
+    /** Whether to share the governance result publicly */
+    sharePublicly?: boolean;
+    /** Spectral quality score for resonance analysis */
+    spectralQuality?: number;
+}
+/**
+ * Solar-enhanced governance check response
+ */
+export interface SolarGovernanceCheckResponse {
+    /** Original recommendation before solar adjustments */
+    originalRecommendation: string;
+    /** Real-time solar context from NOAA GOES */
+    solarContext: SolarContext;
+    /** Vote weight after solar adjustment */
+    adjustedVoteWeight: number;
+    /** Final recommendation with solar warning appended if applicable */
+    finalRecommendation: string;
+    /** Confidence adjustment applied due to solar activity */
+    confidenceAdjustment: number;
+    /** Trinitarium Moral Overlay — moral alignment score (0-1) */
+    trinitariumMoralScore?: number | undefined;
+    moralTension?: 'Aligned' | 'Mild' | 'Significant' | 'Critical' | undefined;
+    trinitariumGematriaFusion?: number | undefined;
+    detectedVirtues?: string[] | undefined;
+    detectedConcerns?: string[] | undefined;
+    /** Server-side authoritative recommendation */
+    recommendation?: string;
+    /** Confidence score from governance */
+    confidence?: number;
+    /** Resonance score */
+    resonanceScore?: number;
+    /** Structural resonance metric */
+    structuralResonance?: number;
+    /** Proximity metric */
+    proximity?: number;
+    /** Phase alignment metric */
+    phaseAlignment?: number;
+    /** Vortex alignment metric */
+    vortexAlignment?: number;
+    /** Synchronization metric */
+    synchronization?: number;
+    /** Signal timing indicator */
+    signalTiming?: string;
+    /** Human-readable hammer reason */
+    hammerReason?: string;
+    /** Whether neural context was used */
+    neuralContextUsed?: boolean;
+    /** Spectral quality score */
+    spectralQuality?: number;
+}
+/**
+ * Solar-enhanced vote result — extends standard vote with solar context
+ */
+export interface SolarGovernanceVoteResult extends GovernanceVoteResult {
+    /** Solar context that influenced the decision */
+    solarContext: SolarContext;
+    /** Confidence adjustment from solar activity */
+    solarConfidenceAdjustment: number;
+}
+/**
+ * Governance vote result after applying decision logic
+ */
+export interface GovernanceVoteResult {
+    /** Final vote decision */
+    vote: 'YES' | 'NO' | 'ABSTAIN';
+    /** Vote weight (affected by governance confidence) */
+    weight: number;
+    /** Human-readable reason for the vote */
+    reason: string;
+    /** Raw governance response for audit trail */
+    governanceResponse: GovernanceCheckResponse;
+    /** Whether the proposal passed governance */
+    passed: boolean;
+    /** Moral-Numerological Tension from Trinitarium Moral Overlay */
+    moralTension?: 'Aligned' | 'Mild' | 'Significant' | 'Critical' | undefined;
+    moralScore?: number | undefined;
+    moralFusion?: number | undefined;
+    detectedVirtues?: string[] | undefined;
+    detectedConcerns?: string[] | undefined;
+}
+/**
+ * Batch governance check for multiple proposals
+ */
+export interface BatchGovernanceCheck {
+    proposals: InferenceProposal[];
+    results: GovernanceVoteResult[];
+    batchId: string;
+    timestamp: number;
+}
+/**
+ * HTTP client configuration
+ */
+export interface GovernanceClientConfig {
+    baseUrl: string;
+    timeoutMs: number;
+    retryAttempts?: number;
+    retryDelayMs?: number;
+}
+/**
+ * Client statistics
+ */
+export interface GovernanceClientStats {
+    requestsTotal: number;
+    requestsSucceeded: number;
+    requestsFailed: number;
+    averageResponseTimeMs: number;
+    lastRequestAt?: number;
+    errors: number;
+}
+/**
+ * Governance error codes
+ */
+export declare enum GovernanceErrorCode {
+    REQUEST_FAILED = "REQUEST_FAILED",
+    TIMEOUT = "TIMEOUT",
+    INVALID_RESPONSE = "INVALID_RESPONSE",
+    NETWORK_ERROR = "NETWORK_ERROR",
+    CONFIG_INVALID = "CONFIG_INVALID",
+    NOT_INITIALIZED = "NOT_INITIALIZED"
+}
+/**
+ * Base governance error
+ */
+export declare class GovernanceError extends Error {
+    code: GovernanceErrorCode;
+    recoverable: boolean;
+    context?: Record<string, unknown> | undefined;
+    constructor(message: string, code: GovernanceErrorCode, recoverable: boolean, context?: Record<string, unknown> | undefined);
+}
+/**
+ * Request timeout error
+ */
+export declare class GovernanceTimeoutError extends GovernanceError {
+    constructor(timeoutMs: number);
+}
+/**
+ * Network error
+ */
+export declare class GovernanceNetworkError extends GovernanceError {
+    constructor(url: string, originalError: Error);
+}
+/**
+ * Type guard for valid governance response
+ */
+export declare function isValidGovernanceResponse(response: unknown): response is GovernanceCheckResponse;
+/**
+ * Type guard for governance error
+ */
+export declare function isGovernanceError(error: unknown): error is GovernanceError;

package/dist/integrations/grok/grok-cli.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Grok CLI Integration for 0xRay
+ *
+ * This module provides the integration points for using 0xRay with the official Grok CLI.
+ *
+ * Primary mechanism: MCP (Model Context Protocol)
+ * Grok CLI can consume MCP servers. By registering the 0xRay MCP servers,
+ * users get access to Governance, skills, and other capabilities directly inside Grok conversations.
+ *
+ * Recommended registration (via npx or Grok's tooling):
+ *   npx 0xray grok install
+ *
+ * This will help configure the user's Grok CLI to include the following MCP servers:
+ * - governance (Dynamo Solar SSOT + real skill deliberation)
+ * - All knowledge-skill MCP servers (code-review, security-audit, researcher, etc.)
+ */
+export interface GrokInstallOptions {
+    force?: boolean;
+    dryRun?: boolean;
+}
+export declare function installForGrokCLI(options?: GrokInstallOptions): Promise<void>;
+declare const _default: {
+    installForGrokCLI: typeof installForGrokCLI;
+};
+export default _default;